Come può una classe non statica chiamare un altro metodo di una classe non statica?

Question

Ho 2 classi entrambe non statiche. Ho bisogno di accedere a un metodo su una classe per restituire un oggetto per l'elaborazione. Ma dal momento che entrambe le classi sono non statiche, non posso semplicemente chiamare il metodo in modo statico. Né posso chiamare il metodo in modo non statico perché il programma non conosce l'identificatore dell'oggetto.

Prima di tutto, se possibile, vorrei che entrambi gli oggetti restassero non statici se possibile. Altrimenti richiederebbe molte ristrutturazioni del resto del codice.

Heres l'esempio nel codice

class Foo 
{ 
    Bar b1 = new Bar(); 

    public object MethodToCall(){ /*Method body here*/ } 
} 

Class Bar 
{ 
    public Bar() { /*Constructor here*/ } 

    public void MethodCaller() 
    { 
     //How can i call MethodToCall() from here? 
    } 
} 

Answer 1

Al fine di qualsiasi codice in un statico o una classe non statica per chiamare un metodo non statico, il chiamante deve avere un riferimento all'oggetto su cui è effettuata la chiamata.

Nel tuo caso, 's MethodCaller deve avere un riferimento a Foo. Si potrebbe passare in un costruttore di Bar o in qualsiasi altro modo che ti piace:

class Foo 
{ 
    Bar b1 = new Bar(this); 

    public object MethodToCall(){ /*Method body here*/ } 
} 

Class Bar 
{ 
    private readonly Foo foo; 

    public Bar(Foo foo) { 
     // Save a reference to Foo so that we could use it later 
     this.foo = foo; 
    } 

    public void MethodCaller() 
    { 
     // Now that we have a reference to Foo, we can use it to make a call 
     foo.MethodToCall(); 
    } 
} 

Answer 2

class Bar 
{ 
    /*...*/ 

    public void MethodCaller() 
    { 
     var x = new Foo(); 
     object y = x.MethodToCall(); 
    } 
} 

BTW, in generale, gli oggetti non hanno nomi.

Answer 3

Passando un'istanza al costruttore:

class Bar 
{ 
    private Foo foo; 

    public Bar(Foo foo) 
    { 
     _foo = foo; 
    } 

    public void MethodCaller() 
    { 
     _foo.MethodToCall(); 
    } 
} 

utilizzati:

Foo foo = new Foo(); 
Bar bar = new Bar(foo); 
bar.MethodCaller(); 

Answer 4

Prova questa:.

class Foo 
{ 
    public Foo() { /*Constructor here*/ } 
    Bar b1 = new Bar(); 

    public object MethodToCall(){ /*Method body here*/ } 
} 

Class Bar 
{ 
    public Bar() { /*Constructor here*/ } 
    Foo f1 = new Foo(); 
    public void MethodCaller() 
    { 
     f1.MethodToCall(); 
    } 
}