diferencia resurrección en el uso de inicializador de objeto

Question

tengo este código:

Esencialmente estoy tratando de demostrar el uso de la C# finalizador y crea un objeto que no puede morir, llamó zombi. Ahora, normalmente esta demostración funciona muy bien, pero hoy traté de usar el mismo código con el inicializador de objetos en lugar de simplemente asignar a la propiedad (Nombre en este caso). Noté que hay una diferencia. A saber, el finalizador nunca se llama, ni siquiera cuando hago mi mejor esfuerzo para que el recolector de basura haga su trabajo.

¿Alguien podría explicar la diferencia, o he encontrado un error en el compilador de C#?

(estoy usando C# 4 en el SP1 de VS2010 en Win7x64)

Gracias.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading; 

namespace Zombie 
{ 
    class Program 
    { 
    static void Main(string[] args) 
    { 
     Console.WriteLine("Main thread: " + Thread.CurrentThread.ManagedThreadId); 

       // case 1: this is where the problem is located. 
     Zombie z = new Zombie { Name = "Guy" }; // object initializer syntax makes that the finalizer is not called. 

       // case 2: this is not causing a problem. The finalizer gets called. 
     //Zombie z = new Zombie(); 
     //z.Name = "Guy"; 

     WeakReference weakZombieGuyRef = new WeakReference(z, true); 

     z = null; 

     GC.GetTotalMemory(forceFullCollection: true); 

     GC.Collect(); 

     while (true) 
     { 

     Console.ReadKey(); 
     if (weakZombieGuyRef.IsAlive) 
     { 
      Console.WriteLine("zombie guy still alive"); 
     } 
     else 
     { 
      Console.WriteLine("Zombie guy died.. silver bullet anyone?"); 
     } 

     Zombie.Instance = null; 

     GC.AddMemoryPressure(12400000); 
     GC.GetTotalMemory(forceFullCollection: true); 

     GC.Collect(); 
     } 


    } 
    } 

    public class Zombie 
    { 
    public string Name { get; set; } 
    public static Zombie Instance = null; 

    ~Zombie() 
    { 
     Console.WriteLine(Thread.CurrentThread.ManagedThreadId); 
     Console.WriteLine("Finalizer called on zombie" + this.Name); 
     lock (typeof(Zombie)) 
     { 
     Instance = this; 

     GC.ReRegisterForFinalize(this); 
     } 
    } 
    } 
} 

Answer 1

EDIT: Si bien la respuesta original a continuación sigue siendo exacta, parece que es la mezcla de la información de depuración y optimización que hace una diferencia aquí.

De mis experimentos:

Compiler flags      Result 
/o+ /debug-       Finalizer runs 
/o+ /debug+       Finalizer runs 
/o- /debug-       Finalizer runs 
/o- /debug+       Finalizer does *not* run 

---

El finalizador todavía se llama en mi caja, cuando se compilan en la línea de comandos con /o+. Supongo que estás ejecutando un depurador, lo que cambia el comportamiento del GC. Sin el depurador, el GC recopilará todo lo que pueda demostrar que nunca será leído. Con el depurador, creo que el GC no recogerá ningún objeto que todavía tenga referencias en la pila, incluso si no hay código para leer las variables en cuestión.

Ahora con un inicializador de objetos, el código del compilador incluye una referencia adicional en la pila. Esta línea:

Zombie z = new Zombie { Name = "Guy" }; 

es efectivamente:

Zombie tmp = new Zombe(); 
tmp.Name = "Guy"; 
Zombie z = tmp; 

La asignación a z sólo se realiza después de todas las propiedades se han establecido.

Supongo que la variable tmp aquí mantiene el objeto vivo.

Answer 2

Si desea objetos que no mueren, no necesita meterse con los finalizadores. Sólo tienen una lista estática privada de todas las instancias, y añadir objetos a la lista a medida que se crean:

class Immortal 
{ 
    static List<Immortal> _immortals = new List<Immortal>(); 

    public Immortal() 
    { 
     _immortals.Add(this); 
    } 
}