CA1019: Define accessor for attribute argument. I don't understand the reason

Today, I was cleaning up some of my code with FXCop and it complained about a Attribute class I had with this violation.

CA1019: Define accessor for attribute argument.

On this page, http://msdn.microsoft.com/en-us/library/ms182136.aspx there is more information, but I still do not get the reason for this as it seems to me more verbose and less relevant.

It gives two codes samples.

using System;

namespace DesignLibrary
{
// Violates rule: DefineAccessorsForAttributeArguments.

[AttributeUsage(AttributeTargets.All)]
public sealed class BadCustomAttribute :Attribute 
{
  string data;

  // Missing the property that corresponds to 
  // the someStringData parameter.

  public BadCustomAttribute(string someStringData)
  {
     data = someStringData;
  }
}


// Satisfies rule: Attributes should have accessors for all arguments.
[AttributeUsage(AttributeTargets.All)]
public sealed class GoodCustomAttribute :Attribute 
{
  开发者_开发百科 string data;

   public GoodCustomAttribute(string someStringData)
   {
      data = someStringData;
   }
   //The constructor parameter and property
   //name are the same except for case.

   public string SomeStringData
   {
      get 
      {
         return data;
      }
   }
}
}

I don't understand why the SomeStringData property is required. Isn't the someStringData a parameter? Why does it need to have its own property if it is already stored in another property?

Actually, mine is a little different as it looks like this.

[AttributeUsage(AttributeTargets.Property)]
public sealed class ExampleAttribute : Attribute
{
    public ExampleAttribute(string attributeValue)
    {
        this.Path = attributeValue;
    }

    public string Name
    {
        get;
        set;
    }

    // Add to add this to stop the CA1019 moaning but I find it useless and stupid?
    public string AttributeValue
    {
        get
        {
            return this.Name;
        }
    }
}

Rather than a private field, I have used a public autoproperty, I had to add the last part to make the warning stop but I don't see the point and it also adds another public field to this class, which is redundant, and seems less clean.

That said, I assume that this warning is raised for a reason so what good reason I am missing here?

Thanks in advance.

FxCop is complaining because your existing property doesn't match the parameter name.
Therefore, it doesn't realize that the parameter actually is exposed.

You should rename the property or parameter to match (except for case), or suppress the warning.

FxCop rule CA1019 is just enforcing the .Net Framework coding guidelines for Attributes.

Use named arguments (read/write properties) for optional parameters. Provide a read/write property with the same name as each named argument, but change the case to differentiate between them.

Documentation Link: http://msdn.microsoft.com/en-us/library/2ab31zeh(v=vs.71).aspx

The reason behind the FxCop warning is that every piece of data you pass into the attribute's constructor should be made publicly available to access when the attribute instance is being retrieved by Reflection.

Let's say you have this:

[BadCustom("My String Data")]
public class DecoratedClass
{ 
}

How will you get "My String Data" back from that attribute instance when you read it using:

BadCustomAttribute attr = typeof(DecoratedClass)
    .GetCustomAttributes(typeof(BadCustomAttribute), false)
    .Single() as BadCustomAttribute;

Now you have the instance of your attribute, but no way to read the string passed into the constructor because you didn't at least declare a read-only property for it.

the idea is that you should write just:

[AttributeUsage(AttributeTargets.Property)]
public sealed class ExampleAttribute : Attribute
{
    public ExampleAttribute(string attributeValue)
    {
        this.AttributeValue = attributeValue;
    }

    public string AttributeValue
    {
        get;
        set;
    }
}

This violation will also be thrown when the parameter name matches the property name, but the data types are different.