Equivalente en C # de la función IsNull () en SQL Server

En SQL Server, puede usar la IsNull()función para verificar si un valor es nulo y, si lo es, devolver otro valor. Ahora me pregunto si hay algo similar en C #.

Por ejemplo, quiero hacer algo como:

myNewValue = IsNull(myValue, new MyValue());

en vez de:

if (myValue == null)
  myValue = new MyValue();
myNewValue = myValue;

Gracias.

Se llama ??operador coalescente nulo ( ):

myNewValue = myValue ?? new MyValue();

Lamentablemente, no hay equivalente al operador de fusión nula que funciona con DBNull; para eso, necesitas usar el operador ternario:

newValue = (oldValue is DBNull) ? null : oldValue;

public static T isNull<T>(this T v1, T defaultValue)
{
    return v1 == null ? defaultValue : v1;
}

myValue.isNull(new MyValue())

Utilice el método Equals:

object value2 = null;
Console.WriteLine(object.Equals(value2,null));

Para trabajar con DB Nulls, creé un montón para mis aplicaciones VB. Los llamo Cxxx2 ya que son similares a las funciones Cxxx integradas de VB.

Puedes verlos en mi proyecto de extensiones CLR

http://www.codeplex.com/ClrExtensions/SourceControl/FileView.aspx?itemId=363867&changeSetId=17967

Escribe dos funciones

    //When Expression is Number
    public static double? isNull(double? Expression, double? Value)
    {
        if (Expression ==null)
        {
            return Value;
        }
        else
        {
            return Expression;
        }
    }


    //When Expression is string (Can not send Null value in string Expression
    public static string isEmpty(string Expression, string Value)
    {
        if (Expression == "")
        {
            return Value;
        }
        else
        {
            return Expression;
        }
    }

Funcionan muy bien

He estado usando el siguiente método de extensión en mis tipos de DataRow:

    public static string ColumnIsNull(this System.Data.DataRow row, string colName, string defaultValue = "")
    {
        string val = defaultValue;
        if (row.Table.Columns.Contains(colName))
        {
            if (row[colName] != DBNull.Value)
            {
                val = row[colName]?.ToString();
            }
        }
        return val;
    }

uso:

MyControl.Text = MyDataTable.Rows[0].ColumnIsNull("MyColumn");
MyOtherControl.Text = MyDataTable.Rows[0].ColumnIsNull("AnotherCol", "Doh! I'm null");

Primero estoy verificando la existencia de la columna porque si ninguno de los resultados de la consulta tiene un valor no nulo para esa columna, el objeto DataTable ni siquiera proporcionará esa columna.

Utilice los métodos siguientes.

    /// <summary>
    /// Returns replacement value if expression is null
    /// </summary>
    /// <param name="expression"></param>
    /// <param name="replacement"></param>
    /// <returns></returns>
    public static long? IsNull(long? expression, long? replacement)
    {
        if (expression.HasValue)
            return expression;
        else
            return replacement;
    }

    /// <summary>
    /// Returns replacement value if expression is null
    /// </summary>
    /// <param name="expression"></param>
    /// <param name="replacement"></param>
    /// <returns></returns>
    public static string IsNull(string expression, string replacement)
    {
        if (string.IsNullOrWhiteSpace(expression))
            return replacement;
        else
            return expression;
    }

    public static T IsNull<T>(this T DefaultValue, T InsteadValue)
    {

        object obj="kk";

        if((object) DefaultValue == DBNull.Value)
        {
            obj = null;
        }

        if (obj==null || DefaultValue==null || DefaultValue.ToString()=="")
        {
            return InsteadValue;
        }
        else
        {
            return DefaultValue;
        }

    }

//This method can work with DBNull and null value. This method is question's answer

Esto se entiende a medias como una broma, ya que la pregunta es un poco tonta.

public static bool IsNull (this System.Object o)
{
   return (o == null);
}

Este es un método de extensión, sin embargo, extiende System.Object, por lo que cada objeto que usa ahora tiene un método IsNull ().

Entonces puedes guardar toneladas de código haciendo:

if (foo.IsNull())

en lugar del super cojo:

if (foo == null)