Proposal: Scoped Type Declaration Syntax for class, record, struct, and interface

[jssmotta]

Scoped Type Declaration Syntax

Summary

Allow type declarations (class, record, struct, interface) to use file-scoped syntax similar to namespaces, reducing nesting and improving readability. Only one scoped type per file, no nesting allowed.

Motivation

Following the success of file-scoped namespaces, developers frequently work with simple types that don't require extensive nesting. A scoped type syntax would:

• Reduce indentation levels consistently across all type declarations
• Improve code readability for simple types
• Maintain consistency with file-scoped namespace pattern
• Streamline DTOs, POCOs, interfaces, and marker types
• Provide uniform syntax across class, record, struct, and interface
• Enforce one-type-per-file best practice

Proposed Syntax

Classes

namespace MyNamespace;
public class PersonDto;

public string Name { get; set; }
public int Age { get; set; }
public DateTime BirthDate { get; set; }

Records

namespace MyNamespace;
public record PersonRecord;

public string Name { get; init; }
public int Age { get; init; }

Structs

namespace MyNamespace;
public struct Point;

public double X { get; set; }
public double Y { get; set; }

Interfaces

namespace MyNamespace;
public interface IPersonRepository;

Task<Person> GetByIdAsync(int id);
Task SaveAsync(Person entity);
Task DeleteAsync(int id);

Examples

Before:

namespace MyNamespace
{
    public class PersonDto
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

After (PersonDto.cs):

namespace MyNamespace;
public class PersonDto;

public string Name { get; set; }
public int Age { get; set; }

Before:

namespace MyNamespace
{
    public interface IPersonService
    {
        Task<PersonDto> GetPersonAsync(int id);
        Task SavePersonAsync(PersonDto person);
    }
}

After (IPersonService.cs):

namespace MyNamespace;
public interface IPersonService;

Task<PersonDto> GetPersonAsync(int id);
Task SavePersonAsync(PersonDto person);

Rules and Constraints

1. One scoped type per file: Only one type can use scoped declaration syntax per file
2. No nesting allowed: Scoped types cannot contain nested type declarations
3. File-scoped only: The semicolon syntax indicates the type extends to end of file
4. Mutually exclusive: Cannot mix scoped type with traditional brace syntax in same file
5. All members belong to scoped type: Everything after the scoped declaration is part of that type
6. Traditional syntax still available: Use braces for files with multiple types or nested types

Benefits

1. Consistency: Extends the file-scoped pattern namespaces
2. Reduced Noise: Eliminates one level of indentation for single-type files
3. Enforces Best Practice: Naturally encourages one-type-per-file organization
4. Modern Style: Aligns with contemporary language design trends
5. Clarity: Clear visual indication that entire file contains one type
6. Uniformity: Same syntax works for class, record, struct, and interface

Migration Example

Legacy Style (multiple types per file):

namespace MyNamespace
{
    public class PersonDto
    {
        public string Name { get; set; }
    }
    
    public class AddressDto
    {
        public string Street { get; set; }
    }
}

Modern Style (separate files with scoped syntax):

PersonDto.cs:

namespace MyNamespace;
public class PersonDto;

public string Name { get; set; }

AddressDto.cs:

namespace MyNamespace;
public class AddressDto;

public string Street { get; set; }

Alternatives Considered

• Keep current syntax only: Does not address verbosity concerns
• Allow multiple scoped types per file: Would create ambiguity about member ownership
• Allow nesting: Would conflict with file-scoped nature of the feature

[HaloFour]

See: #5785 and #928

[HaloFour]

Note that the syntax you're suggesting is already perfectly legal C#:

namespace MyNamespace;
public class PersonDto;