C# Using Directives and Type Aliases in .NET 8

Starting Point: The Basic Namespace Directive

[0:35 - 1:35] The setup begins by turning off implicit usings so that every directive is clearly visible in the code. Without any using statements at the top, calling Console.WriteLine requires the fully qualified name: System.Console.WriteLine. Adding a single directive resolves that:

using System;

using System;

That one line makes every type inside System available by its short name. The directive is not an import in the library sense; no new code is pulled in. It is a namespace shortcut that tells the compiler where to look when it encounters an unqualified type name.

Using Static: Skipping the Class Name

[2:19 - 2:45] The using static form targets a specific static class rather than a namespace. Pointing it at System.Console makes every static member of that class available without the class prefix:

using static System.Console;

WriteLine("Hello, world!");

using static System.Console;

WriteLine("Hello, world!");

Instead of Console.WriteLine, you call WriteLine directly. This form, which arrived in .NET 6, is most useful when a file calls the same static class repeatedly. Eliminating the repeated class name reduces visual noise on every call site.

Type Aliases: Naming Any Type

[3:41 - 6:40] .NET 8 extended the alias syntax so that using can assign a short name to any type. A motivating case is a named tuple. Tuples are common return types when a method needs to send back several related values without a full class definition, but declaring the same tuple type more than once in a file produces a lot of repetition:

// Without an alias, each declaration repeats the full tuple type
(string FirstName, string LastName) GetUser() { ... }
(string FirstName, string LastName) person = GetUser();

// Without an alias, each declaration repeats the full tuple type
(string FirstName, string LastName) GetUser() { ... }
(string FirstName, string LastName) person = GetUser();

A type alias collapses that to a single declaration at the top:

using Person = (string FirstName, string LastName);

using Person = (string FirstName, string LastName);

From that point on in the file, Person stands in for the full tuple definition:

Person GetUser() { ... }
Person person = GetUser();

Person GetUser() { ... }
Person person = GetUser();

The alias lives only inside the file where it is declared. It does not propagate across the application. Note that if you need the type available project-wide, a record or class is the appropriate choice.

Alias vs. Record or Class

[5:32 - 6:23] A common question arises: if Person looks like a record, why not just declare one? The answer comes down to scope and weight. A record or class is a named type that exists across the entire project, carries its own file, and needs to be maintained as the codebase evolves. A tuple alias is a file-local convenience. When you use a two-field tuple two or three times inside one class file, creating a full type definition adds maintenance overhead that the alias avoids. The .NET team's intent is to provide a gradient of options rather than forcing a binary choice between a raw tuple and a full class.

Conclusion

The three using forms cover different needs. The basic namespace directive shortens qualified type names throughout a file, while using static removes the class prefix from static member calls. The .NET 8 type alias assigns a readable name to any type, including tuples, scoped to a single file. Each form reduces repetition without changing the underlying behavior of your code.

Watch the full video on Tim Corey's YouTube channel for a live demonstration of all three forms in a working .NET 8 project.