If your ASP.NET programmer has disappeared and the source code is missing, the application can usually still be modified and maintained. A .NET decompiler reads the compiled DLL and EXE files that are running today and turns them back into readable C#. The page files and the database supply most of the rest. Keene Systems recovers the code, gets it building again and takes over the application. The decompiler does only part of the job: the recovered code still needs experienced developers to make it build, run and stay maintainable.
Many business owners believe they have the source code to their application when they do not. The reasoning is natural: the application is right there on the company’s server, and it has worked for years, so the code must be on that server somewhere.
It usually is not. What runs on the server is the compiled program, the finished product. The source code, the text the programmer wrote and the only form in which the program can be changed, most likely never left the programmer’s own laptop. If that programmer has moved on and cannot be reached, the source code has gone with them.
This comes up often in our work, and it is never a pleasant thing to explain. Seeing the application run does not mean you own its source code, and without the source code nobody can modify or maintain the program.
There is a way back. The source code can be rebuilt from the compiled program. It is not a simple task. A decompiler gets you part of the way, and a good deal of manual work remains before the result builds, runs and can be maintained. It takes a team with experience in ASP.NET and in turning decompiled applications back into working source code. The rest of this page explains how it is done.

The copy of the application that is running today is now the most valuable thing you have. Before anyone tries to fix anything:
bin folder and the configuration files. For a desktop program, copy the whole installation folder.This is the part most business owners do not know, and it is good news. When C# or VB.NET is compiled, it is not turned into raw machine instructions. It becomes an intermediate language, stored in a DLL or EXE file together with a detailed description of every class, method and property in the program. A decompiler reads that file and writes the C# back out.
That makes .NET very different from older software, where losing the source really did mean starting again. In a typical ASP.NET application you will find:
.dll files in the bin folder hold the program’s logic..aspx and .ascx files usually sit on the server as the developer wrote them. So do the .cshtml views of older MVC applications..cs or .vb files there, you already have the source.Decompiling is not hacking and it is not guesswork. It is a mechanical translation, and for .NET it is reliable. The process runs like this:
bin folder. For a desktop program they are the .exe and the .dll files beside it.The first four steps take hours. The last three are where the skill and most of the time go.
Several mature decompilers exist, and most are free. These are the ones in common use:
For a recovery job the choice of tool matters less than people expect. Their output is similar, and we often run a difficult class through two of them and keep the cleaner result. The tool gives you text. Turning that text back into a maintainable application is the real work.
Comes back intact:
Does not come back:
.pdb files were deployed alongside the DLLs. Without them you get names like text2 and num3.Comes back, but needs attention:
.aspx files on the server are empty placeholders and the page layouts are inside the DLLs. They are recoverable, as code that has to be turned back into page markup.No, and it is worth knowing which kind you have before you plan anything.
.accdb or .mdb file holds its own source. A compiled .accde or .mde file does not.The quick test is to open the file in one of the decompilers above. If it shows a tree of classes, it is .NET and the code is recoverable. If it reports that the file is not a .NET assembly, it is not.
Decompiled code is a starting point, not a finished product. Our ASP.NET developers turn it into a proper project again. Once the rebuilt application matches the live one, we put the code under source control in an account your company owns, give the generic names meaningful ones in the areas that will be worked on, and write down how the system fits together, since nobody else will have.
Then we make the first real change, test it and deploy it. That deployment is the proof that the system is back under control. From that point it is an ordinary application with an ordinary support team. See ASP.NET application support and takeover for how that continues, or ask for a code audit first if you want a written opinion on what you have before deciding.
Sometimes the developer has not vanished. They are holding the code back over a dispute, or simply not answering. Whether you are entitled to it depends on what your agreement with them says, and that is a question for your attorney, not for a software firm. The same applies to decompiling: it is a normal way to recover software that was written for your company, and if ownership is in dispute you should take advice first.
What we can tell you is that you are rarely as stuck as it feels. If the application is running on a server you control, the recovery described above does not depend on the developer’s cooperation. We have written more about that situation in when a developer is holding your code hostage.
It is also why our own contract states that the client owns the intellectual property of everything we produce for them, source code included, and why the code lives in a repository the client can reach.
Occasionally recovery is possible but not sensible: the application is very old, small, or built on something that is no longer supported. In that case the running system becomes the specification for a replacement. Every screen, report and rule is visible, and the data comes across intact. Our general guide to lost source code covers that route, and Web Forms and .NET Framework migration covers moving an old ASP.NET system forward.
The next step is a short, no-pressure conversation. Schedule an ASP.NET project exploration call or use the form on this page.
Usually, yes. The compiled .dll files of an ASP.NET application can be decompiled back into readable C#, and the page files and database logic are normally still readable on the server. From those a working project is rebuilt, and the application can then be changed and maintained like any other.
For a .NET DLL, yes in most cases. .NET compiles to an intermediate language that a decompiler such as ILSpy, dnSpy or dotPeek converts back to C#. Class names, method names and logic are recovered. Comments are not, and local variable names are lost unless the .pdb files are available.
If the EXE is a .NET program, yes: it decompiles the same way a DLL does. If it was compiled to native machine code, as C++ and Delphi programs are, it cannot be turned back into maintainable source code.
ILSpy is the most widely used and is free and open source. dnSpy adds a debugger, dotPeek comes from JetBrains, and .NET Reflector is a commercial product from Redgate. Their output is similar. For recovering a whole application, the skill of rebuilding the project matters more than the choice of tool.
Functionally it is the same program. It reads differently from what the developer typed: comments are gone, some names are generic and the project structure has to be rebuilt. Part of our work is cleaning it up and documenting it so it can be maintained.
Yes, but the result is harder to work with. Obfuscation replaces meaningful names with meaningless ones and can tangle the flow of the code. The logic remains, and tools exist that undo part of the scrambling. It is uncommon in custom business applications.
Recovering code for software that was written for your company and that you have the rights to is a normal recovery practice. If ownership is disputed, check your agreement with the developer and ask your attorney before proceeding.
A copy of the application files and a backup of the database. Any old backups, laptops or email attachments from the developer are worth collecting too, because the original source sometimes turns up there.
Hold the source code in a repository your company owns, keep the hosting and domain accounts in the company’s name, and work with a team instead of a single individual. Our contract states that the client owns everything we produce for them.
Keene Systems has built custom business software since 1987. We are veteran-owned, and our 50+ professionals have delivered systems for companies including Hormel, McCormick, IBM and Dartmouth-Hitchcock. See our client list.
Tell us what you still have