¿Estática privada de VB6 en C#?

Question

En VB6 hay variables locales estáticas que mantienen sus valores después de la salida del procedimiento. Es como usar vars públicos pero en bloque local. Por ejemplo:

sub count() 
static x as integer 
x = x + 1 
end sub 

Después de 10 llamadas, x será 10. Traté de buscar lo mismo en .NET (e incluso de Java), pero no había ninguna. ¿Por qué? ¿Rompe el modelo de OOP de alguna manera, y hay una manera de emular eso?

Answer 1

Lo más cerca que se puede conseguir es un campo estático fuera el método:

private static int x; 
public [static] void Foo() { 
    x++; 
} 

---

ejemplo de cierre conforme a lo solicitado:

using System; 
class Program { 
    private static readonly Action incrementCount; 
    private static readonly Func<int> getCount; 
    static Program() { 
     int x = 0; 
     incrementCount =() => x++; 
     getCount =() => x; 
    } 
    public void Foo() { 
     incrementCount(); 
     incrementCount(); 
     Console.WriteLine(getCount()); 
    } 
    static void Main() { 
     // show it working from an instance 
     new Program().Foo(); 
    } 
} 

Answer 2

Siempre puede utilizar variables estáticas en una clase para ese propósito:

class C 
{ 
    static int x=0; 

    void count() 
    { 
    ++x; // this x gets incremented as you want 
    } 
} 

Answer 3

Recuerdo estática privada en Visual Basic. Fueron geniales para alguna tarea específica.

No existe tal cosa en .net. Tendrá que quedarse con la estática fuera del método.

Answer 4

A menudo ese tipo de variables se utilizan para mantener los iteradores. C# tiene estos integrados directamente en el lenguaje a través de la palabra clave yield. He aquí un ejemplo:

IEnumerable<int> TimesTable(int table) 
{ 
    for (int i=0 ; i<12 ; i++) 
    { 
     yield return i * table; 
    } 
} 

En este ejemplo, creamos los valores de la tabla n veces, donde n es especificado por la persona que llama. Podemos utilizar esto en cualquier lugar se utiliza un repetidor, como en un bucle foreach:

foreach (var value in TimesTable(3)) 
{ 
    Console.Write(""+ value + " "); 
} 

... que produce:

3 6 9 12 15 18 21 24 27 30 33 36 

En C++, esto podría haber utilizado variables estáticas como los que se describen desde VB (no soy un tipo VB, así que no sé la sintaxis VB):

int TimesTable(int table) { 
    static i = 1; 
    if (i == 12) { 
     i = 1; 
    } 
    return i++ * table; 
} 

la versión C# es mejor que el C++ (o VB) equivale becuase el iterador se puede cancelar la oreja y puede haber múltiples iteradores activos en un momento dado. Estas cosas no son ciertas para la versión C++ sin más trabajo del desarrollador. En el lado negativo, significa que la única vez que algo como una variable estática es válido en C# es durante la implementación de un iterador, y el valor no persiste más allá de ese alcance.

Espero que sea de alguna utilidad para usted.