### Complete NsDepCop Project Configuration Example

Source: https://context7.com/realvizu/nsdepcop/llms.txt

A comprehensive XML configuration for NsDepCop, demonstrating multi-layer application setup with allowed and disallowed dependencies for both namespaces and assemblies.

```xml
<?xml version="1.0" encoding="utf-8"?>
<NsDepCopConfig
    IsEnabled="true"
    ChildCanDependOnParentImplicitly="true"
    MaxIssueCount="50"
    CheckAssemblyDependencies="true"
    ExcludedFiles="**/*.g.cs,**/Migrations/*.cs">

    <!-- Framework dependencies -->
    <Allowed From="*" To="System.*" />
    <Allowed From="*" To="Microsoft.Extensions.*" />
    <Allowed From="*" To="." />

    <!-- Shared/Common layer - accessible by all -->
    <Allowed From="*" To="MyApp.Common.*" />
    <Allowed From="*" To="MyApp.Models.*" />

    <!-- Domain layer - core business logic -->
    <Allowed From="MyApp.Domain.*" To="MyApp.Domain.*" />

    <!-- Data layer - persistence -->
    <Allowed From="MyApp.Data.*" To="MyApp.Domain.*" />
    <Allowed From="MyApp.Data.*" To="Microsoft.EntityFrameworkCore.*" />

    <!-- Service layer - business operations -->
    <Allowed From="MyApp.Services.*" To="MyApp.Domain.*" />
    <Allowed From="MyApp.Services.*" To="MyApp.Data.*" />

    <!-- API/Web layer - presentation -->
    <Allowed From="MyApp.Api.*" To="MyApp.Services.*" />
    <Allowed From="MyApp.Api.*" To="MyApp.Domain.*" />
    <Allowed From="MyApp.Api.*" To="Microsoft.AspNetCore.*" />

    <!-- Prevent layer violations -->
    <Disallowed From="MyApp.Domain.*" To="MyApp.Data.*" />
    <Disallowed From="MyApp.Domain.*" To="MyApp.Services.*" />
    <Disallowed From="MyApp.Data.*" To="MyApp.Services.*" />
    <Disallowed From="MyApp.Data.*" To="MyApp.Api.*" />
    <Disallowed From="MyApp.Services.*" To="MyApp.Api.*" />

    <!-- Assembly-level rules -->
    <AllowedAssembly From="*" To="mscorlib" />
    <AllowedAssembly From="*" To="netstandard" />
    <AllowedAssembly From="*" To="System.*" />
    <AllowedAssembly From="MyApp.Api" To="MyApp.Services" />
    <AllowedAssembly From="MyApp.Services" To="MyApp.Data" />
    <AllowedAssembly From="MyApp.Services" To="MyApp.Domain" />
    <AllowedAssembly From="MyApp.Data" To="MyApp.Domain" />

</NsDepCopConfig>
```

--------------------------------

### Denylisting Configuration Example

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Use denylisting to allow most dependencies while prohibiting specific ones. Start by allowing all, then specify disallowed combinations.

```xml
<NsDepCopConfig IsEnabled="true">
    <!-- Allow everything by default -->
    <Allowed From="*" To="*" />

    <!-- Prohibit frontend from directly accessing data layer -->
    <Disallowed From="MyApp.UI.*" To="MyApp.Data.*" />

    <!-- Prohibit circular dependencies between Services and Repositories -->
    <Disallowed From="MyApp.Services.*" To="MyApp.UI.*" />

    <!-- Prohibit any namespace from using deprecated code -->
    <Disallowed From="*" To="MyApp.Legacy.*" />
    <Disallowed From="*" To="MyApp.Deprecated.*" />
</NsDepCopConfig>
```

--------------------------------

### Master Configuration File Example

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

This is an example of a master `config.nsdepcop` file located in a common ancestor folder (e.g., solution folder). It defines common allowed dependencies that can be inherited by child project configurations.

```xml
<NsDepCopConfig ChildCanDependOnParentImplicitly="true">
    <Allowed From="*" To="System.*" />
    <Allowed From="*" To="MoreLinq" />
    <Allowed From="*" To="NsDepCop.Core.Util" />
</NsDepCopConfig>
```

