property - nullables c#

¿Convertir int a nullable int?

Question

Necesito saber cómo convertir un int en un int anulable. Sin embargo, sigo recibiendo un error "El operador binario Igual no está definido para los tipos ''System.Nullable`1 [System.Int32]'' y ''System.Int32''." Alguna solución. Debe ser el tipo int de nullable de Microsoft SQL Server.

 somevalue = Expression.Constant(something.GetValue(some,null).To<Nullable<System.Int32>> ());

public static T To<T>(this object obj)
    {
        Type t = typeof(T);
        Type u = Nullable.GetUnderlyingType(t);

        if (u != null)
        {
            if (obj == null)
                return default(T);

            return (T)Convert.ChangeType(obj, u);
        }
        else
        {
            return (T)Convert.ChangeType(obj, t);
        }
    }''

Answer 1

¿Algo así de simple no funciona?

int i; 
int? temp = int.TryParse(<your value>, out i) ? (int?)i : null;

Answer 2

Aqui tienes. Una cadena genérica para una solución primitiva anulable.

int? n = "  99 ".ToNullable<int>(); 

/// <summary>
/// Developed by Taylor Love
/// </summary>
public static class ToNullableStringExtension
{
    /// <summary>
    /// <para>More convenient than using T.TryParse(string, out T). 
    /// Works with primitive types, structs, and enums.
    /// Tries to parse the string to an instance of the type specified.
    /// If the input cannot be parsed, null will be returned.
    /// </para>
    /// <para>
    /// If the value of the caller is null, null will be returned.
    /// So if you have "string s = null;" and then you try "s.ToNullable...",
    /// null will be returned. No null exception will be thrown. 
    /// </para>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="p_self"></param>
    /// <returns></returns>
    public static T? ToNullable<T>(this string p_self) where T : struct
    {
        if (!string.IsNullOrEmpty(p_self))
        {
            var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(T));
            if (converter.IsValid(p_self)) return (T)converter.ConvertFromString(p_self);
            if (typeof(T).IsEnum) { T t; if (Enum.TryParse<T>(p_self, out t)) return t;}
        }

        return null;
    }

https://github.com/Pangamma/PangammaUtilities-CSharp/tree/master/src/StringExtensions

Answer 3

Parece que el código de To está intentando construir una Constant de tipo anulable cuando se le asigna un valor de tipo no anulable, pero no es la forma correcta de hacerlo . La forma en que intenta hacer esto indica que tiene un malentendido acerca de cómo funcionan los tipos de valor en caja.

Ese mensaje de error indica que está construyendo un nodo de árbol de expresión de operador binario que tiene como operandos un nodo de expresión de tipo int. Y un nodo de expresión de tipo int. Eso no es legal; Tienen que ser ambos nullable int. Lo que debería hacer es envolver el nodo del árbol de expresiones int que no acepta valores nulos en un nodo del árbol de expresiones de conversión que lo convierte en un int que acepta valores nulos, y luego pasarlo al constructor del nodo del árbol de expresiones del operador binario.

Es decir, esto está mal:

var someIntExpr = Expression.Constant(123, typeof(int));
var someNubIntExpr = Expression.Constant(null, typeof(int?));
var badEq = Expression.Equal(someIntExpr, someNubIntExpr);

Esto es correcto:

var goodEq = Expression.Equal(Expression.Convert(someIntExpr, typeof(int?)),  someNubIntExpr);

Entonces, ¿por qué es lo que estás haciendo mal?

Tienes un método To<T> que devuelve una T ¿Toma correctamente un int y devuelve el int? equivalente int? . Entonces, ¿qué? Se lo pasa a Expression.Constant , que encuadra el int anulable en un int recuadrado , y luego hace una constante de eso. Usted cree que existe un tipo de valor nulable en caja, pero no lo hay. Un cuadro de tipo de valor anulable a una referencia nula o un tipo de valor no anulable en caja.

Así que también podrías resolver tu problema al no hacer ninguna de estas locuras en primer lugar . Si tiene un int en caja y necesita un nodo de árbol de expresión constante de tipo anulable, simplemente proporcione el tipo .

Expression.Constant(someBoxedIntValue, typeof(int?))

Hecho. Entonces: terminando, tienes dos soluciones:

• Si tiene un int en caja, páselo y el tipo de valor anulable que desea a la fábrica de Constant , o
• Si tiene un nodo de expresión de tipo int en la mano, use la fábrica de nodos de expresión de conversión, y páselo y el tipo deseado.

Ambos le devolverán un nodo de expresión del tipo correcto que se comparará con otro int anulable.

Answer 4

Por lo general, se convierte un int un int? utilizando un yeso.

int? myNullable = (int?) 15;
int myInt = (int) myNullable;

Answer 5

int i = 1;
int? k;
k = i as int?;

De esta forma, convertirás i que es un int en un int.

int? Es la versión corta de Nullable<int> .

Answer 6

int test = 0; // set int

int? num = test; // convert test to a nullable int

num = null; // set num as null