C# Language Proposal: defer Statement

[metinata]

Summary

Introduce a defer statement to the C# language that schedules code for execution at the end of the current lexical scope, providing a cleaner and more intuitive pattern for resource cleanup and deferred actions.

Motivation

Resource management is a frequent task in C# programming, especially in systems interacting with files, network streams, or databases. While C# provides the using statement and try-finally blocks, these constructs can become verbose and reduce readability, especially when multiple cleanup actions are needed.

A defer statement offers:

• Clear intent for delayed execution.
• Flat and readable code structure.
• Natural LIFO (last-in, first-out) ordering of cleanup steps.

This pattern is popular in other languages like Go and can improve C# ergonomics, particularly for low-level programming tasks and infrastructure code.

Examples

void ProcessFile(string path)
{
    var stream = File.OpenRead(path);
    defer stream.Dispose();

    var connection = new SqlConnection(...);
    defer connection.Close();

    // ... additional logic
}

Deferred actions execute in reverse order:

void Example()
{
    Console.WriteLine("Start");
    defer Console.WriteLine("First");
    defer Console.WriteLine("Second");
    Console.WriteLine("End");
}

// Output:
// Start
// End
// Second
// First

Detailed Design

Syntax

defer statement;

Where statement is any valid expression or block. The defer statement is evaluated immediately, but its execution is delayed until the scope ends.

Semantics

• defer must appear within a method body, local function, lambda, or anonymous method.
• Deferred expressions execute when the enclosing scope exits, regardless of how it exits (normal return or exception).
• Multiple deferred expressions run in LIFO order.
• Captures behave like closures.

Scope and Lifetime

• defer operates at the lexical scope level.
• Captured variables are evaluated at the time of the defer statement.

Alternatives Considered

• Continued use of using and try-finally: Functional but verbose and less composable.
• using var declarations: Limited to IDisposable, unsuitable for arbitrary cleanup logic.
• Custom frameworks or helper classes: Adds unnecessary abstraction and complexity.

Drawbacks

• Introduces a new keyword (though currently not used, so low collision risk).
• May encourage less structured resource handling if overused.
• Must ensure predictable behavior in exception-heavy code.

Compatibility

• The defer keyword does not currently exist in C#, making it a safe addition.
• Backward compatibility is preserved.

Future Directions

• defer with await (e.g., defer await conn.CloseAsync();).

• Allow defer blocks:

  defer {
      Log();
      Cleanup();
  }

• Integration with code analyzers for misuse detection.

Implementation Notes

A prototype implementation would involve:

• Extending Roslyn to parse defer as a contextual keyword.
• Tracking deferred actions per scope in semantic model.
• Emitting corresponding IL at scope exit points.

Conclusion

Adding a defer statement to C# would significantly enhance its expressiveness and safety for resource management. It builds on a proven pattern from other languages while aligning with C#’s goal of being both powerful and readable.

[HaloFour]

See: #513

[metinata]

Thanks for the link. I put together a version of defer that includes async support and block style usage

[333fred]

It's still a duplicate, and we try to keep discussion to a single issue