Équivalent C # de la fonction IsNull () dans SQL Server

Dans SQL Server, vous pouvez utiliser le IsNull() fonction pour vérifier si une valeur est nulle et, le cas échéant, renvoyer une autre valeur. Maintenant, je me demande s'il y a quelque chose de similaire en C #.

Par exemple, je veux faire quelque chose comme:

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

au lieu de:

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

Merci.

C'est ce qu'on appelle l' ??opérateur null coalescing ( ):

myNewValue = myValue ?? new MyValue();

Malheureusement, il n'y a pas d'équivalent à l'opérateur de fusion nul qui fonctionne avec DBNull; pour cela, vous devez utiliser l'opérateur ternaire:

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())

Utilisez la méthode Equals:

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

Pour travailler avec DB Nulls, j'ai créé un tas pour mes applications VB. Je les appelle Cxxx2 car ils sont similaires aux fonctions Cxxx intégrées de VB.

Vous pouvez les voir dans mon projet d'extensions CLR

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

Vous écrivez deux fonctions

    //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;
        }
    }

Ils fonctionnent très bien

J'ai utilisé la méthode d'extension suivante sur mes types 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;
    }

usage:

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

Je vérifie d'abord l'existence de la colonne car si aucun des résultats de la requête n'a une valeur non nulle pour cette colonne, l'objet DataTable ne fournira même pas cette colonne.

Utilisez les méthodes ci-dessous.

    /// <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

Ceci est considéré à moitié comme une blague, car la question est un peu ridicule.

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

C'est une méthode d'extension, mais elle étend System.Object, donc chaque objet que vous utilisez a maintenant une méthode IsNull ().

Ensuite, vous pouvez enregistrer des tonnes de code en faisant:

if (foo.IsNull())

au lieu du super boiteux:

if (foo == null)