Renaming is the oldest and most fundamental obfuscation technique, and the one the free tier is built on. It is also the floor every other layer stands on. Understanding exactly what it changes — and what it deliberately leaves alone — is the quickest way to see how much protection names alone buy you, and where you need more.
What renaming does
A compiled .NET assembly carries the full names of everything you declared:
InvoiceCalculator, ValidateLicenseKey,
_connectionString. A decompiler
reads those names straight out of the metadata, which is why decompiled output looks so
much like your source. Renaming replaces each one with a short, meaningless token —
a, b, Ɨ — applied consistently so that every
reference to a renamed member is updated to match and the assembly still links and runs.
It reaches most of what you write: types, methods, fields, properties, events,
parameters and local names where they survive compilation. After the pass,
invoice.Calculate(total) reads as a.b(c). The program behaves
exactly as before — renaming is a pure relabelling — but the names that documented your
intent are gone from the reader's view for good.
What it deliberately does not touch
Just as important is what renaming leaves alone, because those gaps are precisely what the other layers exist to cover:
-
Framework and third-party names. Calls to
HttpClient,File.ReadAllTextor a NuGet package are references to code you did not write; their names must stay for the call to resolve. So the external call graph stays readable after renaming — a separate layer, reference proxying, addresses that. - A library's public API. The public surface of a library is its contract with the code that compiles against it, so renaming it would break every consumer. It is left intact by design — see why public names are only renamed in applications.
- Anything looked up by name at runtime. Reflection, serialization, dependency injection and XAML resolve members by their string names, so renaming them without care breaks the lookup. The tool applies safe rules, but this is the usual source of trouble — the reflection guide lists each case and its fix.
-
String literals. Renaming changes identifiers, not data. Your
"https://api.example.com"or"Trial expired"text is still sitting in the assembly in clear — hiding it is a different layer, string encryption.
What the output looks like
After renaming, a decompile returns code with the same structure as yours but no
readable labels: the classes, methods and branches are all there, named like
Class7.M3(). The shape of the logic is intact — a reader can still
follow that a value is checked and a branch taken — which is why, for code whose value is
in its logic rather than its names, renaming is only the first step. Hiding the shape is
what control-flow obfuscation adds.
ValidateLicenseKey is a, the intent
it carried is lost to the reader permanently. But a deobfuscator can still assign fresh,
consistent placeholder names and hand back navigable structure, and every external call
and string stays as it was. Renaming raises the cost of reading your code; it does not
make it unreadable. The honest framing is in
what obfuscation actually
protects against.
Where renaming is enough, and where it isn't
For a great many projects, names-only protection is the right level: it stops casual
reading, removes the searchable signposts (License, Trial,
Admin), and costs nothing in runtime or compatibility. That is the whole free
tier, and it is a sensible first pass for any assembly — it also flushes out reflection
and serialization problems cheaply before you add anything heavier.
It is not enough when the value is in the logic, the literals or the calls rather than the labels: a licence algorithm a competitor would copy, URLs and keys in your strings, or a network call that gives away where the check lives. Those are what the Pro layers address. The layer decision guide matches each one to the threat it answers, so you add only the depth your project actually needs.