Come si chiama un metodo non statico da un metodo statico in C#?

Question

Ho il seguente codice, voglio chiamare data1() da data2(). È possibile in C#? Se é cosi, come?

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

Answer 1

Avrete bisogno di creare un'istanza della classe e invocare il metodo su di esso.

public class Foo 
{ 
    public void Data1() 
    { 
    } 

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

Answer 2

Non è possibile chiamare un metodo non statico senza prima creare un'istanza della relativa classe padre.

Quindi dal metodo statico, si dovrà creare un'istanza di un nuovo oggetto ...

Vehicle myCar = new Vehicle(); 

... e quindi chiamare il metodo non statico.

myCar.Drive(); 

Answer 3

È necessario creare un'istanza di tale classe all'interno del metodo statico e quindi chiamarla.

Ad esempio come questo:

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

Answer 4

Forse quello che stai cercando è il pattern 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(); 
} 

si devono ancora creare un'istanza della classe, ma è assicurarsi che ci sia solo sola istanza.

Answer 5

Hai solo bisogno di fornire riferimento all'oggetto. Si prega di fornire il nome della classe nella posizione.

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

Answer 6

Supponendo che sia data1() e data2() sono nella stessa classe, poi un'altra alternativa è quella di rendere data1() statico.

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

Answer 7

chiesto scusa per inviare risposta per molto vecchio thread, ma credo che la mia risposta potrebbe aiutare gli altri.

Con l'aiuto di delegati è possibile ottenere la stessa cosa.

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

Il metodo statico non consente mai una chiamata al metodo non statico direttamente.

Motivo: il metodo statico appartiene solo alla sua classe e all'oggetto nay o a qualsiasi istanza.

Così, ogni volta che si tenta di accedere a qualsiasi metodo non statico dal metodo statico all'interno della stessa classe: riceverete:

"È necessario un riferimento a un oggetto per il campo non statico, metodo o proprietà".

Soluzione: Basta dichiarare un riferimento come:

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

non-static method() 
{ 

} 


} 

Answer 9

È possibile utilizzare il metodo chiamata in questo modo: Foo.Dati2()

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(); 
    } 
}