C# ¿Es posible pasar un tipo a un método y hacer que el método devuelva un objeto de ese tipo?

Question

Esto parece que sería posible.

protected SameObjectTypeAsInputParameterObjectType GetAValue(someObject,TypeOrReturnObjectYouWant){ 

//check to see if someObject is null, if not, cast it and send the cast back 

} 

Answer 1

En el ejemplo dado es probable que esté mejor servido simplemente haciendo lo siguiente:

MyClass val = myObject as MyClass; 

Sin embargo, para responder a su pregunta, la respuesta es usar genéricos:

protected T GetAValue<T>(object someObject) 
{ 
    if (someObject is T) 
    { 
     return (T)someObject; 
    } 
    else 
    { 
     // We cannot return null as T may not be nullable 
     // see http://stackoverflow.com/questions/302096/how-can-i-return-null-from-a-generic-method-in-c 
     return default(T); 
    } 
} 

En este método T es un tipo parámetro. Puedes usar T en tu código exactamente de la misma manera que lo harías con cualquier otro tipo (por ejemplo, una cadena), pero ten en cuenta que en este caso no hemos puesto ninguna restricción en lo que T es, y por lo tanto solo los objetos de tipo T tienen las propiedades y métodos de la base object (GetType(), ToString() etc ...)

, obviamente, debemos declarar lo que T es antes de que podamos usarlo - por ejemplo:

MyClass val = GetAValue<MyClass>(myObject); 
string strVal = GetAValue<string>(someObject); 

para obtener más información tomar una mira el MSDN documentation on Generics

Answer 2

Parece que se haría mejor en línea.

Lo que puede hacer es algo como:

var requestedObject = someObject as TheTypeYouWant; 

Cuando se declara algo así como así, usted no conseguirá una excepción de referencia nula. A continuación, sólo puede hacer un simple

if(requestedObject != null){ 
    ... 
} 

Answer 3

Use genéricos:

T foobar<T>() where T : new() 
{ 
    return new T(); 
} 
void somefunc() 
{ 
    Guid g = foobar<Guid>(); 
} 

Answer 4

puede definir el método como este:

protected TReturnType GetAValue<TReturnType>(Object someObject) where TReturnType : class 
{ 
if(someObject is TReturnType) return (TReturnType) someObject; 
return null; 
} 

Alternativamente, si usted no puede garantizar que es un TReturnType tipo de referencia puede dejar fuera de la restricción genérica (TReturnType: clase) y devolver por defecto (TReturnType) en lugar de nulo - esto devolvería el tipo predeterminado de TReturnType que sería 0 para un int ...

Answer 5

Si conoce el tipo en tiempo de compilación (al escribir el código) puede usar genéricos.

Si solo conoce el tipo en tiempo de ejecución (mediante Tipo), puede utilizar la clase Activator.

Answer 6

Dicha conversión se puede hacer usando as

requestedObject as RequestedType 

envolver esta expresión en un método realmente no comprar nada a su

Answer 7

Creo que en realidad podrías estar buscando un Convert.Ch mecanismo angetype.

private static object ChangeTypeTo<T>(this object value) 
{ 
    if (value == null) 
     return null; 

    Type underlyingType = typeof (T); 
    if (underlyingType == null) 
     throw new ArgumentNullException("value"); 

    if (underlyingType.IsGenericType && 
      underlyingType.GetGenericTypeDefinition().Equals(typeof (Nullable<>))) 
    { 
     var converter = new NullableConverter(underlyingType); 
     underlyingType = converter.UnderlyingType; 
    } 

    // Guid convert 
    if (underlyingType == typeof (Guid)) 
    { 
     return new Guid(value.ToString()); 
    } 

    // Check for straight conversion or value.ToString conversion 
    var objType = value.GetType(); 

    // If this is false, lets hope value.ToString can convert otherwise exception 
    bool objTypeAssignable2typeT = underlyingType.IsAssignableFrom(objType); 

    // Do conversion 
    return objTypeAssignable2typeT ? Convert.ChangeType(value, underlyingType) 
      : Convert.ChangeType(value.ToString(), underlyingType); 
}