Création d'une méthode générique en C #
J'essaie de combiner un tas de méthodes similaires dans une méthode générique. J'ai plusieurs méthodes qui renvoient la valeur d'une chaîne de requête, ou null si cette chaîne de requête n'existe pas ou n'est pas au format correct. Cela serait assez facile si tous les types étaient nativement nullables, mais je dois utiliser le type générique nullable pour les nombres entiers et les dates.
Voici ce que j'ai maintenant. Cependant, il renverra un 0 si une valeur numérique est invalide, ce qui est malheureusement une valeur valide dans mes scénarios. Quelqu'un peut-il m'aider? Merci!
public static T GetQueryString<T>(string key) where T : IConvertible
{
T result = default(T);
if (String.IsNullOrEmpty(HttpContext.Current.Request.QueryString[key]) == false)
{
string value = HttpContext.Current.Request.QueryString[key];
try
{
result = (T)Convert.ChangeType(value, typeof(T));
}
catch
{
//Could not convert. Pass back default value...
result = default(T);
}
}
return result;
}
Que se passe-t-il si vous avez spécifié la valeur par défaut à renvoyer au lieu d'utiliser la valeur par défaut (T)?
public static T GetQueryString<T>(string key, T defaultValue) {...}
Cela facilite aussi l'appel:
var intValue = GetQueryString("intParm", Int32.MinValue);
var strValue = GetQueryString("strParm", "");
var dtmValue = GetQueryString("dtmPatm", DateTime.Now); // eg use today's date if not specified
L'inconvénient est que vous avez besoin de valeurs magiques pour indiquer les valeurs de chaîne de requête non valides/manquantes.
Je sais, je sais, mais ...
public static bool TryGetQueryString<T>(string key, out T queryString)
Et ça? Changez le type de retour de T en Nullable<T>
public static Nullable<T> GetQueryString<T>(string key) where T : struct, IConvertible
{
T result = default(T);
if (String.IsNullOrEmpty(HttpContext.Current.Request.QueryString[key]) == false)
{
string value = HttpContext.Current.Request.QueryString[key];
try
{
result = (T)Convert.ChangeType(value, typeof(T));
}
catch
{
//Could not convert. Pass back default value...
result = default(T);
}
}
return result;
}
Vous pouvez utiliser une sorte de peut-être monade (bien que je préfère la réponse de Jay)
public class Maybe<T>
{
private readonly T _value;
public Maybe(T value)
{
_value = value;
IsNothing = false;
}
public Maybe()
{
IsNothing = true;
}
public bool IsNothing { get; private set; }
public T Value
{
get
{
if (IsNothing)
{
throw new InvalidOperationException("Value doesn't exist");
}
return _value;
}
}
public override bool Equals(object other)
{
if (IsNothing)
{
return (other == null);
}
if (other == null)
{
return false;
}
return _value.Equals(other);
}
public override int GetHashCode()
{
if (IsNothing)
{
return 0;
}
return _value.GetHashCode();
}
public override string ToString()
{
if (IsNothing)
{
return "";
}
return _value.ToString();
}
public static implicit operator Maybe<T>(T value)
{
return new Maybe<T>(value);
}
public static explicit operator T(Maybe<T> value)
{
return value.Value;
}
}
Votre méthode ressemblerait à ceci:
public static Maybe<T> GetQueryString<T>(string key) where T : IConvertible
{
if (String.IsNullOrEmpty(HttpContext.Current.Request.QueryString[key]) == false)
{
string value = HttpContext.Current.Request.QueryString[key];
try
{
return (T)Convert.ChangeType(value, typeof(T));
}
catch
{
//Could not convert. Pass back default value...
return new Maybe<T>();
}
}
return new Maybe<T>();
}
Convert.ChangeType() ne gère pas correctement les types ou les énumérations nullables dans .NET 2.0 BCL (je pense cependant que c'est résolu pour BCL 4.0). Plutôt que de rendre l’implémentation externe plus complexe, faites en sorte que le convertisseur travaille plus pour vous. Voici une implémentation que j'utilise:
public static class Converter
{
public static T ConvertTo<T>(object value)
{
return ConvertTo(value, default(T));
}
public static T ConvertTo<T>(object value, T defaultValue)
{
if (value == DBNull.Value)
{
return defaultValue;
}
return (T) ChangeType(value, typeof(T));
}
public static object ChangeType(object value, Type conversionType)
{
if (conversionType == null)
{
throw new ArgumentNullException("conversionType");
}
// if it's not a nullable type, just pass through the parameters to Convert.ChangeType
if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
{
// null input returns null output regardless of base type
if (value == null)
{
return null;
}
// it's a nullable type, and not null, which means it can be converted to its underlying type,
// so overwrite the passed-in conversion type with this underlying type
conversionType = Nullable.GetUnderlyingType(conversionType);
}
else if (conversionType.IsEnum)
{
// strings require Parse method
if (value is string)
{
return Enum.Parse(conversionType, (string) value);
}
// primitive types can be instantiated using ToObject
else if (value is int || value is uint || value is short || value is ushort ||
value is byte || value is sbyte || value is long || value is ulong)
{
return Enum.ToObject(conversionType, value);
}
else
{
throw new ArgumentException(String.Format("Value cannot be converted to {0} - current type is " +
"not supported for enum conversions.", conversionType.FullName));
}
}
return Convert.ChangeType(value, conversionType);
}
}Ensuite, votre implémentation de GetQueryString <T> peut être:
public static T GetQueryString<T>(string key)
{
T result = default(T);
string value = HttpContext.Current.Request.QueryString[key];
if (!String.IsNullOrEmpty(value))
{
try
{
result = Converter.ConvertTo<T>(value);
}
catch
{
//Could not convert. Pass back default value...
result = default(T);
}
}
return result;
}J'aime commencer par une classe comme celle-ci Paramètres de la classe {public int X {get; set;} chaîne publique Y {get; ensemble; } // répéter autant que nécessaire
public settings()
{
this.X = defaultForX;
this.Y = defaultForY;
// repeat ...
}
public void Parse(Uri uri)
{
// parse values from query string.
// if you need to distinguish from default vs. specified, add an appropriate property
}
Cela a bien fonctionné sur des centaines de projets. Vous pouvez utiliser l'une des nombreuses autres solutions d'analyse pour analyser les valeurs.