What access modifiers does C# have, and how do you use them to design a clean API? Explain public, private, protected, internal, protected internal, private protected and file, the default accessibility of each declaration, and InternalsVisibleTo.

1. Enforcement: compiler and runtime

• The C# compiler enforces accessibility at compile time.
• The CLR also enforces it at JIT/load time ("member access checks"): IL that calls a private method in another type fails with MethodAccessException — unless reflection with BindingFlags.NonPublic is used, which bypasses compile-time checks but not (in full trust) the ability to call. Since .NET Core, reflection on private members works; trimming/AOT may remove members accessed only via reflection.
• UnsafeAccessorAttribute (.NET 8) lets code access private members of other types without reflection, efficiently — intended for serialisers and test helpers. It's a deliberate escape hatch; don't use it to work around poor API design.

2. Metadata representation

IL flags: public, private, family (protected), assembly (internal), famorassem (protected internal), famandassem (private protected), plus nested variants for nested types. The file modifier is a C# concept implemented by giving the type a mangled, unique name (<FileName>F..__Helper) and internal accessibility.

3. Accessibility domains and consistency rules

A member's effective accessibility is the intersection of its own and its containing type's: a public method on an internal class is effectively internal. The compiler enforces consistency: a public method can't expose an internal type in its signature (CS0050/CS0051), because consumers couldn't use it.

4. protected access rules

A derived class can access a protected member only through an instance of its own type (or further derived), not through any base-typed instance:

class Base { protected int X; }
class Derived : Base
{
    void M(Base b, Derived d) { _ = d.X; /* ok */ _ = b.X; /* CS1540 error */ }
}

This prevents a subclass from reaching into sibling subclasses' protected state.

5. Public API management

• PublicApiAnalyzers: track public surface in text files; any addition or removal produces a diagnostic until the file is updated — changes become visible in PRs.
• Package validation (<EnablePackageValidation>true</EnablePackageValidation>) compares against a baseline package version to detect breaking changes.
• [EditorBrowsable(EditorBrowsableState.Never)] hides public members from IntelliSense when they must be public for technical reasons.
• [Obsolete] with a diagnostic ID for staged removals.

6. Accessibility and testing strategy

Testing through public APIs keeps tests resilient to refactoring. Expose internals to tests when a component is complex and stable enough to deserve its own tests (e.g. a tax rules engine) but shouldn't be public. Avoid making things public just for tests — it permanently widens the contract.

Try it yourself

1. Make an infrastructure project's implementations internal and expose only a DI registration extension.
2. Add Microsoft.CodeAnalysis.PublicApiAnalyzers to a library and see the diagnostics.
3. Try accessing a protected member through a base-typed reference in a derived class.
4. Create a file class in two files with the same name and confirm no conflict.

// Library: public surface is small, everything else internal
public sealed class OrderService(IOrderStore store)
{
    public async Task<OrderId> PlaceAsync(PlaceOrder cmd, CancellationToken ct)
    {
        var order = OrderFactory.Create(cmd);   // internal helper
        await store.SaveAsync(order, ct);
        return order.Id;
    }
}

internal static class OrderFactory
{
    internal static Order Create(PlaceOrder cmd) => new(OrderId.New(), cmd.CustomerId, cmd.Lines);
}

public class Account
{
    public decimal Balance { get; private set; }          // read anywhere, write here only
    protected void Credit(decimal amount) => Balance += amount;   // for subclasses
    private protected void Audit(string what) { }        // subclasses in THIS assembly only
    protected internal virtual void OnClosed() { }        // subclasses OR same assembly
}

// File-local type: no clash with other files' Helper types
file sealed class Helper
{
    public static string Normalise(string s) => s.Trim().ToUpperInvariant();
}

<!-- Orders.csproj -->
<ItemGroup>
  <InternalsVisibleTo Include="Orders.Tests" />
</ItemGroup>