Aggressive Mode Enterprise

Aggressive mode goes beyond renaming to strip the source-level structure decompilers rely on. Properties and events are no longer recognizable as such; renamed methods can share the same name; compiler-emitted hints that betray the original code shape are gone; parameters are renamed; default parameter values are stripped.

Usage

Aggressive mode is ON by default at the Enterprise tier. Set <DemeanorNoAggressive>true</DemeanorNoAggressive> in your .csproj to disable it for a specific build.

Before & After

public class User
{
    public string Name { get; }
    public string Email { get; }
    public bool IsActive { get; set; } = true;
    public DateTime CreatedAt { get; }

    public User(string name, string email) { ... }
}

public class j
{
    private string m_a;
    private string b;
    private bool c = true;
    private DateTime d = DateTime.UtcNow;

    // No properties — metadata stripped
    string a() => m_a;  // was get_Name
    string a() => b;    // was get_Email
    bool a() => c;      // was get_IsActive
    void a(bool a) { c = a; }

    public j(string a, string a) { ... }
}

Real ILSpy output. Properties are gone — only the underlying access methods remain. Multiple methods share the name a. [DebuggerBrowsable], [CompilerGenerated], [Nullable], and similar compiler attributes are stripped. Parameters are renamed.

What Aggressive Mode Does

• Property and event metadata stripping — the decompiler can no longer reconstruct properties or events; only the underlying methods remain.
• Method-name collision — renamed methods can share the same name even when their signatures differ slightly, removing another visual cue from the decompiled output.
• Compiler-attribute stripping — the markers the C# compiler emits (such as [CompilerGenerated], [Nullable], and [NullableContext]) are removed.
• Field-level hints removed — the readonly hint and similar markers that betray the original declaration shape are dropped.
• Parameter renaming — parameter names are replaced with short identifiers; default values are stripped.

When to Disable

• Reflection on properties or events — typeof(T).GetProperty("Name") will return null after metadata stripping. Exclude specific types.
• Data binding frameworks — WPF, MAUI, and Blazor bind to properties by name. Demeanor automatically detects and protects data-bound properties, but custom binding scenarios may need manual exclusions.

Ready to protect your .NET code?