Transmitindo uma variável usando uma variável Type

Em C #, posso converter uma variável do tipo objeto em uma variável do tipo T, onde T é definido na variável Type?

Aqui está um exemplo de elenco e de conversão:

using System;

public T CastObject<T>(object input) {   
    return (T) input;   
}

public T ConvertObject<T>(object input) {
    return (T) Convert.ChangeType(input, typeof(T));
}

Editar:

Algumas pessoas nos comentários dizem que esta resposta não responde à pergunta. Mas a linha (T) Convert.ChangeType(input, typeof(T))fornece a solução. O Convert.ChangeTypemétodo tenta converter qualquer objeto no tipo fornecido como o segundo argumento.

Por exemplo:

Type intType = typeof(Int32);
object value1 = 1000.1;

// Variable value2 is now an int with a value of 1000, the compiler 
// knows the exact type, it is safe to use and you will have autocomplete
int value2 = Convert.ChangeType(value1, intType);

// Variable value3 is now an int with a value of 1000, the compiler
// doesn't know the exact type so it will allow you to call any
// property or method on it, but will crash if it doesn't exist
dynamic value3 = Convert.ChangeType(value1, intType);

Eu escrevi a resposta com os genéricos, porque eu acho que é muito provável sinal de cheiro de código quando você quer elenco a somethingpara a something elsesem lidar com um tipo real. Com interfaces adequadas que não devem ser necessárias 99,9% das vezes. Talvez existam alguns casos extremos quando se trata de reflexão que possa fazer sentido, mas eu recomendaria evitar esses casos.

Edição 2:

Algumas dicas extras:

• Tente manter seu código o mais seguro possível. Se o compilador não souber o tipo, não será possível verificar se seu código está correto e itens como o preenchimento automático não funcionarão. Simplesmente disse: se você não pode prever o (s) tipo (s) em tempo de compilação, como o compilador seria capaz ?
• Se as classes com as quais você está trabalhando implementarem uma interface comum , você poderá converter o valor nessa interface. Caso contrário, considere criar sua própria interface e faça com que as classes implementem essa interface.
• Se você estiver trabalhando com bibliotecas externas que está importando dinamicamente, verifique também se há uma interface comum. Caso contrário, considere criar pequenas classes de wrapper que implementam a interface.
• Se você deseja fazer chamadas para o objeto, mas não se importa com o tipo, armazene o valor em uma objectou dynamicvariável.
• Os genéricos podem ser uma ótima maneira de criar código reutilizável que se aplica a vários tipos diferentes, sem precisar saber os tipos exatos envolvidos.
• Se você estiver preso, considere uma abordagem diferente ou um refator de código. Seu código realmente precisa ser dinâmico? Tem que dar conta de qualquer tipo que exista?

Outras respostas não mencionam o tipo "dinâmico". Portanto, para adicionar mais uma resposta, você pode usar o tipo "dinâmico" para armazenar o objeto resultante sem precisar converter o objeto convertido com um tipo estático.

dynamic changedObj = Convert.ChangeType(obj, typeVar);
changedObj.Method();

Lembre-se de que, com o uso de "dinâmico", o compilador está ignorando a verificação de tipo estático, que pode introduzir possíveis erros de tempo de execução se você não tomar cuidado.

Aqui está o meu método para converter um objeto, mas não para uma variável de tipo genérico, e sim para uma System.Typedinâmica:

Crio uma expressão lambda em tempo de execução usando System.Linq.Expressions, do tipo Func<object, object>, que desmarca sua entrada, executa a conversão de tipo desejada e, em seguida, fornece o resultado em caixa. Um novo é necessário não apenas para todos os tipos que são convertidos, mas também para os tipos que são convertidos (devido à etapa de remoção da caixa de seleção). Criar essas expressões consome muito tempo, devido à reflexão, à compilação e à construção dinâmica de métodos que são feitas sob o capô. Felizmente, uma vez criadas, as expressões podem ser invocadas repetidamente e sem sobrecarga, então eu cache cada uma.

private static Func<object, object> MakeCastDelegate(Type from, Type to)
{
    var p = Expression.Parameter(typeof(object)); //do not inline
    return Expression.Lambda<Func<object, object>>(
        Expression.Convert(Expression.ConvertChecked(Expression.Convert(p, from), to), typeof(object)),
        p).Compile();
}

private static readonly Dictionary<Tuple<Type, Type>, Func<object, object>> CastCache
= new Dictionary<Tuple<Type, Type>, Func<object, object>>();

public static Func<object, object> GetCastDelegate(Type from, Type to)
{
    lock (CastCache)
    {
        var key = new Tuple<Type, Type>(from, to);
        Func<object, object> cast_delegate;
        if (!CastCache.TryGetValue(key, out cast_delegate))
        {
            cast_delegate = MakeCastDelegate(from, to);
            CastCache.Add(key, cast_delegate);
        }
        return cast_delegate;
    }
}

public static object Cast(Type t, object o)
{
    return GetCastDelegate(o.GetType(), t).Invoke(o);
}

Note que isso não é mágico. A transmissão não ocorre no código, como ocorre com a dynamicpalavra - chave, apenas os dados subjacentes do objeto são convertidos. No momento da compilação, ainda temos que descobrir com precisão qual o tipo de nosso objeto, tornando essa solução impraticável. Eu escrevi isso como um hack para chamar operadores de conversão definidos por tipos arbitrários, mas talvez alguém por aí possa encontrar um melhor caso de uso.

