c# - full - Alcance y cómo limitarlo usando VB.Net

reflector filedisassembler

Question

Si quiero reducir el alcance de una variable en C #, puedo introducir llaves adicionales, es decir:

class Program
{
    static void Main(string[] args)
    {
        myClass x = new myClass();
        x.MyProperty = 1000;
        Console.WriteLine("x = " + x.MyProperty);

        {
            myClass y = new myClass();
            y.MyProperty = 2000;
            Console.WriteLine("y = " + y.MyProperty);
        }

        myClass y2 = new myClass();
        y2.MyProperty = 3000;
        Console.WriteLine("y2 = " + y2.MyProperty);

    }

    class myClass
    {

        public int MyProperty { get; set; }

    }
}

En el ide, ya no puedo hacer referencia a y fuera del alcance introducido por los nuevos refuerzos. Pensé que esto significaría que la variable y estaría disponible para la recolección de basura.

(Es interesante observar que cuando se visualiza el código compilado utilizando un reflector, parece que no hay diferencia con o sin las llaves adicionales)

¿Hay alguna manera similar a esto para reducir el alcance cuando se usa VB.net? ¿Esto tiene algún impacto cuando las variables definidas en el alcance interno pueden ser basura?

Answer 1

Al menos en C #, no hace ninguna diferencia en la recolección de basura cuando no hay un depurador conectado: el GC puede funcionar cuando se lee por última vez una variable, y una variable no cuenta como una raíz de GC después de esa punto. Por ejemplo:

 object y = new object();
 Console.WriteLine("y is still a GC root");
 Console.WriteLine(y);
 Console.WriteLine("y is not a GC root now");
 y = null;
 Console.WriteLine("y is still not a GC root");

(En términos de terminología, la variable en sí misma no se recopila, es solo que mientras cuenta como una "raíz" para el recolector de basura, impide que se recolecte el objeto al que hace referencia).

Cuando tiene un depurador conectado, el GC es mucho más conservador, ya que es posible que desee examinar el valor de una variable después de su último punto de lectura "normal".

El principal beneficio para reducir el alcance es la claridad, IMO. Si una variable tiene un alcance reducido, puede olvidarse de ella cuando no está mirando ese bit de código (suponiendo que no sea capturado por un delegado, etc.).

No sé si VB tiene algún equivalente de un bloque de extracto sin más motivo que el alcance; el equivalente más cercano puede ser una declaración With ... o Do ... Loop While False , ninguna de las cuales es del todo satisfactoria.

Answer 2

no parece haber una buena forma de crear un nuevo ámbito en vb, pero puede crear un bucle que se ejecute solo una vez garantizado y luego declarar su variable dentro de ese bucle.

MSDN tenía esto que decir sobre la vida útil de una variable:

Incluso si el alcance de una variable está limitado a un bloque, su duración sigue siendo la de todo el procedimiento. Si ingresa al bloque más de una vez durante el procedimiento, cada variable de bloque conserva su valor anterior. Para evitar resultados inesperados en tal caso, es aconsejable inicializar las variables de bloque al comienzo del bloque.

src: http://msdn.microsoft.com/en-us/library/1t0wsc67.aspx

parece que las variables solo están sujetas a la recolección de basura una vez que el procedimiento ha finalizado, pero incluso entonces el recolector de basura no se ejecutará a menos que el montón se esté llenando. Lo más probable es que para aplicaciones pequeñas nunca se obtenga basura hasta que se cierre la aplicación.

Answer 3

¿Por qué no solo crear algunos métodos? Un alcance debe ser definido en un método. Una vez que sale del método, abandona el alcance, limpio y fácil. La forma en que lo está haciendo es muy poco ortodoxa: le sugiero que se adhiera a los métodos de convención y uso si está preocupado por el alcance del alcance (lo que está describiendo).

Answer 4

Curiosamente, el convertidor de código developerFusion c # -vb.net convierte

 {
    myClass y = new myClass();
    y.MyProperty = 2000;
    Console.WriteLine("y = " + y.MyProperty);
 }

a

If True Then
   Dim y As New [myClass]()
   y.MyProperty = 2000
   Console.WriteLine("y = " & y.MyProperty)
End If

como una forma de limitar el alcance. Me sorprende que moleste tener en cuenta la respuesta de paintballbob