C# 14 Extension Members on Static Classes: Static Members Only

Overview

This article clarifies what does and does not work when a C# 14 (.NET 10) extension block targets a static class such as System.IO.Directory.

The short answer: a static class can be the target of an extension block, but only static members can be added. Declaring an instance member is a compile error.
Which of the two you get is decided by the receiver form — whether you write the type alone or give the receiver a parameter name.

The article also covers the alternatives when instance-style calls are required, and the evolution of extension member support from C# 3.0 to C# 14.

Prerequisites / Environment

• Language: C# 14 (LangVersion set to 14.0)
• Framework: .NET 10 (verified with SDK 10.0.302)
• Target feature: Extension members (extension block syntax)
• Reference: Classic extension methods (this parameter syntax)

Problem

Whether an extension block targeting a static class compiles depends on how it is written.
Here is the form that does not compile.

using System.IO;

public static class DirectoryExtensions
{
    // error CS0721: 'Directory': static types cannot be used as parameters
    extension(Directory directory)
    {
        public void DeleteIfExists(string path)
        {
            try
            {
                Directory.Delete(path, true);
            }
            catch (DirectoryNotFoundException)
            {
                // Nothing to do when it is already gone.
            }
        }
    }
}

The error is reported at Directory inside extension(Directory directory).
In other words, the receiver declaration itself is rejected, regardless of what the members contain.

Remove the parameter name directory from the receiver and make the member static, and the same Directory target compiles.

using System.IO;

public static class DirectoryExtensions
{
    // This one compiles
    extension(Directory)
    {
        public static void DeleteIfExists(string path)
        {
            try
            {
                Directory.Delete(path, true);
            }
            catch (DirectoryNotFoundException)
            {
                // Nothing to do when it is already gone.
            }
        }
    }
}

At the call site it resolves as though it were a static method that Directory always had.

Directory.DeleteIfExists(@"C:\Temp\TargetDir");

The restriction is sometimes summarized as “extension members cannot be added to static classes,” but what actually cannot be added is instance members.

Cause

The receiver can be written in two forms

The receiver of an extension block can be written either as a type alone or as a parameter.
This is not a stylistic choice: it changes which kinds of members can be declared.

The language specification states that if the receiver parameter is named, the receiver type may not be static.
Once the receiver has a name it is an ordinary parameter, so the existing rule that a static class cannot be used as a parameter type applies unchanged.

Why a static class cannot be a parameter type

C# forbids using the name of a static class as the type of anything that holds a value.
All of the following are compile errors.

extension(Directory directory) is the same situation as the last row, and the reported error is likewise CS0721.

Note that the name of a static class is not entirely unusable as a type.
typeof(Directory) is legal, and member access such as Directory.Exists(path) obviously works.
What is forbidden is using it as the type of a value-holding location: a variable, a parameter, or a type argument.
extension(Directory) compiles precisely because it declares no location that receives the receiver value.

An unnamed receiver cannot carry instance members

Conversely, declaring an instance member inside the extension(Directory) form produces a different error.

extension(Directory)
{
    // error CS9303: cannot declare instance members in an extension block
    //               with an unnamed receiver parameter
    public void DeleteIfExists(string path) { }
}

The body of an instance member refers to the receiver value, so a name for that value is required.
Without a name, no instance member can be declared.

Caught between these two errors, there is no way to write an instance-style extension member on a static class.

Solution

The right option depends on what you are trying to achieve.

• Option A: Call it as Directory.Xxx(...) — declare a static extension member with a type-only receiver.
• Option B: Call it as xxx.Yyy() — declare an extension member on the corresponding instance type (DirectoryInfo).
• Option C: Support C# 13 or earlier — use a plain static helper class.

Implementation

Option A: Static extension member

On C# 14 or later this is the most direct approach. It adds a member that looks as though Directory always had it.

using System.IO;

namespace MyLib;

