Zmienna rodzajowy typ zwrotu w języku C#

Question

Czy istnieje sposób, aby metoda zwróciła jeden z wielu typów ogólnych z metody? Na przykład, mam następujący:

public static T ParseAttributeValue<T>(this XElement element, string attribute) 
    { 
     if(typeof(T) == typeof(Int32)) 
     { 
      return Int32.Parse(element.Attribute(attribute).Value); 
     } 

     if(typeof(T) == typeof(Double)) 
     { 
      return Double.Parse(element.Attribute(attribute).Value); 
     } 

     if(typeof(T) == typeof(String)) 
     { 
      return element.Attribute(attribute).Value; 
     } 

     if(typeof(T) == typeof(ItemLookupType)) 
     { 
      return Enum.Parse(typeof(T), element.Attribute(attribute).Value); 
     } 
    } 

(Jest to tylko bardzo szybkie makieta, jestem świadomy, że każdy kod produkcja musiałaby być znacznie bardziej dokładny w kontroli zerowych etc ...)

Ale kompilator tego nie lubi, narzekając, że Int32 nie może zostać niejawnie przekonwertowany na T (nie działa również z rzutowaniem). Mogę to zrozumieć. W czasie kompilacji nie ma możliwości dowiedzenia się, co to jest T, ale sprawdzam to wcześniej. Czy mimo to mogę to wykonać?

Answer 1

Zrobiłem te typy ogólnych metod w przeszłości. Najłatwiejszym sposobem wnioskowania o typ jest zapewnienie ogólnej funkcji konwertera.

public static T ParseAttributeValue<T> 
      (this XElement element, string attribute, Func<string, T> converter) 
{ 
    string value = element.Attribute(attribute).Value; 
    if (String.IsNullOrWhiteSpace(value)) { 
    return default(T); 
    } 

    return converter(value); 
} 

Można go używać jak poniżej:

int index = element.ParseAttributeValue("index", Convert.ToInt32); 
double price = element.ParseAttributeValue("price", Convert.ToDouble); 

Można nawet podać swoje własne funkcje i mieć całą zabawę w świecie (nawet powrócić anonimowych typów):

ItemLookupType lookupType = element.ParseAttributeValue("lookupType", 
    value => Enum.Parse(typeof(ItemLookupType), value)); 

var item = element.ParseAttributeValue("items", 
    value => { 
    List<string> items = new List<string>(); 
    items.AddRange(value.Split(new [] { ',' })); 
    return items; 
    }); 

Answer 2

Dlaczego w ogóle używasz parametru typu jako typu zwrotu? To działa, tylko wymaga obsady po wywołaniu:

public static Object ParseAttributeValue<T>(this XElement element, string attribute) 
{ 
    if(typeof(T) == typeof(Int32)) 
    { 
     return Int32.Parse(element.Attribute(attribute).Value); 
    } 

    if(typeof(T) == typeof(Double)) 
    { 
     return Double.Parse(element.Attribute(attribute).Value); 
    } 

    if(typeof(T) == typeof(String)) 
    { 
     return element.Attribute(attribute).Value; 
    } 

    if(typeof(T) == typeof(ItemLookupType)) 
    { 
     return Enum.Parse(typeof(T), element.Attribute(attribute).Value); 
    } 
} 

Albo jeszcze lepiej:

public static Int32 ParseAsInt32(this XElement element, string attribute) 
{ 
    return Int32.Parse(element.Attribute(attribute).Value); 
} 

// etc, repeat for each type 

To drugie rozwiązanie ma dodatkową zaletę posiadania znacznie wyższe prawdopodobieństwo uzyskania inlined, plus to będzie (w przypadku typów wartości, takich jak Int32), nie ma potrzeby wstawiania/rozpakowywania wartości. Obie te metody spowodują, że metoda będzie działać nieco szybciej.

Answer 3

Nie wiem, czy jest to dokładnie to, czego potrzebujesz, ale możesz przywrócić skuteczność, jeśli najpierw wyrzucisz na numer object, a następnie na T

public static T ParseAttributeValue<T>(this XElement element, string attribute) 
    { 
     if (typeof(T) == typeof(Int32)) 
     { 
      return (T)(object)Int32.Parse(element.Attribute(attribute).Value); 
     } 

     if (typeof(T) == typeof(Double)) 
     { 
      return (T)(object)Double.Parse(element.Attribute(attribute).Value); 
     } 

     if (typeof(T) == typeof(String)) 
     { 
      return (T)(object)element.Attribute(attribute).Value; 
     } 

     return default(T); 
    } 

Jednak trzeba jeszcze zapewnić T w czasie kompilacji, wywołanie metody jak:

int value = element.ParseAttributeValue<int>("attribute"); 

Answer 4

Oto dwa sposoby robi ...

