Gibt es eine bessere Alternative zum Einschalten des Typs?

Gibt es eine bessere Möglichkeit, das Einschalten eines anderen Typs zu simulieren, da C # switchfür einen Typ nicht möglich ist (was meiner Ansicht nach nicht als Sonderfall hinzugefügt wurde, da isBeziehungen bedeuten, dass casemöglicherweise mehr als ein eindeutiger Typ gilt)?

void Foo(object o)
{
    if (o is A)
    {
        ((A)o).Hop();
    }
    else if (o is B)
    {
        ((B)o).Skip();
    }
    else
    {
        throw new ArgumentException("Unexpected type: " + o.GetType());
    }
}

Das Einschalten von Typen fehlt in C # definitiv ( UPDATE: In C # 7 / VS 2017 wird das Einschalten von Typen unterstützt - siehe Zachary Yates 'Antwort unten ). Um dies ohne eine große if / else if / else-Anweisung zu tun, müssen Sie mit einer anderen Struktur arbeiten. Ich habe vor einiger Zeit einen Blog-Beitrag geschrieben, in dem beschrieben wird, wie eine TypeSwitch-Struktur erstellt wird.

https://docs.microsoft.com/archive/blogs/jaredpar/switching-on-types

Kurzversion: TypeSwitch wurde entwickelt, um redundantes Casting zu verhindern und eine Syntax anzugeben, die einer normalen switch / case-Anweisung ähnelt. Hier ist beispielsweise TypeSwitch in Aktion für ein Standard-Windows-Formularereignis

TypeSwitch.Do(
    sender,
    TypeSwitch.Case<Button>(() => textBox1.Text = "Hit a Button"),
    TypeSwitch.Case<CheckBox>(x => textBox1.Text = "Checkbox is " + x.Checked),
    TypeSwitch.Default(() => textBox1.Text = "Not sure what is hovered over"));

Der Code für TypeSwitch ist eigentlich ziemlich klein und kann einfach in Ihr Projekt eingefügt werden.

static class TypeSwitch {
    public class CaseInfo {
        public bool IsDefault { get; set; }
        public Type Target { get; set; }
        public Action<object> Action { get; set; }
    }

    public static void Do(object source, params CaseInfo[] cases) {
        var type = source.GetType();
        foreach (var entry in cases) {
            if (entry.IsDefault || entry.Target.IsAssignableFrom(type)) {
                entry.Action(source);
                break;
            }
        }
    }

    public static CaseInfo Case<T>(Action action) {
        return new CaseInfo() {
            Action = x => action(),
            Target = typeof(T)
        };
    }

    public static CaseInfo Case<T>(Action<T> action) {
        return new CaseInfo() {
            Action = (x) => action((T)x),
            Target = typeof(T)
        };
    }

    public static CaseInfo Default(Action action) {
        return new CaseInfo() {
            Action = x => action(),
            IsDefault = true
        };
    }
}

Mit C # 7 , das mit Visual Studio 2017 (Release 15. *) ausgeliefert wurde, können Sie Typen in caseAnweisungen verwenden (Mustervergleich):

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

Mit C # 6 können Sie eine switch-Anweisung mit dem Operator nameof () verwenden (danke @Joey Adams):

switch(o.GetType().Name) {
    case nameof(AType):
        break;
    case nameof(BType):
        break;
}

Mit C # 5 und früheren Versionen könnten Sie eine switch-Anweisung verwenden, aber Sie müssen eine magische Zeichenfolge verwenden, die den Typnamen enthält ... was nicht besonders refaktorfreundlich ist (danke @nukefusion).

switch(o.GetType().Name) {
  case "AType":
    break;
}

Eine Möglichkeit besteht darin, ein Wörterbuch von Typebis Action(oder einen anderen Delegaten) zu haben. Suchen Sie die Aktion anhand des Typs und führen Sie sie dann aus. Ich habe das schon früher für Fabriken benutzt.

Mit JaredPars Antwort im Hinterkopf schrieb ich eine Variante seiner TypeSwitchKlasse, die Typinferenz für eine schönere Syntax verwendet:

