Convert.ChangeType() échoue sur les types Nullables

Question

Je veux convertir une chaîne en une valeur de propriété d'un objet, dont le nom est une chaîne. J'essaie de le faire de la manière suivante :

string modelProperty = "Some Property Name";
string value = "SomeValue";
var property = entity.GetType().GetProperty(modelProperty);
if (property != null) {
    property.SetValue(entity, 
        Convert.ChangeType(value, property.PropertyType), null);
}

Le problème est que cette opération échoue et génère une exception Invalid Cast lorsque le type de propriété est un type nullable. Il ne s'agit pas d'un cas où les valeurs ne peuvent pas être converties - elles fonctionnent si je le fais manuellement (par ex. DateTime? d = Convert.ToDateTime(value); ) J'ai vu des questions similaires mais je n'arrive toujours pas à le faire fonctionner.

Answer 1

Non testé, mais peut-être que quelque chose comme ça fonctionnera :

string modelProperty = "Some Property Name";
string value = "Some Value";

var property = entity.GetType().GetProperty(modelProperty);
if (property != null)
{
    Type t = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;

    object safeValue = (value == null) ? null : Convert.ChangeType(value, t);

    property.SetValue(entity, safeValue, null);
}

Answer 2

Vous devez obtenir le type sous-jacent afin de faire cela...

Essayez ceci, je l'ai utilisé avec succès avec des génériques :

//Coalesce to get actual property type...
Type t = property.PropertyType();
t = Nullable.GetUnderlyingType(t) ?? t;

//Coalesce to set the safe value using default(t) or the safe type.
safeValue = value == null ? default(t) : Convert.ChangeType(value, t);

Je l'utilise à plusieurs endroits dans mon code, par exemple dans une méthode d'aide que j'utilise pour convertir les valeurs des bases de données d'une manière sûre :

public static T GetValue<T>(this IDataReader dr, string fieldName)
{
    object value = dr[fieldName];

    Type t = typeof(T);
    t = Nullable.GetUnderlyingType(t) ?? t;

    return (value == null || DBNull.Value.Equals(value)) ? 
        default(T) : (T)Convert.ChangeType(value, t);
}

Appelé en utilisant :

string field1 = dr.GetValue<string>("field1");
int? field2 = dr.GetValue<int?>("field2");
DateTime field3 = dr.GetValue<DateTime>("field3");

J'ai écrit une série d'articles de blog, dont celui-ci, à l'adresse suivante http://www.endswithsaurus.com/2010_07_01_archive.html (Faites défiler la page jusqu'à l'addendum, @JohnMacintyre a en fait repéré le bogue dans mon code original qui m'a conduit sur le même chemin que celui que vous empruntez maintenant). J'ai fait quelques petites modifications depuis ce post qui inclut la conversion des types enum aussi, donc si votre propriété est un Enum, vous pouvez toujours utiliser le même appel de méthode. Il suffit d'ajouter une ligne pour vérifier les types d'enum et vous êtes prêt pour la course en utilisant quelque chose comme :

if (t.IsEnum)
    return (T)Enum.Parse(t, value);

Normalement, il faudrait vérifier les erreurs ou utiliser TryParse au lieu de Parse, mais vous voyez le tableau.

Answer 3

Cela fonctionne parfaitement même pour les types Nullables :

TypeConverter conv = TypeDescriptor.GetConverter(type);
return conv.ConvertFrom(value);

Pour la sécurité du type, vous devez également appeler conv.CanConvertFrom(type) avant d'appeler la méthode ConvertFrom() . Dans le cas où il renvoie false, vous pouvez vous rabattre sur ChangeType ou autre chose.

Answer 4

C'est un peu long pour un exemple, mais il s'agit d'une approche relativement robuste, qui sépare la tâche de couler une valeur inconnue vers un type inconnu.

J'ai une méthode TryCast qui fait quelque chose de similaire, et prend en compte les types nullables.

