Itérer sur les paramètres de la méthode à des fins de validation

Bien, non, sauf si vous comptez:

public void Foo(string x, object y, Stream z, int a)
{
    CheckNotNull(x, y, z);
    ...
}

public static void CheckNotNull(params object[] values)
{
    foreach (object x in values)
    {
        if (x == null)
        {
            throw new ArgumentNullException();
        }
    }
}

Pour éviter la création de la matrice a frappé, vous pourriez avoir un certain nombre de surcharges pour différents nombres d'arguments:

public static void CheckNotNull(object x, object y)
{
    if (x == null || y == null)
    {
        throw new ArgumentNullException();
    }
}

//etc

Une alternative serait d'utiliser les attributs de déclarer que les paramètres ne devrait pas être nulle, et obtenir PostSharp pour générer les contrôles appropriés:

public void Foo([NotNull] string x, [NotNull] object y, 
                [NotNull] Stream z, int a)
{
    //PostSharp would inject the code here.
}

Certes je voudrez probablement PostSharp de le convertir en Les Contrats De Code des appels, mais je ne sais pas comment bien les deux jouent ensemble. Peut-être un jour, nous allons être en mesure d'écrire les Spec#:

public void Foo(string! x, object! y, Stream! z, int a)
{
    //Compiler would generate Code Contracts calls here
}

... mais pas dans un futur proche 🙂

OriginalL'auteur Jon Skeet

J'ai eu la même question il y a quelques temps, mais je voulais le faire à des fins de journalisation. Je n'ai jamais trouvé une bonne solution, mais trouvé ce lien concernant l'utilisation d'un AOP approche fondée sur les méthode de journalisation d'entrées et de sortie. L'essentiel, c'est le besoin d'utiliser un framework qui permet la lecture de votre classe et injecter du code à l'exécution pour faire ce que vous essayez de faire. N'a pas l'air facile.

Comment faire pour intercepter un appel de méthode en C#?

OriginalL'auteur Binz

Vous pouvez regarder dans La Validation De Bloc D'Application qui peut être traité comme un exemple de validation automatique et L'Unité De Bloc D'Application (en particulier son interception fonction) en ce qui concerne l'interception des appels et de l'inspection des paramètres.

OriginalL'auteur Dzmitry Huba

Après avoir fourni un exemple trivial d'une méthode à l'aide de la params mot-clé, RaYell dit:

À mon avis, toutefois, il n'est pas une bonne
façon de faire les choses. Vous aurez à
contrôler manuellement le type de votre
paramètres, leur position dans le
tableau d'entrée et vous ne serez pas en mesure de
utilisation de la fonctionnalité intellisense pour eux dans Visual
Studio.

Je serais certainement d'accord que la déclaration d'une méthode qui prend deux strings, un int, un object que peut avoir la valeur null, et un autre MyClass objet à l'aide de params est une mauvaise idée. Cependant, il y sont (à mon avis) parfaitement valide et approprié aux applications de la params mot-clé, à savoir lorsque les paramètres sont tous du même type. Par exemple:

public T Max<T>(T x, T y) where T : IComparable<T> {
    return x.CompareTo(y) > 0 ? x : y;
}

public T Max<T>(params T[] values) where T : IComparable<T> {
    T maxValue = values[0];

    for (int i = 1; i < values.Length; i++) {
        maxValue = Max<T>(maxValue, values[i]);
    }

    return maxValue;
}

OriginalL'auteur Dan Tao