How to Obfuscate a .NET Application
Without Breaking Reflection

1 The Problem

When a .NET obfuscator scrambles metadata identifiers, it replaces human-readable class, method, property, and field names (such as MyApp.Processor or ProcessData) with non-printable unicode characters, random string patterns, or encrypted metadata tokens.

Standard C# compilation bakes metadata tokens directly into method calls (e.g., IL call instance void MyApp.Processor::ProcessData()). Renaming these tokens in Intermediate Language (IL) changes both the declaration and the static call site in tandem, allowing direct method calls to execute without issue.

If an obfuscator renames MyApp.SomeClass to a.a or \u0001, the runtime reflection lookup searches for the literal string "MyApp.SomeClass", fails to find it in the obfuscated metadata table, and throws a runtime exception.

2 Reflection-Dependent Code Example

Below is a practical implementation featuring dynamic type loading and method invocation commonly found in factory patterns, dependency injection engines, and plugin architectures.

using System;
using System.Reflection;

namespace MyApp
{
    public interface IProcessor
    {
        void ProcessData(string payload);
    }

    public class DataProcessor : IProcessor
    {
        public void ProcessData(string payload)
        {
            Console.WriteLine($"[Processing Payload]: {payload}");
        }
    }

    public class ReflectionFactory
    {
        public static void ExecuteDynamicCall()
        {
            // 1. Dynamic type resolution via literal string
            Type targetType = Type.GetType("MyApp.DataProcessor");
            if (targetType == null)
            {
                throw new InvalidOperationException("Failed to locate target type via reflection.");
            }

            // 2. Dynamic instantiation
            object instance = Activator.CreateInstance(targetType);

            // 3. Dynamic method resolution
            MethodInfo method = targetType.GetMethod("ProcessData");
            if (method == null)
            {
                throw new MissingMethodException("MyApp.DataProcessor", "ProcessData");
            }

            // 4. Dynamic invocation
            method.Invoke(instance, new object[] { "Encrypted_Order_Payload_9921" });
        }
    }
}

Imports System.Reflection

Namespace MyApp
    Public Interface IProcessor
        Sub ProcessData(ByVal payload As String)
    End Interface

    Public Class DataProcessor
        Implements IProcessor

        Public Sub ProcessData(ByVal payload As String) Implements IProcessor.ProcessData
            Console.WriteLine($"[Processing Payload]: {payload}")
        End Sub
    End Class

    Public Class ReflectionFactory
        Public Shared Sub ExecuteDynamicCall()
            ' 1. Dynamic type resolution via literal string
            Dim targetType As Type = Type.GetType("MyApp.DataProcessor")
            If targetType Is Nothing Then
                Throw New InvalidOperationException("Failed to locate target type via reflection.")
            End If

            ' 2. Dynamic instantiation
            Dim instance As Object = Activator.CreateInstance(targetType)

            ' 3. Dynamic method resolution
            Dim method As MethodInfo = targetType.GetMethod("ProcessData")
            If method Is Nothing Then
                Throw New MissingMethodException("MyApp.DataProcessor", "ProcessData")
            End If

            ' 4. Invocation
            method.Invoke(instance, New Object() {"Encrypted_Order_Payload_9921"})
        End Sub
    End Class
End Namespace

3 What Happens Under Naive Obfuscation

When an application containing dynamic reflection calls is processed using default, aggressive symbol renaming:

Because the literal string "MyApp.DataProcessor" inside your code remains unchanged while assembly metadata is mutated to randomized symbols, standard runtime lookup fails completely.

4 Step-by-Step Opaquer Configuration

Follow these steps inside Opaquer .NET Obfuscator to keep reflection operational while protecting the underlying application logic.

5 Before/After Visual Decompiler View (ILSpy)

Compare how decompilers like ILSpy view your code under different obfuscation configurations:

6 Testing the Obfuscated Application

Always validate protected binaries in your build pipeline prior to distribution:

7 Common Failures and Fixes

8 Production Recommendations

9 Frequently Asked Questions