Do private classes need to be accessed by properties?

Question

I am using an instance of a private class as the state object supplied to a stream.BeginRead operation. (The class is private to my main stream reading/writing class.)

public class MainClass
{
    // ...

    private class ResponseState
    {
        public IResponse response;
        public Stream stream;
        public byte[] buffer = new byte[1024];
    }
}

Access to the class is via the fields directly. Should I really be providing access to the class via properties in this case, even though it is only to be used for holding state?

Interested to know what others do.

Answer 1

It's not required by the C# language, but it is good practice never to expose a field directly for maintainability reasons - it is suggested to use a property instead.

See StyleCop SA1401: FieldsMustBePrivate.

TypeName - FieldsMustBePrivate
CheckId - SA1401
Category - Maintainability Rules

Cause

A field within a C# class has an access modifier other than private.

Rule Description

A violation of this rule occurs whenever a field in a class is given non-private access. For maintainability reasons, properties should always be used as the mechanism for exposing fields outside of a class, and fields should always be declared with private access. This allows the internal implementation of the property to change over time without changing the interface of the class.

Fields located within C# structs are allowed to have any access level.

How to Fix Violations

To fix a violation of this rule, make the field private and add a property to expose the field outside of the class.

If your class is purely state for the containing class then you could consider placing the members directly inside the class that uses them. If your class is more than just state (and I suspect it is) then it should follow the usual maintainability rules.

Answer 2

I would - encapsulation is useful inside the class as well as outside the class. By funneling all access to a member through a well know interface (i.e. the property) you are giving yourself the flexibility to add logic around that access later without changing calling code.

It may seem like overkill but honestly, given automatically implemented properties, it is so easy to declare a property that you may as well go ahead and use one to give yourself maximum flexibility.