Come faccio a passare un valore da un bambino al modulo padre?

Come faccio a passare un valore da un bambino al modulo padre? Ho una stringa che vorrei restituire al genitore.

Ho lanciato il bambino usando:

FormOptions formOptions = new FormOptions(); formOptions.ShowDialog(); 

Creare una proprietà (o un metodo) in FormOptions , ad esempio GetMyResult :

 using (FormOptions formOptions = new FormOptions()) { formOptions.ShowDialog(); string result = formOptions.GetMyResult; // do what ever with result... } 

Se stai usando formOptions per scegliere un singolo valore e poi chiudere, il suggerimento di Mitch è un buon modo per andare . Il mio esempio qui sarebbe usato se avessi avuto bisogno che il bambino potesse comunicare al genitore rimanendo aperto.

Nel tuo modulo genitore, aggiungi un metodo pubblico che il modulo figlio chiamerà, ad esempio

 public void NotifyMe(string s) { // Do whatever you need to do with the string } 

Successivamente, quando è necessario avviare la finestra secondaria dal genitore, utilizzare questo codice:

 using (FormOptions formOptions = new FormOptions()) { // passing this in ShowDialog will set the .Owner // property of the child form formOptions.ShowDialog(this); } 

Nel modulo figlio, utilizzare questo codice per restituire un valore al genitore:

 ParentForm parent = (ParentForm)this.Owner; parent.NotifyMe("whatever"); 

Il codice in questo esempio sarebbe meglio utilizzato per qualcosa di simile a una finestra degli strumenti che è destinata a fluttuare sopra il modulo principale. In questo caso, si aprirà il modulo figlio (con .TopMost = true) utilizzando .Show () anziché .ShowDialog ().

Un design come questo significa che la forma figlio è strettamente accoppiata alla forma genitore (dal momento che il bambino deve lanciare il suo proprietario come ParentForm per chiamare il suo metodo NotifyMe). Tuttavia, questo non è automaticamente una cosa negativa.

Puoi anche creare una proprietà pubblica.

 // Using and namespace... public partial class FormOptions : Form { private string _MyString; // Use this public string MyString { // in get { return _MyString; } // .NET } // 2.0 public string MyString { get; } // In .NET 3.0 or newer // The rest of the form code } 

Quindi puoi ottenerlo con:

 FormOptions formOptions = new FormOptions(); formOptions.ShowDialog(); string myString = formOptions.MyString; 

È inoltre ansible creare un sovraccarico di ShowDialog nella class figlia che ottiene un parametro out che restituisce il risultato.

 public partial class FormOptions : Form { public DialogResult ShowDialog(out string result) { DialogResult dialogResult = base.ShowDialog(); result = m_Result; return dialogResult; } } 

Utilizzare la proprietà pubblica del modulo figlio

 frmOptions { public string Result; } frmMain { frmOptions.ShowDialog(); string r = frmOptions.Result; } 

Usa gli eventi

 frmMain { frmOptions.OnResult += new ResultEventHandler(frmMain.frmOptions_Resukt); frmOptions.ShowDialog(); } 

Usa la proprietà pubblica del modulo principale

 frmOptions { public frmMain MainForm; MainForm.Result = "result"; } frmMain { public string Result; frmOptions.MainForm = this; frmOptions.ShowDialog(); string r = this.Result; } 

Usa object Control.Tag; Questo è comune a tutti i controlli di proprietà pubblica che possono contenere un System.Object. Puoi tenere lì la stringa o MyClass o MainForm – qualsiasi cosa!

 frmOptions { this.Tag = "result": } frmMain { frmOptions.ShowDialog(); string r = frmOptions.Tag as string; } 

Beh, ho appena incontrato lo stesso problema qui – forse un po ‘diverso. Tuttavia, penso che questo sia il modo in cui l’ho risolto:

  1. nella mia forma genitore ho dichiarato il modulo figlio senza istanza, ad es. RefDateSelect myDateFrm; Quindi questo è disponibile per i miei altri metodi all’interno di questa class / modulo

  2. successivamente, un metodo visualizza il figlio di nuova istanza:

     myDateFrm = new RefDateSelect(); myDateFrm.MdiParent = this; myDateFrm.Show(); myDateFrm.Focus(); 
  3. il mio terzo metodo (che vuole i risultati del bambino) può arrivare in qualsiasi momento e ottenere semplicemente risultati:

     PDateEnd = myDateFrm.JustGetDateEnd(); pDateStart = myDateFrm.JustGetDateStart();` 

    Nota: i metodi figlio JustGetDateStart() sono pubblici all’interno di CHILD come:

     public DateTime JustGetDateStart() { return DateTime.Parse(this.dtpStart.EditValue.ToString()); } 

Spero che aiuti.

Per Picrofo EDY

Dipende, se si usa ShowDialog() come un modo per mostrare il proprio modulo e per chiuderlo si usa il pulsante di chiusura invece di this.Close() . Il modulo non sarà smaltito o distrutto, sarà solo nascosto e le modifiche potranno essere apportate dopo che sono sparite. Per chiuderlo correttamente è necessario il metodo Dispose() o Close() . D’altra parte, se si utilizza il metodo Show() e lo si chiude, il modulo verrà eliminato e non potrà essere modificato in seguito.

Se si visualizza un modulo figlio come finestra di dialogo modale, è ansible impostare la proprietà DialogResult del modulo figlio con un valore dall’enumerazione DialogResult che a sua volta nasconde la finestra di dialogo modale e restituisce il controllo al modulo di chiamata. A questo punto, il genitore può accedere ai dati del modulo figlio per ottenere le informazioni di cui ha bisogno.

Per maggiori informazioni controllare questo link: http://msdn.microsoft.com/en-us/library/system.windows.forms.form.dialogresult(v=vs.110).aspx

Molti modi per scuoiare il gatto qui e il suggerimento di @ Mitch è un buon modo. Se si desidera che il modulo client abbia più ‘controllo’, è ansible passare l’istanza del genitore al figlio quando viene creato e quindi è ansible chiamare qualsiasi metodo padre pubblico sul figlio.

Penso che il modo più semplice sia usare la proprietà Tag nella class FormOptions per impostare il valore Tag = che devi passare e dopo che il metodo ShowDialog lo ha letto come

 myvalue x=(myvalue)formoptions.Tag; 

Quando si utilizza il metodo ShowDialog() o Show() e quindi si chiude il modulo, l’object modulo non viene completamente distrutto ( chiusura! = Distruzione ). Rimarrà vivo, solo che è in uno stato “chiuso”, e puoi ancora fare qualcosa.