Adding Annotations for ReSharper Code Inspection

[BrunoJuchli]

Hi
Given the following code:

public static class ForEachExtensions
{
    public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
    {
        Guard.That(() => enumerable).IsNotNull();
        Guard.That(() => action).IsNotNull();

        foreach (T item in enumerable)
        {
            action(item);
        }
    }
}

ReSharper will warn us of "Possible multiple enumeration of IEnumerable". This is because - of course - ReSharper does not know whether the external .That() method is actually enumerating the IEnumerable or not.
However we can tell ReSharper that the That() method is not enumerating the IEnumerable. This can be done either by adding attributes to the implementation of Seterlund.CodeGuard or by adding an an XML file besides the Seterlund.CodeGuard.dll. The attributes don't require to reference a JetBrains library or the likes. Also see http://www.jetbrains.com/resharper/webhelp/Code_Analysis__Code_Annotations.html

Given that the code attributes don't require any external dependency and they clutter the code only a little, i think it might be a viable alternative. It would certainly be easiest to maintain. So at this point i personally would prefer this, but of course, the external XML annotations are good enough, too.

Would you accept a pull request for this feature and if so, which method would you prefer?

btw. Thank you for the great library! :)

[3komma14]

Hi.
Thanks.
Just send the pull request and I will have a look at it and then update the
lib.

Per Ivar
8. aug. 2014 08:34 skrev "Bruno Juchli" notifications@github.com følgende:

Hi
Given the following code:

public static class ForEachExtensions
{
public static void ForEach(this IEnumerable enumerable, Action action)
{
Guard.That(() => enumerable).IsNotNull();
Guard.That(() => action).IsNotNull();

    foreach (T item in enumerable)
    {
        action(item);
    }
}

}

ReSharper will warn us of "Possible multiple enumeration of IEnumerable".
This is because - of course - ReSharper does not know whether the external
.That() method is actually enumerating the IEnumerable or not.
However we can tell ReSharper that the That() method is not enumerating
the IEnumerable. This can be done either by atting attributes to the
implementation of Seterlund.CodeGuard or by adding an an XML file besides
the Seterlund.CodeGuard.dll. The attributes don't require a reference to
anything jetbrains. Also see
http://www.jetbrains.com/resharper/webhelp/Code_Analysis__Code_Annotations.html

Given that the code attributes don't require any external dependency and
they clutter the code only a little, i think it might be a viable
alternative. It would certainly be easiest to maintain. So at this point i
personally would prefer this, but of course, the external XML annotations
are good enough, too.

Would you accept a pull request for this feature and if so, which method
would you prefer?

btw. Thank you for the great library! :)

—
Reply to this email directly or view it on GitHub
#15.

[BrunoJuchli]

So i've been looking into it.

First issue: on Guard.That(Expression<Func<T>> argument)) the [NoEnumeration] attribute can't work because the expression specified in the client code is accessing the IEnumerable-variable, and that's where ReSharper warns that multiple enumeration occurs - not because it is passed to .That.

Second issue: Using [NoEnumeration] on Guard.That<T>(T argument, string argumentName) is a bad idea because the enumeration verifications can/do enumerate the IEnumerable - so it would be wrong.

However, i found another beneficial attribute: with [InvokerParameterName] string argumentName you can tell ReSharper code completion to suggest argument names of the calling method (maybe it also warns if you're not using an argument name, don't know about that, though).

Next issue:
I didn't get i working without requiring ReSharper to be configured accordingly. I thought putting the annotations-attributes in the namespace JetBrains.Annotations would result in R# picking it up automatically.
Thats - sadly - not the case.
Putting the attributes in a namespace Seterlund.CodeGuard.Annotations it works, but only after configuring resharper to consider these attributes (check Seterlund.CodeGuard.Annotations in the list at ReSharper --> Options --> Code Inspection --> Code Annotations).

I have not yet checked XML annotations, maybe these would work without requiring configuration.

---

Personal summary:
-Not feasible to suppress most warnings, since suppression would be invalid for some cases
-parameter name suggestion only after configuring resharper to consider Seterlund.CodeGuard.Annotations --> most users won't use it
-Probably most people are using the Guard.That(Expression<Func<T>> argument)) overload any way, so for them there is no benefit in any annotations

So i suggest to close the issue and not add any annotations at all.

However if you disagree and think that there would be considerable benefit in adding [InvokerParameterName] to the overload where you specify the argument name, i'd be willing to add it and send a pull request.