class A { string Name { get; } }
class B : A { string LongName { get; } }
class C : A { string FullName { get; } }
class X { public string ToString(IFormatProvider provider); }
class Y { public string GetIdentifier(); }

public string GetName(object value)
{
    string name = null;
    TypeSwitch.On(value)
        .Case((C x) => name = x.FullName)
        .Case((B x) => name = x.LongName)
        .Case((A x) => name = x.Name)
        .Case((X x) => name = x.ToString(CultureInfo.CurrentCulture))
        .Case((Y x) => name = x.GetIdentifier())
        .Default((x) => name = x.ToString());
    return name;
}

Beachten Sie, dass die Reihenfolge der Case()Methoden wichtig ist.

Holen Sie sich den vollständigen und kommentierten Code für meine TypeSwitchKlasse . Dies ist eine funktionierende Kurzversion:

public static class TypeSwitch
{
    public static Switch<TSource> On<TSource>(TSource value)
    {
        return new Switch<TSource>(value);
    }

    public sealed class Switch<TSource>
    {
        private readonly TSource value;
        private bool handled = false;

        internal Switch(TSource value)
        {
            this.value = value;
        }

        public Switch<TSource> Case<TTarget>(Action<TTarget> action)
            where TTarget : TSource
        {
            if (!this.handled && this.value is TTarget)
            {
                action((TTarget) this.value);
                this.handled = true;
            }
            return this;
        }

        public void Default(Action<TSource> action)
        {
            if (!this.handled)
                action(this.value);
        }
    }
}

Erstellen Sie eine Oberklasse (S) und lassen Sie A und B davon erben. Deklarieren Sie dann eine abstrakte Methode für S, die jede Unterklasse implementieren muss.

Wenn Sie dies tun, kann die "foo" -Methode auch ihre Signatur in Foo (S o) ändern, wodurch sie typsicher wird, und Sie müssen diese hässliche Ausnahme nicht auslösen.

Sie können den Mustervergleich in C # 7 oder höher verwenden:

switch (foo.GetType())
{
    case var type when type == typeof(Player):
        break;
    case var type when type == typeof(Address):
        break;
    case var type when type == typeof(Department):
        break;
    case var type when type == typeof(ContactType):
        break;
    default:
        break;
}

Sie sollten Ihre Methode wirklich überladen und nicht versuchen, die Begriffsklärung selbst vorzunehmen. Die meisten Antworten berücksichtigen bisher keine zukünftigen Unterklassen, was später zu wirklich schrecklichen Wartungsproblemen führen kann.

Wenn Sie C # 4 verwenden, können Sie die neue dynamische Funktionalität nutzen, um eine interessante Alternative zu erzielen. Ich sage nicht, dass dies besser ist, tatsächlich scheint es sehr wahrscheinlich, dass es langsamer sein würde, aber es hat eine gewisse Eleganz.

class Thing
{

  void Foo(A a)
  {
     a.Hop();
  }

  void Foo(B b)
  {
     b.Skip();
  }

}

Und die Verwendung:

object aOrB = Get_AOrB();
Thing t = GetThing();
((dynamic)t).Foo(aorB);

Der Grund dafür ist, dass bei einem dynamischen C # 4-Methodenaufruf die Überladungen zur Laufzeit und nicht zur Kompilierungszeit behoben werden. Ich habe vor kurzem etwas mehr über diese Idee geschrieben . Ich möchte noch einmal wiederholen, dass dies wahrscheinlich schlechter abschneidet als alle anderen Vorschläge. Ich biete es einfach als Kuriosität an.

Ja, dank C # 7 kann dies erreicht werden. So geht's (mit Ausdrucksmuster ):

switch (o)
{
    case A a:
        a.Hop();
        break;
    case B b:
        b.Skip();
        break;
    case C _: 
        return new ArgumentException("Type C will be supported in the next version");
    default:
        return new ArgumentException("Unexpected type: " + o.GetType());
}

Für integrierte Typen können Sie die TypeCode-Enumeration verwenden. Bitte beachten Sie, dass GetType () etwas langsam ist, aber in den meisten Situationen wahrscheinlich nicht relevant.

switch (Type.GetTypeCode(someObject.GetType()))
{
    case TypeCode.Boolean:
        break;
    case TypeCode.Byte:
        break;
    case TypeCode.Char:
        break;
}