--------------------------------

### Install NsDepCop via .NET CLI

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Install the NsDepCop NuGet package using the .NET CLI. This command adds the package to your project.

```bash
# Install via .NET CLI
dotnet add package NsDepCop
```

--------------------------------

### Minimal Project-Level Config for Inheritance

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

A minimal `config.nsdepcop` file in a project folder is required to enable inheritance, even if all settings are inherited. This example sets `InheritanceDepth` to enable the inheritance mechanism.

```xml
<NsDepCopConfig InheritanceDepth="3"/>
```

--------------------------------

### Config Inheritance Example

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Configure inheritance to share rules across projects. A master config in the solution folder can be inherited by project-level configs.

```xml
<!-- Solution-level config: C:\MySolution\config.nsdepcop -->
<NsDepCopConfig ChildCanDependOnParentImplicitly="true">
    <!-- Common rules for all projects -->
    <Allowed From="*" To="System.*" />
    <Allowed From="*" To="Microsoft.Extensions.*" />
    <Allowed From="*" To="Newtonsoft.Json.*" />

    <!-- Shared internal dependencies -->
    <Allowed From="*" To="MyCompany.Shared.*" />
</NsDepCopConfig>

<!-- Project-level config: C:\MySolution\MyProject\config.nsdepcop -->
<NsDepCopConfig InheritanceDepth="1">
    <!-- Project-specific rules (inherits all rules from parent) -->
    <Allowed From="MyProject.*" To="MyProject.Core.*" />
    <Allowed From="MyProject.Controllers" To="Microsoft.AspNetCore.*" />
</NsDepCopConfig>

<!-- Minimal inheritance-only config -->
<NsDepCopConfig InheritanceDepth="3"/>
```

--------------------------------

### Install NsDepCop via Package Manager Console

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Install the NsDepCop NuGet package using the Package Manager Console in Visual Studio. This command adds the package to your project.

```powershell
# Or via Package Manager Console
Install-Package NsDepCop
```

--------------------------------

### NsDepCop Namespace Dependency Rules with Wildcards

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Examples of defining namespace dependency rules using exact names, wildcards (*, ?), and regex patterns. These rules control which namespaces can reference others.

```xml
<NsDepCopConfig IsEnabled="true">
    <!-- Exact namespace match -->
    <Allowed From="MyApp.Controllers" To="MyApp.Services" />

    <!-- Wildcard: MyApp and all sub-namespaces can use System and all sub-namespaces -->
    <Allowed From="MyApp.*" To="System.*" />

    <!-- Single-level wildcard: any direct child of MyApp can use Logging -->
    <Allowed From="MyApp.?" To="MyApp.Logging" />

    <!-- Any namespace named Repository can use the Data namespace ancestor -->
    <Allowed From="*.Repository" To="MyApp.Data.*" />

    <!-- Regex pattern: match namespaces with version numbers -->
    <Allowed From="/MyApp\.V[0-9]+\..*/" To="MyApp.Common.*" />

    <!-- Complex wildcard: any Serialization namespace under System -->
    <Allowed From="MyApp.*" To="System.*.Serialization.*" />
</NsDepCopConfig>
```

--------------------------------

### Namespace Dependency Example

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/DependencyControl.md

Illustrates a scenario where Namespace A depends on Namespace B through inheritance, field usage, properties, and method signatures.

```csharp
namespace A
{
    using B;

    class A1 : B1
    {
        B2 field1;
        B3 Property1 { get; set; }
        B4 MyMethod(B5 p) { ... }
    }
}
namespace B
{
    interface B1 {}
    class B2 {}
    struct B3 {}
    enum B4 {}
    delegate void B5();
}
```

--------------------------------

### Visible Members Configuration Example

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Control which types from a namespace are visible to others using VisibleMembers. This can be defined per-dependency or globally.

