[C#/.NET] Declareren klasse, overerving Generic Type T

[Creegfire]

Nieuwe topicstart:

Ontwikkelomgeving: VS2008

Experiment:

Mijn bedoeling is dat een zelf reeds gecreerde klasse (bijvoorbeeld zoals later in één van posts wordt genoemd PresentationObject) overerft van de generic type " T " waarbij deze " T " dus iedere vorm van een opgegeven klasse kan aannemen. Ik heb bijvoorbeeld de klasse Medewerker gemaakt waarin een property staat waar ik de medewerker naam kan ophalen en setten. Nu wil ik bijvoorbeeld een presentationobject aanmaken die alle eigenschappen van medewerker erft dus waaronder ook die property. Nee, ik wil het niet zoals dit doen: PresentationObject (erft van) Medewerker maar ik wil het zoals dit doen PresentationObject (erft van) T, waarbij ik de " T " eigenlijk de klasse Medewerker wil plaatsen.

Problemen:

Om deze generic type " T " te kunnen gebruiken moet hij bekend zijn IN de klasse, dus de klasse moet dan automatisch zo worden opgebouwd:

public class PresentationObject<T>
{
}

Op deze manier wordt de T gemaakt binnen de klasse alleen ik kan hier verder niets mee. Want ik kan hem helaas niet laten gedragen hoe ik het wil. Ik moet dus eigenlijk een manier hebben om de T binnen de klasse te kunnen maken zodat hij het opgegeven object kan aannemen en eventueel via een property (zoals later in één van mijn posts aangegeven) het type kan ophalen en ook dus de property's gebruiken van het object dat is gekoppeld aan mijn PresentationObject.

Kortweg gezegd het PresentationObject moet zich gaan gedragen naar Medewerker met alle eigenschappen die zijn beschreven binnen medewerker.

Ik hoop dat het zo duidelijker is geworden en ik heb echt mijn best gedaan om mijn topic start een beetje goed aan te passen .

Mijn vraag is dus hoe kan ik dit oplossen. Jullie hebben al verschillende oplossingen aangeboden en deze zal ik ook gaan proberen. In ieder geval echt bedankt alvast voor het meedenken van jullie .

[ Voor 82% gewijzigd door Creegfire op 13-09-2008 15:23 ]

[MTWZZ]

Je zegt het zelf al een beetje: T is compile-time onbekend. En aangezien het nogal lastig is om te overerven van iets wat niet bekend is gaat dat dus ook niet.

[Creegfire]

Ja, dat spreekt voor zich eigenlijk, maar als je bijvoorbeeld dus dit doet Test<T> dan is de T wel binnen de klasse bekend. Is het niet mogelijk om die "T" al ergens eerder bekend gemaakt kan worden en eventueel een klasse toegekend kan worden?

[Flard]

Ik moet eerlijk zeggen dat ik je TS niet helemaal begrijp, maar bedoel je niet dit:

C#:

public class NieuweTest : Test<int>
{
}

of bedoel je:

C#:

public class NieuweTest<T> : Test<T>
{
}

[Creegfire]

Blijkbaar weer geen goede TS gemaakt haha ben er slecht in maar goed.

Wat ik eigenlijk aan het experimenteren ben is het volgende.

Mijn eerste idee was om een bepaald Type die ik zelf heb gemaakt (voorbeeld Test) mag andere zaken overerven van een ander type dat ik heb gemaakt (voorbeeld Test2). Niet moeilijk allemaal en als ik ze wil laten overerven zal het zo gedaan worden Test : Test2.

Mijn bedoeling is om het type "T" te gaan gebruiken om alle willekeurige klassen die ik maak dat hij daarvan kan overerven. Dus komt het eigenlijk zo uit te zien public class Test : " T ". Helaas gaat dit niet op omdat de " T " niet bekend is. Om deze T te kunnen instantieren moet je het op de volgende manier doen. public class Test<T> en zodoende wordt er door de gehele klasse de " T " geinstantieerd zodat deze iedere type kan aannemen wat ik wil. Na enige research voordat ik de topic start heb gemaakt heb ik al iets ontdekt om dit op een andere manier te doen.

C#:

// Ok, hier wordt dus T geinstantieerd in de klasse en kan ik tijdens het constructen van deze klasse opnieuw aangeven welke klasse ik erin wil hebben.
// Als ik dus op de volgende manier doe constructen
// Test2 test = new Test2
// PresentationObject<Test2> test2 = new PresentationObject<Test2>(test)
// Kan ik op de volgende manier hun waardes aanroepen test2.GetClassType.<methode>
// Hier is opzicht niets mis mee alleen wat ik dan het liefste ervan af wil hebben is de <Test2> en dat ik het gewoon als PresentationObject kan laten maken.
// Daarbij heb ik dus bij het volgende stukje code het geprobeerd om op een andere manier op te lossen. Dat stukje code werkt helaas niet.

    public class PresentationObject<T>
    {
        private T classType;
        public T GetclassType
        {
            get { return classType; }
        }

        public PresentationObject(T classType)
        {
            this.classType = classType;
        }
    }

    public class PresentationObject
    {
        private Type classType;
        public Type GetClassType
        {
            get { return classType;  }
        }

        public PresentationObject(Type classType)
        {
            this.classType = classType;
        }
    }

Ik hoop dat mijn experiment nu wat duidelijk is.

[Flard]

Eh, om eerlijk te zijn begrijp ik het nog niet...
(Lees je eigen verhaal eens door, het zijn behoorlijk slecht lopende zinnen)

Is het niet mogelijk wat specifiekere voorbeeldcode te geven, want je code is erg abstract en ook niet echt duidelijk (naar mijn mening).
Misschien kun je je probleem wat concreter uitleggen, met wat meer klassen(en methoden in je klassen) en voorbeeldcode. Wat er mis is met je code, en hoe je het liever zou willen schrijven.

[Sebazzz]

Zoek eens op interfaces. Dat moet je een stuk verder helpen.

Een interface is een sjabloon waarmee je kan vastleggen welke methode (en geloof ik ook welke fields/properties) een object moet hebben. Succes!

Interfaces zijn echter geen classes op zichzelf en kunnen geen code uitvoeren, maar je kan wel classes ervan afleiden en dan die als argument van een methode geven.

Bijvoorbeeld leidt je klasse X af ITestKlasse en dan kan je bijvoorbeeld dit als methodedefinitie doen:

C#:

private void Blaat(ITestKlasse c) { } 

[ Voor 44% gewijzigd door Sebazzz op 12-09-2008 20:45 ]

[whoami]

Ik snap geen hol van je topicstart. Ik zou zeggen, zet je eens rustig, adem een paar keer goed in en uit, bouw goede zinnen, en herlees je post voor je submit.

Nu, ik vermoed dat je wil dat je een 'constraint' wil plaatsen, dat je generisch type T dus van een bepaald type moet zijn ?

code:

public class MyClass<T>  where T : SomeOtherType
{}

Of wat bedoel je daar met dat 'GetClassType' ? Wil je dat daar het concrete type van T gereturned wordt ? (typeof()) ? En wat wil je er dan mee doen ?

[Ruudjah]

Mijn bedoeling is om het type "T" te gaan gebruiken om alle willekeurige klassen die ik maak dat hij daarvan kan overerven.

Je wilt dus een klasse hebben met hierin bepaalde functionaliteit die je wil gebruiken voor alle andere klasses. Als deze functionaliteit generiek is, kan je het beste een abstracte basis klasse grbuiken, en daar gewoon van overerven. Als de functionaliteit specifiek is, is een interface handiger. Interfaces definieren namelijk alleen wat, en niet hoe terwijl een abstracte basisklasse beide (kan) doen. Overigens hoeft die klasse niet abstract te zijn, concreet werkt ook: abstract is alleen handig als de basisklasse zelf niet geinstantieerd hoeft (of zelfs moet) te worden.

[Grijze Vos]

Je wil gewoon encapsulatie toepassen, niet inheritance. (Als ik je goed begrijp.)
Zoek eens het strategy pattern op, volgens mij komt dat in de buurt van wat je wilt.

[ Voor 50% gewijzigd door Grijze Vos op 13-09-2008 11:53 ]

[roy-t]

Volgens mij wil de TS gewoon een classe hebben die als argument een classtype T mee krijgt en daarnaeen nieue classe aanmaken die overerft van T.

[paulh]

Daar zijn toch interfaces voor. Maak dan een interface die hetzelfde moet voorstellen als T en zorg dat je andere classes die interface implementeren. Gebruik desnoods een lege interface.

[ Voor 10% gewijzigd door paulh op 13-09-2008 14:51 ]