Für benutzerdefinierte Typen können Sie eine eigene Aufzählung erstellen und entweder eine Schnittstelle oder eine Basisklasse mit abstrakter Eigenschaft oder Methode ...

Abstrakte Klassenimplementierung von Eigentum

public enum FooTypes { FooFighter, AbbreviatedFool, Fubar, Fugu };
public abstract class Foo
{
    public abstract FooTypes FooType { get; }
}
public class FooFighter : Foo
{
    public override FooTypes FooType { get { return FooTypes.FooFighter; } }
}

Abstrakte Klassenimplementierung der Methode

public enum FooTypes { FooFighter, AbbreviatedFool, Fubar, Fugu };
public abstract class Foo
{
    public abstract FooTypes GetFooType();
}
public class FooFighter : Foo
{
    public override FooTypes GetFooType() { return FooTypes.FooFighter; }
}

Schnittstellenimplementierung von Eigenschaften

public enum FooTypes { FooFighter, AbbreviatedFool, Fubar, Fugu };
public interface IFooType
{
    FooTypes FooType { get; }
}
public class FooFighter : IFooType
{
    public FooTypes FooType { get { return FooTypes.FooFighter; } }
}

Schnittstellenimplementierung der Methode

public enum FooTypes { FooFighter, AbbreviatedFool, Fubar, Fugu };
public interface IFooType
{
    FooTypes GetFooType();
}
public class FooFighter : IFooType
{
    public FooTypes GetFooType() { return FooTypes.FooFighter; }
}

Einer meiner Mitarbeiter hat mir auch gerade davon erzählt: Dies hat den Vorteil, dass Sie es für buchstäblich jede Art von Objekt verwenden können, nicht nur für diejenigen, die Sie definieren. Es hat den Nachteil, etwas größer und langsamer zu sein.

Definieren Sie zunächst eine statische Klasse wie folgt:

public static class TypeEnumerator
{
    public class TypeEnumeratorException : Exception
    {
        public Type unknownType { get; private set; }
        public TypeEnumeratorException(Type unknownType) : base()
        {
            this.unknownType = unknownType;
        }
    }
    public enum TypeEnumeratorTypes { _int, _string, _Foo, _TcpClient, };
    private static Dictionary<Type, TypeEnumeratorTypes> typeDict;
    static TypeEnumerator()
    {
        typeDict = new Dictionary<Type, TypeEnumeratorTypes>();
        typeDict[typeof(int)] = TypeEnumeratorTypes._int;
        typeDict[typeof(string)] = TypeEnumeratorTypes._string;
        typeDict[typeof(Foo)] = TypeEnumeratorTypes._Foo;
        typeDict[typeof(System.Net.Sockets.TcpClient)] = TypeEnumeratorTypes._TcpClient;
    }
    /// <summary>
    /// Throws NullReferenceException and TypeEnumeratorException</summary>
    /// <exception cref="System.NullReferenceException">NullReferenceException</exception>
    /// <exception cref="MyProject.TypeEnumerator.TypeEnumeratorException">TypeEnumeratorException</exception>
    public static TypeEnumeratorTypes EnumerateType(object theObject)
    {
        try
        {
            return typeDict[theObject.GetType()];
        }
        catch (KeyNotFoundException)
        {
            throw new TypeEnumeratorException(theObject.GetType());
        }
    }
}

Und dann können Sie es so verwenden:

switch (TypeEnumerator.EnumerateType(someObject))
{
    case TypeEnumerator.TypeEnumeratorTypes._int:
        break;
    case TypeEnumerator.TypeEnumeratorTypes._string:
        break;
}

Ich mochte Virtlinks Verwendung der impliziten Eingabe , um den Schalter besser lesbar zu machen, aber ich mochte nicht, dass ein Early-Out nicht möglich ist und dass wir Zuweisungen vornehmen. Lassen Sie uns den Perf ein wenig aufdrehen.

public static class TypeSwitch
{
    public static void On<TV, T1>(TV value, Action<T1> action1)
        where T1 : TV
    {
        if (value is T1) action1((T1)value);
    }

