Method virtualization is the strongest protection layer we offer, and the one most worth understanding before you reach for it. It does not obscure your method — it replaces it with something a .NET decompiler cannot read as .NET at all.
The idea
Every other layer leaves your logic as .NET IL — renamed, tangled or wrapped, but still IL, and still something tools like ILSpy understand. Virtualization breaks that assumption. A virtualized method's IL is translated into a different instruction set — a custom bytecode — and the original IL is removed. In its place sits a small interpreter (a virtual machine) that the obfuscator embeds in your assembly. At runtime the method call runs the interpreter over the bytecode and produces the same result.
The point is the mismatch. A .NET decompiler expects IL and knows how to read it. It does not know your private bytecode or your private interpreter, so pointing it at a virtualized method yields the interpreter's dispatch loop — not your algorithm. To recover the logic, an attacker first has to understand the VM itself, then hand-trace the bytecode through it. That is a different and much larger job than reading decompiled C#.
How you choose what to virtualize
Virtualization is opt-in per method, not a switch for the whole assembly. You
mark the methods that matter with a [Virtualize] attribute, and only those
are converted; everything else is obfuscated normally. This is deliberate — the layer
is powerful and expensive, so it is designed to be aimed, not sprayed.
[Virtualize]
decimal ComputeLicenceKey(string seed, int tier)
{
// the logic you least want a competitor to read
}
Good candidates are the few methods that hold real value: a licensing or activation check, a pricing or scoring algorithm, a proprietary calculation, anything you would be genuinely hurt to see reproduced.
The trade-offs that matter
- Performance. A virtualized method runs through an interpreter instead of as JIT-compiled native code, so it is substantially slower than the original — often by a large multiple. This is fine for a licence check that runs once at startup and disastrous for a method in a tight inner loop. Never virtualize hot-path code. More in does obfuscation slow your app down?
- Size. The embedded interpreter adds to the assembly. It is a fixed cost paid once, not per method, but it is there.
- Supported constructs. Virtualization translates IL into another form, and not every construct is worth or able to be translated. Mark small, self-contained methods; keep the heavy framework interop and exotic control flow out of the virtualized set.
- Debugging. You cannot step through a virtualized method the normal way. Keep an unvirtualized build for your own diagnostics.
How it compares
Virtualization is the headline feature of several commercial protectors — .NET Reactor, Eazfuscator.NET and ArmDot all build around it, at one-time prices from roughly US$249 to US$1,799. We offer the same class of protection as a per-method opt-in on the Pro plan at $29/month. If you need virtualization wired into a local build on every compile, those tools fit that workflow; if you want to apply it to a handful of key methods without installing or licensing anything, this is the lighter path.
Using it well
Treat virtualization as a scalpel. Identify the two or three methods whose logic is the
actual product, confirm none of them is performance-critical, mark them
[Virtualize], and leave the rest to renaming, string encryption and
control-flow obfuscation. Protection is a budget; spend the expensive layer only where
it pays off.