c# variavel Conversão de tipo genérico FROM string




converter variavel int para string c# (8)

Eu tenho uma classe que eu quero usar para armazenar "propriedades" para outra classe. Essas propriedades simplesmente possuem um nome e um valor. Idealmente, o que eu gostaria é poder adicionar propriedades tipadas , para que o "valor" retornado seja sempre do tipo que eu quero que seja.

O tipo deve ser sempre primitivo. Esta classe subclasse uma classe abstrata que basicamente armazena o nome e valor como string. A idéia é que esta subclasse irá adicionar algum tipo de segurança para a classe base (assim como me poupar em alguma conversão).

Então, eu criei uma classe que é (mais ou menos) isso:

public class TypedProperty<DataType> : Property
{
    public DataType TypedValue
    {
        get { // Having problems here! }
        set { base.Value = value.ToString();}
    }
}

Então a questão é:

Existe uma maneira "genérica" ​​de converter de string de volta para um primitivo?

Eu não consigo encontrar qualquer interface genérica que liga a conversão através da placa (algo como ITryParsable teria sido ideal!).


Não tenho certeza se entendi suas intenções corretamente, mas vamos ver se isso ajuda.

public class TypedProperty<T> : Property where T : IConvertible
{
    public T TypedValue
    {
        get { return (T)Convert.ChangeType(base.Value, typeof(T)); }
        set { base.Value = value.ToString();}
    }
}

Eu usei lobos resposta e funciona. Mas eu tive um problema com a conversão de duplas por causa das configurações de cultura. Então eu adicionei

return (T)Convert.ChangeType(base.Value, typeof(T), CultureInfo.InvariantCulture);

Você poderia usar um constructo como uma classe de traços . Dessa forma, você teria uma classe auxiliar parametrizada que sabe como converter uma cadeia em um valor de seu próprio tipo. Então seu getter pode ser assim:

get { return StringConverter<DataType>.FromString(base.Value); }

Agora, devo salientar que minha experiência com tipos parametrizados é limitada a C ++ e seus modelos, mas imagino que haja alguma maneira de fazer o mesmo tipo de coisa usando genéricos C #.


O método de lubos hasko falha para nullables. O método abaixo funcionará para anuláveis. Eu não pensei nisso, no entanto. Achei por meio do Google: http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx Crédito para "Tuna Toksoz"

Primeiro uso:

TConverter.ChangeType<T>(StringValue);  

A turma está abaixo.

public static class TConverter
{
    public static T ChangeType<T>(object value)
    {
        return (T)ChangeType(typeof(T), value);
    }

    public static object ChangeType(Type t, object value)
    {
        TypeConverter tc = TypeDescriptor.GetConverter(t);
        return tc.ConvertFrom(value);
    }

    public static void RegisterTypeConverter<T, TC>() where TC : TypeConverter
    {

        TypeDescriptor.AddAttributes(typeof(T), new TypeConverterAttribute(typeof(TC)));
    }
}

Para muitos tipos (integer, double, DateTime etc), existe um método Parse estático. Você pode invocá-lo usando reflexão:

MethodInfo m = typeof(T).GetMethod("Parse", new Type[] { typeof(string) } );

if (m != null)
{
    return m.Invoke(null, new object[] { base.Value });
}

TypeDescriptor.GetConverter(PropertyObject).ConvertFrom(Value)

TypeDescriptor é classe tendo método GetConvertor que aceita um objeto Type e, em seguida, você pode chamar o método ConvertFrom para converter o value para esse objeto especificado.


Ainda outra variação. Lida com Nullables, bem como situações em que a cadeia é nula e T não é anulável.

public class TypedProperty<T> : Property where T : IConvertible
{
    public T TypedValue
    {
        get
        {
            if (base.Value == null) return default(T);
            var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
            return (T)Convert.ChangeType(base.Value, type);
        }
        set { base.Value = value.ToString(); }
    }
}

public class TypedProperty<T> : Property
{
    public T TypedValue
    {
        get { return (T)(object)base.Value; }
        set { base.Value = value.ToString();}
    }
}

Eu usando a conversão através de um objeto. É um pouco mais simples.





type-safety