[c# .NET] generics/templates in C#

[Verwijderd]

Hallo,

Ik ben bezig met een C# project, en daar zou ik graag generics voor gebruiken. Ik wil bijvoorbeeld 2 functies maken die data 'versturen'.. De te-versturen data kan zowel een integer zijn, een float .. doet er niet toe..

In C# doe ik dit alsvolgt:

C++:

    template <class T1,class T2>
    void  schrijf_message(T1 data1,T2 data2){
        init_buffer();
        _schrijf_message(data1);
        _schrijf_message(data2);
        transmit_buffer();
    }
    
    template <class T1,class T2,class T3>
    void  schrijf_message(T1 data1,T2 data2,T3 data3){
        init_buffer();
        _schrijf_message(data1);
        _schrijf_message(data2);
        _schrijf_message(data3);
        transmit_buffer();
    } 

maar ik krijg maar niets werkende in C#? Iemand die een voorbeeld daarvan heeft?

Alvast bedankt,
Alexander

[ThunderNet]

http://msdn2.microsoft.co...rary/ms379564(VS.80).aspx
Dit al doorgelezen?

[Padschild]

Voorbeelden genoeg: http://msdn2.microsoft.co...rary/ms379564(VS.80).aspx

ThunderNet beat me to it...

[ Voor 20% gewijzigd door Padschild op 19-09-2007 14:16 ]

[Verwijderd]

bedankt voor de reacties,

dit heb al uitgevist, maar het uitvoeren lukt toch maar niet ...

C#:

public void verstuur_bericht<Type1>(Type1 waarde1)
        {
            // gewenste datatype plaatsen
            _buffer_data(waarde1);
        }

       
        public void _buffer_data(sbyte waarde)
        {
           // DOE IETS 
        
        }

normaal zou dit toch moeten compileren? want waarde1 'kan' een sbyte zijn ?

of bekijk ik dit verkeerd ?

[kenneth]

Maar waarde1 'kan' ook een ander type zijn waardoor impliciete conversie niet werkt, toch?

En wat zijn de compiler errors?

[Verwijderd]

kenneth schreef op woensdag 19 september 2007 @ 14:54:
Maar waarde1 'kan' ook een ander type zijn waardoor impliciete conversie niet werkt, toch?

En wat zijn de compiler errors?

die waarde1 'kan' idd ook een ander type zijn, maar ook al schrijf ik de functies uit met alle mogelijke types ( sbyte, byte, short, ushort, int, uint, .... ) .. dit werkt niet ?

de compiler errors:

1:The best overloaded method match for 'Perdum_COM.clsCAN._buffer_data(sbyte)' has some invalid arguments D:\Mijn Documenten\VS_projects\Perdum_soft\Perdum_COM\clsCAN.cs 63 13 Perdum_COM

2: Argument '1': cannot convert from 'Type1' to 'sbyte' D:\Mijn Documenten\VS_projects\Perdum_soft\Perdum_COM\clsCAN.cs 63 26 Perdum_COM

[.oisyn]

.Net Generics zijn geen C++ templates. Generics werken tijdens runtime, terwijl templates tijdens compile-time werken. Je kunt dus geen overloads maken van eenzelfde functie en de compiler tijdens template instantiatie uit laten zoeken welke overload voor welke template parameter aangeroepen moet worden, want er is geen template instantiatie. Aangezien het type idd alles kan zijn, heb je ook 1 functie (en dus geen overloads) nodig die alles accepteert.

Vandaar dat je op zo'n generic parameter alleen maar die memberfuncties aan kunt roepen die op object werken (want dat is het enige type dat bij alle mogelijke aanroepen zeker weten gelijk is - deze assumptie kun je uitbreiden door een where clause op te nemen, zodat de assumptie gemaakt kan worden dat een type ten minste een subclass is van het type dat jij opgeeft)

Had je trouwens ook wel geweten als je gewoon de documentatie daaromtrend had gelezen
Dit is ook een aardige zoekquery: [google=c# generics vs c++ templates]

[ Voor 40% gewijzigd door .oisyn op 19-09-2007 15:07 ]

[Verwijderd]

.oisyn schreef op woensdag 19 september 2007 @ 15:02:
.Net Generics zijn geen C++ templates. Generics werken tijdens runtime, terwijl templates tijdens compile-time werken. Je kunt dus geen overloads maken van eenzelfde functie en de compiler tijdens template instantiatie uit laten zoeken welke overload voor welke template parameter aangeroepen moet worden, want er is geen template instantiatie. Aangezien het type idd alles kan zijn, heb je ook 1 functie (en dus geen overloads) nodig die alles accepteert.

Vandaar dat je op zo'n generic parameter alleen maar die memberfuncties aan kunt roepen die op object werken (want dat is het enige type dat bij alle mogelijke aanroepen zeker weten gelijk is - deze assumptie kun je uitbreiden door een where clause op te nemen, zodat de assumptie gemaakt kan worden dat een type ten minste een subclass is van het type dat jij opgeeft)

Had je trouwens ook wel geweten als je gewoon de documentatie daaromtrend had gelezen
Dit is ook een aardige zoekquery: [google=c# generics vs c++ templates]

bedankt voor de uitleg..

Wat ik dus wil doen op mijn manier kan niet? Maar hoe kan ik dit dan oplossen op die generics manier? Een generic aanmaken, en dan kijken welk type het mogelijk kan zijn?

[.oisyn]

Reflection. Maar volgens mij ben je gewoon serialization aan het implementeren, je kunt de parameters dus ook gewoon serializen naar een stream oid

[_Thanatos_]

Een generic aanmaken, en dan kijken welk type het mogelijk kan zijn?

Dat is ook mogelijk, en wel met de typeof operator:

C#:

public void MyMethod<T>(T param1) {
   //Je kan @compile-time het type van param1 bepalen:
   if (typeof(param1) == typeof(string)) {
      //...
   }
   //Of @runtime, als compile-time om wat voor reden dan ook niet gaat:
   if (param1.GetType() == typeof(string)) {
      //...
   }
}

Maar je kan natuurlijk ook de is en de as operators gebruiken als je where T:class (dacht ik) erbij definieert

[riezebosch]

_Thanatos_ schreef op woensdag 19 september 2007 @ 21:52:
[...]

Dat is ook mogelijk, en wel met de typeof operator:

C#:

public void MyMethod<T>(T param1) {
   //Je kan @compile-time het type van param1 bepalen:
   if (typeof(param1) == typeof(string)) {
      //...
   }
   //Of @runtime, als compile-time om wat voor reden dan ook niet gaat:
   if (param1.GetType() == typeof(string)) {
      //...
   }
}

Maar je kan natuurlijk ook de is en de as operators gebruiken als je where T:class (dacht ik) erbij definieert

Meestal wil je dat ook niet zo. Want dan zijn je generics niet echt generiek meer

[prototype]

Zoals al eerder gezegd gaat dit niet werken en ik verwijs je naar artikelen over covariantie van typesystems voor een volledige verklaring.

_Thanatos_ schreef op woensdag 19 september 2007 @ 21:52:
[...]

Dat is ook mogelijk, en wel met de typeof operator:

C#:

public void MyMethod<T>(T param1) {
   //Je kan @compile-time het type van param1 bepalen:
   if (typeof(param1) == typeof(string)) {
      //...
   }
   //Of @runtime, als compile-time om wat voor reden dan ook niet gaat:
   if (param1.GetType() == typeof(string)) {
      //...
   }
}

Maar je kan natuurlijk ook de is en de as operators gebruiken als je where T:class (dacht ik) erbij definieert

Zoals al eerder gezegd is dit niet generic laat staan wenselijk. Een C++ book author waar de naam me even van ontschiet schreef ooit dat wanneer je de type moest weten van een object je jezelf voor de kop moest slaan met datzelfde boek Het druist namelijk nogal tegen abstractie en polymorfie in.

Je delegeert de call nu in feite voor elke situatie hardcoded wat ook niet bijster lekker is om te onderhouden. Ik zou toch even je ontwerp opnieuw evalueren. Indien je toch dicht bij een oplossing wil blijven zoals je 'm nu hebt zou ik je aanraden om even te kijken naar de Visitor pattern, die zou in dit geval wel als double dispatcher voor je op kunnen treden om de juiste overloads te pakken.

[.oisyn]

Dat gaat dus niet werken, tenzij je een visitor interface op de primitieven geimplementeerd krijgt . Kijkend naar de code van de topicstarter wil hij gewoon serializen, niets meer en niets minder.

[prototype]

.oisyn schreef op donderdag 20 september 2007 @ 01:46:
Dat gaat dus niet werken, tenzij je een visitor interface op de primitieven geimplementeerd krijgt . Kijkend naar de code van de topicstarter wil hij gewoon serializen, niets meer en niets minder.

D'oh, iets teveel Ruby gedaan
Maar volgens mij is 't idd wat je zegt, dat TS naar serialiseren zoekt.