Passare PropertyType

Question

Come posso fare questo lavoro?

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

Non voglio usare il nome dal stringa di confronto per i tipi è solo awfull e possono essere soggette a modifiche.

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

È possibile utilizzare un approccio ibrido per TypeCode.Oggetto dove è dinamico se con typeof.Questo è molto veloce, perché per la prima parte - il cambio - il compilatore è in grado di decidere in base a una tabella di ricerca.

Answer 2

Non si può.Cosa si può fare è creare un mapping tra i Tipi e di un suo delegato, utilizzando un dizionario:

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 3

Penso che ciò che si cerca è una buona Mappa.L'utilizzo di delegati e di un Generico IDictionary puoi fare quello che vuoi.

Provare qualcosa di simile a questo:

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 4

Io personalmente preferisco il Dictionary<Type, other> approccio più...Posso fornire anche un altro esempio: http://www.timvw.be/presenting-namevaluecollectionhelper/

Nel caso In cui si insiste sulla scrittura di un interruttore di caso di dichiarazione si potrebbe utilizzare il nome del Tipo...

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

Answer 5

C# 7.0 supporta lo switch su tipi come una parte del più grande pattern matching.Questo esempio è tratto da .NET blog post che annuncia nuove funzionalità:

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

Answer 6

Non ti preoccupare di utilizzo di stringhe all'interno di un interruttore perché se si dispone di più il compilatore converte automaticamente in un hash di ricerca dando prestazioni decenti, nonostante un aspetto abbastanza pessima.

Il problema di stringhe di tipo di modifica può essere risolto facendo un esplicito hash ricerca di se stessi e della compilazione del constents di hash in un costruttore statico.Che modo l'hash è popolare con le stringhe corrette in fase di runtime in modo che rimangano corretto.

Answer 7

Non si può fare questo con l'interruttore in c#, come il caso deve essere costante.

Cosa c'è di sbagliato con:

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

Answer 8

Recentemente ho dovuto fare qualcosa di simile e l'utilizzo di switch non era un'opzione.Facendo un' == il typeof(x) va bene, ma un modo più elegante da fare potrebbe essere qualcosa di simile a questo:

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

Ma, io non sono certo che è possibile utilizzare la "è" parola chiave, in questo modo, penso che funziona solo per gli oggetti...

Answer 9

Circa il stringmatching:e ' stato uno dei reqs in questione per non farlo attraverso stringmatching.

Il dizionario è un approccio userò quando ho messo questo intero algoritmo di serializzazione nella propria libreria.Per ora voglio prima provare la typeCode come il mio caso utilizza solo i tipi di base.Se non funziona torno a sciame di se stesso :S

Prima di ppl mi chiede perché voglio che la mia serializzazione:1) .netto di serializzazione xml non serializzare proprietà senza setter 2) la serializzazione deve rispettare alcune regole legacy

Answer 10

Basta usare il normale if/else if/else modello:

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