Wie kann ich dem Compiler mitteilen, dass meine Generics definitiv "|=" oder Casting zu int zulassen werden?

Question

Ich bin neu in Generika in C#, und ich versuche, eine Methode zu erstellen, die Generika verwenden wird. Ich stolperte über das where-Schlüsselwort, als ich versuchte, eine lokale Variable zu erstellen, also bin ich sicher, dass es Teil der Lösung sein wird.

Der Grund dafür ist, ich habe mehrere verschiedene Enum-Variablen, aber die Methode würde das gleiche zu jeder tun (eine Zeichenfolge, die eine der Enum definierten Werte ist, schalten Sie es auf, mit der Enum wie ein Bit-Feld).

Ich habe die meisten dieser zusammen, der Teil, den ich jetzt an ist in der Lage, die generische Methode zu sagen, es ist ok, um "|=" zu ermöglichen, wie ich sicher bin, dass jeder Typ übergeben in den Operator unterstützen wird.

Ich möchte die Allgemeingültigkeit möglichst beibehalten, also entweder eine Aufzählung oder eine Liste, und ich würde je nach Typ unterschiedliche Codepfade ausführen.

Ein Beispiel für das, was ich meine, ist

enum someType { value1 = 1<<0, value2 = 1<<1, value3 = 1<<2 }; // and so on
// some more enums

private T someMethod<T>(string myIdentifyers) 
    where T: new()
{
    // suppose myIdentifiers is 1 more more of the valid enum options
    // assume that the correct strings and enum combinations will be passed
    T retval = new T();

    while () {
    // assume a loop with a method call that parses off one identifyer at a time
        // if I have to convert the enum to an int first, so be it, but
        // at this point I can't tell it that a cast to int exists
        retval |= (T)System.Enum.Parse( typeof(T), oneIdentifyer, false );
    }

    return retval;
}

Answer 1

Ich würde etwas in der Art versuchen (Pseudocode):

[Flags]
enum someType { value1 = 1<<0, value2 = 1<<1, value3 = 1<<2 }; // and so on
// some more enums

private T someMethod<T>(string myIdentifyers) 
    where T: struct, new()
{
           // check if enum
    if (typeof(T).BaseType != typeof(Enum)) // we should probably check for the flags attribute too
            throw new Exception();

    // suppose myIdentifiers is 1 more more of the valid enum options
    // assume that the correct strings and enum combinations will be passed
    int retval = 0;

    while () {
    // assume a loop with a method call that parses off one identifyer at a time
        // if I have to convert the enum to an int first, so be it, but
        // at this point I can't tell it that a cast to int exists
        retval |= (int) (object) System.Enum.Parse( typeof(T), oneIdentifyer, false );
    }

    return (T) (object) retval;
}

Answer 2

Im Allgemeinen gibt es keine gute Möglichkeit, Operatoren auf einem generischen Typ aufzurufen, obwohl es einige Tricks und Umgehungen gibt, die unter bestimmten Umständen helfen können.

Siehe diese ähnliche Frage: Generischer C#-Code und der Plus-Operator

In diesem Fall, da Sie wissen, dass Ihre Enums zu und von int casten, ich denke, Brunos Methode ist der Weg zu gehen.

Answer 3

Es ist nicht möglich, zu formulieren enum generische Beschränkungen ab C# 4. Auch ist es nicht möglich, Operator-Beschränkungen auszudrücken.

Dennoch denke ich, dass Sie nach einer Methode wie dieser suchen:

public static T AssembleFlagsEnum<T>(IEnumerable<string> names) where T : struct
{
    return (T)(object)names.Aggregate(0, 
       (valSoFar, name) => valSoFar | Convert.ToInt32(Enum.Parse(typeof(T), name)));
}

Beachten Sie, dass dadurch nicht bestätigt wird, dass der Typ ein [Flags] enum. Es funktioniert auch nicht bei Enums, die andere Basis-Typen als int .

Answer 4

Leider ist das nicht möglich.

Sie können mit der Option Struktur Einschränkung zu sagen, Werttyp, aber offensichtlich, dass mehr als Ganzzahlen umfasst. Das Einzige, was Sie dann tun könnten, ist, zu Beginn des Codes den tatsächlichen Typ zu überprüfen.

Die unterstützten Einschränkungen sind beschrieben unter http://msdn.microsoft.com/en-us/library/d5x73970.aspx

Sie können keine Operator-Einschränkungen vornehmen - siehe Lösung für überladene Operator-Beschränkung in .NET Generika