Skip to main content

How to Resolve Error "CS0576: Namespace 'namespace' contains a definition conflicting with alias 'alias'" in C#

The Compiler Error CS0576 is a naming collision error regarding Using Aliases. The message reads: "Namespace 'MyNamespace' contains a definition conflicting with alias 'MyAlias'".

In C#, you can create an alias for a namespace or class using the using AliasName = TargetType; syntax. This is useful for shortening long names or resolving ambiguities. However, if you define an alias (e.g., Grid) and then declare a class, struct, or interface with the exact same name (Grid) inside the same namespace scope, the compiler cannot decide what the name "Grid" refers to.

This guide explains how these conflicts occur and how to rename your alias or type to resolve them.

Understanding Using Aliases​

A using alias tells the compiler: "Whenever I type X, I actually mean System.X."

using SysConsole = System.Console; 

// Later...
SysConsole.WriteLine("Hello");

However, if you also create a class named SysConsole in your code, the compiler gets confused. It has two instructions:

  1. SysConsole maps to System.Console.
  2. SysConsole maps to your local class public class SysConsole.

This contradiction triggers CS0576.

Scenario: The Name Clash​

This error frequently happens when you define a class that shares a name with a common library type, and you try to alias that library type to avoid typing the full namespace.

Example: imagine you are writing a data processing app. You create a class named Data, but you also want to use System.Data conveniently.

// 1. We define an alias 'Data' pointing to 'System.Data'
using Data = System.Data; 

namespace MyApp
{
    // 2. We define a class also named 'Data' inside the namespace
    // ⛔️ Error CS0576: Namespace 'MyApp' contains a definition 
    // conflicting with alias 'Data'.
    public class Data 
    {
        public int Id { get; set; }
    }

    public class Program
    {
        public void Run()
        {
            // The compiler doesn't know if 'Data' refers to the namespace alias 
            // or the class defined above.
            var d = new Data(); 
        }
    }
}

The simplest fix is to change the name of the alias to something unique. This preserves your ability to use the shorthand while distinguishing it from your local class.

Solution: rename the alias from Data to SysData.

// ✅ Correct: The alias 'SysData' does not conflict with class 'Data'
using SysData = System.Data; 

namespace MyApp
{
    public class Data 
    {
        public int Id { get; set; }
    }

    public class Program
    {
        public void Run()
        {
            // Uses the local class
            var d = new Data(); 

            // Uses the alias for the System namespace
            var row = new SysData.DataRow(null); 
        }
    }
}

Solution 2: Use Fully Qualified Names​

If the alias is causing problems and you only use the external library a few times, you can simply remove the alias entirely. Instead, use the full namespace path when you need the external type.

Solution: remove the using ... = ... line.

// Alias removed
using System; 

namespace MyApp
{
    // ✅ Correct: No alias exists to conflict with this name.
    public class Data 
    {
        public int Id { get; set; }
    }

    public class Program
    {
        public void Run()
        {
            var d = new Data();

            // ✅ Correct: Type the full name for the external type
            System.Data.DataRow row = null; 
        }
    }
}

Conclusion​

CS0576 is a naming collision between a shortcut (alias) and a definition (class/struct).

  1. Check the top of the file: Look for using Name = ....
  2. Check the namespace: Look for class Name, struct Name, or enum Name.
  3. Resolve: Rename the alias (e.g., using LibName = ...) to make it distinct.

Table of Contents