File Access Modifier in C# with Examples (C# 11 Guide)

File Access Modifier in C# – Why It Exists and When to Use It

The Problem

In real projects, we often create helper classes that are only needed inside one file.

If we use internal, those classes become accessible across the entire project. This can lead to:

• Accidental usage
• Poor code organization
• Tight coupling between files

So the question is:
How do we restrict a class to just one file?

The Solution

C# introduced the file access modifier.

It allows you to define a class that is:

• Accessible only within the same file
• Completely hidden from other files

This gives better control over your code and improves encapsulation.

file class DataFormatter
{
    public string Format(string data)
    {
        return data.Trim();
    }
}

public class DataService
{
    public void Execute()
    {
        var formatter = new DataFormatter();
        Console.WriteLine(formatter.Format("  sample  "));
    }
}

Note: The file access modifier restricts a class so that it is accessible only within the same source file. Multiple classes inside the same file can use it, but it cannot be accessed from another file, even within the same project. It is mainly used for helper classes and provides better encapsulation than internal.

Can we use file inside another class?

No. We cannot use file for nested classes

public class Outer
{
    file class Inner  // Not allowed
    {
    }
}

Key Points about file Access Modifier in C#

General Rules

• file restricts a type to only the same source file
• Introduced in C# 11
• Works only with top-level types
• Cannot be used inside another class (no nested file types)

Supported Types

You can use file with:

• file class
• file struct
• file interface
• file record

Example:

file struct MyStruct { }
file interface IHelper { }

Inheritance Rules

• A file class can inherit from another class (if accessible)

file class Base { }

file class Derived : Base  // Allowed (same file)
{
}

Cannot inherit a file class from another file.  Because it is not visible

Interface Implementation

• file classes can implement interfaces

file interface IHelper
{
    void DoWork();
}

file class Helper : IHelper
{
    public void DoWork() { }
}

Works only within the same file

Real Usage Scenarios

• Helper classes used only in one file
• Utility logic tightly coupled to a feature
• Avoiding accidental usage across project

Limitations

• Cannot be used for:
  • Nested classes
  • Members (methods, properties, fields)
• Only applies to types, not methods or variables

Best Practice

• Use file when:
  • The class is not reusable
  • Logic should stay in one file
  • You want strong encapsulation

Conclusion

The file access modifier is a simple but powerful feature in C# that helps you control how your code is used. By restricting a class, struct, or interface to a single file, it ensures that internal logic stays exactly where it belongs.

It is especially useful when you are working with helper classes or feature-specific logic that should not be exposed to the rest of the project. Compared to internal, it provides a stricter level of encapsulation, which helps avoid accidental usage and keeps your codebase clean.

From a design perspective, using file encourages better organization and makes your intent clear to other developers. When someone reads your code, they immediately understand that certain types are meant to be used only within that file.

In short, the file modifier is a great tool for writing more maintainable, readable, and well-structured applications.