Convertir en Nullable à partir d'une chaîne en utilisant la réflexion
-
23-08-2019 - |
Question
Comment puis-je convertir en Nullable d'une chaîne en utilisant la réflexion?
Je le code suivant pour convertir presque tous les types de valeur donnée presque toute valeur. Il y a un peu de code ci-dessus cette option pour utiliser le IsAssignableFrom, etc. c'est donc le dernier recours.
MethodInfo parse = t.GetMethod("Parse", new Type[] { typeof(string) });
if (parse != null)
{
object parsed = parse.Invoke(null, new object[] { value.ToString() });
return (T)parsed;
}
else
{
throw new InvalidOperationException("The value you specified is not a valid " + typeof(T).ToString());
}
Le problème vient quand je veux convertir à un type nullable comme longtemps?.
De toute évidence, la longue? classe ne dispose pas d'une méthode parse.
Comment extraire la méthode d'analyse de la annulable de template type?
EDIT:
Voici une batterie de tests à court, je suis en train de passer:
[Test]
public void ConverterTNullable()
{
Assert.That((int?)1, Is.EqualTo(Converter<int?>.Convert(1)));
Assert.That((int?)2, Is.EqualTo(Converter<int?>.Convert(2.0d)));
Assert.That(3, Is.EqualTo(Converter<long>.Convert(3)));
Assert.That((object)null, Is.EqualTo(Converter<long?>.Convert("")));
Assert.That((object)null, Is.EqualTo(Converter<long?>.Convert(null)));
Assert.That((object)null, Is.EqualTo(Converter<long?>.Convert(DBNull.Value)));
Assert.That((long)1, Is.EqualTo(Converter<long?>.Convert("1")));
Assert.That((long)2, Is.EqualTo(Converter<long?>.Convert(2.0)));
Assert.That((long?)3, Is.EqualTo(Converter<long>.Convert(3)));
}
Et l'ensemble de la fonction:
/// <summary>
/// Converts any compatible object to an instance of T.
/// </summary>
/// <param name="value">The value to convert.</param>
/// <returns>The converted value.</returns>
public static T Convert(object value)
{
if (value is T)
{
return (T)value;
}
Type t = typeof(T);
if (t == typeof(string))
{
if (value is DBNull || value == null)
{
return (T)(object)null;
}
else
{
return (T)(object)(value.ToString());
}
}
else
{
if (value is DBNull || value == null)
{
return default(T);
}
if (value is string && string.IsNullOrEmpty((string)value))
{
return default(T);
}
try
{
return (T)value;
}
catch (InvalidCastException)
{
}
if (Nullable.GetUnderlyingType(t) != null)
{
t = Nullable.GetUnderlyingType(t);
}
MethodInfo parse = t.GetMethod("Parse", new Type[] { typeof(string) });
if (parse != null)
{
object parsed = parse.Invoke(null, new object[] { value.ToString() });
return (T)parsed;
}
else
{
throw new InvalidOperationException("The value you specified is not a valid " + typeof(T).ToString());
}
}
}
La solution 3
J'ai ajouté ce peu:
if (Nullable.GetUnderlyingType(t) != null)
{
t = Nullable.GetUnderlyingType(t);
}
MethodInfo parse = t.GetMethod("Parse", new Type[] { typeof(string) });
Merci à tous!
Autres conseils
Je serais probablement utiliser le TypeConverter
dans ce cas, et ; par exemple sur le chemin ... Nullable.GetUnderlyingType()
static void Main()
{
long? val1 = Parse<long?>("123");
long? val2 = Parse<long?>(null);
}
static T Parse<T>(string value)
{
return (T) TypeDescriptor.GetConverter(typeof(T))
.ConvertFrom(value);
}
Cela devrait au travail. (Code est intégré dans une méthode d'extension pour simplifier, mais il ne peut pas être ce que vous voulez.)
public static T? ParseToNullable<T>(this string value) where T : struct
{
var parseMethod = typeof(T).GetMethod("Parse", new Type[] { typeof(string) });
if (parseMethod == null)
return new Nullable<T>();
try
{
var value = parseMethod.Invoke(null, new object[] { value.ToString() });
return new Nullable<T>((T)value);
}
catch
{
return new Nullable<T>();
}
}
Maintenant, si vous voulez que le paramter de type générique lui-même pour le type nullable plutôt que celle sous-jacente (je ne vois pas vraiment un avantage dans), vous pouvez utiliser:
Nullable.GetUnderlyingType(typeof(T))
comme Marc Gravell a suggéré, et il ne nécessite que quelques modifications mineures au code.