Code Focused

Default Access Levels in C# and Visual Basic

It pays to be explicit and not use the emotional defaults of each language.

The C# and Visual Basic access modifiers let you indicate the level of interpersonal relationships your type member can have. Whether they're Private, Public or something else, each modifier makes clear what code can access each member.

Every access modifier in C# has a parallel modifier in Visual Basic, and most of them use the same names. The "public" modifier in C# is identical to the Visual Basic "Public" modifier. The "private" and "protected" keywords are, likewise, identical in Visual Basic, save for the initial capital letter. The lone exception is the C# "internal" modifier, which is called "Friend" in Visual Basic.

This difference in naming might shed light on how each language treats type members when you omit access modifiers from your member declarations. C#, the shy language that it is, tends to internalize things, keeping them private in the absence of a clear direction from the programmer. As a result, all C# class members are private by default. If you want them to be anything other than private, you need to be explicit:

class JustSomeClass
{
  // ----- All members are private by default.
  int ThisFieldIsPrivate;
  private int SoIsThisOne;
  public int FinallySomethingPublic;
}

Visual Basic, on the other hand, is a big, friendly, bear-hug of a language, a bit more trusting than C#, and somewhat free with its type members. If you leave the access modifiers off of a field or constant declaration in Visual Basic, those members will be Private, just as in C#. However, all other members -- methods, properties, events and so on -- are Public by default, and will be Public unless you indicate differently:

Class JustSomeClass
  ' ----- Fields and constants are Private by default.
  Dim ThisFieldIsPrivate As Integer
  Private SoIsThisOne As Integer

  ' ----- Methods are Public by default.
  Sub RandomPublicMethod()
  End Sub

  Private Sub ButThisIsPrivate()
  End Sub
End Class

The friendly attitude of Visual Basic extends to structures, as well. All structure members are Public by default. This varies considerably from C#, which considers structure members private unless otherwise indicated. In both languages, a structure member can never by marked as Protected:

// ----- Simple C# structure.
struct JustSomeStructure
{
  int TypicalPrivateMember;
}

' ----- Simple Visual Basic structure.
Structure JustSomeStructure
  Dim TypicalPublicMember As Integer
End Structure

At the namespace level, where classes and structures typically live, things start to even out again in both languages. You can apply the access modifiers to type declarations, but if you leave them out, C# will treat classes as internal:

namespace SomeApplication
{
  // ----- This class is internal by default.
  class SomeClass
  {
    // ----- Members are private by default.
  }
}
Visual Basic, likewise, treats unmodified types as Friend:
Namespace SomeApplication
  ' ----- This class is Friend by default.
  Class SomeClass
    ' ----- Members are Private or Public by default,
    '       as described earlier.
  End Class
End Namespace

The moral is: Don't let your type members be controlled by the emotional defaults of each language. Be explicit.

About the Author

Tim Patrick has spent more than thirty years as a software architect and developer. His two most recent books on .NET development -- Start-to-Finish Visual C# 2015, and Start-to-Finish Visual Basic 2015 -- are available from http://owanipress.com. He blogs regularly at http://wellreadman.com.

comments powered by Disqus
Most   Popular
Upcoming Events

.NET Insight

Sign up for our newsletter.

Terms and Privacy Policy consent

I agree to this site's Privacy Policy.