```xml
<NsDepCopConfig IsEnabled="true">
    <!-- Allow GameLogic to use only Vector2 and Vector3 from UnityEngine -->
    <Allowed From="GameLogic.*" To="UnityEngine">
        <VisibleMembers>
            <Type Name="Vector2" />
            <Type Name="Vector3" />
            <Type Name="Quaternion" />
        </VisibleMembers>
    </Allowed>

    <!-- Define global visible surface for a namespace (applies to all consumers) -->
    <VisibleMembers OfNamespace="MyApp.Internal">
        <Type Name="IPublicService" />
        <Type Name="PublicConfig" />
    </VisibleMembers>

    <!-- Generic types use metadata format with backtick -->
    <Allowed From="MyApp.Services" To="System.Collections.Generic">
        <VisibleMembers>
            <Type Name="List`1" />
            <Type Name="Dictionary`2" />
            <Type Name="IEnumerable`1" />
        </VisibleMembers>
    </Allowed>
</NsDepCopConfig>
```

--------------------------------

### Disable NsDepCop with Environment Variable

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Globally disable the NsDepCop tool by setting the DisableNsDepCop environment variable to 'true' or '1'. This affects newly started processes, including MSBuild and Visual Studio integrations.

```bash
setx DisableNsDepCop 1
```

--------------------------------

### Run Unit Tests

Source: https://github.com/realvizu/nsdepcop/blob/master/CLAUDE.md

Executes the unit tests for the NsDepCop.Test project.

```bash
dotnet test source/NsDepCop.Test/NsDepCop.Test.csproj
```

--------------------------------

### Project-Level Configuration with Inheritance

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

This `config.nsdepcop` file in a project folder enables configuration inheritance by setting `InheritanceDepth`. It defines project-specific allowed dependencies that take precedence over inherited settings.

```xml
<NsDepCopConfig InheritanceDepth="1">
    <Allowed From="NsDepCop.MsBuildTask" To="NsDepCop.Core.Interface.*" />
    <Allowed From="NsDepCop.MsBuildTask" To="NsDepCop.Core.Factory" />
    <Allowed From="NsDepCop.MsBuildTask" To="Microsoft.Build.*" />
</NsDepCopConfig>
```

--------------------------------

### Build Analyzer Project

Source: https://github.com/realvizu/nsdepcop/blob/master/CLAUDE.md

Builds the analyzer project, which automatically restores and builds its dependencies.

```bash
dotnet build source/NsDepCop.Analyzer/NsDepCop.Analyzer.csproj
```

--------------------------------

### Basic NsDepCop Configuration

Source: https://context7.com/realvizu/nsdepcop/llms.txt

A basic configuration file for NsDepCop. Ensure the build action is set to 'C# analyzer additional file'. This configuration allows all namespaces to use System.* and the global namespace, and defines specific dependencies between layers of the application.

```xml
<?xml version="1.0" encoding="utf-8"?>
<NsDepCopConfig IsEnabled="true" ChildCanDependOnParentImplicitly="true">
    <!-- Allow all namespaces to use System.* -->
    <Allowed From="*" To="System.*" />

    <!-- Allow all namespaces to use the global namespace (for anonymous types) -->
    <Allowed From="*" To="." />

    <!-- Define layer-specific dependencies -->
    <Allowed From="MyApp.UI.*" To="MyApp.Services.*" />
    <Allowed From="MyApp.Services.*" To="MyApp.Data.*" />
    <Allowed From="MyApp.Services.*" To="MyApp.Models.*" />
    <Allowed From="MyApp.Data.*" To="MyApp.Models.*" />
</NsDepCopConfig>
```

--------------------------------

### Run Source-Based Integration Tests

Source: https://github.com/realvizu/nsdepcop/blob/master/CLAUDE.md

Executes integration tests that verify the analyzer against C# source files.

```bash
dotnet test source/NsDepCop.SourceTest/NsDepCop.SourceTest.csproj
```

--------------------------------

### Default Assembly References for Allowlisting

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

When using an allowlisting approach for assemblies, include these rules to permit references to core .NET assemblies like mscorlib, netstandard, and System.*.

```xml
<NsDepCopConfig IsEnabled="true" CheckAssemblyDependencies="true">
    <AllowedAssembly From="*" To="mscorlib" />
    <AllowedAssembly From="*" To="netstandard" />
    <AllowedAssembly From="*" To="System.*" />
