Gewusst wie: Konvertieren einer Zeichenfolge in einen Nullable-Typ, Die erst zur Laufzeit Bestimmt wird?

Ich habe den code unten und ich brauche, um zu konvertieren eine Zeichenfolge in einer Art, die ist auch angegeben String:

 Type t = Type.GetType("System.Nullable`1[[System.DateTime, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]");

            object d = Convert.ChangeType("2012-02-23 10:00:00", t);

Ich bekomme die folgende Fehlermeldung:

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

Wie wäre das schön möglich?

Ich weiß, eine hässliche Möglichkeit wäre zu prüfen, ob der Typ nullable verwenden, wenn:

    Type possiblyNullableType = Type.GetType("System.Nullable`1[[System.DateTime, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]");

    var underlyingType = Nullable.GetUnderlyingType(possiblyNullableType);

    Object result;

    //if it's null, it means it wasn't nullable
    if (underlyingType != null)
    {
        result = Convert.ChangeType("2012-02-23 10:00:00", underlyingType);
    }

Wäre es eine bessere Möglichkeit?

Dank,

InformationsquelleAutor der Frage The Light | 2012-02-24

  1. 30

    Gibt es zwei Probleme.

    Erstens Convert.ChangeType einfach nicht unterstützt nullable-Typen.

    Zweitens, selbst wenn es das täte, durch Boxen, das Ergebnis (die Zuordnung zu einer object), Sie wäre ja schon ein Umwandlung in ein DateTime.

    Könnte man spezielle Fall von auf null festlegbaren Typen:

    string s = "2012-02-23 10:00:00";
Type t = Type.GetType("System.Nullable`1[[System.DateTime, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]");
object d;

if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>))
{
    if (String.IsNullOrEmpty(s))
        d = null;
    else
        d = Convert.ChangeType(s, t.GetGenericArguments()[0]);
}
else
{
    d = Convert.ChangeType(s, t);
}

    InformationsquelleAutor der Antwort

  2. 9

    Schrieb ich die unten generische helper-Methode, die funktioniert in den meisten Szenarien (nicht getestet mit generischen Typen):

    static void Main(string[] args)
{
    Object result =
        ConvertValue(
            "System.Nullable`1[[System.DateTime, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]",
            "2012-02-23 10:00:00");
}

public static Object ConvertValue(string typeInString, string value)
{
    Type originalType = Type.GetType(typeInString);

    var underlyingType = Nullable.GetUnderlyingType(originalType);

    //if underlyingType has null value, it means the original type wasn't nullable
    object instance = Convert.ChangeType(value, underlyingType ?? originalType);

    return instance;
}

    InformationsquelleAutor der Antwort The Light

  3. 2
    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

  4. 1

    So etwas? Es sei denn, Sie wirklich brauchen, um es dynamisch.

    if (string.IsNullOrEmpty(input))
{
   return new DateTime?();
}
else
{
   return new DateTime?(DateTime.Parse(input));
}

    Könnten Sie überprüfen, um zu sehen, ob dein Typ ist einer der "nullable" - Typen und dann könnte man vielleicht etwas finden, nützlich, hier:

    Konvertieren string nullable-Datentyp (int, double, etc...)

    InformationsquelleAutor der Antwort Paddy

Schreibe einen Kommentar