Coding Bolt

If you’re working with .NET, you know that managing namespaces can sometimes feel like a bit of a chore. You start a new file, and the first thing you do is add a handful of using statements at the top. It’s repetitive, and frankly, a little tedious. But with .NET 6 and beyond, there’s a feature that can make this process a lot easier: global using.

What is Global Using?

Global using is a way to declare using statements that apply to your entire project. Instead of adding the same using statements at the top of each file, you can declare them once, and they’ll be automatically available everywhere in your project. This means less boilerplate code and a cleaner, more readable project.

Why Use Global Using?

There are several reasons why you want to use global using in your .NET projects:

1. Reduce Repetition: The most obvious benefit is that you no longer need to repeat common using directives in every file. This not only saves time but also reduces the chance of missing a using statement, which can lead to frustrating compiler errors.
2. Cleaner Code: With global usings, the top of your files won’t be cluttered with using statements. This allows you to focus on the actual code, making your files cleaner and easier to read.
3. Consistent Imports: By centralizing your using statements, you ensure that all files in your project are working with the same set of namespaces, which helps maintain consistency across your codebase.

How to Use Global Using

Using global using is pretty straightforward. You can declare them in a few different ways:

1. In a .csproj File

You can define a global using directly in your project file. Here’s how you do it:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Using Include="System" />
    <Using Include="System.Collections.Generic" />
    <Using Include="System.Linq" />
  </ItemGroup>

</Project>

In this example, System, System.Collections.Generic, and System.Linq are made available globally throughout your project.

2. In a .cs File

Alternatively, you can add global usings in a .cs file by using the global keyword:

global using System;
global using System.Collections.Generic;
global using System.Linq;

By placing these statements in a single .cs file (e.g., GlobalUsings.cs), they’ll apply to the entire project. It’s a handy way to manage common namespaces.

3. Using Implicit Global Usings

.NET 6 also introduced implicit global usings for common namespaces. By default, .NET automatically includes global usings for many commonly used namespaces like System, System.Linq, System.Collections.Generic, and others when you create a new project. You can customize or disable these implicit usings if needed.
For example, in a typical ASP.NET Core web application, the following namespaces are automatically included as global usings:

System
System.Linq
System.Collections.Generic
Microsoft.AspNetCore.Builder
Microsoft.AspNetCore.Hosting
Microsoft.Extensions.DependencyInjection
Microsoft.Extensions.Hosting

This is enabled by the following config in your project:

<PropertyGroup>
  <ImplicitUsings>disable</ImplicitUsings>
</PropertyGroup>

Each global using applies to the entire project in which they are declared. This means that if you place a global using statement in a .cs file within a specific project, it will apply to all the files within that project only. It won’t automatically apply to other projects within the same solution unless those projects reference the same global usings file.

Sharing Global Using Across Multiple Projects

If you want to share global using across multiple projects within a solution, you have a couple of options:

1. Shared Project or Linked Files: You can create a shared project or use linked files that include the global usings file. This allows multiple projects to reference the same set of global usings. However, this approach involves some additional setup.
2. Manual Duplication: You can manually add the global usings file to each project where you want the global usings to apply. This ensures that each project has access to the same global usings.

Best Practices for Global Usings

While global usings are convenient, they should be used wisely:

• Avoid Overuse: Don’t go overboard and declare every possible namespace as a global using. Only include namespaces that are truly used across multiple files in your project.
• Project-Specific: Consider using different global usings for different projects, especially in a solution with multiple projects. This helps keep the global usings relevant to each specific project.
• Review Regularly: As your project evolves, some global usings might no longer be needed. It’s good practice to review them periodically and remove any that are no longer in use.

A Real-World Example

Imagine you’re building an ASP.NET Core web application. Typically, you’ll need namespaces like Microsoft.AspNetCore.Mvc, Microsoft.Extensions.DependencyInjection, and System.Linq across many files. Instead of repeatedly adding these in each file, you can declare them as global usings in a single file:

global using Microsoft.AspNetCore.Mvc;
global using Microsoft.Extensions.DependencyInjection;
global using System.Linq;

This makes your project cleaner and your development process smoother.

Wrapping Up

Global usings in .NET are a simple yet powerful feature that can help you write cleaner, more maintainable code. By reducing the repetition of common using directives, you can focus more on what really matters—building great software.

Affiliate promo

If you love learning new stuff and want to support me, consider buying a course from Dometrain using this link: Browse courses – Dometrain. Thank you!