VB.NET Access Modifiers

Access modifiers in VB.NET control the accessibility of program elements (like variables, methods, classes, and properties) within your code and across assemblies (compiled program units). They dictate which parts of your code can see and interact with these elements. Here's a breakdown of the different access modifiers and their functionalities:

There are four access specifiers available in VB.NET:


The most permissive access modifier. Elements declared as Public are accessible from any part of your code, regardless of the namespace or assembly they reside in.

Use Case: Public elements are meant to be used by other parts of your application or potentially even external code that references your assembly. Examples include utility functions or classes designed for general use.
Public Class MyClass Public myPublicVariable As Integer Public Sub MyPublicMethod() ' Code here End Sub End Class Dim obj As New MyClass() obj.myPublicVariable = 10 ' Accessing public variable obj.MyPublicMethod() ' Accessing public method


Elements declared as Protected are accessible from within the class where they are defined, as well as from derived classes that inherit from that class. They are not directly accessible from outside the inheritance hierarchy.

Use Case: Protected elements are often used in base classes to provide functionality that derived classes can reuse or extend. This promotes code reuse and maintainability.
Public Class MyBaseClass Protected myProtectedVariable As Integer Protected Sub MyProtectedMethod() ' Code here End Sub End Class Public Class MyDerivedClass Inherits MyBaseClass Public Sub AccessProtectedMember() myProtectedVariable = 10 ' Accessing protected variable MyProtectedMethod() ' Accessing protected method End Sub End Class

Friend (Default)

Elements declared as Friend are accessible from within the same assembly (compiled program unit) where they are defined. They are not accessible from other assemblies, even if those assemblies reference yours.

Use Case: Friend elements are useful for sharing code between classes within the same assembly while keeping them hidden from external code. This promotes modularity within an assembly.
Public Class MyClass Friend myFriendVariable As Integer Friend Sub MyFriendMethod() ' Code here End Sub End Class Dim obj As New MyClass() obj.myFriendVariable = 10 ' Accessing friend variable obj.MyFriendMethod() ' Accessing friend method


The most restrictive access modifier. Elements declared as Private are only accessible within the same class or structure where they are defined. They are hidden from other parts of your code and external assemblies.

Use Case: Private elements are typically used for internal implementation details within a class that don't need to be exposed externally. This promotes encapsulation and data hiding.
Public Class MyClass Private myPrivateVariable As Integer Private Sub MyPrivateMethod() ' Code here End Sub End Class Dim obj As New MyClass() obj.myPrivateVariable = 10 ' Error: Private variable not accessible obj.MyPrivateMethod() ' Error: Private method not accessible

Protected Friend (Combination)

This modifier combines aspects of Protected and Friend. Elements declared as Protected Friend are accessible from within the class where they are defined, derived classes (like Protected), and also from other classes within the same assembly (like Friend).

Use Case: Protected Friend elements provide a way to share functionality between classes within an inheritance hierarchy and also with other classes within the same assembly, while still hiding them from external code.

These access specifiers help in encapsulating and controlling the visibility of members, allowing for proper encapsulation and modular design. By choosing the appropriate access specifier, you can ensure that the members of your class are accessible and used only where necessary, enhancing the security and maintainability of your code.

Choosing the Right Access Modifier

  1. Default Access: By default, elements in a class are Private unless explicitly declared otherwise.
  2. General Principle: Aim for the most restrictive access modifier possible while still achieving the desired functionality. This promotes encapsulation and reduces the risk of unintended side effects.
  3. Public: Use sparingly for elements truly meant for external consumption.
  4. Private: Favor Private for internal implementation details.
  5. Protected and Friend: Consider these for code sharing within inheritance hierarchies or within the same assembly, respectively.
  6. Protected Friend: Use cautiously for specific scenarios where controlled sharing across inheritance and assembly boundaries is required.


Access modifiers govern the visibility and accessibility of class members. Following a principle of least privilege, developers typically default to private access for encapsulation, only exposing members as necessary with more permissive modifiers like protected, friend, or public. Careful consideration of access modifiers ensures code integrity, encapsulation, and facilitates maintainability in VB.NET projects.