Access modifiers (public, private, internal) in C Sharp (C#) - Deep Dive

Overview - Access modifiers (public, private, internal)

What is it?

Access modifiers in C# are keywords that control the visibility of classes, methods, and variables. They decide who can see or use a part of your code. The main modifiers are public, private, and internal, each allowing different levels of access. This helps keep code organized and safe from unwanted changes.

Why it matters

Without access modifiers, all parts of a program would be open to everyone, making it easy to accidentally change important data or break code. Access modifiers protect your code by hiding details that should not be changed directly. This makes programs more reliable and easier to maintain, especially when many people work on the same project.

Where it fits

Before learning access modifiers, you should understand basic C# syntax and how classes and methods work. After mastering access modifiers, you can learn about advanced topics like inheritance, encapsulation, and design patterns that rely on controlling access to code parts.

Mental Model

Core Idea

Access modifiers are like doors with different locks that control who can enter and use parts of your code.

Think of it like...

Imagine a house with rooms: public rooms are open to all guests, private rooms are locked and only the owner can enter, and internal rooms are accessible only to family members living in the house.

┌───────────────┐
│   Public      │  ← Open to everyone
├───────────────┤
│   Internal    │  ← Accessible within the same assembly (like family)
├───────────────┤
│   Private     │  ← Only accessible inside the class (owner only)
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Public Access Modifier

Concept: Public members are accessible from anywhere in the program or other programs that use it.

In C#, when you mark a class or method as public, it means anyone can use it. For example: public class Car { public void Drive() { // anyone can call this method } } This means other parts of your program or even other programs can create a Car and call Drive.

Result

The Drive method can be called from any other code without restrictions.

Knowing public means open access helps you decide which parts of your code should be freely usable by others.

2

Foundation

Understanding Private Access Modifier

Concept: Private members are only accessible inside the class they belong to.

When you mark something private, it hides it from all other code except inside the same class. For example: public class Car { private int speed; public void SetSpeed(int value) { speed = value; // allowed because inside the class } } No other class can see or change speed directly.

Result

The speed variable is hidden from outside code, protecting it from accidental changes.

Understanding private access helps you protect important details and control how your class works.

3

Intermediate

Exploring Internal Access Modifier

Concept: Internal members are accessible only within the same assembly or project.

Internal means the code can be used anywhere inside the same compiled project but not from outside. For example: internal class Helper { internal void Assist() { // usable only inside this project } } If another project tries to use Helper, it will not see it.

Result

Internal members are hidden from other projects but open inside the current one.

Knowing internal access helps you share code safely within a project while hiding it from outside users.

4

Intermediate

Combining Access Modifiers in Classes

Concept: Classes can have members with different access levels to control visibility precisely.

You can mix public, private, and internal inside one class to decide what others can see: public class BankAccount { private decimal balance; internal string AccountNumber; public void Deposit(decimal amount) { balance += amount; } } Here, balance is hidden, AccountNumber is visible inside the project, and Deposit is open to everyone.

Result

Different parts of the class have different visibility, improving safety and flexibility.

Understanding how to combine modifiers lets you design classes that protect data but still provide useful features.

5

Intermediate

Default Access Levels in C#

Concept: If you don't specify an access modifier, C# uses a default based on the context.

For example, class members are private by default, but top-level classes are internal by default: class MyClass { // internal by default int number; // private by default } Knowing defaults helps avoid mistakes and keeps code clean.

Result

Code without explicit modifiers still has controlled access based on C# rules.

Knowing defaults prevents accidental exposure or hiding of code parts.

6

Advanced

Access Modifiers and Assembly Boundaries

🤔Before reading on: Do you think internal members are accessible from other projects referencing the assembly? Commit to yes or no.

Concept: Internal limits access to the same assembly, which is a compiled unit like a DLL or EXE.

An assembly is a compiled output of your project. Internal members are visible only inside this assembly. Even if another project references your assembly, it cannot access internal members: // Assembly A internal class SecretHelper {} // Assembly B referencing A // Cannot access SecretHelper This keeps internal details hidden across project boundaries.

Result

Internal members are protected from external projects, enforcing modular design.

Understanding assemblies clarifies why internal is a powerful tool for organizing large applications.

7

Expert

Friend Assemblies and InternalsVisibleTo

🤔Quick: Can you make internal members visible to specific external projects? Commit to yes or no.

Concept: C# allows making internal members visible to selected assemblies using the InternalsVisibleTo attribute.

Sometimes you want to share internal details with trusted projects, like test projects. You can add this to AssemblyInfo.cs: [assembly: InternalsVisibleTo("MyProject.Tests")] This lets the test project access internal members without making them public to everyone.

Result

Internal members become accessible to specific assemblies, enabling controlled sharing.

Knowing this advanced feature helps maintain encapsulation while supporting testing and modular design.

Under the Hood

At runtime, access modifiers do not exist as separate entities; they are enforced by the compiler and runtime metadata. The compiler checks access rules and prevents unauthorized code from compiling. The Common Language Runtime (CLR) uses metadata to enforce visibility, ensuring that private and internal members cannot be accessed from outside their allowed scope. This enforcement helps maintain program correctness and security.

Why designed this way?

Access modifiers were designed to support encapsulation, a core principle of object-oriented programming. They allow developers to hide implementation details and expose only what is necessary. This separation reduces bugs and improves maintainability. The internal modifier was introduced to support modular programming within assemblies, balancing openness and protection. Alternatives like making everything public would lead to fragile codebases.

┌─────────────────────────────┐
│        Source Code          │
│  (with access modifiers)    │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│        Compiler             │
│  Checks access rules,       │
│  generates metadata         │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│   Compiled Assembly (DLL)   │
│  Contains metadata about    │
│  public, private, internal  │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│    Runtime (CLR)            │
│  Enforces access at runtime │
│  based on metadata          │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does private mean no other code can ever access the member, even subclasses? Commit to yes or no.

Common Belief: Private members can be accessed by subclasses because they are part of the same class family.

Reality: Private members are only accessible inside the exact class they are declared in, not in subclasses.

Why it matters: Assuming subclasses can access private members leads to errors and forces developers to use less safe access levels like protected.

Quick: Can internal members be accessed by any project referencing the assembly? Commit to yes or no.

Common Belief: Internal means accessible by any code that references the assembly, so it's almost like public.

Reality: Internal members are only accessible within the same assembly, not by external projects referencing it.

Why it matters: Misunderstanding internal can cause accidental exposure of code or failed builds when external projects try to access internal members.

Quick: Does omitting an access modifier always make a member public? Commit to yes or no.

Common Belief: If you don't write an access modifier, the member is public by default.

Reality: Class members are private by default, and top-level classes are internal by default in C#.

Why it matters: Assuming default public access can expose sensitive data or cause unexpected access errors.

Quick: Can you use private access modifier on top-level classes? Commit to yes or no.

Common Belief: You can make a top-level class private to hide it completely.

Reality: Top-level classes cannot be private; they are internal by default or explicitly public.

Why it matters: Trying to make a class private causes compilation errors and confusion about visibility.

Expert Zone

1

Internal access is assembly-based, not namespace-based, so classes in the same namespace but different assemblies cannot access each other's internal members.

2

The InternalsVisibleTo attribute can expose internals to multiple assemblies, but it requires strong-naming for security in signed assemblies.

3

Private members are not accessible by derived classes, but protected members are; choosing between private and protected affects inheritance design.

When NOT to use

Avoid using public for all members as it breaks encapsulation and increases maintenance cost. Use protected instead of private only when inheritance requires access. Internal should not be used to expose APIs to unrelated projects; use public or friend assemblies instead.

Production Patterns

In large projects, internal is used to hide helper classes and methods from external consumers while allowing full access inside the assembly. Public APIs expose only necessary classes and methods. Private members encapsulate implementation details. Friend assemblies are used to allow test projects to access internals without exposing them publicly.

Connections

Encapsulation (Object-Oriented Programming)

Access modifiers are the language feature that enforces encapsulation.

Understanding access modifiers deepens the grasp of encapsulation, which protects object state and behavior from unintended interference.

Modular Design (Software Engineering)

Internal access modifier supports modular design by limiting visibility to within a module or assembly.

Knowing how internal works helps design software modules that are loosely coupled and easier to maintain.

Privacy in Data Security

Access modifiers conceptually mirror privacy controls in data security, controlling who can see or change information.

Recognizing this connection helps appreciate why hiding details in code is as important as protecting personal data in security.

Common Pitfalls

#1 Exposing sensitive data by making fields public instead of private.

Wrong approach:

public int balance; // exposes balance to all code

Correct approach:

private int balance; // hides balance inside the class

Root cause:

Misunderstanding that public means open to all, leading to accidental data exposure.

#2 Trying to access internal members from another project referencing the assembly.

Wrong approach:

var helper = new Helper(); // Helper is internal in another assembly, causes error

Correct approach:

// Access only public members or use InternalsVisibleTo for friend assemblies

Root cause:

Confusing internal with public and not understanding assembly boundaries.

#3 Assuming private members are accessible in subclasses and trying to use them directly.

Wrong approach:

class Child : Parent { void Test() { Console.WriteLine(privateMember); } }

Correct approach:

Use protected instead of private if subclass access is needed.

Root cause:

Not knowing the difference between private and protected access levels.

Key Takeaways

Access modifiers control who can see and use parts of your code, protecting it from unwanted changes.

Public means open to all, private means only inside the class, and internal means inside the same assembly.

Using access modifiers properly helps keep code safe, organized, and easier to maintain.

Understanding assembly boundaries is key to using internal correctly in large projects.

Advanced features like InternalsVisibleTo allow controlled sharing of internal members with trusted projects.