web-dev-qa-db-fra.com

Convertir en un type à la volée en C # .NET

Je souhaite convertir un objet en un type qui sera affecté au moment de l'exécution.

Par exemple, supposons que j’ai une fonction qui assigne une valeur de chaîne (d’un TextBox or Dropdownlist) à un Object.Property.

Comment pourrais-je convertir la valeur en type approprié? Par exemple, cela pourrait être un entier, une chaîne ou une énumération. 

Public void Foo(object obj,string propertyName,object value)
{
  //Getting type of the property og object.
  Type t= obj.GetType().GetProperty(propName).PropertyType;

  //Now Setting the property to the value .
  //But it raise an error,because sometimes type is int and value is "2"
  //or type is enum (e.a: Gender.Male) and value is "Male"
  //Suppose that always the cast is valid("2" can be converted to int 2)

  obj.GetType().GetProperty(propName).SetValue(obj, value, null);
}
c#reflectioncastinggetproperty
19
nAviD

Vous devez utiliser la fonction Convert.ChangeType (...) (l'entrée pourrait tout aussi bien être un objet ... Je viens d'avoir une version de chaîne précuite):

/// <summary>
/// Sets a value in an object, used to hide all the logic that goes into
///     handling this sort of thing, so that is works elegantly in a single line.
/// </summary>
/// <param name="target"></param>
/// <param name="propertyName"></param>
/// <param name="propertyValue"></param>
public static void SetPropertyValueFromString(this object target,               
                              string propertyName, string propertyValue)
{
    PropertyInfo oProp = target.GetType().GetProperty(propertyName);
    Type tProp = oProp.PropertyType;

    //Nullable properties have to be treated differently, since we 
    //  use their underlying property to set the value in the object
    if (tProp.IsGenericType
        && tProp.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
    {
        //if it's null, just set the value from the reserved Word null, and return
        if (propertyValue == null)
        {
            oProp.SetValue(target, null, null);
            return;
        }

        //Get the underlying type property instead of the nullable generic
        tProp = new NullableConverter(oProp.PropertyType).UnderlyingType;
    }

    //use the converter to get the correct value
    oProp.SetValue(target, Convert.ChangeType(propertyValue, tProp), null);
}
35
fordareh

Un type de convertisseur universel est ce que vous cherchez! Pas un exploit facile ..

Essayez cette approche:

Universal Type Converter

Vous pouvez dans NuGet Install-Package UniversalTypeConverter

De plus, l'utilisation de Generics est-elle hors de question? Cela faciliterait la solution si vous connaissiez au moins le type de conversion souhaité.

2
Anas Karkoukli

Voici une autre façon de le faire, mais je ne suis pas sûr 

Sans support pour les types génériques:

public void Foo(object obj,string propertyName,object value) 
{ 
    //Getting type of the property og object. 
    Type type = obj.GetType().GetProperty(propertyName).PropertyType;

    obj.GetType().GetProperty(propertyName).SetValue(obj, Activator.CreateInstance(type, value), null);
}

Avec support pour les types génériques:

public void Foo(object obj,string propertyName,object value) 
{ 
    //Getting type of the property og object. 
    Type type = obj.GetType().GetProperty(propertyName).PropertyType;

    if (type.IsGenericType)
        type = type.GetGenericArguments()[0];

    obj.GetType().GetProperty(propertyName).SetValue(obj, Activator.CreateInstance(type, value), null);
}
1
James Johnson

J'ai utilisé la fonction Convert en C #. Ma conversion est basée sur la réflexion:

Type type = this.myObject.GetType();

if (type.Name == "MyObjectClass") {
var Voucherrequest = (MyObjectClass)Convert.ChangeType(myObject, typeof(MyObjectClass));

Tout cela en supposant que vous sachiez quel type vous souhaitez convertir. Vous pouvez même faire un changement et avoir plusieurs types que vous souhaitez également réfléchir.

0
JEuvin

Je ne suis pas sûr que cela fonctionne, mais essayez-le:

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

Public void Foo(object obj,string propertyName,object value)
{
    Type t= obj.GetType().GetProperty(propName).PropertyType;
    obj.GetType().GetProperty(propName).SetValue(obj, value.To<t>(), null);
}
0
Marco