Wie rufe ich eine nicht statische Methode von einer statischen Methode in C # auf?

Ich habe den folgenden Code, ich möchte anrufen data1()aus data2(). Ist das in C # möglich? Wenn das so ist, wie?

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

Sie müssen eine Instanz der Klasse erstellen und die Methode darauf aufrufen.

public class Foo
{
    public void Data1()
    {
    }

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

Vielleicht suchen Sie nach dem Singleton-Muster?

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

Sie müssen noch eine Instanz der Klasse erstellen, stellen jedoch sicher, dass nur eine Instanz vorhanden ist.

Sie müssen eine Instanz dieser Klasse innerhalb der statischen Methode erstellen und dann aufrufen.

Zum Beispiel so:

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

Sie können eine nicht statische Methode nicht aufrufen, ohne zuvor eine Instanz ihrer übergeordneten Klasse erstellt zu haben.

Mit der statischen Methode müssten Sie also ein neues Objekt instanziieren ...

Vehicle myCar = new Vehicle();

... und rufen Sie dann die nicht statische Methode auf.

myCar.Drive();

Sie müssen nur eine Objektreferenz angeben. Bitte geben Sie Ihren Klassennamen in der Position an.

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

Ich habe mich entschuldigt, eine Antwort für einen sehr alten Thread zu posten, aber ich glaube, meine Antwort kann anderen helfen.

Mit Hilfe eines Delegierten kann das Gleiche erreicht werden.

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

Die statische Methode erlaubt niemals einen nicht statischen Methodenaufruf direkt.

Grund: Die statische Methode gehört nur zu ihrer Klasse und zu keinem Objekt oder einer beliebigen Instanz.

Wenn Sie also versuchen, von einer statischen Methode innerhalb derselben Klasse auf eine nicht statische Methode zuzugreifen, erhalten Sie:

"Für das nicht statische Feld, die Methode oder die Eigenschaft ist eine Objektreferenz erforderlich."

Lösung: Deklarieren Sie einfach eine Referenz wie:

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

non-static method()
{

}


}

Sie können die Aufrufmethode folgendermaßen verwenden: 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();
    }
}

Unter der Annahme, dass beide data1()und data2()in derselben Klasse sind, besteht eine andere Alternative darin, data1()statisch zu machen .

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