Switch over PropertyType

Question

Como posso fazer este trabalho?

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

Eu não quero usar o nome desde seqüência de comparação para tipos é apenas awfull e pode ser sujeita a alterações.

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

Você pode usar uma abordagem híbrida para TypeCode.Object onde dinâmico se com typeof. Isto é muito rápido, porque para a primeira parte - o interruptor -. O compilador pode decidir com base em uma tabela de pesquisa

Answer 2

Você não pode. O que você pode fazer é criar um mapeamento entre tipos e um delegado usando um dicionário:

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

Eu acho que o que você está procurando aqui é um bom mapa. Usando delegados e um IDictionary genérico você pode fazer o que quiser.

Tente algo parecido com isto:

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

Eu pessoalmente prefiro a abordagem Dictionary<Type, other> o mais ... I pode ainda fornecer-lhe outro exemplo: http : //www.timvw.be/presenting-namevaluecollectionhelper/

No caso de você insistir em escrever uma declaração switch-caso, você poderia usar o nome Tipo ...

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

Answer 5

C # 7.0 apoiará chave em tipos como parte do maior recurso de correspondência de padrões. Este exemplo é retirado .NET blogue post que anuncia novos recursos:

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

Não se preocupe sobre o uso de cordas dentro de um interruptor, porque se você tem vários o compilador irá convertê-lo automaticamente em uma pesquisa de hash dando um desempenho decente apesar olhando muito horrível.

O problema de cordas tipo em mudança pode ser resolvido fazendo-lo em uma pesquisa de hash explícita-se e preencher os constents do hash em um construtor estático. Dessa forma, o hash é preenchido com as cordas corretas em tempo de execução para que eles permaneçam correta.

Answer 7

Você não pode fazer isso com interruptor no c #, como o caso tem que ser constante.

O que é errado com:

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

Answer 8

Recentemente, tive de fazer algo semelhante e utilizando a chave não era uma opção. Fazendo uma == na typeof (x) é bom, mas uma maneira mais elegante poderia ser a de fazer algo parecido com isto:

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

Mas, eu não estou certo de que você pode usar o "é" palavra-chave desta forma, eu acho que só funciona para objetos ...

Answer 9

Sobre o stringmatching: era um dos reqs em questão para não fazê-lo através stringmatching

.

O dicionário é uma abordagem que vai usar quando eu colocar esse algoritmo serialização inteiro em sua própria biblioteca. Como por agora vou primeiro tentar o typecode como meu caso só usa tipos básicos. Se isso não funcionar, eu vou voltar para o enxame de if / elses: S

Antes de ppl me perguntam por que eu quero o meu próprio serialização: 1) Líquido xml serialização faz não propriedades serializar sem formadores 2) serialização tem de obedecer a algumas regras de legado

Answer 10

Basta usar o normal se / else if / else padrão:

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