[C#] Object casten naar een variabel type

[maikel]

Ik heb in C# een class gebouwd die een collectie maakt van een bepaalde type.
Dit type kun je als parameter meegeven.
Maar nu wil ik zorgen dat als die collectie eenmaal gemaakt is, hij ook strongly-typed is: dus dat er alleen objecten van het opgegeven type in de collectie kunnen voorkomen.
Hiervoor wil ik een stukje code gebruiken als:

code:

public <type> this[int index]
{
    get
    {
        return (<type>)  List[index];
    }
    set
    {
        List[index] = value;
    }
}

Mijn vraag is nu wat ik precies bij '<type>' moet invullen. Als ik daar gewoon de variabelenaam (in mijn geval 'type') invul, geeft ie een foutmelding: ... denotes a 'field' where a 'class' was expected.
Weet iemand hoe dit wel kan ??

[Alarmnummer]

Niet, wat jij namelijk bedoelt zijn geparametriseerde types en dat kan .NET nog niet.

[Verwijderd]

Dit gaat nooit lukken. C# kan dit (voorlopig nog?) niet. Het beste wat je kan doen is daar 'object' neerzetten. Dan kan je er alles in stoppen, maar bij het eruit halen zal je moeten casten, of een foreach loopje moeten gebruiken.

[Verwijderd]

Als je een type safe collection wil maken is dit tooltje erg handig.

collectiongen

[maikel]

Shit, echt weer wat voor mij om dingen te willen die de taal niet ondersteund.

[Verwijderd]

Volgens mij is een type safe collection precies wat je wil... en dat is goed zelf te bouwen met collectiongen.

In de MSDN library van juli 2002, wellicht ook op internet ?

ms-help://MS.MSDNQTR.2002JUL.1033/vbcon/html/vaconCreatingYourOwnCollectionClass.htm

[ Voor 0% gewijzigd door Verwijderd op 21-08-2002 12:11 . Reden: Linkjes altijd moeilijk ]

[maikel]

Ik bouw ze nu ook met de hand ja, maar ik wilde even kijken of het ook dynamischer kon. Nu heb ik nogal veel verschillende collection-classes in m'n project staan die allemaal nagenoeg hetzelfde doen (alleen met een ander type) en het zou netter zijn als dat 1 dynamische class was.

Die collectiongen heb ik wel even geprobeerd, maar toen ik 'm toe wilde voegen aan m'n solution ging ie zeuren over een database en begon SourceSafe ook nog eens te zeuren. Dus het ligt er al weer af.
Met de hand is bijna net zo simpel.

[Alarmnummer]

Zoals je aan zijn syntax kan zien weet je dat hij generics (geparametriseerde types) bedoelt. Ik heb al even gekeken naar syntax extensies voor c# en generics, maar ik heb niets gevonden behalve voorstellen ed. Ik geloof dat het bij de volgende versie van .NET zit, maar ik neem aan dat er dan ook al lang syntax extensies uitzijn.

[maikel]

Alarmnummer schreef op 21 augustus 2002 @ 12:46:
Zoals je aan zijn syntax kan zien weet je dat hij generics (geparametriseerde types) bedoelt. Ik heb al even gekeken naar syntax extensies voor c# en generics, maar ik heb niets gevonden behalve voorstellen ed. Ik geloof dat het bij de volgende versie van .NET zit, maar ik neem aan dat er dan ook al lang syntax extensies uitzijn.

Is er iets van bekend over wanneer ik die kan verwachten ?
Ik ga dan denk ik maar wat op GoT rondkijken totdat ik weer verder kan.

[Alarmnummer]

ik neem aan dat het nog een hele tijd kan duren voordat zoiets te verkrijgen is. Ik werk op dit moment met een syntax extensie voor Java: Nice en die heeft oa ook generics en nog tig andere fantastische dingen, maar deze is ook nog lang niet klaar en dat kan ook nog wel een tijdje duren.

Een probleem aan generics is, dat veel libraties ook met behulp daarvan herschreven kunnen worden en daarom duurt het een tijdje voordat het standaard erin zit, terwijl de compiler zelf niet zo veel werk is.

[Verwijderd]

maikel schreef op 21 augustus 2002 @ 12:40:
Ik bouw ze nu ook met de hand ja, maar ik wilde even kijken of het ook dynamischer kon. Nu heb ik nogal veel verschillende collection-classes in m'n project staan die allemaal nagenoeg hetzelfde doen (alleen met een ander type) en het zou netter zijn als dat 1 dynamische class was.

Als je nu een base class maakt met object's en daar van inherit voor alle types, die je nodig hebt? Dan hoef je de gedeelde methods niet meer te implementeren. Meer generiek kan ik me niet bedenken en heel erg OO

[maikel]

Verwijderd schreef op 21 augustus 2002 @ 13:34:
[...]


Als je nu een base class maakt met object's en daar van inherit voor alle types, die je nodig hebt? Dan hoef je de gedeelde methods niet meer te implementeren. Meer generiek kan ik me niet bedenken en heel erg OO

Ik inherit van CollectionBase, maar moet nog wel een aantal methods steeds opnieuw implementeren aangezien het type elke keer anders is.
En het zou dus generieker kunnen als ik dat type maar variabel kon houden, maar dat gaat dus voorlopig niet.

[mbravenboer]

Even een voorbeeldje zoals je dit met geparameterizeerde typen kan doen:

code:

public class Pair<F, S> {

  private F _first;
  private S _second;

  public Pair(F first, S second) {
    super();
    _first  = first;
    _second = second;
  }

  public F getFirst() {
    return _first;
  }

  public S getSecond() {
    return _second;
  }

Je kan de Pair klasse bijvoorbeeld zo gebruiken:

code:

public void test(Pair<String, Integer> pair) {
  String val1 = pair.getFirst();
  Integer val2 = pair.getSecond();
}

Je kan je zelf vast wel voorstellen hoe dit bij andere collections gaat .

[maikel]

mbravenboer schreef op 21 augustus 2002 @ 14:03:
Even een voorbeeldje zoals je dit met geparameterizeerde typen kan doen:

code:

public class Pair<F, S> {

  private F _first;
  private S _second;

  public Pair(F first, S second) {
    super();
    _first  = first;
    _second = second;
  }

  public F getFirst() {
    return _first;
  }

  public S getSecond() {
    return _second;
  }

Je kan de Pair klasse bijvoorbeeld zo gebruiken:

code:

public void test(Pair<String, Integer> pair) {
  String val1 = pair.getFirst();
  Integer val2 = pair.getSecond();
}

Je kan je zelf vast wel voorstellen hoe dit bij andere collections gaat .

Ik volg je niet helemaal.
Zou je er wat meer uitleg bij kunnen geven ?

[mbravenboer]

In klassieke Java/C# zou je de Pair klasse zo implementeren:

code:

public class Pair

  private Object _first;
  private Object _second;

  public Pair(Object first, Object second) {
    super();
    _first  = first;
    _second = second;
  }

  public Object getFirst() {
    return _first;
  }

  public Object getSecond() {
    return _second;
  }
}

Als je nu een Pair hebt waarvan je weet dat twee Strings inzitten, zal je toch nog een cast moeten uitvoeren als je het resultaat van de methode getFirst als een String wilt hebben:

code:

String s = (String) pair.getFirst();

De klasse Pair die ik hierboven liet zien is geparameterizeerd met twee typen: F en S. In de klasse Pair kan je deze parameters gebruiken alsof het gewone typen zijn: je ziet op verschillende plaatsen F en S staan, waar je normaal een type zou verwachten.

Als je de klasse Pair gaat gebruiken moet je aangeven met welke typen je deze klasse wilt parameterizen: je geeft aan wat F en S zijn. Dit zie je terug in dit stukje: Pair<String, Integer>. Hiermee geef je aan dat F een String is, en S een Integer.

Je krijgt nu dus in feite deze betekenis van de code:

code:

public class Pair

  private String _first;
  private Integer _second;

  public Pair(String first, Integer second) {
    super();
    _first  = first;
    _second = second;
  }

  public String getFirst() {
    return _first;
  }

  public Integer getSecond() {
    return _second;
  }
}

Je kan nu gewoon de methode getFirst() aanroepen en je krijgt dan een String terug.

In C++ zou je met templates exact hetzelfde kunnen doen en dan zou deze code ook echt gegenereerd worden. In Generic Java is dit niet zo en in C# zal het ook niet zo zijn.

[maikel]

Aha, nu snap ik het !
Maar werkt dit zo ook in C# ??
Bij mij vindt ie "public class Pair<F, S>" niet zo erg grappig.

[mbravenboer]

maikel: Aha, nu snap ik het !

Mooi .

Maar werkt dit zo ook in C# ??

Op dit moment nog niet: Microsoft gaat dit in de volgende grote update van .NET introduceren. Er zijn al verschillende papers gepubliceerd over de aanpak (zie mijn resources voor microsoft .net) en intern zullen er al wel implementaties zijn. Voor ons is er echter nog niets te downloaden voor zover ik weet.

Voor Java is er al tijden een tool die deze geparameterizeerde typen vertaalt in normale code (via type erasure). Dit is GJ. JSR 14 bereid al een flinke tijd de introductie van geparameterizeerde typen in Java voor. Er is nu ongeveer 1.5 jaar een compiler beschikbaar die representatief is voor hetgene wat er in de Java 2 SDK 1.5 gaat komen. Ik gebruik deze al sinds het begin en heb dus al mijn volledige codebase geparameterizeerd. Het functioneert prima .

Als Microsoft lang wacht met de introductie van generics zullen er denk ik snel tools vergelijkbaar met GJ opduiken voor C#. Wellicht dat ze zelfs al in ontwikkeling zijn, want het ligt erg voor de hand om dit te gaan ontwikkelen .

[maikel]

Ik had even een klein beetje hoop dat jij een 'work-around' had gevonden.
Maar goed, dan maar wachten tot Bill's kornuiten met een nieuwe versie komen.
Overigens lijkt mij een implementatie van MS toch wat beter dan zo'n 3rd party-implementatie.