</NsDepCopConfig>
```

--------------------------------

### Configure Allowed Namespace Dependencies

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Defines which namespaces are allowed to reference others. Use this to enforce architectural boundaries. Supports wildcard and exact matching.

```xml
<NsDepCopConfig IsEnabled="true" ChildCanDependOnParentImplicitly="true">
    <Allowed From="*" To="System.*" />
    <Allowed From="NsDepCop.*" To="Microsoft.CodeAnalysis.*" />
    <Allowed From="NsDepCop.ParserAdapter.Roslyn" To="NsDepCop.Analysis" />
</NsDepCopConfig>
```

--------------------------------

### Run Single Test by Name

Source: https://github.com/realvizu/nsdepcop/blob/master/CLAUDE.md

Executes a specific test case by its fully qualified name.

```bash
dotnet test source/NsDepCop.Test/NsDepCop.Test.csproj --filter "FullyQualifiedName~TestMethodName"
```

--------------------------------

### Disable NsDepCop in Directory.Build.Props

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Create or update this file in the source root to prevent NsDepCop from running during every build.

```xml
<Project>
  <PropertyGroup>
    <DisableNsDepCop>true</DisableNsDepCop>
  </PropertyGroup>
</Project>
```

--------------------------------

### NsDepCop Assembly Dependency Rules

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Configuration for enabling and defining assembly-level dependency rules. This checks which assemblies can reference other assemblies. Assembly dependency checking is disabled by default.

```xml
<NsDepCopConfig IsEnabled="true" CheckAssemblyDependencies="true">
    <!-- Allow all assemblies to reference core .NET assemblies -->
    <AllowedAssembly From="*" To="mscorlib" />
    <AllowedAssembly From="*" To="netstandard" />
    <AllowedAssembly From="*" To="System.*" />

    <!-- Define layer dependencies at assembly level -->
    <AllowedAssembly From="MyApp.Web" To="MyApp.Services" />
    <AllowedAssembly From="MyApp.Services" To="MyApp.Data" />
    <AllowedAssembly From="MyApp.Services" To="MyApp.Models" />
    <AllowedAssembly From="MyApp.Data" To="MyApp.Models" />

    <!-- Prevent Repository layer from depending on Service layer -->
    <DisallowedAssembly From="*.Repository" To="*.Service" />
</NsDepCopConfig>
```

--------------------------------

### Configure Assembly Dependency Checking

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Enables assembly dependency checking and defines allowed and disallowed assembly references. Use 'CheckAssemblyDependencies="true"' to activate this feature.

```xml
<NsDepCopConfig IsEnabled="true" CheckAssemblyDependencies="true">
    <AllowedAssembly From="*" To="*" />
    <DisallowedAssembly From="*.Repository" To="*.Service" />
</NsDepCopConfig>
```

--------------------------------

### Allow Namespace Dependency

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Defines that the 'From' namespace can depend on the 'To' namespace. Wildcards can be used for broader matching.

```xml
<Allowed From="MyNamespace" To="System" />
```

```xml
<Allowed From="MyNamespace" To="System.*" />
```

```xml
<Allowed From="MyNamespace" To="*" />
```

```xml
<Allowed From="MyNamespace" To="." />
```

```xml
<Allowed From="MyNamespace" To="System.*.Serialization.*" />
```

--------------------------------

### Set MaxIssueCount for Gradual Adoption

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Configure NsDepCop to allow a specific number of existing violations while preventing new ones. This setting automatically lowers the count as issues are fixed.

```xml
<!-- Step 1: Set MaxIssueCount to current violation count -->
<NsDepCopConfig
    IsEnabled="true"
    MaxIssueCount="247"
    AutoLowerMaxIssueCount="true">

    <!-- Your dependency rules -->
    <Allowed From="*" To="System.*" />
    <!-- ... -->

</NsDepCopConfig>

<!--
This configuration:
1. Allows builds to succeed with up to 247 violations (current state)
2. Fails the build if violations increase above 247 (prevents new violations)
3. Automatically reduces MaxIssueCount when developers fix issues
4. Over time, MaxIssueCount ratchets down as violations are fixed
-->
```

--------------------------------

### Disable NsDepCop in Directory.Build.props

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Disable NsDepCop for all projects within a directory tree by setting the `DisableNsDepCop` property in `Directory.Build.props`.

```xml
<!-- Disable in Directory.Build.props for all projects in a directory tree -->
<Project>
  <PropertyGroup>
    <DisableNsDepCop>true</DisableNsDepCop>
  </PropertyGroup>
