Marquer les paramètres comme NON Nullables dans C # /. NET?

Existe-t-il un attribut simple ou un contrat de données que je peux attribuer à un paramètre de fonction qui empêche nulld'être passé en C # /. NET? Idéalement, cela vérifierait également au moment de la compilation pour s'assurer que le littéral nulln'est utilisé nulle part pour lui et au moment de l'exécution ArgumentNullException.

Actuellement, j'écris quelque chose comme ...

if (null == arg)
  throw new ArgumentNullException("arg");

... pour chaque argument que j'espère ne pas être null.

Sur la même note, y a-t-il un contraire à celui Nullable<>par lequel ce qui suit échouerait:

NonNullable<string> s = null; // throw some kind of exception

Il n'y a malheureusement rien de disponible au moment de la compilation.

J'ai un peu une solution hacky que j'ai publiée sur mon blog récemment, qui utilise une nouvelle structure et des conversions.

Dans .NET 4.0 avec le truc des contrats de code , la vie sera beaucoup plus agréable. Il serait toujours très agréable d'avoir une syntaxe de langage réelle et un support autour de la non-nullabilité, mais les contrats de code aideront beaucoup.

J'ai également une méthode d'extension dans MiscUtil appelée ThrowIfNull qui le rend un peu plus simple.

Un dernier point - une raison d'utiliser " if (null == arg)" au lieu de " if (arg == null)"? Je trouve ce dernier plus facile à lire, et le problème que le premier résout en C ne s'applique pas à C #.

Je sais que je suis incroyablement en retard pour cette question, mais je pense que la réponse deviendra pertinente à mesure que la dernière itération majeure de C # se rapproche de la sortie, puis est publiée. Dans C # 8.0, un changement majeur se produira, C # supposera que tous les types sont considérés comme non nuls.

Selon Mads Torgersen:

Le problème est que les références nulles sont si utiles. En C #, ils sont la valeur par défaut de chaque type de référence. Quelle serait la valeur par défaut d'autre? Quelle autre valeur aurait une variable, jusqu'à ce que vous puissiez décider quoi d'autre lui attribuer? Avec quelle autre valeur pourrions-nous ouvrir un tableau de références fraîchement alloué, jusqu'à ce que vous arriviez à le remplir?

En outre, parfois nul est une valeur sensible en soi. Parfois, vous voulez représenter le fait que, par exemple, un champ n'a pas de valeur. Qu'il est correct de passer «rien» pour un paramètre. L'accent est mis sur parfois, cependant. Et c'est là une autre partie du problème: les langages comme C # ne vous permettent pas d'exprimer si un nul ici est une bonne idée ou non.

La résolution décrite par Mads est donc:

1. Nous pensons qu'il est plus courant de vouloir qu'une référence ne soit pas nulle. Les types de référence nulles seraient les plus rares (bien que nous n'ayons pas de bonnes données pour nous dire de combien), ce sont donc eux qui devraient nécessiter une nouvelle annotation.

2. Le langage a déjà une notion de - et une syntaxe pour - les types valeur Nullable. L'analogie entre les deux rendrait l'ajout de langue plus facile sur le plan conceptuel et plus simple sur le plan linguistique.

3. Il semble juste que vous ne devriez pas vous charger ou charger votre consommateur de valeurs nulles encombrantes à moins que vous n'ayez activement décidé que vous les vouliez. Les valeurs nulles, et non leur absence, devraient être la chose à laquelle vous devez explicitement opter.

Un exemple de la fonctionnalité souhaitée:

public class Person
{
     public string Name { get; set; } // Not Null
     public string? Address { get; set; } // May be Null
}

L'aperçu est disponible pour Visual Studio 2017, version 15.5.4+.

Je sais que c'est une TRÈS vieille question, mais celle-ci manquait ici:

Si vous utilisez ReSharper / Rider, vous pouvez utiliser le cadre annoté .

Edit : Je viens d'avoir un -1 aléatoire pour cette réponse. C'est très bien. Sachez simplement qu'elle est toujours valide, même si ce n'est plus l'approche recommandée pour les projets C # 8.0 + (pour comprendre pourquoi, voir la réponse de Greg ).

Découvrez les validateurs dans la bibliothèque d'entreprise. Vous pouvez faire quelque chose comme:

private MyType _someVariable = TenantType.None;
[NotNullValidator(MessageTemplate = "Some Variable can not be empty")]
public MyType SomeVariable {
    get {
        return _someVariable;
    }
    set {
        _someVariable = value;
    }
}

Puis dans votre code lorsque vous souhaitez le valider:

Microsoft.Practices.EnterpriseLibrary.Validation.Validator myValidator = ValidationFactory.CreateValidator<MyClass>();

ValidationResults vrInfo = InternalValidator.Validate(myObject);

pas le plus joli mais:

public static bool ContainsNullParameters(object[] methodParams)
{
     return (from o in methodParams where o == null).Count() > 0;
}

vous pouvez également faire preuve de plus de créativité dans la méthode ContainsNullParameters:

public static bool ContainsNullParameters(Dictionary<string, object> methodParams, out ArgumentNullException containsNullParameters)
       {
            var nullParams = from o in methodParams
                             where o.Value == null
                             select o;

            bool paramsNull = nullParams.Count() > 0;


            if (paramsNull)
            {
                StringBuilder sb = new StringBuilder();
                foreach (var param in nullParams)
                    sb.Append(param.Key + " is null. ");

                containsNullParameters = new ArgumentNullException(sb.ToString());
            }
            else
                containsNullParameters = null;

            return paramsNull;
        }

bien sûr, vous pouvez utiliser un intercepteur ou une réflexion, mais ils sont faciles à suivre / à utiliser avec peu de frais généraux

Ok, cette réponse est un peu tardive, mais voici comment je résous le problème:

public static string Default(this string x)
{
    return x ?? "";
}

Utilisez cette méthode d'extension pour pouvoir traiter les chaînes nulles et vides comme la même chose.

Par exemple

if (model.Day.Default() == "")
{
    //.. Do something to handle no Day ..
}

Pas idéal je sais car vous devez vous rappeler d'appeler default partout mais c'est une solution.