Jak podać typ domyślny dla generycznych?

Question

Mam klasy, która obecnie ma kilka metod, które biorą parametry liczb całkowitych. Te liczby całkowite są odwzorowywane na operacje, które może wykonywać aplikacja. Chciałbym uczynić klasą rodzajową, aby konsumenci klasy mogli podać typ wyliczeniowy, który mają ze wszystkimi operacjami w nim zawartymi, wtedy metody przyjmą parametry tego typu wyliczeniowego. Jednak chcę, aby nie byli w stanie określić typu ogólnego w ogóle i domyślnie powrócić do liczb całkowitych bez zmiany składni z obecnego sposobu. czy to możliwe?

Answer 1

Nie można tego zrobić w definicji klasy:

var foo = new MyGenericClass(); // defaults to integer... this doesn't work 
var bar = new MyGenericClass<MyEnum>(); // T is a MyEnum 

Jeśli naprawdę cenimy implicitness domyślnego typu int samopoczucia, trzeba to zrobić ze statycznym fabryce metoda, chociaż nie widzę jej wartości.

public class MyGenericClass<T> 
{ 
    public static MyGenericClass<T> Create() 
    { 
     return new MyGenericClass<T>(); 
    } 
    public static MyGenericClass<int> CreateDefault() 
    { 
     return new MyGenericClass<int>(); 
    } 
} 

Zobacz poniżej, jak naprawdę nie korzystasz z powyższych.

var foo = MyGenericClass<MyEnum>.Create(); 
var bar1 = MyGenericClass.CreateDefault(); // doesn't work 
var bar2 = MyGenericClass<int>.CreateDefault(); // works, but what's the point 

Jeśli chcesz wziąć go jeszcze dalej, można utworzyć statyczną klasy fabrycznej, że rozwiąże to, ale to jeszcze bardziej absurdalne rozwiązanie jeśli robisz to dla żadnego innego powodu niż dostarczenie domyślne wpisz:

public static class MyGenericClassFactory 
{ 
    public static MyGenericClass<T> Create<T>() 
    { 
     return new MyGenericClass<T>(); 
    } 
    public static MyGenericClass<int> Create() 
    { 
     return new MyGenericClass<int>(); 
    } 
} 

var foo = MyGenericClassFactory.Create(); // now we have an int definition 
var bar = MyGenericClassFactory.Create<MyEnum>(); 

Answer 2

Kompilator można wywnioskować argumentów typu na metod większość czasu w zależności od typu argumentów przekazany:

public void DoSomething<T>(T test) { 
} 

można nazwać z

DoSomething(4);     // = DoSomething<int>(4); 
DoSomething(MyEnum.SomeValue); // = DoSomething<MyEnum>(MyEnum.SomeValue); 

Nawiasem mówiąc, możesz mieć nietypowe przeciążenia metody ogólnej.

Answer 3

Zachowaj oryginalną wersję (wersja nietypowa) i utwórz jej ogólną wersję.

Następnie wywołaj wersję ogólną ze swojej wersji generycznej.

void Main() 
{ 
DoSomething(2); 
DoSomething(EnumValue); 

} 

public void DoSomething(int test) { 
DoSomething<int>(test); 
} 

// Define other methods and classes here 
public void DoSomething<T>(T test) { 
Console.WriteLine(test); 
} 

Answer 4

A więc ... czemu nie użyć prostego dziedziczenia? Jak:

class MyGenericClass<T> 
{ 
} 

class MyGenericClass : MyGenericClass<int> 
{ 
} 

ten sposób można napisać w obie strony:

var X = new MyGenericClass<string>(); 
var Y = new MyGenericClass(); // Is now MyGenericClass<int>