Interesting questions on knowledge of C # and .NET mechanisms

In the CLR, every object on the heap has a pointer to a type object. This is necessary, for example, to find the values ​​of static fields and the implementation of static methods for an instance of a type. But the type object referenced by the type instance also has a reference to the type object and is an “instance” for the System.Type type object, the type object for which the CLR is created on startup.



In this diagram, the Manager object refers to the Manager type object, the pointer to which object type refers to the System.Type type object.

Can. The delegate is not just a wrapper for the method, but a full-fledged class, and a class can be made both nested in the parent class and simply declared in the global scope. That is, a delegate can be defined wherever a class can be defined.

')

internal class Feedback : System.MulticastDelegate { //  public Feedback(Object object, IntPtr method); // ,       public virtual void Invoke(Int32 value); // ,     public virtual IAsyncResult BeginInvoke(Int32 value, AsyncCallback callback, Object object); public virtual void EndInvoke(IAsyncResult result); } 

Another interesting question is why the delegate class constructor contains two parameters, and in the code we simply pass a pointer to the method (internal for the CLR, according to which it will find this method)?

 delegate void Test(int value); void A(int v) { Console.WriteLine(v); } void TestDelegate() { var t = new Test(A); t(1); } 

It's simple - because the compiler, when creating the delegate itself, substitutes the value of the parameter object for the constructor . If the method by which the delegate is initialized is static, null is passed. Otherwise, an object is passed to the instance of the class to which the method belongs. In this case, the state of this object can be changed through the this keyword within the method.

Displays 2. When delegates are placed in a chain at the delegate's chain, the internal field is filled in, which is an array of delegates (in case there are more than one number, otherwise the method reference is stored). All delegates are run sequentially. Returns the value of the latter, the rest are not taken into account.

In order to understand this, open the assembly in ildasm.

You can make sure that in this case the lambda expression is not a method, but a whole class!

 .method private hidebysig instance void Test() cil managed { //  : 44 (0x2c) .maxstack 2 .locals init ([0] class ConsoleApplication1.Program/'<>c__DisplayClass1_0' 'CS$<>8__locals0') IL_0000: newobj instance void ConsoleApplication1.Program/'<>c__DisplayClass1_0'::.ctor() IL_0005: stloc.0 IL_0006: nop IL_0007: ldloc.0 IL_0008: ldc.i4.5 IL_0009: stfld int32 ConsoleApplication1.Program/'<>c__DisplayClass1_0'::pass1 IL_000e: ldloc.0 IL_000f: ldstr "Passing test" IL_0014: stfld object ConsoleApplication1.Program/'<>c__DisplayClass1_0'::pass2 IL_0019: ldloc.0 //    ! IL_001a: ldftn instance void ConsoleApplication1.Program/'<>c__DisplayClass1_0'::'<Test>b__0'(object) IL_0020: newobj instance void [mscorlib]System.Threading.WaitCallback::.ctor(object, native int) IL_0025: call bool [mscorlib]System.Threading.ThreadPool::QueueUserWorkItem(class [mscorlib]System.Threading.WaitCallback) IL_002a: pop IL_002b: ret } // end of method Program::Test 

But the description of the class itself and it contains the method under discussion:



The compiler determines whether the lambda expression contains references to local variables. If not, a static method is generated (or an instance method, if the lambda expression contains references to the members of the type instance). And if references to local variables are present, then a class is generated that contains the required fields and the method described in the lambda expression.

Displays 4. Operator ~ performs bitwise reversion.

 Console.WriteLine("{0:x8}, {1:x8}", -5, ~(-5)); //  fffffffb, 00000004 

Moreover, for a value of 5 will display -6.

The fact is that the garbage collector itself sets thresholds for generations (depending on the actual behavior of the application). As soon as the size of the generation in the managed pile exceeds the threshold, the garbage collection begins (this is described in great detail in Richter). Therefore, calls to GC.Collect () should most often be avoided. But it may be necessary to manually clean the garbage, if a one-time event occurred, which led to the destruction of many old objects . Thus, based on past behavior, the garbage collector predictions will not be accurate, and garbage collection will be most welcome.

 //   int rand3() { int x, y; do { x = rand2(); y = rand2(); } while (x == 0 && y == 1); return x + y; } //   int rand3() { int r = 2 * rand2() + rand2(); if (r < 3) return r; return rand3(); }