</Project>
```

--------------------------------

### NsDepCopConfig Attributes Reference

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Configure analyzer behavior using attributes on the root NsDepCopConfig element. These attributes control various aspects of the analysis process.

```xml
<NsDepCopConfig
    IsEnabled="true"
    ChildCanDependOnParentImplicitly="true"
    ParentCanDependOnChildImplicitly="false"
    MaxIssueCount="100"
    AutoLowerMaxIssueCount="true"
    InheritanceDepth="1"
    CheckAssemblyDependencies="true"
    ExcludedFiles="**/*.g.cs,**/*.Designer.cs,TestFiles/*.cs">

    <!-- Rules go here -->

</NsDepCopConfig>

<!-- Attribute Reference:
IsEnabled (true/false, default: true)
    - Set to false to skip analysis for this project

ChildCanDependOnParentImplicitly (true/false, default: false)
    - When true, child namespaces can reference parent namespaces without explicit rules
    - Recommended: true (matches C# type resolution behavior)

ParentCanDependOnChildImplicitly (true/false, default: false)
    - When true, parent namespaces can reference child namespaces without explicit rules
    - Recommended: false (children should be more concrete than parents)

MaxIssueCount (int, default: 100)
    - Analysis stops after this many issues are reported

AutoLowerMaxIssueCount (true/false, default: false)
    - Automatically reduces MaxIssueCount when fewer issues are found
    - Useful for gradual cleanup of existing violations

InheritanceDepth (int, default: 0)
    - Number of parent folder levels to search for config files to inherit
    - Set to 1 for solution-level inheritance

CheckAssemblyDependencies (true/false, default: false)
    - Enable assembly-level dependency checking

ExcludedFiles (comma-separated glob patterns)
    - Files matching these patterns are excluded from analysis
    - Paths are relative to the config file location
-->
```

--------------------------------

### Disable NsDepCop Globally via Environment Variable

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Use the `setx` command to disable NsDepCop globally for all projects by setting the `DisableNsDepCop` environment variable.

```bash
# Disable globally via environment variable
setx DisableNsDepCop 1

# Or set to true
setx DisableNsDepCop true
```

--------------------------------

### Deny Namespace Dependency

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Defines that the 'From' namespace must not depend on the 'To' namespace. This requires an 'allow all' rule to be present for denylisting to function.

```xml
<NsDepCopConfig>
    <Allowed From="*" To="*" />
    <Disallowed From="MyFrontEnd.*" To="MyDataAccess.*" />
</NsDepCopConfig>
```

--------------------------------

### Force NsDepCop execution in MSBuild

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Use this command to override the disabled state and force the tool to run during an MSBuild process.

```bash
msbuild MySolution.sln -t:NsDepCop_Analyze -p:ForceNsDepCop=true
```

--------------------------------

### NsDepCop Diagnostic Codes Reference

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Reference for NsDepCop diagnostic codes, including their severity and suggested fixes. These codes appear in the Visual Studio Error List and build output.

```text
NSDEPCOP01 - Illegal namespace reference
  Severity: Warning (default)
  The designated type cannot reference the other type because their
  namespaces cannot depend on each other according to the current rules.
  Fix: Update config.nsdepcop rules or refactor to avoid the dependency.

NSDEPCOP02 - Too many dependency issues
  Severity: Warning (default)
  The number of issues exceeded MaxIssueCount, analysis was stopped.
  Fix: Correct reported issues or increase MaxIssueCount.

NSDEPCOP03 - No config file found
  Severity: Info
  No config.nsdepcop file was found with build action 'C# analyzer additional file'.
  Fix: Add config.nsdepcop to the project if analysis is desired.

NSDEPCOP04 - Analysis disabled
  Severity: Info
  IsEnabled="false" was set in the config file.

NSDEPCOP05 - Config error
  Severity: Error
  Error loading config.nsdepcop (malformed XML, file permissions, etc.).
  Fix: Verify config file syntax and accessibility.

NSDEPCOP06 - Tool disabled via environment variable
  Severity: Info
  The DisableNsDepCop environment variable is set to True or 1.

NSDEPCOP07 - Illegal assembly reference
  Severity: Warning (default)
  The designated assembly cannot reference another assembly per current rules.
  Fix: Update assembly dependency rules or refactor project references.
```

--------------------------------

### Set Max Issue Count in NsDepCop Config

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Configure NsDepCop to prevent the introduction of new dependency issues by setting the current number of issues as the maximum allowed. This ensures that no new issues can be created until existing ones are resolved.

```xml
<NsDepCopConfig MaxIssueCount="<the current number of issues>">
```

--------------------------------

### Enable Implicit Child-to-Parent Namespace Dependencies

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Set `ChildCanDependOnParentImplicitly` to 'true' on the `NsDepCopConfig` element to allow child namespaces to implicitly depend on their parent namespaces, similar to C# type resolution. The default is 'false' for backward compatibility.

```xml
<NsDepCopConfig ChildCanDependOnParentImplicitly="true">
    <!-- The following rule is not necessary because the ChildCanDependOnParentImplicitly="true" attribute implies it. -->
    <Allowed From="MyNamespace.SubNamespace" To="MyNamespace" />
</NsDepCopConfig>
```

--------------------------------

### Enable Auto Lower Max Issue Count in NsDepCop Config

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Enable automatic reduction of the maximum issue count to encourage gradual fixing of dependency issues. This setting helps developers address problems over time by progressively lowering the threshold.

```xml
<NsDepCopConfig AutoLowerMaxIssueCount="true" MaxIssueCount="<the current number of issues>">
```

--------------------------------

### Define Namespace Surface for Specific Dependency

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Use `<VisibleMembers>` within an `<Allowed>` element to specify which types from a namespace are visible to another specific namespace. This controls the surface of a namespace for a particular dependency.

```xml
<Allowed From="GameLogic" To="UnityEngine">
    <VisibleMembers>
        <Type Name="Vector2" />
        <Type Name="Vector3" />
    </VisibleMembers>
</Allowed>
```

--------------------------------

### Define Global Namespace Surface

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Use `<VisibleMembers>` with the `OfNamespace` attribute to define a global surface for a namespace, making specified types visible to all namespaces that depend on it. This is not embedded within an `<Allowed>` element.

```xml
<VisibleMembers OfNamespace="UnityEngine">
    <Type Name="Vector2" />
    <Type Name="Vector3" />
</VisibleMembers>
```

--------------------------------

### Configure Analyzer Service Call Retry Time Spans

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Troubleshooting.md

Set longer wait intervals for the analyzer server to spin up by adding AnalyzerServiceCallRetryTimeSpans to your config.nsdepcop file. This is useful for older versions of NsDepCop.

```xml
<NsDepCopConfig AnalyzerServiceCallRetryTimeSpans="100,1000,10000">

```

--------------------------------

### Allow Referencing Global Namespace for Anonymous Types

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Troubleshooting.md

To avoid false alarms caused by anonymous types in older NsDepCop versions, add a rule to allow referencing the global namespace. This configuration is added to your config.nsdepcop file.

```xml
<Allowed From="YourNamespace" To="." />

```

```xml
<Allowed From="*" To="." />

```

--------------------------------

### Disable NsDepCop with MSBuild Property

Source: https://github.com/realvizu/nsdepcop/blob/master/doc/Help.md

Disable the NsDepCop tool within MSBuild builds by setting the DisableNsDepCop property to 'true'. This is an alternative to using environment variables for disabling the tool during the build process.

```xml
<PropertyGroup>
  <DisableNsDepCop>true</DisableNsDepCop>
</PropertyGroup>
```

--------------------------------

### Disable NsDepCop in Specific Config File

Source: https://context7.com/realvizu/nsdepcop/llms.txt

Disable NsDepCop for a specific project or configuration by setting `IsEnabled` to `false` within its `NsDepCopConfig` file.

```xml
<!-- Disable in specific config file -->
<NsDepCopConfig IsEnabled="false">
</NsDepCopConfig>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.