ArchUnitNET Documentation

ArchUnitNET cannot detect type dependencies when a class accesses a const field.

When a method accesses a constant (e.g., public const string ConstField = "Value";), the C# compiler replaces the field access with the literal value (using the Ldstr opcode) at compile time. Because the field reference is not present in the IL (Intermediate Language), ArchUnitNET's dependency analysis cannot trace the dependency back to the class containing the constant field.

If you attempt to assert that a method has a type dependency on a class containing only constants, the assertion will fail.

class ClassWithStaticField
{
    public const string ConstField = "ConstField";
}

class ClassAccessingField
{
    public void MethodAccessingConstField()
    {
        // The compiler replaces this with the literal string, 
        // removing the dependency on ClassWithStaticField in the IL.
        var a = ClassWithStaticField.ConstField;
    }
}

// This assertion will FAIL:
var method = Architecture.GetClassOfType(typeof(ClassAccessingField))
    .GetMethodMembers()
    .First(member => member.FullNameContains("MethodAccessingConstField"));

var methodTypeDependencies = method.GetTypeDependencies().ToList();
Assert.Contains(Architecture.GetClassOfType(typeof(ClassWithStaticField)), methodTypeDependencies);

You can derive dependency rules directly from PlantUML component diagrams. ArchUnitNET will ensure that your code adheres strictly to the dependencies defined in the diagram.

Requirements:

• The diagram must be a component diagram.
• You must associate types to components using stereotypes (e.g., <<Model.*>>).
• ArchUnitNET uses a regex as the namespace identifier (unlike standard ArchUnit which uses two dots).

Note: Only dependencies explicitly specified in the diagram are considered. Unknown dependencies are ignored.

Example PlantUML:

@startuml
[Model] <<Model.*>>
[Controller] <<Controller.*>>

[Controller] --> [Model]
@enduml

Usage in C#:

string myDiagram = "./Resources/my-diagram.puml";
IArchRule someRule = Types().Should().AdhereToPlantUmlDiagram(myDiagram);
someRule.Check(Architecture);

String myDiagram = "./Resources/my-diagram.puml";
IArchRule someRule = Types().Should().AdhereToPlantUmlDiagram(myDiagram);
someRule.Check(Architecture);

ArchUnitNET uses a fluent API to define architectural rules. You typically follow this workflow:

1. Import: Use using static ArchUnitNET.Fluent.ArchRuleDefinition; to simplify rule creation.
2. Declare Layers/Groups: Use Types(), Classes(), or Interfaces() combined with predicates (like ResideInNamespace or ImplementInterface) to create IObjectProvider variables. Use .As("description") to provide human-readable names for failures.
3. Define Rules: Combine providers using .Should() and predicates (like .Be(), .NotDependOnAny(), or .HaveNameContaining()).
4. Execute: Call .Check(Architecture) to validate the rules against your loaded architecture.

using static ArchUnitNET.Fluent.ArchRuleDefinition;

// 1. Declare layers
private readonly IObjectProvider<IType> ExampleLayer = 
    Types().That().ResideInAssembly("ExampleAssembly").As("Example Layer");

private readonly IObjectProvider<Class> ExampleClasses = 
    Classes().That().ImplementInterface("IExampleInterface").As("Example Classes");

// 2. Define and check rules
[Fact]
public void TypesShouldBeInCorrectLayer()
{
    IArchRule rule = Classes().That().Are(ExampleClasses).Should().Be(ExampleLayer);
    rule.Check(Architecture);
}

[Fact]
public void ExampleLayerShouldNotAccessForbiddenLayer()
{
    IArchRule rule = Types().That().Are(ExampleLayer)
        .Should().NotDependOnAny(ForbiddenLayer)
        .Because("it's forbidden");
    rule.Check(Architecture);
}

ArchUnitNET allows you to define architectural rules using a fluent API. The workflow involves three main steps:

1. Load the Architecture: Use ArchLoader to load the assemblies you want to analyze. For performance, load the architecture once (e.g., in a static field).
2. Define Selectors: Use methods like Types(), Classes(), and Interfaces() combined with predicates (e.g., ResideInAssembly, ImplementInterface) to select the code elements you want to target. Use .As("description") to provide human-readable names for these selections.
3. Define and Check Rules: Use the .Should() syntax to define constraints (e.g., Be(), NotDependOnAny(), HaveNameContaining()) and call .Check(Architecture) to validate the rules against the loaded architecture.

Rules can be combined using the .And() method.

using ArchUnitNET.Domain;
using ArchUnitNET.Loader;
using ArchUnitNET.Fluent;
using Xunit;

// Use static import for easier rule definition
using static ArchUnitNET.Fluent.ArchRuleDefinition;

namespace ExampleTest
{
    public class ExampleArchUnitTest
    {
        // 1. Load architecture once
        private static readonly Architecture Architecture = new ArchLoader().LoadAssemblies(
            System.Reflection.Assembly.Load("ExampleClassAssemblyName"),
            System.Reflection.Assembly.Load("ForbiddenClassAssemblyName")
        ).Build();

        // 2. Define selectors
        private readonly IObjectProvider<IType> ExampleLayer =
            Types().That().ResideInAssembly("ExampleAssembly").As("Example Layer");

        private readonly IObjectProvider<Class> ExampleClasses =
            Classes().That().ImplementInterface("IExampleInterface").As("Example Classes");

        // 3. Write and check rules
        [Fact]
        public void TypesShouldBeInCorrectLayer()
        {
            IArchRule rule = Classes().That().Are(ExampleClasses).Should().Be(ExampleLayer);
            rule.Check(Architecture);
        }

        [Fact]
        public void ExampleLayerShouldNotAccessForbiddenLayer()
        {
            // Rules can include custom reasons for failure
            IArchRule rule = Types().That().Are(ExampleLayer).Should()
                .NotDependOnAny(Types().That().ResideInNamespace("ForbiddenNamespace"))
                .Because("it's forbidden");
            rule.Check(Architecture);
        }
    }
}