O que é o caminho mais curto para afirmar que um atributo é aplicado ao método em c #?

Question

O que é o caminho mais curto para afirmar que um atributo é aplicado ao método em c #?

Eu estou usando nunit-2.5

:)

Answer 1

MethodInfo mi = typeof(MyType).GetMethod("methodname");    

Assert.IsFalse (Attribute.IsDefined (mi, typeof(MyAttributeClass)));

Answer 2

Eu não tenho certeza do método afirmam que usos NUnit, mas você pode simplesmente usar esta expressão booleana para o parâmetro que é passado para ele (supondo que você é capaz de usar LINQ:

methodInfo.GetCustomAttributes(attributeType, true).Any()

Se o atributo é aplicado, então ele irá retornar true.

Se você quiser fazer uma versão genérica (e não usar typeof) você pode usar um método genérico para fazer isso para você:

static bool IsAttributeAppliedToMethodInfo<T>(this MethodInfo methodInfo) 
    where T : Attribute
{
    // If the attribute exists, then return true.
   return methodInfo.GetCustomAttributes(typeof(T), true).Any();
}

E, em seguida, chamá-lo em seu método assert assim:

<assert method>(methodInfo.IsAttributeAppliedToMethodInfo<MyAttribute>());

Para fazer isso com uma expressão, você pode definir o seguinte método de extensão em primeiro lugar:

public static MethodInfo 
    AssertAttributeAppliedToMethod<TExpression, TAttribute>
    (this Expression<T> expression) where TAttribute : Attribute
{
    // Get the method info in the expression of T.
    MethodInfo mi = (expression.Body as MethodCallExpression).Method;

    Assert.That(mi, Has.Attribute(typeof(TAttribute)));
}

E, em seguida, chamá-lo no código como este:

(() => Console.WriteLine("Hello nurse")).
    AssertAttributeAppliedToMethod<MyAttribute>();

Note que não importa o que os parâmetros que são passados ??para o método são, como o método nunca é chamado, ele simplesmente precisa da expressão.

Answer 3

Uma alternativa para nunit 2.5:

var methodInfo = typeof(MyType).GetMethod("myMethod");

Assert.That(methodInfo, Has.Attribute(typeof(MyAttribute)));