I’ve been using FxCop to lint my C# code. It’s a very impressive tool. It uses introspection to analyze .NET assemblies and report on all sorts of problems. Like most tools of this sort, some of the suggestions are useful, some are just noise, and some seem contrary to progress.

One of the things it’s bothered about is public members in classes. If you write code like this:

// version 1
class MyClass
{
    public string MyString;
}

then FxCop will complain and direct you to this explanation: Do not declare visible instance fields. The guidance directs you to rewrite it like this:

// version 2
class MyClass
{
    private string myString;

    public string MyString
    {
        get { return myString; }
        set { myString = value; }
    }
}

The reason given for all the extra verbiage is to avoid exposing implementation details. But this seems misguided to me. After all, the caller of version 1 writes something like this:

MyClass myobj = new MyClass();
myobj.MyString = "little bunny foo-foo";

while the caller of version 2 writes something like this:

MyClass myobj = new MyClass();
myobj.MyString = "little bunny foo-foo";

That’s right: they’re exactly the same. So how have I exposed an implementation detail? I could start with version 1, and change it to version 2, and no calling code would have to change at all. Ergo, the implementation is not exposed.

The FxCop documentation takes pains to point out that version 2 is optimized to be as efficient as version 1. But I still have to write and later wade through those extra lines of code, and for what?

Am I missing something because I’m a C# and .NET newbie? In Python, getters and setters are superfluous. Is C# so different?