🏗️ C# Access Modifiers

🧲 Introduction – Why Access Modifiers Matter in C#?

Access modifiers are fundamental in controlling how members of a class are exposed to other parts of a program. They are crucial to achieving encapsulation, one of the pillars of object-oriented programming in C#. Proper use of access modifiers helps protect internal data, enforce APIs, and improve maintainability.

🎯 In this guide, you’ll learn:

• What access modifiers are and how they work
• The different types of access levels in C#
• How to apply them to classes, fields, properties, methods, and constructors
• Best practices for visibility and security in class design

🔍 Core Concept – What Are Access Modifiers in C#?

Access modifiers define the visibility scope of types and type members (fields, properties, methods, etc.).

C# Provides the Following Access Modifiers:

💻 Code Examples – With Explanations

🧱 Example 1: Public and Private

public class User
{
    private string password;
    public string Username;

    public void SetPassword(string pwd)
    {
        password = pwd;
    }
}

🔹 Explanation:

• password is private – cannot be accessed outside User
• Username is public – accessible anywhere

🛡️ Example 2: Protected and Internal

public class BaseClass
{
    protected int protectedValue = 42;
    internal int internalValue = 99;
}

public class DerivedClass : BaseClass
{
    public void ShowValues()
    {
        Console.WriteLine(protectedValue); // OK
        Console.WriteLine(internalValue);  // OK
    }
}

🔹 Explanation:

• protectedValue accessible in the derived class
• internalValue accessible within the same assembly

🌀 Example 3: Protected Internal vs Private Protected

public class Base
{
    protected internal int x = 10;
    private protected int y = 20;
}

• protected internal: accessible from any derived class or any code in the same assembly
• private protected: accessible from a derived class within the same assembly only

💡 Best Practices & Tips

📘 Best Practices

• Keep class fields private and expose them via properties
• Use public only when absolutely necessary
• Limit visibility to what’s needed, no more

💡 Tips

• Combine protected and internal for flexible access in class libraries
• Use private protected for secure internal inheritance

⚠️ Pitfalls

• Overusing public exposes implementation and breaks encapsulation
• Misusing internal can unintentionally expose data across unrelated classes

📊 Access Modifier Comparison Table

🛠️ Use Cases – Where Access Modifiers Are Critical

• Library Development: Expose only public APIs, keep implementation details private
• Secure Code: Prevent unauthorized access to sensitive data (private or protected)
• Inheritance: Safely share behavior with protected and private protected
• Assembly-Level Design: Use internal to restrict visibility to components

📌 Summary – Recap & Next Steps

Access modifiers in C# are essential tools for data encapsulation, API design, and secure coding. By limiting visibility, you improve maintainability, avoid misuse, and enforce clean coding principles.

🔍 Key Takeaways:

• Use private by default, expose only what’s needed
• protected enables controlled inheritance
• internal and protected internal help in assembly-wide design
• private protected is ideal for secure framework design

⚙️ Real-World Relevance:
Access modifiers control how parts of your app interact—be it in ASP.NET APIs, class libraries, or game components in Unity.

❓ FAQ – C# Access Modifiers

❓ What is the default access modifier for class members?
✅ private for members inside a class.

❓ Can I use access modifiers with class declarations?
✅ Yes, but top-level classes can only be public or internal.

❓ What’s the difference between protected and private?
✅ protected allows access in derived classes, private restricts it to the same class.

❓ Can a method be protected internal?
✅ Yes, it’s accessible within the same assembly or from derived classes in other assemblies.

❓ Should I make fields public?
✅ ❌ No. Always encapsulate fields using private + public/protected properties.