    public static void On<TV, T1, T2>(TV value, Action<T1> action1, Action<T2> action2)
        where T1 : TV where T2 : TV
    {
        if (value is T1) action1((T1)value);
        else if (value is T2) action2((T2)value);
    }

    public static void On<TV, T1, T2, T3>(TV value, Action<T1> action1, Action<T2> action2, Action<T3> action3)
        where T1 : TV where T2 : TV where T3 : TV
    {
        if (value is T1) action1((T1)value);
        else if (value is T2) action2((T2)value);
        else if (value is T3) action3((T3)value);
    }

    // ... etc.
}

Nun, das macht meine Finger weh. Lass es uns in T4 machen:

<#@ template debug="false" hostSpecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ import namespace="System.Linq" #> 
<#@ import namespace="System.IO" #> 
<#
    string GenWarning = "// THIS FILE IS GENERATED FROM " + Path.GetFileName(Host.TemplateFile) + " - ANY HAND EDITS WILL BE LOST!";
    const int MaxCases = 15;
#>
<#=GenWarning#>

using System;

public static class TypeSwitch
{
<# for(int icase = 1; icase <= MaxCases; ++icase) {
    var types = string.Join(", ", Enumerable.Range(1, icase).Select(i => "T" + i));
    var actions = string.Join(", ", Enumerable.Range(1, icase).Select(i => string.Format("Action<T{0}> action{0}", i)));
    var wheres = string.Join(" ", Enumerable.Range(1, icase).Select(i => string.Format("where T{0} : TV", i)));
#>
    <#=GenWarning#>

    public static void On<TV, <#=types#>>(TV value, <#=actions#>)
        <#=wheres#>
    {
        if (value is T1) action1((T1)value);
<# for(int i = 2; i <= icase; ++i) { #>
        else if (value is T<#=i#>) action<#=i#>((T<#=i#>)value);
<#}#>
    }

<#}#>
    <#=GenWarning#>
}

Das Beispiel von Virtlink ein wenig anpassen:

TypeSwitch.On(operand,
    (C x) => name = x.FullName,
    (B x) => name = x.LongName,
    (A x) => name = x.Name,
    (X x) => name = x.ToString(CultureInfo.CurrentCulture),
    (Y x) => name = x.GetIdentifier(),
    (object x) => name = x.ToString());

Lesbar und schnell. Nun, wie jeder in seinen Antworten immer wieder betont und die Art dieser Frage berücksichtigt, ist die Reihenfolge bei der Typübereinstimmung wichtig. Deshalb:

• Stellen Sie die Blatttypen zuerst und die Basistypen später.
• Stellen Sie bei Peer-Typen wahrscheinlichere Übereinstimmungen an die erste Stelle, um die Leistung zu maximieren.
• Dies bedeutet, dass kein spezieller Standardfall erforderlich ist. Verwenden Sie stattdessen einfach den Basistyp im Lambda und setzen Sie ihn zuletzt ein.

Angesichts der Tatsache, dass die Vererbung es ermöglicht, ein Objekt als mehr als einen Typ zu erkennen, kann ein Wechsel meiner Meinung nach zu einer schlechten Mehrdeutigkeit führen. Zum Beispiel:

Fall 1

{
  string s = "a";
  if (s is string) Print("Foo");
  else if (s is object) Print("Bar");
}

Fall 2

{
  string s = "a";
  if (s is object) Print("Foo");
  else if (s is string) Print("Bar");
}

Weil s eine Zeichenfolge und ein Objekt ist. Ich denke, wenn du ein schreibst switch(foo), erwartest du, dass foo zu einem und nur einem der passtcase Aussagen . Bei einem Einschalttyp kann die Reihenfolge, in der Sie Ihre case-Anweisungen schreiben, möglicherweise das Ergebnis der gesamten switch-Anweisung ändern. Ich denke das wäre falsch.

Sie können sich eine Compilerprüfung der Typen einer "typeswitch" -Anweisung vorstellen, bei der überprüft wird, ob die aufgezählten Typen nicht voneinander erben. Das gibt es aber nicht.

foo is Tist nicht dasselbe wie foo.GetType() == typeof(T)!!

Ich würde auch

• Verwenden Sie die Methodenüberladung (genau wie x0n ) oder
• Verwenden Sie Unterklassen (genau wie Pablo ) oder
• Wenden Sie das Besuchermuster an .

Eine andere Möglichkeit wäre, ein Schnittstellen-IThing zu definieren und es dann in beiden Klassen zu implementieren. Hier ist das Snipet:

public interface IThing
{
    void Move();
}

public class ThingA : IThing
{
    public void Move()
    {
        Hop();
    }

