comment utiliser.TryParse dans une méthode générique alors que T est soit double ou Int

je suis d'accord avec Mark Byers. Ce n'est probablement pas une bonne idée d'essayer de faire cette méthode générique. Un peu de duplication de code ne fera pas de mal (tant que ce n'est vraiment qu'un peu). Le fait que vous pourriez utiliser tout struct avec votre version générique aussi ne fait pas passer ça pour une bonne idée pour moi.

si vous voulez vraiment faire cela, vous pouvez essayer d'utiliser la réflexion (comme suggéré par la MINUSTAH), mais ce serait à la fois laid et lent.

à la place, vous pourriez utiliser Convert.ChangeType():

private T GetValue<T>(string str) where T : struct 
{
    return (T)Convert.ChangeType(str, typeof(T));
}

je voudrais envisager la rédaction d'une extension ou une méthode statique:

delegate bool TryParse<T>(string str, out T value);

public static T GetValue<T>(this string str, TryParse<T> parseFunc)
{
    T val;
    parseFunc(str, out val);
    return val;
}

vous devez alors fournir le TryParse mise en œuvre que vous souhaitez utiliser:

int i = "1234".GetValue<int>(int.TryParse);

Être averti que cette fonction silencieusement retourne une valeur par défaut si l'analyse échoue. Vous pouvez retourner default(T) si le TryParse delegate retourne false.

Donc au lieu d'écrire:

double d = GetDoubleValue(str);

vous voulez être capable d'écrire ceci?

double d = GetValue<double>(str);

même si vous pouvez le faire fonctionner, Quel est l'avantage? Personnellement, je ne pense pas que ce soit une grande amélioration pour le client. Le seul avantage est de ne pas avoir à appliquer la même méthode deux fois. Mais étant donné la simplicité de la méthode et la difficulté de mettre en œuvre ce type de réutilisation du code, il semble raisonnable ici de dupliquer ces quelques lignes de code.

vous n'êtes pas seul avec ce problème. Jetez un coup d'oeil à d'autres méthodes dans le cadre .NET qui fonctionnent sur différents types et voir comment ils l'ont résolu. Voici comment BinaryReader permet de lire différents types:

• BinaryReader.ReadBoolean
• BinaryReader.ReadByte
• BinaryReader.ReadChar
• BinaryReader.ReadInt32
• etc..

ce n'est pas joli, mais c'est comme ça que ça se passe.

en ce qui concerne votre mise à jour, j'ai deux autres remarques à faire.

Vous mentionner que vous il y a probablement plus de deux types, ce qui pourrait entraîner une plus grande duplication du même code. Étant donné que la méthode est très concise et simple, il ne semble pas un problème de copier et coller le code. C'est une exception raisonnable à la règle que vous ne devriez pas copier et coller du code, à mon avis. L'approche ici réduit la quantité de duplication, bien que vous ayez encore besoin de beaucoup de méthodes nommées de la même façon dans votre interface publique.

cependant je pense qu'il est important de mentionnez qu'il semble erroné d'utiliser silencieusement une valeur par défaut dans votre situation, comme Lee l'a déjà mentionné dans un commentaire. Si un utilisateur fait une erreur lors de la saisie des données, il doit recevoir un message d'erreur. Vous devriez utiliser une sorte de cadre de validation pour vous assurer que les chaînes sont valides et pour informer votre utilisateur du problème s'il n'est pas valide. Une fois que vous avez validé tout, il est sûr à utiliser int.Parse au lieu de int.TryParse parce que vous savez que le traitement réussisse. Et si l'analyse échoue, c'est une situation exceptionnelle (un bug dans votre validation) donc il semble juste que l'application se dérobe avec une exception et enregistre une trace de pile. Cela vous aidera à trouver et à corriger le bogue.

j'ai fait un simple échantillon. Le code n'est pas optimal, mais il fonctionne comme prévu.

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(GetValue<int>("123"));
        Console.WriteLine(GetValue<double>("123.123"));
        Console.WriteLine(GetValue<DateTime>("2001-01-01 01:01:01"));
    }

    static T GetValue<T>(string s)
    {
        var tryParse = typeof (T).GetMethod(
            "TryParse", new [] {typeof(string), typeof(T).MakeByRefType()});
        if (tryParse == null)
            throw new InvalidOperationException();


        T t = default (T);
        var parameters = new object[] {s, t};
        var success = tryParse.Invoke(null, parameters);
        if ((bool) success) t = (T)parameters[1];
        return t;
    }
}

Vous pouvez essayer avec la réflexion: d'abord, essayer de trouver une méthode "TryParse" sur le type remplacé par .

T t;
var typeInfo = typeof(T);
var method = typeInfo.GetMethod("TryParse", BindingFlags.Public | BindingFlags.Static);
var result = (bool)method.Invoke(null, new object[] { str, t });

if (result)
    return t;

ce code n'est pas testé; il n'est pas non plus optimal du point de vue des performances.

Comme vous le voyez, vous ne pouvez pas restreindre where TDouble ou Int32, c'est pourquoi vous avez probablement struct sur cette place (int et double ne sont pas struct). Les types de valeurs ne peuvent pas être utilisés comme restrictions sur les génériques.

donc vous ne pouvez pas taper safe assurez-vous que TryParse la méthode existe. Vous devez soit taper T et jeter une exception si elle est soit double ou int comme dans la réponse par @ie.

Ma suggestion est d'utiliser différents signature:

private static bool GetValue(string str, out double result)
{
...    
}

private static bool GetValue(string str, out int result)
{
...    
}

alternativement vous pouvez introduire une interface IParsable. Boîte double ou int résultat et implémentation de la conversion implicite en double ou entier.

Qu'une méthode d'extension ?

public static class Extensions
{    
    public static Nullable<T> TryParse<T>(this String str) where T:struct
    {
        try
        {
            T parsedValue = (T)Convert.ChangeType(str, typeof(T));
            return parsedValue;
        }
        catch { return null; }
    }
}

utilisation :

int i = "123".TryParse<int>() ?? 0;