¿Cómo puedo llamar a un método no estático desde un método estático en C#?

Question

Tengo el siguiente código, quiero llamar al data1() desde data2(). ¿Es esto posible en C#? ¿Si es así, cómo?

private void data1() 
{ 
} 
private static void data2() 
{ 
    data1(); //generates error 
} 

Answer 1

Tendrá que crear una instancia de la clase e invocar el método en ella.

public class Foo 
{ 
    public void Data1() 
    { 
    } 

    public static void Data2() 
    { 
     Foo foo = new Foo(); 
     foo.Data1(); 
    } 
} 

Answer 2

No puede llamar a un método no estático sin crear primero una instancia de su clase principal.

lo tanto, desde el método estático, que habría que crear una instancia de un nuevo objeto ...

Vehicle myCar = new Vehicle(); 

... y luego llamar al método no estático.

myCar.Drive(); 

Answer 3

Debe crear una instancia de esa clase dentro del método estático y luego llamarla.

Por ejemplo así:

public class MyClass 
{ 
    private void data1() 
    { 
    } 
    private static void data2() 
    { 
    MyClass c = new MyClass(); 
    c.data1(); 
    } 
} 

Answer 4

Tal vez lo que busca es el patrón Singleton?

public class Singleton 
{ 
    private Singleton() {} 

    public void DoWork() 
    { 
     // do something 
    } 

    // You can call this static method which calls the singleton instance method. 
    public static void DoSomeWork() 
    { 
     Instance.DoWork(); 
    } 

    public static Singleton Instance 
    { 
     get { return instance; } 
    } 

    private static Singleton instance = new Singleton(); 
} 

usted todavía tiene que crear una instancia de la clase, pero se asegura de que hay solamente una instancia.

Answer 5

Solo necesita proporcionar una referencia de objeto. Por favor ingrese su nombre de clase en el puesto.

private static void data2() 
{ 
    <classname> c1 = new <classname>(); 
    c1. data1(); 
} 

Answer 6

Suponiendo que tanto data1() y data2() están en la misma clase, a continuación, otra alternativa es hacer data1() estática.

private static void data1() 
{ 
} 
private static void data2() 
{ 
    data1(); 
} 

Answer 7

Se ha disculpado por la respuesta de un hilo muy antiguo, pero creo que mi respuesta puede ayudar a otra.

Con la ayuda del delegado se puede lograr lo mismo.

public class MyClass 
{ 
    private static Action NonStaticDelegate; 

    public void NonStaticMethod() 
    { 
     Console.WriteLine("Non-Static!"); 
    } 

    public static void CaptureDelegate() 
    { 
     MyClass temp = new MyClass(); 
     MyClass.NonStaticDelegate = new Action(temp.NonStaticMethod); 
    } 

    public static void RunNonStaticMethod() 
    { 
     if (MyClass.NonStaticDelegate != null) 
     { 
      // This will run the non-static method. 
      // Note that you still needed to create an instance beforehand 
      MyClass.NonStaticDelegate(); 
     } 
    } 
} 

Answer 8

El método estático nunca permite una llamada al método no estático directamente.

Motivo: El método estático pertenece solo a su clase, y a ningún objeto o instancia.

Por lo tanto, cada vez que intente acceder a cualquier método no estático del método estático dentro de la misma clase: usted recibirá:

"se requiere una referencia de objeto para el campo no estático, método o propiedad".

Solución: Sólo declarar una referencia como:

public class <classname> 
{ 
static method() 
{ 
    new <classname>.non-static(); 
} 

non-static method() 
{ 

} 


} 

Answer 9

Puede utilizar el método llamado de la siguiente manera: Foo.Data2()

public class Foo 
{ 
    private static Foo _Instance; 

    private Foo() 
    { 
    } 

    public static Foo GetInstance() 
    { 
     if (_Instance == null) 
      _Instance = new Foo(); 
     return _Instance; 
    } 

    protected void Data1() 
    { 
    } 

    public static void Data2() 
    { 
     GetInstance().Data1(); 
    } 
}