Pondo de lado o boxe e o unboxing para simplificar, não há nenhuma ação específica de tempo de execução envolvida na transmissão ao longo da hierarquia de herança. É principalmente uma coisa de tempo de compilação. Essencialmente, uma conversão diz ao compilador para tratar o valor da variável como outro tipo.

O que você poderia fazer depois do elenco? Você não conhece o tipo, portanto não poderá chamar nenhum método. Não haveria nada de especial que você pudesse fazer. Especificamente, ele pode ser útil apenas se você conhecer os tipos possíveis em tempo de compilação, convertê-lo manualmente e manipular cada caso separadamente com ifinstruções:

if (type == typeof(int)) {
    int x = (int)obj;
    DoSomethingWithInt(x);
} else if (type == typeof(string)) {
    string s = (string)obj;
    DoSomethingWithString(s);
} // ...

Como você pode fazer aquilo? Você precisa de uma variável ou campo do tipo T em que possa armazenar o objeto após a conversão, mas como pode ter essa variável ou campo se conhecer T somente em tempo de execução? Então, não, não é possível.

Type type = GetSomeType();
Object @object = GetSomeObject();

??? xyz = @object.CastTo(type); // How would you declare the variable?

xyz.??? // What methods, properties, or fields are valid here?

Quando se trata de transmitir para o tipo Enum:

private static Enum GetEnum(Type type, int value)
    {
        if (type.IsEnum)
            if (Enum.IsDefined(type, value))
            {
                return (Enum)Enum.ToObject(type, value);
            }

        return null;
    }

E você vai chamar assim:

var enumValue = GetEnum(typeof(YourEnum), foo);

Isso foi essencial para mim no caso de obter o valor do atributo Description de vários tipos de enumeração pelo valor int:

public enum YourEnum
{
    [Description("Desc1")]
    Val1,
    [Description("Desc2")]
    Val2,
    Val3,
}

public static string GetDescriptionFromEnum(Enum value, bool inherit)
    {
        Type type = value.GetType();

        System.Reflection.MemberInfo[] memInfo = type.GetMember(value.ToString());

        if (memInfo.Length > 0)
        {
            object[] attrs = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), inherit);
            if (attrs.Length > 0)
                return ((DescriptionAttribute)attrs[0]).Description;
        }

        return value.ToString();
    }

e depois:

string description = GetDescriptionFromEnum(GetEnum(typeof(YourEnum), foo));
string description2 = GetDescriptionFromEnum(GetEnum(typeof(YourEnum2), foo2));
string description3 = GetDescriptionFromEnum(GetEnum(typeof(YourEnum3), foo3));

Como alternativa (melhor abordagem), esse elenco poderia ser assim:

 private static T GetEnum<T>(int v) where T : struct, IConvertible
    {
        if (typeof(T).IsEnum)
            if (Enum.IsDefined(typeof(T), v))
            {
                return (T)Enum.ToObject(typeof(T), v);
            }

        throw new ArgumentException(string.Format("{0} is not a valid value of {1}", v, typeof(T).Name));
    }

Depois de não encontrar nada para contornar a exceção "O objeto deve implementar o IConvertible" ao usar a resposta do Zyphrax (exceto para implementar a interface) .. Tentei algo um pouco não convencional e trabalhei para a minha situação.

Usando o pacote nuget Newtonsoft.Json ...

var castedObject = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(myObject), myType);

Dano, o problema é que você não tem um T.

você só tem uma variável Type.

Dica para a MS, se você pudesse fazer algo como

TryCast<typeof(MyClass)>

se resolveria todos os nossos problemas.

Eu nunca vou entender por que você precisa de até 50 reputação para deixar um comentário, mas eu apenas tinha que dizer que a resposta @Curt é exatamente o que eu estava procurando e, espero, outra pessoa.

No meu exemplo, tenho um ActionFilterAttribute que estava usando para atualizar os valores de um documento de patch json. Eu não sabia qual era o modelo T para o documento de correção, pois precisava serializá-lo e desserializá-lo para um JsonPatchDocument simples, modificá-lo e, em seguida, porque eu tinha o tipo, serializar e desserializar novamente para o tipo.

Type originalType = //someType that gets passed in to my constructor.

var objectAsString = JsonConvert.SerializeObject(myObjectWithAGenericType);
var plainPatchDocument = JsonConvert.DeserializeObject<JsonPatchDocument>(objectAsString);

var plainPatchDocumentAsString= JsonConvert.SerializeObject(plainPatchDocument);
var modifiedObjectWithGenericType = JsonConvert.DeserializeObject(plainPatchDocumentAsString, originalType );

public bool TryCast<T>(ref T t, object o)
{
    if (
        o == null
        || !typeof(T).IsAssignableFrom(o.GetType())
        )
        return false;
    t = (T)o;
    return true;
}

ainda mais limpo:

    public static bool TryCast<T>(ref T t, object o)
    {
        if (!(o is T))
        {
            return false;
        }

        t = (T)o;
        return true;
    }

Se você precisar converter objetos em tempo de execução sem saber o tipo de destino, poderá usar a reflexão para criar um conversor dinâmico.

Esta é uma versão simplificada (sem o método gerado em cache):

    public static class Tool
    {
            public static object CastTo<T>(object value) where T : class
            {
                return value as T;
            }

            private static readonly MethodInfo CastToInfo = typeof (Tool).GetMethod("CastTo");

            public static object DynamicCast(object source, Type targetType)
            {
                return CastToInfo.MakeGenericMethod(new[] { targetType }).Invoke(null, new[] { source });
            }
    }

então você pode chamá-lo:

    var r = Tool.DynamicCast(myinstance, typeof (MyClass));