Existe alguna forma de aplicar / limitar los tipos que se pasan a las primitivas? (bool, int, string, etc.)

Ahora, sé que puede limitar el parámetro de tipo genérico a una implementación de tipo o interfaz a través dedónd cláusula Sin embargo, esto no se ajusta a la factura de los primitivos (AFAIK) porque no todos tienen un terreno común (aparte deobjet antes de que alguien diga! :PAG)

ntonces, mis pensamientos actuales son apretar los dientes y hacer una grancambia declaración y lanzar un ArgumentException en caso de fracaso ..

EDIT 1:

Solo para aclarar

La definición del código debería ser como:

public class MyClass<GenericType> ....

Y instanciación:

MyClass<bool> = new MyClass<bool>(); // Legal
MyClass<string> = new MyClass<string>(); // Legal
MyClass<DataSet> = new MyClass<DataSet>(); // Illegal
MyClass<RobsFunkyHat> = new MyClass<RobsFunkyHat>(); // Illegal (but looks awesome!)

EDIT 2

@ Jon Limjap - Buen punto, y algo que ya estaba considerando ... Estoy seguro de que hay un método genérico que se puede usar para determinar si el tipo es de valor o tipo de referencia ...

Esto podría ser útil para eliminar instantáneamente muchos de los objetos con los que no quiero tratar (pero luego debe preocuparse por las estructuras que se utilizan, comoTall) .. Interesante problema no? :)

Aquí está

where T : struct

Tomado de MSDN.

Tengo curiosidad ... ¿Podría hacerse esto en .NET 3.x usando métodos de extensión? Cree una interfaz e implemente la interfaz en los métodos de extensión (que probablemente sería más limpio que un interruptor un poco gordo). Además, si luego necesita extenderlo a cualquier tipo personalizado liviano, también pueden implementar la misma interfaz, sin que sea necesario realizar cambios en el código base.

¿Qué piensan ustedes

Sad news es que estoy trabajando en Framework 2 !! :R

EDIT 3

Esto fue tan simple siguiendo aJon Limjaps Pointer .. ¡Tan simple que casi quiero llorar, pero es genial porque el código funciona de maravilla!

Así que esto es lo que hice (¡te reirás!):

Code agregado a la clase genérica

bool TypeValid()
{
    // Get the TypeCode from the Primitive Type
    TypeCode code = Type.GetTypeCode(typeof(PrimitiveDataType));

    // All of the TypeCode Enumeration refer Primitive Types
    // with the exception of Object and Empty (Null).
    // Since I am willing to allow Null Types (at this time)
    // all we need to check for is Object!
    switch (code)
    {
        case TypeCode.Object:
            return false;
        default:
            return true;
    }
}

Entonces, un pequeño método de utilidad para verificar el tipo y lanzar una excepción,

private void EnforcePrimitiveType()
{
    if (!TypeValid())
        throw new InvalidOperationException(
            "Unable to Instantiate SimpleMetadata based on the Generic Type of '" + typeof(PrimitiveDataType).Name + 
            "' - this Class is Designed to Work with Primitive Data Types Only.");
}

Todo lo que hay que hacer es llamar aEnforcePrimitiveType () en los constructores de clases. ¡Trabajo hecho! : -)

El único inconveniente, solo arroja una excepción en el tiempo de ejecución (obviamente) en lugar del tiempo de diseño ... Pero eso no es gran cosa y podría recogerse con utilidades como FxCop (que no usamos en el trabajo).

Gracias especiales a Jon Limjap por este!