    public void Hop(){  
        //Implementation of Hop 
    }

}

public class ThingA : IThing
{
    public void Move()
    {
        Skip();
    }

    public void Skip(){ 
        //Implementation of Skip    
    }

}

public class Foo
{
    static void Main(String[] args)
    {

    }

    private void Foo(IThing a)
    {
        a.Move();
    }
}

Gemäß der C # 7.0-Spezifikation können Sie eine lokale Variable mit einem Gültigkeitsbereich casevon a deklarieren switch:

object a = "Hello world";
switch (a)
{
    case string myString:
        // The variable 'a' is a string!
        break;
    case int myInt:
        // The variable 'a' is an int!
        break;
    case Foo myFoo:
        // The variable 'a' is of type Foo!
        break;
}

Dies ist der beste Weg, um so etwas zu tun, da es sich nur um Casting- und Push-on-the-Stack-Operationen handelt. Dies sind die schnellsten Operationen, die ein Interpreter unmittelbar nach bitweisen Operationen und booleanBedingungen ausführen kann.

Vergleichen Sie dies mit a Dictionary<K, V> ist hier viel weniger Speicher belegt: Das Halten eines Wörterbuchs erfordert mehr Speicherplatz im RAM und einige Berechnungen mehr von der CPU, um zwei Arrays (eines für Schlüssel und das andere für Werte) zu erstellen und Hash-Codes für die zu platzierenden Schlüssel zu sammeln Werte zu ihren jeweiligen Schlüsseln.

Soweit ich weiß, glaube ich nicht, dass es einen schnelleren Weg geben könnte, wenn Sie nicht nur einen if- then- elseBlock mit dem isOperator wie folgt verwenden möchten :

object a = "Hello world";
if (a is string)
{
    // The variable 'a' is a string!
} else if (a is int)
{
    // The variable 'a' is an int!
} // etc.

Sie können überladene Methoden erstellen:

void Foo(A a) 
{ 
    a.Hop(); 
}

void Foo(B b) 
{ 
    b.Skip(); 
}

void Foo(object o) 
{ 
    throw new ArgumentException("Unexpected type: " + o.GetType()); 
}

Und wandeln Sie das Argument in dynamictype um, um die statische Typprüfung zu umgehen:

Foo((dynamic)something);

Sie suchen nach Discriminated Unionseiner Sprachfunktion von F #, aber Sie können einen ähnlichen Effekt erzielen, indem Sie eine von mir erstellte Bibliothek namens OneOf verwenden

https://github.com/mcintyre321/OneOf

Der Hauptvorteil gegenüber switch(und ifund exceptions as control flow) besteht darin, dass es zur Kompilierungszeit sicher ist - es gibt keinen Standardhandler oder Durchfall

void Foo(OneOf<A, B> o)
{
    o.Switch(
        a => a.Hop(),
        b => b.Skip()
    );
}

Wenn Sie ein drittes Element zu o hinzufügen, wird ein Compilerfehler angezeigt, da Sie im Switch-Aufruf einen Handler Func hinzufügen müssen.

Sie können auch a .Matchausführen, das einen Wert zurückgibt, anstatt eine Anweisung auszuführen:

double Area(OneOf<Square, Circle> o)
{
    return o.Match(
        square => square.Length * square.Length,
        circle => Math.PI * circle.Radius * circle.Radius
    );
}

Erstellen Sie eine Schnittstelle IFooableund lassen Sie Ihre Aund BKlassen eine gemeinsame Methode implementieren, die wiederum die entsprechende Methode aufruft, die Sie möchten:

interface IFooable
{
    public void Foo();
}

class A : IFooable
{
    //other methods ...

    public void Foo()
    {
        this.Hop();
    }
}

class B : IFooable
{
    //other methods ...

