Üzerinde geçiş yapma PropertyType

Question

Bu işi nasıl yapabilirim? türleri için karşılaştıran dize sadece awfull ve değişime tabi olabilir çünkü

switch(property.PropertyType){ 
    case typeof(Boolean): 
     //doStuff 
     break; 
    case typeof(String): 
     //doOtherStuff 
     break; 
    default: break; 
} 

Ben adı kullanmak istemiyoruz.

Answer 1

 System.Type propertyType = typeof(Boolean); 
     System.TypeCode typeCode = Type.GetTypeCode(propertyType); 
     switch (typeCode) 
     { 
      case TypeCode.Boolean: 
       //doStuff 
       break; 
      case TypeCode.String: 
       //doOtherStuff 
       break; 
      default: break; 
     } 

Sen TypeCode.Object için bir hibrit yaklaşımı kullanabilirsiniz:/else desen/eğer

if(property.PropertyType == typeof(bool)) { 
    //dostuff; 
} 
else if (property.PropertyType == typeof(string)) { 
    //do other stuff; 
} 

Answer 2

Bir anahtar içinde dizeleri kullanma hakkında endişelenmeyin, çünkü derleyiciniz birkaç kez otomatik olarak onu oldukça iyi görünmesine rağmen iyi bir performans veren bir karma aramaya dönüştürecektir.

Türü dizginin değişmesi sorunu, onu açık bir karma arayışına dönüştürerek ve karma bir yapıda karma karmalarını doldurarak çözülebilir. Bu şekilde karma, çalışma zamanında doğru dizelerle doldurulur, böylece doğru kalır.

Answer 3

Durumun sabit olması gerektiğinden, C# anahtarını kullanarak bunu yapamazsınız.

sorununun ne:

if (property.PropertyType == typeof(Boolean)) 
{ 
} 
else if (property.PropertyType == typeof(String)) 
{ 
} 
else if (...) 
{ 
} 

Answer 4

Sadece normal bir kullanma tipeof ile dinamik. Bu çok hızlı çünkü ilk bölüm için - anahtar - derleyici bir arama tablosuna göre karar verebilir.

Answer 5

Yapamazsınız. Ne yapabilirsiniz bir sözlük kullanarak Türleri ve bir temsilci arasında bir eşleme yaratmaktır:

var TypeMapping = new Dictionary<Type, Action<string>>(){ 
    {typeof(string), (x)=>Console.WriteLine("string")}, 
    {typeof(bool), (x)=>Console.WriteLine("bool")} 
}; 



string s = "my string"; 

TypeMapping[s.GetType()]("foo"); 
TypeMapping[true.GetType()]("true"); 

Answer 6

Geçenlerde benzer bir şey yapmak zorunda ve anahtarı kullanarak bir seçenek değildi. typeof (x) bir == yapmak iyi, ama daha zarif bir şekilde böyle bir şey yapmak için olabilir: Kullanabileceğin emin değilim

if(property.PropertyType is bool){ 
    //dostuff; 
} 
else if (property.PropertyType is string){ 
    //do other stuff; 
} 

Ama anahtar kelime içinde "dir" Bu şekilde, sadece nesneler için çalışır düşünüyorum ...

Answer 7

Bence burada aradığınız şey iyi bir Harita. Delegeleri ve Genel bir IDictionary kullanarak istediğinizi yapabilirsiniz.

böyle bir şey deneyin:

private delegate object MyDelegate(); 

private IDictionary<Type, MyDelegate> functionMap = new IDictionary<Type, MyDelegate>(); 

public Init() 
{ 
    functionMap.Add(typeof(String), someFunction); 
    functionMap.Add(tyepof(Boolean), someOtherFunction); 
} 

public T doStuff<T>(Type someType) 
{ 
    return (T)functionMap[someType](); 
} 

Answer 8

Ben şahsen Dictionary<Type, other> en yaklaşım tercih ... Hatta sana başka bir örnek sağlayabilir: Bir anahtar-durum yazma durumunda http://www.timvw.be/presenting-namevaluecollectionhelper/

ısrar Eğer Tip adını kullanabilirsiniz deyim ... stringmatching Hakkında

switch (blah.PropertyType.FullName) 
{ 
    case typeof(int).FullName: break; 
    case typeof(string).FullName: break; 
} 

Answer 9

: o inci bunu söz konusu Reqs biriydi kaba stringmatching.

Bu sözlük, tüm serileştirme algoritmasını kendi kütüphanesine yerleştirdiğimde kullanacağım bir yaklaşım. Şimdilik, ilk olarak, yalnızca temel tipler kullandığım için typeCode'u deneyeceğim. ben de bundan sürüsü geri döner çalışmazsa/birinin ise: S

Kendi seri istiyorum neden ppl ask me önce: 1) .net xml seri hale belirleyiciler olmadan özelliklerini serileştirmez 2) serileştirme bazı eski kurallara uymak zorundadır

Answer 10

C# 7.0, daha büyük desen eşleştirme özelliğinin bir parçası olarak türleri açmayı destekleyecektir. Bu örnek yeni özellikler açıkladı .NET blog post alınır:

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)); 
}