public static bool TryCast<T>(this object value, out T result)
{
    var type = typeof (T);

    // If the type is nullable and the result should be null, set a null value.
    if (type.IsNullable() && (value == null || value == DBNull.Value))
    {
        result = default(T);
        return true;
    }

    // Convert.ChangeType fails on Nullable<T> types.  We want to try to cast to the underlying type anyway.
    var underlyingType = Nullable.GetUnderlyingType(type) ?? type;

    try
    {
        // Just one edge case you might want to handle.
        if (underlyingType == typeof(Guid))
        {
            if (value is string)
            {
                value = new Guid(value as string);
            }
            if (value is byte[])
            {
                value = new Guid(value as byte[]);
            }

            result = (T)Convert.ChangeType(value, underlyingType);
            return true;
        }

        result = (T)Convert.ChangeType(value, underlyingType);
        return true;
    }
    catch (Exception ex)
    {
        result = default(T);
        return false;
    }
}

Bien sûr, TryCast est une méthode avec un paramètre de type, donc pour l'appeler dynamiquement, vous devez construire vous-même l'InfoMéthode :

var constructedMethod = typeof (ObjectExtensions)
    .GetMethod("TryCast")
    .MakeGenericMethod(property.PropertyType);

Ensuite, pour définir la valeur réelle de la propriété :

public static void SetCastedValue<T>(this PropertyInfo property, T instance, object value)
{
    if (property.DeclaringType != typeof(T))
    {
        throw new ArgumentException("property's declaring type must be equal to typeof(T).");
    }

    var constructedMethod = typeof (ObjectExtensions)
        .GetMethod("TryCast")
        .MakeGenericMethod(property.PropertyType);

    object valueToSet = null;
    var parameters = new[] {value, null};
    var tryCastSucceeded = Convert.ToBoolean(constructedMethod.Invoke(null, parameters));
    if (tryCastSucceeded)
    {
        valueToSet = parameters[1];
    }

    if (!property.CanAssignValue(valueToSet))
    {
        return;
    }
    property.SetValue(instance, valueToSet, null);
}

Et les méthodes d'extension pour gérer property.CanAssignValue...

public static bool CanAssignValue(this PropertyInfo p, object value)
{
    return value == null ? p.IsNullable() : p.PropertyType.IsInstanceOfType(value);
}

public static bool IsNullable(this PropertyInfo p)
{
    return p.PropertyType.IsNullable();
}

public static bool IsNullable(this Type t)
{
    return !t.IsValueType || Nullable.GetUnderlyingType(t) != null;
}

Answer 5

J'avais un besoin similaire, et la réponse de LukeH m'a mis sur la voie. J'ai créé cette fonction générique pour faciliter les choses.

    public static Tout CopyValue<Tin, Tout>(Tin from, Tout toPrototype)
    {
        Type underlyingT = Nullable.GetUnderlyingType(typeof(Tout));
        if (underlyingT == null)
        { return (Tout)Convert.ChangeType(from, typeof(Tout)); }
        else
        { return (Tout)Convert.ChangeType(from, underlyingT); }
    }

L'utilisation est comme ça :

        NotNullableDateProperty = CopyValue(NullableDateProperty, NotNullableDateProperty);

Notez que le deuxième paramètre est juste utilisé comme prototype pour montrer à la fonction comment convertir la valeur de retour, donc il n'a pas besoin d'être la propriété de destination. Ce qui signifie que vous pouvez également faire quelque chose comme ceci :

        DateTime? source = new DateTime(2015, 1, 1);
        var dest = CopyValue(source, (string)null);

Je l'ai fait de cette façon au lieu d'utiliser un out parce que vous ne pouvez pas utiliser out avec les propriétés. Tel quel, il peut fonctionner avec les propriétés et les variables. Vous pouvez également créer une surcharge pour passer le type à la place si vous le souhaitez.