Existe-t-il une fonction Parse () générique qui convertira une chaîne en n'importe quel type à l'aide de parse?

Je souhaite convertir une chaîne en un type générique comme intou dateou longbasé sur le type de retour générique.

En gros, une fonction comme Parse<T>(String)celle-ci renvoie un élément de type T.

Par exemple, si un int a été passé, la fonction doit le faire en int.parseinterne.

System.Convert.ChangeType

Selon votre exemple, vous pourriez faire:

int i = (int)Convert.ChangeType("123", typeof(int));
DateTime dt = (DateTime)Convert.ChangeType("2009/12/12", typeof(DateTime));

Pour satisfaire votre exigence de "type de retour générique", vous pouvez écrire votre propre méthode d'extension:

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

Cela vous permettra de faire:

int i = "123".ChangeType<int>();

Eh bien, on dirait que je suis trop tard pour répondre sur ce fil. Mais voici ma mise en œuvre:

Fondamentalement, j'ai créé une méthode Extention pour la classe Object. Il gère tous les types, c'est-à-dire nullable, classes et struct.

 public static T ConvertTo<T>(this object value)
           {
               T returnValue;

               if (value is T variable)
                   returnValue = variable;
               else
                   try
                   {
                       //Handling Nullable types i.e, int?, double?, bool? .. etc
                       if (Nullable.GetUnderlyingType(typeof(T)) != null)
                       {
                           TypeConverter conv = TypeDescriptor.GetConverter(typeof(T));
                           returnValue = (T) conv.ConvertFrom(value);
                       }
                       else
                       {
                           returnValue = (T) Convert.ChangeType(value, typeof(T));
                       }
                   }
                   catch (Exception)
                   {
                       returnValue = default(T);
                   }

               return returnValue;
           }

System.Convert.ChangeTypene convertit en aucun type. Pensez à ce qui suit:

• types nullables
• énumérations
• Guid etc.

Ces conversions sont possibles avec cette implémentation de ChangeType .

version plus propre de la réponse de Pranay

public static T ConvertTo<T>(this object value)
{
    if (value is T variable) return variable;

    try
    {
        //Handling Nullable types i.e, int?, double?, bool? .. etc
        if (Nullable.GetUnderlyingType(typeof(T)) != null)
        {
            return (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value);
        }

        return (T)Convert.ChangeType(value, typeof(T));
    }
    catch (Exception)
    {
        return default(T);
    }
}

Il existe quelques conventions dans le .NET pour convertir des objets d'un type à un autre.

• Convert.ChangeType si le type implémente IConvertible
• TypeDescriptor.GetConverter si le type a un TypeConverterAttribute

Mais ces méthodes sont beaucoup plus lentes que vos méthodes habituelles T.Parse(string), provoquent une boxe et impliquent de nombreuses allocations à chaque fois que vous souhaitez convertir une valeur unique.

Pour ValueString , j'ai choisi de trouver une méthode d'analyse statique appropriée du type utilisant la réflexion, de créer une expression lambda en l'appelant et de mettre en cache le délégué compilé pour une utilisation future (voir cette réponse pour un exemple).

Il revient également aux méthodes que j'ai mentionnées ci-dessus si le type n'a pas de méthode d'analyse appropriée (voir la section sur les performances dans le readme).

var v = new ValueString("15"); // struct
var i = v.As<int>(); // Calls int.Parse.