Attribute to inform method caller of the type of exceptions thrown by that method

Question

I'm not looking to implement the Java "throws" keyword. See http://www.artima.com/intv/handcuffsP.html for a discussion on the merits of the throws keyword and why it was not implemented in C#.

I am, however, curious if there's a way to create an attribute like the following:

[ThrowsException( exceptionType = NullReferenceException )] 
[ThrowsException( exceptionType = AuthenticationException )]
public void Login( Credentials credz ) 
{
    // ... etc...
}

such that - when calling a method which has been decorated with one or multiple ThrowsException attributes, the type of exceptions thrown by said method (at least the ones that are explicitly declared by the ThrowsException attribute) would be visible in the method's documentation

This is not the same as the Java "throws" keyword as it would not require that the caller handle these exceptions. Doing so could introduce breaking changes e.g. in a client application that does not handle new exceptions introduced by a version change.

While one could use:

/// <exception cref="member">description</exception>

My intent for using attributes is so that the project does not compile if the name of the exception has been changed or if the exception no longer exists. Therefore, How To Document Thrown Exceptions, is not the same question.

---

Update: 2013-05-23

I've figured out a way to resolve via the use of an attribute and without the use of plug-ins. I will try to get around to it this weekend and will be happy to post the solution if it works as expected. If someone beats me to posting a solution, I will happily accept their answer.

Since I won't be able to get around to this until Monday, I'm offering a bounty if you can beat me to it - An acceptable answer would:

• ( not include the use of a visual studio plug-in or any third-party tool
• && provide a way to include the exception(s) in the XML documentation
• && ensure type safety is enforced during compilation )
• || prove it is not possible to meet the preceding three requirements in order to provide a solution to the problem posed in this question

I would consider it acceptable for the XML documentation not to reflect the exceptions, from the ThrowsException attributes, until after the project has been built.

It would be interesting to see a Resharper-based solution (since it is common to most of the development shops I have worked in), but it will not be accepted if there is a solution that remains agnostic of third-party tools. Similarly, a solution that works only in Visual Studio would be accepted over a solution dependent on Resharper, but it would not be accepted if there is a solution that would work in other IDEs e.g. MonoDevelop (more frameworks supported - even better).

Answer 1

In C# you document classes and their members with a XML documentation. In Visual Studio, start typing slashes over something and by the third slash it'll auto-generate the most common tags for you to fill in. It looks vaguely like Javadoc and JSDoc.

You are looking, specifically, for this tag.

Answer 2

My intent for using attributes is so that the project does not compile if the name of the exception has been changed or if the exception no longer exists. Therefore, How To Document Thrown Exceptions, is NOT the same question.

You can do this without using attributes, instead by writing <exception> documentation and configuring your project like this:

Project properties -> 'Build' tab:
'Output' section: Check 'XML documentation file'.
'Treat warnings as erros' section: Check 'Specific warnings' and add warning 1574.

This way project won't compile if XML documentation cref attribute value cannot be resolved.