c# - Difference in code execution when extension method present but not called -

TL; DR, question:

What effect code can be .net (for example, JIT / optimization) in the presence of an extension method of the effect code?

Background

I am facing a test failure MSTE depends on whether it appears that the unrelated assemblies are also examined .

I saw the failure of the test and saw from accident that the failure occurred only when another test assembly was filled. Both will start to perform integration tests running on united and unity test assemblies and will fail on the 21st integration test under 4.5 CLR, while it will not be under 4.0 CLR (otherwise otherwise). I removed all the tests, but the integration test failed from the assembly. Performance now looks like both the test assemblies have been loaded, MSEST loads both assemblies then execute a test in the Integration Testing Assembly, which is unsuccessful.

  & gt; Mstest.exe /testcontainer:Unittests.dll /testcontainer:IntegrationTests.dll Loading C: \ Proj \ Test \ bin \ x86 \ Release \ Unittests.dll ... Loading C: \ Proj \ Test \ bin \ X86 \ release \ integrationtests. Dll ... Starting execution ... Results Top Level Test ------- --------------- Failed Proj.IntegrationTest.IntegrationTest21   
 Without preparing the assembly in the execution, the exam passes.  
  & gt; Mstest.exe /testcontainer:IntegrationTests.dll Loading C: \ Proj \ Test \ bin \ x86 \ Release \ integrationtests.dll ... Execution Start ... Results Top Level Testing ------- - ------------- Prose. Passed I thought it should be a  [assembly initial]  Unittest of the object executed on the test test, or perhaps any kind of stable position. .dll or a common dependency is being modified when the test assembly was loaded. I do not find any fixed constructor nor units init in unitsets DLL. I doubted the difference in a deployment when the Units assembly was included (assembly assembly allocated in different editions), but I compare the pass / fail deployment wires and they are binary equivalents.  
 So what part of the unittests is causing the assembly exam difference? With unit tests, I had taken half of the tests at one time, till I drill it into a source file in the unit test assembly. With the test class, an extension method has been declared:  
 In addition to this extension category, there is now a test case in the Dummy Test class in the Unite Assembly. The failure of the test occurs when I have a dummy test method declaring the  and  extension method I can remove the remaining balance of the test argument unless Unicast DLL is a single file in which this happens : Unittests.dll [Test class] Public class DummyTest {[TestMethod] Public Zero TestNothing () {}} Public Stable Class IEnumerableExtension {Public Fixed IEnumerable & lt;  
  // UnummestTest.cs T & gt; Sammetric Difference & Lt; T & gt; (This IEnumerable & lt; T & gt; @this, IEnumerable & lt; T & gt; k) {Return to this @. (Excluding) .cancat (except that. (@thes)); }}   
 If the testing method  or  extensions class has been removed, then the test passes both, are present, and the exam fails.  
 There is no call to the extension method created from the assembly, and before executing the integration tests, no code is executed in the unit assembly (as far as I am concerned).  
 I am sure the integration test is very complex, because JIT difference in optimization can create a difference. What I see in the floating point?   
 
 
 Problem is caused by error loading.  
 When a CLR runtime is loaded, a class or method always inspects all the types of things used in those objects. It does not matter whether the type / method is actually called or not is the fact of the announcement. On returning to your sample, the extension method  symmetry  declares that it uses the system with system  and  concat  methods. Core assembly  
 What's happening is an error occurred while loading  code.Core assembly from  System.Linq.Enumerable .  
 Due to that behavior, the first step is to move that you can login to the exact exception that you get on test failure.