Mauvais usage de peut-être monade et les méthodes d'extension dans C#?

même si je suis un fan des méthodes d'extension, Je ne pense pas que cela soit vraiment utile. Vous avez encore la répétition des expressions (dans la version monadique), et cela signifie Juste que vous devez expliquer Maybe à tout le monde. La courbe d'apprentissage ajoutée ne semble pas avoir assez d'avantages dans ce cas.

la version IfNotNull réussit au moins à éviter la répétition, mais je pense qu'elle est encore un peu trop longue sans être vraiment plus claire.

peut-être qu'un jour nous aurons un opérateur de déréférencement à sécurité nulle...

tout comme un côté, ma méthode d'extension semi-maléfique préférée est:

public static void ThrowIfNull<T>(this T value, string name) where T : class
{
    if (value == null)
    {
        throw new ArgumentNullException(name);
    }
}

qui vous permet de tourner ce:

void Foo(string x, string y)
{
    if (x == null)
    {
        throw new ArgumentNullException(nameof(x));
    }
    if (y == null)
    {
        throw new ArgumentNullException(nameof(y));
    }
    ...
}

en:

void Foo(string x, string y)
{
    x.ThrowIfNull(nameof(x));
    y.ThrowIfNull(nameof(y));
    ...
}

il y a encore la méchante répétition du nom du paramètre, mais au moins c'est plus ordonné. Bien sûr, dans .NET 4.0 j'utiliserais des contrats de Code, c'est ce sur quoi je suis censé écrire en ce moment... Stack Overflow est un grand travail d'évitement ;)

si vous voulez une méthode d'extension pour réduire le si imbriqué comme vous avez, vous pourriez essayer quelque chose comme ceci:

public static object GetProperty(this object o, Type t, string p)
{
    if (o != null)
    {
        PropertyInfo pi = t.GetProperty(p);
        if (pi != null)
        {
            return pi.GetValue(o, null);
        }
        return null;
    }
    return null;
}

alors dans votre code vous ne feriez que:

string activeControlName = (Form.ActiveForm as object)
    .GetProperty(typeof(Form),"ActiveControl")
    .GetProperty(typeof(Control),"Name");

Je ne sais pas si je voudrais l'utiliser souvent en raison de la lenteur de la réflexion, et je ne pense pas vraiment que ce beaucoup mieux que l'alternative, mais il devrait fonctionner, indépendamment de savoir si vous frappez un null en cours de route...

(Note: je pourrais avoir obtenu ces types mélangés) :)

dans le cas où vous avez affaire à C# 6.0 / VS 2015 et au-dessus, ils ont maintenant une solution intégrée pour la propagation nulle:

string ans = nullableString?.Length.ToString(); // null if nullableString == null, otherwise the number of characters as a string.

l'échantillon initial fonctionne et est le plus facile à lire en un coup d'oeil. Est-il vraiment nécessaire de l'améliorer?

la solution IfNotNull est la meilleure (jusqu'à ce que L'équipe C# nous donne un opérateur de déréférencement à sécurité nulle, c'est-à-dire).

Je ne suis pas fou des deux solutions. Quel était le problème avec la version asorter de l'original:

string activeControlName = null;
if (Form.ActiveForm != null)
    if (Form.ActiveForm.ActivControl != null) activeControlname = activeControl.Name;

si ce n'est pas cela, alors je regarderais l'écriture D'un NotNullChain ou FluentNotNull objet qui peut enchaîner quelques tests pas null dans une rangée. Je suis d'accord que la méthode d'extension IfNotNull agissant sur un null semble un peu bizarre - même si les méthodes d'extension ne sont que du sucre syntaxique.

je pense que la réponse de Mark Synowiec pourrait faire générique.

à mon humble avis, je pense que le C# noyau de l'équipe devrait ressembler à ce "problème", même si je pense qu'il y a des choses plus importantes à résoudre.

sûr, original 2-niché si est beaucoup plus lisible que d'autres choix. Mais en suggérant que vous voulez résoudre le problème plus généralement, voici une autre solution:

try
{
    var activeForm = Form.ActiveForm; assumeIsNotNull(activeForm);
    var activeControl = activeForm.ActiveControl; assumeIsNotNull(activeControl);
    var activeControlname = activeControl.Name;
}
catch (AssumptionChainFailed)
{
}

où

class AssumptionChainFailed : Exception { }
void assumeIsNotNull(object obj)
{
    if (obj == null) throw new AssumptionChainFailed();
}