In C# .net, come si accede a un controllo da un metodo statico?

Question

Ho un'applicazione in C# .net che ha un MainForm e alcune classi.
Una di queste classi riceve i messaggi di dati in arrivo da una rete.
Ho bisogno di inserire il testo di questi messaggi in una casella di testo su più righe sul modulo principale.
Posso inviare il messaggio a un metodo nel MainForm rendendo il metodo statico, ma il metodo statico non può accedere ai controlli MainForm.

TheIncomingDataClass.cs

namespace TheApplicationName 
{ 
    class TheIncomingDataClass 
    { 

    public void IncomingMessage(IncomingMessageType message) 
    { 
      TheApplicationName.MainForm.ReceiveMSG(message); 
    } 

MainForm.cs

public static void ReceiveMSG(string message) 
{ 
    txtDisplayMessages.AppendText(message); //This line causes compile error 
} 

L'errore di compilazione:
È necessario un riferimento oggetto per i TheApplicationName.MainForm.txtDisplayMessages nonstatic campo, metodo o proprietà' '

Qualsiasi aiuto è apprezzato.

Sono ancora un principiante del C# quindi per favore sii descrittivo.

Answer 1

Un metodo statico non ha accesso ai membri come txtDisplayMessages perché non fa parte di tale istanza. Vi suggerisco di leggere i concetti dei metodi statici e di quant'altro, perché questo è un concetto agnostico abbastanza imparziale. Sarebbe meglio servire tale metodo rimuovendo il modificatore statico, perché non ha bisogno di essere statico - sembra che avrebbe bisogno di essere chiamato da quella particolare istanza di quell'oggetto.

Answer 2

genera un evento dalla classe a cui il modulo può iscriversi.

Answer 3

Basta rimuovere il modificatore statico, non è necessario per i propri scopi. Ulteriori informazioni sulla statica here.

Answer 4

La sua possibile passare in un riferimento alla forma attuale in questo modo:

public static void ReceiveMSG(string message, MainForm mainform) 
{ 
    mainform.txtDisplayMessages.AppendText(message); 
} 

Anche se, come ha suggerito un evento è probabilmente un modo migliore di farlo.

Answer 5

È possibile risolvere questo problema rimuovendo la parola chiave statica.

Quando vedi "statico", pensa: senza un'istanza di questo tipo.

Quando si chiama un metodo non statico, è necessario utilizzare esplicitamente qualche istanza. Il metodo può accedere a quell'istanza usando la parola chiave "this".

Quando si chiama un metodo statico, non esiste un'istanza: si sono abbandonati i limiti di OO e si trovano ora in un contesto di programmazione strutturale o funzionale. Se vuoi un'istanza di qualcosa, devi portarla come parametro.

Answer 6

Penso che potresti avere l'approccio sbagliato su questo. Sembra che tu stia cercando di inviare messaggi a un client da un processo esterno. Ci sono modi per farlo, ma diventerà complicato. Il mio suggerimento sarebbe quello di chiedere al cliente di sondare periodicamente qualsiasi processo con i dati, forse ogni 10 secondi a seconda delle esigenze. Questo sarà molto più facile che spingere da un server all'altro.

Answer 7

Per continuare come è stato fatto, il "TheIncomingDataClass" deve avere un riferimento all'oggetto MainForm con cui deve essere interfacciato. Quando si crea un'istanza di questa classe (presumibilmente da un metodo di istanza di MainForm), sarà necessario passare un riferimento a questo oggetto MainForm.

class TheIncomingDataClass{ 
    MainForm form; 

    public TheIncomingDataClass(MainForm form){ 
     this.form = form; 
    } 
} 

class MainForm : Form{ 
    MainForm(){ 
     new TheIncomingDataClass(this); 
    } 
} 

Tuttavia, come suggerito da Bugs, probabilmente sarebbe meglio fare questo un evento su TheIncomingDataClass e la sottoscrizione di essa da MainForm.

class IncomingMessageEventArgs : EventArgs{ 
    IncomingMessageType message; 

    public IncomingMessageType Message{get{return message;}} 

    public IncomingMessageEventArgs(IncomingMessageType message){ 
     this.message = message; 
    } 
} 

class TheIncomingDataClass{ 
    public event EventHandler<IncomingMessageEventArgs> MessageReceived; 

    protected virtual void OnMessageReceived(IncomingMessageEventArgs e){ 
     if(MessageReceived != null) 
      MessageReceived(this, e); 
    } 

    public void IncomingMessage(IncomingMessageType message){ 
     OnMessageReceived(new IncomingMessageEventArgs(message)); 
    } 
} 

class MainForm : Form{ 
    MainForm(){ 
     new TheIncomingDataClass().MessageReceived += 
      (s, e)=>txtDisplayMessages.AppendText(e.Message.ToString()); 
    } 
} 

Answer 8

Ok, ecco qui. I metodi statici possono accedere solo ai membri statici. Il tuo metodo ReceiveMSG è statico. txtDisplayMessages non lo è e quindi non puoi accedervi. Perché il tuo metodo deve essere statico? Inutile dire che se rimuovi la parola chiave statica che risolverà il tuo problema.

Basta rendere ReceiveMSG parte di una classe, creare un'istanza della classe e quindi chiamare il metodo sull'istanza.

Penso che dovresti pubblicare il tipo di soluzione che ti aspetti.

Answer 9

Visto che siete nuovi in ​​C# manterrò il più semplice possibile. Dovresti avere un file Program.cs che abbia un singolo metodo Main (questo sarebbe stato generato da Visual Studio). Sarà necessario far sembrare il seguente:

class Program 
{ 
    public static readonly MainForm MainForm; 

    static void Main() 
    { 
     Application.EnableVisualStyles(); 
     MainForm = new MainForm(); // These two lines 
     Application.Run(MainForm); // are the important ones. 
    } 
} 

Ora nel tuo messaggio in arrivo si avrà un modo per accedere a quella forma.

public void IncomingMessage(IncomingMessageType message) 
{ 
     Program.MainForm.RecieveMSG(message); 
} 

Tale metodo nella forma sarebbe quindi un metodo di istanza (non statico). Per esempio.

public void RecieveMSG(IncomingMessageType message) // NB: No static 
{ 
    txtDisplayMessages.Text = message.Text; // Or whatever. 
} 

Ci sono modi migliori per farlo - ma come principiante penso che questo sarebbe l'approccio migliore.

La differenza tra statico e istanza (l'istanza è quando non si dice statico) è enorme. Per ottenere un metodo, un campo o una proprietà di istanza (che sono chiamati collettivamente membri in C#) è necessario avere l'istanza contenente. Quindi:

Person p = new Person(); // You now have an instance. 
p.Name = "Fred"; // You are using an instance property. 

statiche sono l'opposto, sono la stessa ovunque nella vostra applicazione (più tecnicamente all'interno dello stesso dominio di applicazione - ma se sei un principiante non sarà necessario preoccuparsi di che per un po '). Non hai bisogno di un'istanza per raggiungerli (oggetti per i codewidgets "I metodi statici possono accedere solo ai membri statici"). Ad esempio:

// Where Planet is a class and People is a static property. 
// Somewhat confusingly the Add method is an instance - best left for the student :). 
Planet.People.Add(new Person("Fred")); 

Speriamo che questo dia una buona indicazione di cosa sia l'istanza e l'istanza e dove usarli. La cosa più importante però è cercare di evitare membri statici nel miglior modo possibile: possono causare incubi di manutenzione.

Microsoft ha un intero write-up sui concetti importanti in relazione a questo.