¿Cómo convertir un TypeCode a un tipo real?

Question

En el siguiente código obtengo colType que es un número de código para el tipo. ¿Pero cómo convertiría ese número en el tipo real? ¡¡Gracias!!

for (int j = 0; j < dvColumns.Count; j++) 
{ 
    // Get the name of the column. 
    drvCols = dvColumns[j]; 
    colName = drvCols.Row.ItemArray[3].ToString(); 

    // Get columns data type code and save it off. 
    colType = Convert.ToInt32(drvCols.Row.ItemArray[11]); 
} 

Answer 1

no creo que hay alguna manera de hacer esto de forma nativa en el .NET Framework, como todos los ejemplos que he visto utilizar una sentencia switch grande como para manejar la conversión (por ejemplo: here).

Sin embargo, si intenta obtener el tipo como un paso intermedio hacia la conversión de un objeto a ese tipo, siempre puede usar Convert.ChangeType que acepta un TypeCode como parámetro.

double d = -1.234; 
int i = (int)Convert.ChangeType(d, TypeCode.Int32); 

Desafortunadamente, sin ver lo que está tratando de hacer que realmente no puedo decir si ChangeType sería útil o no.

EDIT:

para convertir un int a un OleDbType, que sólo puede echarlo:

int i = 72; //72 is the value for OleDbType.Guid 
if(Enum.IsDefined(typeof(System.Data.OleDb.OleDbType), i)) 
{ 
    System.Data.OleDb.OleDbType dbType = (System.Data.OleDb.OleDbType)i; 
    Console.WriteLine(dbType); 
} 
else 
    Console.WriteLine("{0} is not defined for System.Data.OleDb.OleDbType", i); 

Answer 2

Utilización de una sentencia switch:

public static Type ToType(this TypeCode code) 
    { 
     switch (code) 
     { 
      case TypeCode.Boolean: 
       return typeof(bool); 

      case TypeCode.Byte: 
       return typeof(byte); 

      case TypeCode.Char: 
       return typeof(char); 

      case TypeCode.DateTime: 
       return typeof(DateTime); 

      case TypeCode.DBNull: 
       return typeof(DBNull); 

      case TypeCode.Decimal: 
       return typeof(decimal); 

      case TypeCode.Double: 
       return typeof(double); 

      case TypeCode.Empty: 
       return null; 

      case TypeCode.Int16: 
       return typeof(short); 

      case TypeCode.Int32: 
       return typeof(int); 

      case TypeCode.Int64: 
       return typeof(long); 

      case TypeCode.Object: 
       return typeof(object); 

      case TypeCode.SByte: 
       return typeof(sbyte); 

      case TypeCode.Single: 
       return typeof(Single); 

      case TypeCode.String: 
       return typeof(string); 

      case TypeCode.UInt16: 
       return typeof(UInt16); 

      case TypeCode.UInt32: 
       return typeof(UInt32); 

      case TypeCode.UInt64: 
       return typeof(UInt64); 
     } 

     return null; 
    } 

Answer 3

Es aún más simple:

Type type = Type.GetType("System." + colType); 

Si desea convertir un valor a ese tipo puede utilizar el código descriptivo directamente

Convert.ChangeType(value, colType); 

Answer 4

La respuesta exacta a la pregunta en el PO (usando pista de schoetbi) sería:

public static Type GetType(TypeCode code) 
    {   
     return Type.GetType("System." + Enum.GetName(typeof(TypeCode), code)); 
    } 

Answer 5

Así es como me gusta hacerlo. Prefiero usar una tabla estática frente a un gran interruptor o reflejo para esto.

/// <summary> 
/// Table that maps TypeCode to it's corresponding Type. 
/// </summary> 
static IReadOnlyDictionary<TypeCode, Type> TypeCodeToTypeMap = new Dictionary<TypeCode, Type> 
{ 
    { TypeCode.Boolean, typeof(bool) }, 
    { TypeCode.Byte, typeof(byte) }, 
    { TypeCode.Char, typeof(char) }, 
    { TypeCode.DateTime, typeof(DateTime) }, 
    { TypeCode.DBNull, typeof(DBNull) }, 
    { TypeCode.Decimal, typeof(decimal) }, 
    { TypeCode.Double, typeof(double) }, 
    { TypeCode.Empty, null }, 
    { TypeCode.Int16, typeof(short) }, 
    { TypeCode.Int32, typeof(int) }, 
    { TypeCode.Int64, typeof(long) }, 
    { TypeCode.Object, typeof(object) }, 
    { TypeCode.SByte, typeof(sbyte) }, 
    { TypeCode.Single, typeof(Single) }, 
    { TypeCode.String, typeof(string) }, 
    { TypeCode.UInt16, typeof(UInt16) }, 
    { TypeCode.UInt32, typeof(UInt32) }, 
    { TypeCode.UInt64, typeof(UInt64) } 
}; 

/// <summary> 
/// Convert a TypeCode ordinal into it's corresponding Type instance. 
/// </summary> 
public static Type ToType(this TypeCode code) 
{ 
    Type type = null; 

    TypeCodeToTypeMap.TryGetValue(code, out type); 

    return type; 
}