public static class DirectoryExtensions
{
    extension(Directory)
    {
        /// <summary>
        /// Deletes the directory at the specified path if it exists.
        /// </summary>
        public static void DeleteIfExists(string path)
        {
            try
            {
                Directory.Delete(path, true);
            }
            catch (DirectoryNotFoundException)
            {
                // Nothing to do when it is already gone.
            }
        }

        /// <summary>The default working directory.</summary>
        public static string DefaultRoot => @"C:\Temp";
    }
}

The call site looks as follows.

using System;
using System.IO;
using MyLib; // omit this and you get CS0117

Directory.DeleteIfExists(@"C:\Temp\TargetDir");
Console.WriteLine(Directory.DefaultRoot);

As the comment notes, without a using for the namespace that declares the extension members, the compiler reports CS0117 — Directory does not contain a definition for DeleteIfExists.
This is the same constraint that applies to classic extension methods, not something specific to static extension members.

Option B: Extension member on DirectoryInfo

DirectoryInfo is an ordinary instantiable type, so its receiver can carry a parameter name.
This is the option to use when calls should be consistently instance-style.

using System.IO;

public static class DirectoryInfoExtensions
{
    // DirectoryInfo is not a static class, so the parameter form is allowed
    extension(DirectoryInfo directoryInfo)
    {
        /// <summary>
        /// Deletes the directory if it exists.
        /// </summary>
        public void DeleteIfExists()
        {
            try
            {
                directoryInfo.Delete(true);
            }
            catch (DirectoryNotFoundException)
            {
                // Nothing to do when it is already gone.
            }
        }
    }
}

The call site looks as follows.

var dir = new DirectoryInfo(@"C:\Temp\TargetDir");
dir.DeleteIfExists();

Creating a DirectoryInfo instance is an extra step, but it is convenient when the path is resolved once and several operations follow.

Option C: Static helper class

When C# 13 or earlier must be supported, extension blocks are unavailable, so a conventional static class is the fallback.

using System.IO;

public static class DirectoryHelper
{
    /// <summary>
    /// Deletes the directory at the specified path if it exists.
    /// </summary>
    public static void DeleteIfExists(string path)
    {
        try
        {
            Directory.Delete(path, true);
        }
        catch (DirectoryNotFoundException)
        {
            // Nothing to do when it is already gone.
        }
    }
}

DirectoryHelper.DeleteIfExists(@"C:\Temp\TargetDir");

The Directory.DeleteIfExists(...) form is not available, but the location of the method is unambiguous.

Notes

• The extension block syntax is available only in C# 14 (.NET 10) and later.
  Earlier versions are limited to the classic this-parameter extension method syntax.
• Static extension members also require the declaring namespace to be imported at the call site.
  Forgetting it yields CS0117 (no such definition), which does not obviously indicate a failed extension member lookup.
• An extension block that extends a static class cannot contain user-defined operators (CS9321).
  An operator must take the extended type as a parameter, and a static class cannot be one.
• The API shapes of Directory (static methods) and DirectoryInfo (instance members) differ.
  The counterpart of Directory.Exists(path) is the directoryInfo.Exists property — one takes an argument and the other does not.

Alternatives / Comparison

Supplementary: Evolution of Extension Members from C# 3.0 to C# 14

Support for attaching members to existing types has expanded incrementally across C# versions.

The this-parameter syntax can only declare instance extension methods; before C# 14 there was no way to attach a static member at all.
Adding a member such as Directory.DeleteIfExists(...) to a static class first became possible with the C# 14 extension block.

Summary

Targeting a static class with an extension block is possible.
What is not possible is adding an instance member: naming the receiver turns the static class into a parameter type, which produces CS0721.

• To call it as Directory.Xxx(...), declare static members inside extension(Directory) (Option A).
• To call it instance-style, define the members on a corresponding instance type such as DirectoryInfo (Option B).
• To support C# 13 or earlier, fall back to a conventional static helper class (Option C).