Generische Einschränkungen: Unterscheidung zwischen Werten und Referenzen
In C# können generische Einschränkungen verwendet werden, um bestimmte Anforderungen an Typparameter durchzusetzen. Dies ist besonders nützlich, wenn zwischen Werttypen, Nullable-Werttypen und Referenztypen unterschieden werden soll.
Einschränkungen für Werte und Nullable-Werttypen
Beachten Sie den folgenden Code, der unterscheidet zwischen einfachen Werttypen und nullbaren Werttypen:
static void Foo<T>(T a) where T : struct { } // Plain value type (e.g. int) static void Foo<T>(T? a) where T : struct { } // Nullable value type (e.g. int?)
Einschränkungen als Referenz Typen
Der Versuch, mithilfe von where T : class eine Einschränkung für Referenztypen zu definieren, führt jedoch zu einem Compilerfehler. Dies liegt daran, dass bei der Überlastungsauflösung Einschränkungen erzwungen werden und Parameter Vorrang vor Einschränkungen haben.
Um dieses Problem zu lösen, kann die Einschränkung in einen Parameter eingefügt werden, wenn auch auf weniger elegante Weise:
class RequireStruct<T> where T : struct { } class RequireClass<T> where T : class { } static void Foo<T>(T a, RequireStruct<T> ignore = null) where T : struct { } // Plain value type static void Foo<T>(T? a) where T : struct { } // Nullable value type static void Foo<T>(T a, RequireClass<T> ignore = null) where T : class { } // Reference type
Durch Platzieren der Einschränkung innerhalb des optionalen Parameters „ignore“ kann der Compiler zwischen den verschiedenen Fällen unterscheiden, ohne dass es zu Konflikten mit den Parametertypen kommt. Dies ermöglicht die beabsichtigte Zuordnung von Referenztypen zur richtigen Funktionsüberladung.
Das obige ist der detaillierte Inhalt vonWie können generische C#-Einschränkungen zwischen Werttypen, Nullable-Werttypen und Referenztypen unterscheiden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!