Wie kann ich dies beheben, um eine generische Konvertierung in Nullable & lt; T & gt;

Derzeit benutze ich dieses praktischen Umbau-Erweiterung-Methode, um Konvertierungen zwischen Typen:

    public static T To<T>(this IConvertible obj)
    {
        return (T)Convert.ChangeType(obj, typeof(T));
    }

Allerdings nicht, wie das konvertieren gültige Werte um null-Werte zulässt, zum Beispiel, dies schlägt fehl:

    "1".To<int?>();

Natürlich, 1 ist einfach in eine (int?), aber es kommt die Fehlermeldung:

    Invalid cast from 'System.String' to 'System.Nullable`1[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]'.

Dies ist ein offensichtlich Vereinfachtes Beispiel, in Wirklichkeit bin ich es verwenden, um Konvertierungen von string-Typen in etwa so:

packageDb.Quantity = package.package.ElementDeep(Namespace + "PackageQuantity", Namespace + "ActualQuantity", Namespace + "Quantity").ValueOrNull().To<int?>();

Wenn Konvertieren.ChangeType nicht wie null-Werte zulassen, jemand irgendwelche tollen Ideen?

InformationsquelleAutor der Frage TheSoftwareJedi | 2009-04-27

  1. 94
    public static T To<T>(this IConvertible obj)
{
    Type t = typeof(T);
    Type u = Nullable.GetUnderlyingType(t);

    if (u != null)
    {
        return (obj == null) ? default(T) : (T)Convert.ChangeType(obj, u);
    }
    else
    {
        return (T)Convert.ChangeType(obj, t);
    }
}

    InformationsquelleAutor der Antwort LukeH

  2. 4
    public static T To<T>(this IConvertible obj) 
{
    Type t = typeof(T);
    if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>))
        t = t.GetGenericArguments()[0];

    return (T)Convert.ChangeType(obj, t); 
}

    Aber wenn die Konvertierung fehlschlägt, wird eine exception werfen, - nicht wieder eine null als erwartet werden sollte.

    InformationsquelleAutor der Antwort Henrique

  3. 3

    Habe ich landete mit diesem

    private static T To<T>(this Object @object, Boolean returnDefaultOnException)
{
    Type type = typeof(T);
    Type underlyingTypeOfNullable = Nullable.GetUnderlyingType(type);
    try
    {
        return (T) Convert.ChangeType(@object, underlyingTypeOfNullable ?? type);
    }
    catch (Exception exception)
    {
        if (returnDefaultOnException)
            return default(T);
        String typeName = type.Name;
        if (underlyingTypeOfNullable != null)
            typeName += " of " + underlyingTypeOfNullable.Name;
        throw new InvalidCastException("Object can't be cast to " + typeName, exception);

    }
}
public static T To<T>(this Object @object) { return @object.To<T>(returnDefaultOnException: false); }
public static T ToOrDefault<T>(this Object @object) { return @object.To<T>(returnDefaultOnException: true); }

    Verhält es sich wie die LINQ-extension-Methoden Single und SingleOrDefault und First und FirstOrDefault.

    Kurz To<T>() versucht zu konvertieren und wirft auf Fehler während der ToOrDefault<T>() versucht zu konvertieren und zurück default(T) auf Fehler.

    InformationsquelleAutor der Antwort Nick Strupat

  4. 2

    Vielleicht fehlt mir der Punkt, aber in der Instanz von Nullable, wie funktioniert Ihre Methode entweder eine Lesbarkeit, Leistung, Wartung oder Vorteil gegenüber einer einfachen Besetzung, wie (int?)1 ?

    Abgesehen davon, dass vielleicht eine andere Erweiterung Methode? 

    public static T? ToNullable<T>(this T obj) where T:struct
{
    return (T?)obj;
}

    Bearbeiten

    Nach der überprüfung Ihrer Bearbeiten, warum sollte der generische Funktion, die ich angegeben habe, funktionieren nicht als Ersatz für Ihre To<T> Funktion in dieser Zeile? Sie können nicht zulassen, dass eine Umstellung auf null-Werte zulässt, der für jede Art (das ist, warum ChangeType funktioniert nicht), weil das generische akzeptiert nur Wert-Typen. Sie müssen entweder eine Funktion verwenden, wie die, die ich zur Verfügung gestellt oder ändern Sie Ihre Signatur To<T> nehmen nur die Werte und fügen Sie eine Besondere Hülle für Nullable<T>.

    InformationsquelleAutor der Antwort Adam Robinson

  5. 2

    Luke ' s Lösung war gut für mich (und offensichtlich bekam sein Stimmen), aber ich vereinfacht es für mich auf diese Weise

        private static Type ResolveType(String typeName)
    {
        Type t = Type.GetType(typeName);
        if (t == null)
            return null;

        Type u = Nullable.GetUnderlyingType(t);

        if (u != null) {
            t = u;
        }
        return t;
    }

    da ich erst aus einer Zeichenkette, die nicht von einem Typ...
    Gedanken?

    InformationsquelleAutor der Antwort Eugenio Miró

  6. 1

    Dies ist die Methode, die ich derzeit benutze (ich habe meine Antwort auf SO), es konvertiert von string nullable-Typ:

        public static Nullable<T> ConvertToNullable<T>(this string s) where T : struct
    {
        if (!string.IsNullOrEmpty(s.Trim()))
        {
            TypeConverter conv = TypeDescriptor.GetConverter(typeof(Nullable<>).MakeGenericType(typeof(T)));
            return (Nullable<T>)conv.ConvertFrom(s);
        }
        return null;
    }

    InformationsquelleAutor der Antwort Nathan Koop

  7. 0

    erweitern @LukeH code:

    public static T GetValue<T>(string Literal, T DefaultValue)
    {
        if (Literal == null || Literal == "" || Literal == string.Empty) return DefaultValue;
        IConvertible obj = Literal;
        Type t = typeof(T);
        Type u = Nullable.GetUnderlyingType(t);

        if (u != null)
        {
            return (obj == null) ? DefaultValue : (T)Convert.ChangeType(obj, u);
        }
        else
        {
            return (T)Convert.ChangeType(obj, t);
        }
    }

    InformationsquelleAutor der Antwort Hossein Shahabi

  8. 0

    Diese Methode funktioniert, was Sie brauchen, und es sieht nett aus, während es zu tun.

        ///<summary>
    ///<para>More convenient than using T.TryParse(string, out T). 
    ///Works with primitive types, structs, and enums.
    ///Tries to parse the string to an instance of the type specified.
    ///If the input cannot be parsed, null will be returned.
    ///</para>
    ///<para>
    ///If the value of the caller is null, null will be returned.
    ///So if you have "string s = null;" and then you try "s.ToNullable...",
    ///null will be returned. No null exception will be thrown. 
    ///</para>
    ///<author>Contributed by Taylor Love (Pangamma)</author>
    ///</summary>
    ///<typeparam name="T"></typeparam>
    ///<param name="p_self"></param>
    ///<returns></returns>
    public static T? ToNullable<T>(this string p_self) where T : struct
    {
        if (!string.IsNullOrEmpty(p_self))
        {
            var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
            if (converter.IsValid(p_self)) return (T)converter.ConvertFromString(p_self);
            if (typeof(T).IsEnum) { T t; if (Enum.TryParse<T>(p_self, out t)) return t;}
        }

        return null;
    }

    https://github.com/Pangamma/PangammaUtilities-CSharp/tree/master/src/StringExtensions

    InformationsquelleAutor der Antwort Pangamma

Schreibe einen Kommentar