Question: I have written a program that doesn't do anything usefull, this is `static void Main(string[] args)`:

```
int a = 0;
a++; // ... for another 2048 times
     // not in a for loop or something
     // just this a++ 2048 times

```

It's written in a default Console Application class, 
Yes. It just does that.
It's exacly 12.800 bytes.

Then I the variable `a` to `someSortOfRidiculousSuspiciousWeirdAndSuperSuperEnormousMegaHyperGigaVariableNameThatsNotReallyFunToReadOrWrite`.
I compiled it and the size is exacly the same(12.800 bytes).

Why is that? If I decompile it, I can see the long file name. I also see that calling the variable does not increase size at all, because it's associated with some sort of number that would have been the same if it were `a`. I however see this:

```
.locals init
(
    [0] int32 someSortOfRidiculousSuspiciousWeirdAndSuperSuperEnormousMegaHyperGigaVariableNameThatsNotReallyFunToReadOrWrite
)

```

This would be significantly smaller when it's just replaced again with `num1`(not `a`, as you would think), but I can't see it back anywhere in the file size!

Why is that?

Also: I think the properties window(For clearance: right-click on the file in windows --> properties) of the assemlby isn't right. When I add a few of `Console.WriteLine("Test")` does not increase size too.

EDIT:
People suggested to make my variable name > 512 bytes.
If my variable name reaches > 512 characters(512 bytes), I get the compiler error "Identifier too long"

Answer: 
This is affected by the internal structure of a PE32 file, the file format for Windows EXE and DLL files. Sections in this file have a minimum size. Actually controlled by a setting in your project. Project + Properties, Build tab, Advanced button, File Alignment setting. Any C# project will have this set at 512 bytes, the minimum allowed for a PE32 file.

A further detail is what happens to local variables. The name of the variable is not in fact stored in the .NET assembly. The decompiler you used retrieved it from the PDB file. Otherwise the reason why decompilers like ILSpy and Reflector need to generate fake names for local variables on assemblies that you don't have the PDB for, like .NET Framework assemblies.

So no matter what name you pick for the variable, the assembly will never get bigger. Just the PDB file. And the changes you make need to add at least 511 bytes of MSIL and/or metadata to reliably increase the size of the EXE/DLL file.
Binary files tend to be whole disk block size. 12800 happens to be 512\*25.

Try adding at least 512 characters worth of data to ensure that you need another block.