Should you use the private access modifier if it's redundant? [closed]

Answer 1

Marking it as private makes it clear that it is deliberate, rather than "I didn't actually think about it, so I don't know if it would be better as something else."; so I do like making it explicit. I wouldn't get religious about it, though.

Also - this prevents having to remember rules... members are private by default, (outer) types are internal by default; nested types are private by default...

Make it clear... make it explicit ;-p

Answer 2

First I will ask if there is a previous code convention/standard about that being used by the team. If there is any, you should follow it.

If you have to define the convention, I will push for the explicit way.

My reasons?;

• I like to keep the same structure (I mean a.-access modifier, b.-return-type/type, c.-name).
• I don't want (and I don't expect others) to remember all the modifiers by default (which are here).
• Not all the languages have the same rules.
• And somehow I think that, somehow, forces the developer to think and be more conscious about the scope of the variable/method and the exposition of those. If you have some experience this will probably not apply, but if you are a newbie, or you work with people with less experience, I think that is useful.

Answer 3

Always use the explicit form. If for whatever reason the underlying assumption changes, the code with an explicit denotation of access won't break, whereas the implicit connotation my easily break.

Also, when you are talking about different types of structures, they may have different default accessibilities. Without the explicit modifiers, the ownus is on the reader to know which structure has what default. E.g. in C#, struct fields default to public, class fields default to private, and class definitions default to internal.

Answer 4

I always omit it for two reasons: to reduce visual clutter, and to do the right thing by default.

In C#, everything defaults to the least visibility possible. A class member (field, method, property) defaults to private. A class defaults to internal. A nested class defaults to private.

Thus if you omit your visibility except where you need it, you'll be automatically using the least visibility possible, which is the right way to do things anyway.

If you need something to be more visible, then add the modifier. This makes it easy to see items that deviate from the default visibility.

(Unfortunately, this rule only holds for C#. In VB .NET and in F#, the defaults are quite different and definitely not "least visibility possible" in most cases.)

Answer 5

I go for explicit all the time. If nothing else it demonstrates your intention more clearly. If I want something to be private I will say so. Explicitly typing the modifier makes sure I think about it, rather than just leaving things private because its quicker. That an a long list of members line up better :)

Answer 6

I always specify the visibility explicitly. I prefer not letting the compiler guess my intentions.