    public void Foo()
    {
        this.Skip();
    }
}

class ProcessingClass
{
    public void Foo(object o)
    {
        if (o == null)
            throw new NullRefferenceException("Null reference", "o");

        IFooable f = o as IFooable;
        if (f != null)
        {
            f.Foo();
        }
        else
        {
            throw new ArgumentException("Unexpected type: " + o.GetType());
        }
    }
}

Beachten Sie, dass es besser ist, aszuerst zu prüfen isund dann zu wirken, da Sie auf diese Weise 2 Würfe machen, was teurer ist.

In solchen Fällen erhalte ich normalerweise eine Liste mit Prädikaten und Aktionen. Etwas in diese Richtung:

class Mine {
    static List<Func<object, bool>> predicates;
    static List<Action<object>> actions;

    static Mine() {
        AddAction<A>(o => o.Hop());
        AddAction<B>(o => o.Skip());
    }

    static void AddAction<T>(Action<T> action) {
        predicates.Add(o => o is T);
        actions.Add(o => action((T)o);
    }

    static void RunAction(object o) {
        for (int i=0; o < predicates.Count; i++) {
            if (predicates[i](o)) {
                actions[i](o);
                break;
            }
        }
    }

    void Foo(object o) {
        RunAction(o);
    }
}

Nachdem ich die Optionen verglichen hatte, die hier einige Antworten auf F # -Funktionen gegeben hatten, stellte ich fest, dass F # eine bessere Unterstützung für typbasiertes Umschalten bietet (obwohl ich mich immer noch an C # halte).
Vielleicht möchten Sie hier und hier sehen .

C # 8-Verbesserungen des Mustervergleichs machten es möglich, dies so zu tun. In einigen Fällen erledigt es die Arbeit und prägnanter.

        public Animal Animal { get; set; }
        ...
        var animalName = Animal switch
        {
            Cat cat => "Tom",
            Mouse mouse => "Jerry",
            _ => "unknown"
        };

Ich würde eine Schnittstelle mit jedem Namen und Methodennamen erstellen, der für Ihren Switch sinnvoll wäre. Nennen wir sie jeweils: IDoabledas sagt, dass sie implementiert werden sollen void Do().

public interface IDoable
{
    void Do();
}

public class A : IDoable
{
    public void Hop() 
    {
        // ...
    }

    public void Do()
    {
        Hop();
    }
}

public class B : IDoable
{
    public void Skip() 
    {
        // ...
    }

    public void Do()
    {
        Skip();
    }
}

und ändern Sie die Methode wie folgt:

void Foo<T>(T obj)
    where T : IDoable
{
    // ...
    obj.Do();
    // ...
}

Zumindest sind Sie damit zur Kompilierungszeit sicher und ich vermute, dass es in Bezug auf die Leistung besser ist, als den Typ zur Laufzeit zu überprüfen.

Ich stimme Jon darin zu, dass es eine Reihe von Aktionen für den Klassennamen gibt. Wenn Sie Ihr Muster beibehalten, sollten Sie stattdessen das Konstrukt "as" verwenden:

A a = o as A;
if (a != null) {
    a.Hop();
    return;
}
B b = o as B;
if (b != null) {
    b.Skip();
    return;
}
throw new ArgumentException("...");

Der Unterschied besteht darin, dass wenn Sie das Muster verwenden, wenn (foo ist Bar) {((Bar) foo) .Action (); } Du machst das Typ Casting zweimal. Jetzt wird der Compiler vielleicht optimieren und diese Arbeit nur einmal ausführen - aber ich würde mich nicht darauf verlassen.

Wie Pablo vorschlägt, ist der Schnittstellenansatz fast immer das Richtige, um damit umzugehen. Um Switch wirklich nutzen zu können, besteht eine andere Alternative darin, eine benutzerdefinierte Aufzählung zu haben, die Ihren Typ in Ihren Klassen angibt.

enum ObjectType { A, B, Default }

interface IIdentifiable
{
    ObjectType Type { get; };
}
class A : IIdentifiable
{
    public ObjectType Type { get { return ObjectType.A; } }
}

class B : IIdentifiable
{
    public ObjectType Type { get { return ObjectType.B; } }
}

void Foo(IIdentifiable o)
{
    switch (o.Type)
    {
        case ObjectType.A:
        case ObjectType.B:
        //......
    }
}

Dies ist auch in BCL implementiert. Ein Beispiel ist MemberInfo.MemberTypes , ein anderes GetTypeCodefür primitive Typen wie:

void Foo(object o)
{
    switch (Type.GetTypeCode(o.GetType())) // for IConvertible, just o.GetTypeCode()
    {
        case TypeCode.Int16:
        case TypeCode.Int32:
        //etc ......
    }
}

Dies ist eine alternative Antwort, die Beiträge von JaredPar- und VirtLink-Antworten mit den folgenden Einschränkungen mischt:

• Die Schalterkonstruktion verhält sich wie eine Funktion und empfängt Funktionen als Parameter für Fälle.
• Stellt sicher, dass es ordnungsgemäß erstellt wurde und immer eine Standardfunktion vorhanden ist .
• Es wird nach dem ersten Match zurückgegeben (wahr für JaredPar-Antwort, nicht wahr für VirtLink).

Verwendungszweck:

 var result = 
   TSwitch<string>
     .On(val)
     .Case((string x) => "is a string")
     .Case((long x) => "is a long")
     .Default(_ => "what is it?");

Code:

public class TSwitch<TResult>
{
    class CaseInfo<T>
    {
        public Type Target { get; set; }
        public Func<object, T> Func { get; set; }
    }

    private object _source;
    private List<CaseInfo<TResult>> _cases;

    public static TSwitch<TResult> On(object source)
    {
        return new TSwitch<TResult> { 
            _source = source,
            _cases = new List<CaseInfo<TResult>>()
        };
    }

    public TResult Default(Func<object, TResult> defaultFunc)
    {
        var srcType = _source.GetType();
       foreach (var entry in _cases)
            if (entry.Target.IsAssignableFrom(srcType))
                return entry.Func(_source);

        return defaultFunc(_source);
    }

    public TSwitch<TResult> Case<TSource>(Func<TSource, TResult> func)
    {
        _cases.Add(new CaseInfo<TResult>
        {
            Func = x => func((TSource)x),
            Target = typeof(TSource)
        });
        return this;
    }
}

Ja - verwenden Sie einfach den etwas seltsam benannten "Pattern Matching" ab C # 7, um eine Übereinstimmung mit Klasse oder Struktur zu erzielen:

IObject concrete1 = new ObjectImplementation1();
IObject concrete2 = new ObjectImplementation2();

switch (concrete1)
{
    case ObjectImplementation1 c1: return "type 1";         
    case ObjectImplementation2 c2: return "type 2";         
}

ich benutze

    public T Store<T>()
    {
        Type t = typeof(T);

        if (t == typeof(CategoryDataStore))
            return (T)DependencyService.Get<IDataStore<ItemCategory>>();
        else
            return default(T);
    }

Sollte mit funktionieren

Fallart _:

mögen:

int i = 1;
bool b = true;
double d = 1.1;
object o = i; // whatever you want

switch (o)
{
    case int _:
        Answer.Content = "You got the int";
        break;
    case double _:
        Answer.Content = "You got the double";
        break;
    case bool _:
        Answer.Content = "You got the bool";
        break;
}

Wenn Sie die Klasse kennen, die Sie erwarten, aber noch kein Objekt haben, können Sie dies sogar tun:

private string GetAcceptButtonText<T>() where T : BaseClass, new()
{
    switch (new T())
    {
        case BaseClassReview _: return "Review";
        case BaseClassValidate _: return "Validate";
        case BaseClassAcknowledge _: return "Acknowledge";
        default: return "Accept";
    }
}

Ab C # 8 können Sie den neuen Schalter noch präziser gestalten. Und mit der Discard-Option _ können Sie vermeiden, dass unnötige Variablen erstellt werden, wenn Sie diese nicht benötigen:

        return document switch {
            Invoice _ => "Is Invoice",
            ShippingList _ => "Is Shipping List",
            _ => "Unknown"
        };

Rechnung und Versandliste sind Klassen und Dokument ist ein Objekt, das eine von beiden sein kann.