c# Changer de casse sur le type c #





2 Answers

Le code suivant fonctionne plus ou moins comme on s'attendrait à un commutateur de type qui ne regarde que le type réel (par exemple, ce qui est retourné par GetType() ).

public static void TestTypeSwitch()
{
    var ts = new TypeSwitch()
        .Case((int x) => Console.WriteLine("int"))
        .Case((bool x) => Console.WriteLine("bool"))
        .Case((string x) => Console.WriteLine("string"));

    ts.Switch(42);     
    ts.Switch(false);  
    ts.Switch("hello"); 
}

Voici la machinerie nécessaire pour le faire fonctionner.

public class TypeSwitch
{
    Dictionary<Type, Action<object>> matches = new Dictionary<Type, Action<object>>();
    public TypeSwitch Case<T>(Action<T> action) { matches.Add(typeof(T), (x) => action((T)x)); return this; } 
    public void Switch(object x) { matches[x.GetType()](x); }
}
c# .net optimization switch-statement

Dupliquer possible:
C # - Existe-t-il une meilleure alternative que celle de 'allumer le type'?

Bonjour supposons que je reçois un gros if / else sur le type de classe. c'est là un moyen de le faire avec un boîtier de commutateur?

Exemple :

function test(object obj)
{
if(obj is WebControl)
{

}else if(obj is TextBox)
{

}
else if(obj is ComboBox)
{

}

etc ...

Je voudrais créer quelque chose comme

switch(obj)
{
case is TextBox:
break;
case is ComboBox:
break;

}

}




Voici une option qui reste aussi vrai que je pourrais faire à l'exigence de l'OP de pouvoir activer le type. Si vous plissez assez fort, cela ressemble presque à une véritable déclaration de changement.

Le code appelant ressemble à ceci:

var @switch = this.Switch(new []
{
    this.Case<WebControl>(x => { /* WebControl code here */ }),
    this.Case<TextBox>(x => { /* TextBox code here */ }),
    this.Case<ComboBox>(x => { /* ComboBox code here */ }),
});

@switch(obj);

Le x dans chaque lambda ci-dessus est fortement typé. Aucun casting requis.

Et pour faire ce travail magique, vous avez besoin de ces deux méthodes:

private Action<object> Switch(params Func<object, Action>[] tests)
{
    return o =>
    {
        var @case = tests
            .Select(f => f(o))
            .FirstOrDefault(a => a != null);

        if (@case != null)
        {
            @case();
        }
    };
}

private Func<object, Action> Case<T>(Action<T> action)
{
    return o => o is T ? (Action)(() => action((T)o)) : (Action)null;
}

Presque apporte des larmes à vos yeux, non?

Néanmoins, cela fonctionne. Prendre plaisir.






Related