Type rules

A type rule selects types, then asserts something about them: the types they use with Assert.Architecture, or their names and shape with Assert.All.

Select the types

ArchitectureModel.Types is a list of TypeElement: select the types with LINQ. The failure messages show the expression you pass to the assertion, so a variable with a clear name, such as domain, gives a clear message.

These members of TypeElement cover the common filters:

Name is the name without the namespace and the generic arity (Repository for Repository<T>), so t.Name.EndsWith("Repository", StringComparison.Ordinal) filters by name.

The members that take a type, such as Implements<T>(), compare full names. Pass a generic type definition, such as typeof(Repository<>), to match all its instantiations. The overloads that take a string expect the name as written in metadata: MyApp.Repository`1, MyApp.Outer+Inner.

Combine sets with LINQ (Except, Concat) or with a collection expression: [.. application, .. web].

Check the dependencies

The predicates take a TypeReference, which has the same IsInNamespace and IsInNamespaceOrChildren members as TypeElement:

var architecture = ArchitectureModel.FromAssemblyContaining<Order>();
var domain = architecture.Types.Where(t => t.IsInNamespaceOrChildren("SampleApp.Domain"));

// The types of the domain may use each other and the types of .NET, nothing else
Assert.Architecture.DependsOnlyOn(domain, t => t.IsInNamespaceOrChildren("System"));

DoesNotAccessMember bans a member of a type that is otherwise allowed, such as the current time:

var architecture = ArchitectureModel.FromAssemblyContaining<Order>();
var types = architecture.Types.Where(t => t.IsInNamespaceOrChildren("SampleApp"));

Assert.Architecture.DoesNotAccessMember<DateTime>(types, "Now", "the current time comes from TimeProvider");
Assert.Architecture.DoesNotAccessMember<DateTime>(types, nameof(DateTime.UtcNow), "the current time comes from TimeProvider");

The model explains what counts as a dependency.

Check the names and the shape

Assert.All from Meziantou.Framework.Assertions checks a predicate on each type, with the members of TypeElement:

var architecture = ArchitectureModel.FromAssemblyContaining<Order>();
var repositories = architecture.Types.Where(t => t.IsClass && t.Implements<IOrderRepository>());

Assert.NotEmpty(repositories);
Assert.All(repositories, t => t.Name.EndsWith("Repository", StringComparison.Ordinal));
Assert.All(repositories, t => t.IsSealed);
Assert.All(architecture.Types.Where(t => t.IsInNamespaceOrChildren("SampleApp.Domain") && !t.IsInterface), t => t.IsImmutable);

• Assert.All passes when the collection is empty: add Assert.NotEmpty when a typo in the filter must fail.
• Assert.All reports the first type that does not match the predicate.
• IsImmutable is true when the instance fields are readonly or constant, and the instance properties have no setter other than init.

The members of the types are in the model too, so the same pattern checks methods, properties or fields:

var architecture = ArchitectureModel.FromAssemblyContaining<Order>();
var handlers = architecture.Types.Where(t => t.IsInNamespace("SampleApp.Application") && t.Name.EndsWith("Handler", StringComparison.Ordinal));

Assert.All(handlers.SelectMany(t => t.Methods).Where(method => method.Accessibility == ElementAccessibility.Public), method => method.IsAsync);