下面的“重新编译程序集”是什么意思？| C#

Question

I faced the follwing section when reading a book about C#:

Constants should be avoided for two important reasons: the value must be known at compile time, and it must be expressible as a literal string, Boolean, or number value. Every reference to the const field is replaced with the literal value at compile time, which will, therefore, not be reflected if the value changes in a future version and you do not recompile any assemblies that reference it to get the new value.

I have two questions now.

1- What does it mean by the highlited part "future version" above?

2- What does it mean when it says: you do not recompile any assemblies... ? I didn't get it when I saw this part, can anyone explain that how an assembly get recompiled?

Answer 1

Let's say you maintain a class library named ProjectA . You include a constant named SomeUtil.AConstantValue and set it to an int value of 1 . You release this as AssemblyVersion 1.0.0.0 and FileVersion 1.0.0.0.

ProjectA 1.0.0.0

Now let's say someone consumes your library project in ProjectB and uses the value of SomeUtil.AConstantValue . They compile their assembly, which copies the value 1 into the MSIL of the assembly. But that is fine at this point, because it is the same as ProjectA .

ProjectB 1.0.0.0
   |
    ---- ProjectA 1.0.0.0

Next, you discover that the value 1 is not a high enough value for ProjectA 's SomeUtil.AConstantValue to work correctly. So, you change the value to a 2 and release the patch with AssemblyVersion 1.0.0.0 and and FileVersion 1.1.0.0.

ProjectA 1.1.0.0

The author of ProjectB sees you have released a new version of ProjectA and decides to xCopy (fancy speak for copy and paste) the DLL to upgrade it. Since it has an AssemblyVersion of 1.0.0.0, it is binary compatible so there is no need to recompile ProjectB . However, since the value of 1 was copied into ProjectB when it was compiled, it doesn't see the new constant value.

ProjectB 1.0.0.0 (note the version here didn't change because it wasn't recompiled)
   |
    ---- ProjectA 1.1.0.0

---

If you imagine the same scenario, but use a static field instead of a constant, ProjectB will immediately start using the new value 2 for SomeUtil.AConstantValue . This is a better situation, because there won't be a difference in behavior if ProjectB is recompiled vs the new DLL simply copied along with ProjectB .

NOTE: Generally speaking, this scenario doens't play out very often if you use NuGet because most people will recompile the application when they get the new version. The advice given is to cover cases where the DLL is unzipped from the NuGet package and copied to the bin/app folder manually or installed into the Global Assembly Cache. Any of these scenarios can be done without forcing a recompile of ProjectB .

Answers

1. What does it mean by the highlited part "future version" above?

   Using the above scenario, the "future version" referred to would be FileVersion 1.1.0.0. It is considered a "future version" here, because ProjectB was compiled against FileVersion 1.0.0.0 (in the past).

2. What does it mean when it says: you do not recompile any assemblies...?

   In the above scenario, the author of ProjectB decided to copy the ProjectA DLL you authored into their application directory. This overwrites FileVersion 1.0.0.0. Most of the code changes that were made to ProjectA will immediately start being used by replacing the DLL (assembly). However, the constant value would not be utilized unless ProjectB is recompiled while referencing ProjectA .

I didn't get it when I saw this part, can anyone explain that how an assembly get recompiled?

C# is one of many different compiled languages. With a compiled language the source code that is written is compiled into a format that more closely represents the machine code that the computer uses. .NET compiles down to a format called intermediate language (IL or MSIL), which is what usually gets deployed to the target device. In general, compiling makes the code run faster than if it is simply interpreted on demand.

There are compilers built into Integrated Development Environments (IDEs) such as Visual Studio , Visual Studio Code , or JetBrains Ryder , as well as software development kits (SDKs) that can compile on the command line (for example, the .NET SDK which has a compile command do.net build ).

References

• Interpreted vs. compiled languages: What's the difference?