static T ReadSetting<T>(string value) 
    { 
     object valueObj = null; 
     if (typeof(T) == typeof(Int32)) 
      valueObj = Int32.Parse(value); 
     return (T)valueObj; 
    } 
    static dynamic ReadSetting2<T>(string value) 
    { 
     if (typeof(T) == typeof(Int32)) 
      return Int32.Parse(value); 
     throw new UnsupportedException("Type is unsupported"); 
    } 
    static void Main(string[] args) 
    { 
     int val1 = ReadSetting<Int32>("2"); 
     int val2 = ReadSetting2<Int32>("3"); 
    } 

Answer 5

z C++ szablony, to coś by zadziałało, ale tylko jeśli każdy fragment kodu byłby w innej, odrębnej specjalizacji. Rzeczą, która czyni tę pracę jest to, że nieużywane szablony funkcji nie są kompilowane (lub dokładniej: nie w pełni utworzone), więc fakt, że fragment kodu byłby nieprawidłowy, gdyby ta kopia szablonu była tworzona za pomocą innego typu, nie wchodzić na górę.

C# jest inny, a AFAIK nie ma specjalizacji dla leków generycznych. Jednym ze sposobów osiągnięcia tego, co próbujesz zrobić, podczas pracy z ograniczeniami języka C#, byłoby utworzenie jednej funkcji z bardziej abstrakcyjnym typem zwracania i użycie parametru ParseAttributeValue tylko do rzucenia go do T.

Więc trzeba:

private static Object AbstractParseValue(System.Type t, XElement element, string attribute) 

i

public static T ParseAttributeValue<T>(this XElement element, string attribute) 
{ 
    return (T)AbstractParseValue(typeof(T), element, attribute); 
} 

Answer 6

Net ma już kilka wielkich procedur konwersji ciąg można użyć! A TypeConverter może wykonać większość ciężkiego podnoszenia dla ciebie. Wtedy nie musisz się martwić dostarczając własnych implementacji parsowania dla wbudowanych typów.

Należy pamiętać, że istnieją interfejsy API obsługujące locale pod adresem TypeConverter, które mogą być używane, jeśli konieczne jest przetwarzanie wartości analizowanych w różnych kulturach.

Poniższy kod będzie analizować wartości przy użyciu domyślnego Kultura:

using System.ComponentModel; 

public static T ParseAttributeValue<T>(this XElement element, string attribute) 
{ 
    var converter = TypeDescriptor.GetConverter(typeof(T)); 
    if (converter.CanConvertFrom(typeof(string))) 
    { 
     string value = element.Attribute(attribute).Value; 
     return (T)converter.ConvertFromString(value); 
    } 

    return default(T); 
} 

to będzie pracować dla wielu typów wbudowanych, i można ozdobić typów niestandardowych z TypeConverterAttribute celu umożliwienia im udziału w także konwersję typu. Oznacza to, że w przyszłości będziesz mógł analizować nowe typy bez konieczności zmiany implementacji ParseAttributeValue.

patrz: http://msdn.microsoft.com/en-us/library/system.componentmodel.typeconverter.aspx

Answer 7

Sugerowałbym, że zamiast testowania parametru type każdym razem procedura jest wykonywana, należy utworzyć rodzajowe klasy statyczne coś takiego:

 
internal static class ElementParser<T> 
{ 
    public static Func<XElement, string, T> Convert = InitConvert; 

    T DefaultConvert(XElement element, string attribute) 
    { 
    return Default(T); // Or maybe throw exception, or whatever 
    } 

    T InitConvert(XElement element, string attribute) 
    { 
    if (ElementParser<int>.Convert == ElementParser<int>.InitConvert) 
    { // First time here for any type at all 
     Convert = DefaultConvert; // May overwrite this assignment below 
     ElementParser<int>.Convert = 
     (XElement element, string attribute) => 
      Int32.Parse(element.Attribute(attribute).Value); 
     ElementParser<double>.Convert = 
     (XElement element, string attribute) => 
      Int32.Parse(element.Attribute(attribute).Value); 
     // etc. for other types 
    } 
    else // We've done other types, but not this type, and we don't do anything nice for it 
    { 
     Convert = DefaultConvert; 
    } 
    return Convert(element, attribute);  
    } 
} 
public static T ParseAttributeValue(this XElement element, string attribute) 
{ 
    ElementParser<T>.Convert(element, attribute); 
} 

Stosując to podejście, jedna osoba będzie musiała wykonać specjalne czynności tylko przy pierwszym użyciu określonego typu. Następnie konwersję można przeprowadzić przy użyciu tylko jednego ogólnego wywołania delegowanego. Raz można łatwo dodać dowolną liczbę typów, a nawet umożliwić zarejestrowanie konwerterów dla dowolnego typu w środowisku wykonawczym.