tabla - tipos de datos en c# pdf

¿Cómo verificar si existe un molde implícito o explícito?

Question

Tengo una clase genérica y deseo hacer cumplir que las instancias del parámetro tipo son siempre "cast-able" / convertible from String. ¿Es posible hacer esto sin, por ejemplo, usar una interfaz?

Posible implementación:

public class MyClass<T> where T : IConvertibleFrom<string>, new()
{
    public T DoSomethingWith(string s)
    {
        // ...
    }
}

Implementación ideal:

public class MyClass<T>
{
    public T DoSomethingWith(string s)
    {
        // CanBeConvertedFrom would return true if explicit or implicit cast exists
        if(!typeof(T).CanBeConvertedFrom(typeof(String))
        {
            throw new Exception();
        }
        // ...
    }
}

La razón por la que preferiría esta implementación "ideal" es principalmente para no forzar a todas las Ts a implementar IConvertibleFrom <>.

Answer 1

¿Por qué no puedes hacer algo como esto?

public class MyClass<T> where T : string
{
    public T DoSomethingWith(string s)
    {
        // ...
    }
}

De esta forma, puede verificar si s es convertible a T en el código DoSomethingWith . Desde allí puedes lanzar una excepción si no puede, o hacer el casting, si puede

Answer 2

if(!typeof(T).IsAssignableFrom(typeof(String))) {
    throw new Exception();
}

Answer 3

Dado que desea convertir el tipo de cadena sellado, puede ignorar las posibles conversiones anulables, de boxeo, de referencia y explícitas. Solo op_Implicit() califica. Un enfoque más genérico es proporcionado por la clase System.Linq.Expressions.Expression:

using System.Linq.Expressions;
...
    public static T DoSomethingWith(string s)
    {
      var expr = Expression.Constant(s);
      var convert = Expression.Convert(expr, typeof(T));
      return (T)convert.Method.Invoke(null, new object[] { s });
    }

Tenga cuidado con el costo de Reflection.