Skip to main content

How to Resolve Error "CS0268: Imported type 'type' is invalid. It contains a circular base class dependency." in C#

The Compiler Error CS0268 is a metadata and inheritance error. The message reads: "Imported type 'MyType' is invalid. It contains a circular base class dependency."

In C#, a class cannot inherit from itself, nor can it inherit from a class that eventually inherits back from the first class (e.g., A inherits from B, and B inherits from A).

  • If you write this code within a single project, you get CS0146.
  • If this situation arises from referenced DLLs (Assemblies), you get CS0268.

This error usually indicates that your project references are corrupted, out of sync, or that you are referencing two libraries that have conflicting definitions of the same class hierarchy.

Understanding the Circular Dependency​

The C# compiler needs to calculate the memory layout of a class. It starts at the base class and adds the fields of the derived class. If Class A extends Class B, and Class B extends Class A, the memory calculation enters an infinite loop.

The "Imported" Aspect: CS0268 specifically means the compiler found this loop while reading the Metadata of a compiled DLL you added as a reference. The DLL itself claims a hierarchy that is mathematically impossible in the current context.

Scenario 1: Corrupted or Out-of-Sync Builds​

This is the most common cause. You have two projects, Project A and Project B.

  1. You built Project A referencing an old version of Project B.
  2. You changed inheritance in Project B and rebuilt it.
  3. You are now compiling a third project that references both, and the metadata definitions conflict, creating a logical loop that didn't exist in source code but exists in the compiled artifacts.

Example of Problem​

  • DLL 1 says: class Dog : Animal
  • DLL 2 says: class Animal : Dog (Perhaps due to a bad refactoring or version mismatch).

The compiler tries to load Dog and sees it depends on Animal. It loads Animal and sees it depends on Dog. Infinite recursion -> CS0268.

Solution: Clean and Rebuild​

You need to wipe the existing compiled binaries to force a fresh dependency resolution.

  1. Close Visual Studio (sometimes file locks prevent cleaning).
  2. Delete the bin and obj folders in all referenced projects.
  3. Open Visual Studio.
  4. Rebuild Solution.

Scenario 2: Circular Project References​

Ideally, Visual Studio prevents you from adding a circular reference (Project A references Project B, Project B references Project A). However, if you reference compiled DLLs manually (file references) instead of Project References, you can accidentally create this loop.

Scenario Setup​

  • Assembly A.dll contains Class A : Class B.
  • Assembly B.dll contains Class B : Class A.

If you reference both DLLs in your application, the compiler cannot resolve the types.

Solution: Refactor Hierarchy​

You must break the circular dependency. Typically, this involves extracting the shared base classes into a third assembly.

Before (Circular):

  • Assembly A (References B)
  • Assembly B (References A)

After (Linear):

  • Assembly Core: Contains BaseClass.
  • Assembly A: References Core. Class A : BaseClass.
  • Assembly B: References Core. Class B : BaseClass.

Scenario 3: IL Weaving Tools​

Advanced tools like PostSharp, Fody, or obfuscators modify the Intermediate Language (IL) of your DLLs after compilation. If these tools are misconfigured, they might accidentally inject an inheritance relationship that creates a cycle or corrupts the metadata.

Observations​

If cleaning the solution does not work, and you use IL weaving tools:

  1. Check the build logs for errors from the weaving tool.
  2. Disable the weaving tool temporarily (comment it out in .csproj or packages.config).
  3. Rebuild.

If the error disappears, the issue lies in the configuration of that tool.

Conclusion​

CS0268 is rarely a syntax error in the file you are currently editing. It is an infrastructure error.

  1. The "Turn it off and on again" fix: Delete bin/obj folders and Rebuild All. This fixes 95% of cases.
  2. Check References: Ensure you aren't referencing two versions of the same library that disagree on class inheritance.
  3. Refactor: Ensure your architecture doesn't have circular dependencies between Assemblies.

Table of Contents