C# przełącznik z typów

Question

EDIT: This is now available in C# 7.0.

---

Mam następujący fragment kodu, który sprawdza dany PropertyInfo „s type.

PropertyInfo prop; 

// init prop, etc... 

if (typeof(String).IsAssignableFrom(prop.PropertyType)) { 
    // ... 
} 
else if (typeof(Int32).IsAssignableFrom(prop.PropertyType)) { 
    // ... 
} 
else if (typeof(DateTime).IsAssignableFrom(prop.PropertyType)) { 
    // ... 
} 

Czy istnieje sposób, aby użyć switch oświadczenie w tym scenariuszu? To jest mój obecny rozwiązanie:

switch (prop.PropertyType.ToString()) { 
    case "System.String": 
     // ... 
     break; 
    case "System.Int32": 
     // ... 
     break; 
    case "System.DateTime": 
     // ... 
     break; 
    default: 
     // ... 
     break; 
} 

Nie sądzę, jest to najlepsze rozwiązanie, bo teraz muszę dać pełną String wartość danego type. Jakieś wskazówki?

Answer 1

Odpowiem dokładnie na pytanie: Nie ma mowy.

switch od C# 6 dokładnie obsługuje stałe stałe określonych typów. Nie próbujesz dopasować stałych. Wywołujesz wielokrotnie metodę IsAssignableFrom.

Pamiętaj, że IsAssignableFrom to , a nie identycznie jak w przypadku pasujących typów. Dlatego każde rozwiązanie oparte na porównaniach równości lub tabelach mieszających nie może działać.

Myślę, że rozwiązanie if ... else if, które masz, jest całkowicie w porządku.

Answer 2

Nie ma ogólnej drogi, ale częściej nie, te gałęzie zawierają bardzo podobny kod. Jeden wzór, który prawie zawsze działa dla mnie, to użycie słownika;

var myIndex = new Dictionary<Type, string> { 
    { typeof(string), "some text" },  
    { typeof(int), "a whole number" },  
    { typeof(decimal), "a fraction" },  
}; 

string description; 
if (myIndex.TryGetValue(prop.PropertyType, out description)) { 
    Console.WriteLine("This type is " + description); 
} else { 
    // 'default' 
} 

Answer 3

Użyj metody ToString, ale zamiast literałów użyj caseof (string) .Name (jeśli to możliwe) nie masz teraz naprzeciwko mnie.

Answer 4

Przede wszystkim IsAssignableFrom jest lepszy niż porównanie ciągów w przypadku dziedziczonych typów. Na przykład typeof(TextReader).IsAssignableFrom(typeof(StreamReader)) będzie true, ponieważ StreamReader odziedziczona po TextReader, również praca dla interfejsów.

Jeśli trzeba tylko bezpośrednie porównanie, mogę zaproponować stworzenie Dictionary<Type,Action<PropertyInfo>>, na przykład:

var typeSelector = new Dictionary<Type, Action<PropertyInfo>>() 
{ 
    {typeof(int), IntAction } 
    {typeof(string), StringAction } 
    {typeof(DateTime), DateTimeAction } 
}; 

Wtedy można go używać tak:

Action<PropertyInfo> action; 
if (typeSelector.TryGetValue(prop.PropertyType, out action)) 
    action(prop); 
else 
    throw new InvalidDataException("Unsupported type"); 

Sure w tym przypadku trzeba będzie utwórz metodę dla każdego typu lub wpisz kod podczas tworzenia słownika.

Answer 5

To jest teraz dostępne w języku C# 7.0.

To rozwiązanie jest dla mojego oryginalnego pytania; switch oświadczenia pracować na value z PropertyInfo a nie jego PropertyType:

PropertyInfo prop; 

// init prop, etc... 

var value = prop.GetValue(null); 

switch (value) 
{ 
    case string s: 
     // ... 
     break; 
    case int i: 
     // ... 
     break; 
    case DateTime d: 
     // ... 
     break; 
    default: 
     // ... 
     break; 
} 

---

odpowiedź Nieco bardziej ogólna:

switch(shape) 
{ 
    case Circle c: 
     WriteLine($"circle with radius {c.Radius}"); 
     break; 
    case Rectangle s when (s.Length == s.Height): 
     WriteLine($"{s.Length} x {s.Height} square"); 
     break; 
    case Rectangle r: 
     WriteLine($"{r.Length} x {r.Height} rectangle"); 
     break; 
    default: 
     WriteLine("<unknown shape>"); 
     break; 
    case null: 
     throw new ArgumentNullException(nameof(shape)); 
} 

referencyjny: https://blogs.msdn.microsoft.com/dotnet/2016/08/24/whats-new-in-csharp-7-0/

Answer 6

Jak pokazano w odpowiedzi Marten WIKSTRÖM za: „How to use switch-case on a Type?” można użyć Type.GetTypeCode jako takie:

switch (Type.GetTypeCode(type)) 
{ 
    case TypeCode.Int32: 
     // It's an int 
    break; 

    case TypeCode.String: 
     // It's a string 
    break; 

    // Other type code cases here... 

    default: 
     // Fallback to using if-else statements... 
     if (type == typeof(MyCoolType)) 
     { 
      // ... 
     } 
     else if (type == typeof(MyOtherType)) 
     { 
      // ... 
    } // etc... 
}