Verificarea tipului general

Primitivele par să fie specificate în TypeCode enumerare:

Poate că există o modalitate de a afla dacă un obiect conține codul TypeCode enum fără a fi nevoie să îl deplasați la un anumit obiect sau să apelați GetType() sau typeof() ?

Update It was right under my nose. The code sample there shows this:

static void WriteObjectInfo(object testObject)
{
    TypeCode    typeCode = Type.GetTypeCode( testObject.GetType() );

    switch( typeCode )
    {
        case TypeCode.Boolean:
            Console.WriteLine("Boolean: {0}", testObject);
            break;

        case TypeCode.Double:
            Console.WriteLine("Double: {0}", testObject);
            break;

        default:
            Console.WriteLine("{0}: {1}", typeCode.ToString(), testObject);
            break;
        }
    }
}

E încă un comutator urât. Dar este un loc bun pentru a începe!

Destul de mult ce a spus @Lars:

//Force T to be a value (primitive) type.
public class Class1 where T: struct

//Force T to be a reference type.
public class Class1 where T: class

//Force T to be a parameterless constructor.
public class Class1 where T: new()

Toate lucrările în .NET 2, 3 și 3.5.

public class Class1 where GenericType : struct
{
}

Aceasta părea să facă treaba.

Dacă puteți tolera utilizarea metodelor din fabrică (în locul constructorilor MyClass pe care i-ați cerut), puteți face întotdeauna ceva de genul:

class MyClass
{
  private readonly T _value;

  private MyClass(T value) { _value = value; }

  public static MyClass FromInt32(int value) { return new MyClass(value); }
  public static MyClass FromString(string value) { return new MyClass(value); }
 //etc for all the primitive types, or whatever other fixed set of types you are concerned about
}

A problem here is that you would need to type MyClass.FromInt32, which is annoying. There isn't a very good way around this if you want to maintain the private-ness of the constructor, but here are a couple of workarounds:

• Create an abstract class MyClass. Make MyClass inherit from MyClass and nest it within MyClass. Move the static methods to MyClass. This will all the visibility work out, at the cost of having to access MyClass as MyClass.MyClass.
• Use MyClass as given. Make a static class MyClass which calls the static methods in MyClass using MyClass (probably using the appropriate type each time, just for giggles).
• (Easier, but certainly weird) Make an abstract type MyClass which inherits from MyClass. (For concreteness, let's say MyClass.) Because you can call static methods defined in a base class through the name of a derived class, you can now use MyClass.FromString.

Acest lucru vă oferă o verificare statică în detrimentul mai multor scrisori.

Dacă sunteți mulțumit de verificarea dinamică, aș folosi câteva variante ale soluției TypeCode de mai sus.

Puteți simplifica metoda EnforcePrimitiveType utilizând typeof (PrimitiveDataType) .IsPrimitive . Am pierdut ceva?

Use a custom FxCop rule that flags undesirable usage of MyClass<>.

@Rob, Enum va aluneca prin funcția TypeValid , deoarece TypeCode este Integer . Am actualizat funcția de verificat și pentru Enum .

Private Function TypeValid() As Boolean
    Dim g As Type = GetType(T)
    Dim code As TypeCode = Type.GetTypeCode(g)

    ' All of the TypeCode Enumeration refer Primitive Types
    ' with the exception of Object and Empty (Nothing).
    ' Note: must also catch Enum as its type is Integer.
    Select Case code
        Case TypeCode.Object
            Return False
        Case Else
            ' Enum's TypeCode is Integer, so check BaseType
            If g.BaseType Is GetType(System.Enum) Then
                Return False
            Else
                Return True
            End If
    End Select
End Function

Având o provocare similară, mă întrebam cum v-ați simțit despre Interfața IConvertible . Aceasta permite ceea ce solicită solicitantul și vă puteți extinde cu propriile implementări.

Exemplu:

    public class MyClass
    where TKey : IConvertible
{
   //class intentionally abbreviated
}

Mă gândesc la asta ca la o soluție, cu toate că multe dintre cele sugerate făceau parte și din selecția mea.

Preocuparea mea este - cu toate acestea - este înșelătoare pentru dezvoltatorii potențiali care folosesc clasa ta?

Noroc - și mulțumiri.