Πώς να ανοίξετε μια άλλη από μια φόρμα. Προσθήκη φορμών. Αλληλεπίδραση μεταξύ μορφών. Ένα παράδειγμα κατασκευής και προγραμματικής κλήσης μιας φόρμας

Η ερώτηση που εξετάζεται σε αυτό το άρθρο είναι πιο πιθανό να σχετίζεται με το θέμα της κατασκευής μιας αρχιτεκτονικής εφαρμογής και όχι συγκεκριμένα με το πρόβλημα που εξετάζεται. Η μεταφορά δεδομένων από τη μια φόρμα στην άλλη δεν είναι καθόλου δύσκολη. Για να γίνει αυτό, αρκεί να ανοίξουμε το στοιχείο ελέγχου του οποίου τα δεδομένα θέλουμε να αποκτήσουμε, δηλαδή να το επισημάνουμε με τον δημόσιο τροποποιητή. Επίσης, μια άλλη επιλογή είναι δυνατή. Για παράδειγμα, στην πρώτη μορφή δημιουργούμε ένα αντικείμενο της δεύτερης φόρμας περνώντας μια αναφορά στον εαυτό μας στον κατασκευαστή, δηλαδή περνώντας μια αναφορά στην πρώτη από την πρώτη μορφή στη δεύτερη
SecondForm secondForm = νέο SecondForm(this);
Φυσικά, πριν το κάνετε αυτό, θα πρέπει να φροντίσετε να δημιουργήσετε μια υπερφόρτωση για τον κατασκευαστή της δεύτερης φόρμας.

Και αυτή η μέθοδος είναι αρκετά κοινή. Ωστόσο, με την απλότητά του, φέρει πολλά πιθανά προβλήματα, με το κυριότερο να είναι η παραβίαση της αρχής της ενθυλάκωσης. Με μια λέξη, η δεύτερη μορφή δεν πρέπει να γνωρίζει τίποτα για την ύπαρξη της πρώτης και, πολύ περισσότερο, να μην μπορεί να την επηρεάσει.

Η λύση σε αυτό το πρόβλημα είναι αρκετά απλή. Ας δούμε απευθείας τον κώδικα. Δημιουργούμε στον σχεδιαστή κύρια μορφή(θα ξεκινήσει όταν ξεκινήσει η εφαρμογή). Ας βάλουμε ένα Πλαίσιο κειμένου, ΕπιγραφήΚαι Κουμπί.

Κάνοντας κλικ στο κουμπί θα ανοίξει η δεύτερη φόρμα και το κείμενο από πεδίο κειμένουη κύρια φόρμα θα μεταφερθεί στο πεδίο κειμένου της δεύτερης φόρμας. Αρχικά, η δεύτερη φόρμα μοιάζει με αυτό:

Παρόμοια με το πρώτο, έχει τα ίδια χειριστήρια. Δεν χρειαζόμαστε άλλα. Το σημείο εισόδου της εφαρμογής εκκινεί την κύρια φόρμα:

Χρήση του συστήματος. χρησιμοποιώντας System.Collections.Generic; χρησιμοποιώντας System.Linq; χρησιμοποιώντας System.Windows.Forms; namespace From1FormTo2 ( στατική κλάση Πρόγραμμα ( // Το κύριο σημείο εισόδου για την εφαρμογή. static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) )

Ο κύριος κώδικας φόρμας μοιάζει με αυτό:

Χρήση του συστήματος. χρησιμοποιώντας System.Collections.Generic; χρησιμοποιώντας System.ComponentModel; χρησιμοποιώντας System.Data; χρησιμοποιώντας System.Drawing; χρησιμοποιώντας System.Linq; χρησιμοποιώντας System.Text; χρησιμοποιώντας System.Windows.Forms; namespace From1FormTo2 ( δημόσια μερική κλάση MainForm: Form ( //δεύτερη φόρμα SecondForm secondForm; //κατασκευαστής δημόσια MainForm() ( InitializeComponent(); ) //χειριστής συμβάντων μεταφοράς δεδομένων //από την κύρια φόρμα στο δεύτερο ιδιωτικό κενό btn_mainForm_Click(object αποστολέας, EventArgs e) ( secondForm = new SecondForm(tb_mainForm.Text.Trim()); secondForm.ShowDialog(); if (secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = secondForm.ReturnData())))

Κατά συνέπεια, μην ξεχάσετε να συνδέσετε το κουμπί στην εκδήλωση Κάντε κλικ. Εδώ στην κύρια κατηγορία φόρμας υπάρχει ένα πεδίο SecondForm secondForm, που αντιπροσωπεύει το αντικείμενο της δεύτερης μορφής. Όταν κάνετε κλικ στο κουμπί "Υποβολή", δημιουργείται μια δεύτερη φόρμα (καλείται ο υπερφορτωμένος κατασκευαστής, θα το δημιουργήσουμε αργότερα) και εκκινείται χρησιμοποιώντας τη μέθοδο ShowDialog(). Σε αυτή την περίπτωση, αυτή η μέθοδος είναι κατάλληλη για εμάς. Επιπλέον, μετά από αυτό φροντίζουμε να ελέγξουμε αν η δεύτερη φόρμα ήταν κλειστή, αλλά πατήσαμε το κουμπί της. Εάν έγινε κλικ σε ένα κουμπί στη δεύτερη φόρμα, τότε η πρώτη φόρμα θα πρέπει να δέχεται δεδομένα από τη δεύτερη. Αυτό συμβαίνει με την κλήση της μεθόδου ReturnData()στη δεύτερη μορφή.

Τώρα το πιο ενδιαφέρον μέρος είναι ο κώδικας της δεύτερης φόρμας:

Χρήση του συστήματος. χρησιμοποιώντας System.Collections.Generic; χρησιμοποιώντας System.ComponentModel; χρησιμοποιώντας System.Data; χρησιμοποιώντας System.Drawing; χρησιμοποιώντας System.Linq; χρησιμοποιώντας System.Text; χρησιμοποιώντας System.Windows.Forms; Χώρος ονομάτων From1FormTo2 ( δημόσια μερική κλάση SecondForm: Form ( //υπερφορτωμένος κατασκευαστής δημόσια SecondForm(στοιχοσειρά δεδομένων) ( InitializeComponent(); tb_secondForm.Text = δεδομένα; ) //χειριστής συμβάντων μεταφοράς δεδομένων //από τη δεύτερη φόρμα στην κύρια ιδιωτική κενό btn_secondForm_Click (αποστολέας αντικειμένου, EventArgs e) ( this.DialogResult = DialogResult.OK; ) // δημόσια μέθοδογια πρόσβαση // στο πεδίο κειμένου αυτής της δημόσιας συμβολοσειράς φόρμας ReturnData() ( return (tb_secondForm.Text.Trim()); ) ) )

Όπως μπορείτε να δείτε, υπάρχει μια υπερφόρτωση ενός κατασκευαστή που δέχεται έναν τύπο συμβολοσειράς. Θυμηθείτε ότι προσπαθούμε να μεταφέρουμε κείμενο από ένα TextBox. Στον κατασκευαστή, τα στοιχεία έχουν προγραμματιστεί να αρχικοποιηθούν και το κείμενο του πεδίου κειμένου ορίζεται στην τιμή που μεταδίδεται από την πρώτη φόρμα. Στη συνέχεια, με την εγγραφή σας στην εκδήλωση Κάντε κλικγια το κουμπί της δεύτερης φόρμας, δημιουργήσαμε έναν χειριστή btn_secondForm_Click, το οποίο προσομοιώνει τη λειτουργία του κουμπιού "Ok" οποιουδήποτε πλαισίου διαλόγου. Έτσι, κάνοντας κλικ στο κουμπί «Υποβολή» (της δεύτερης φόρμας), εκτελούμε τη συνθήκη

(secondForm .DialogResult == DialogResult .OK)

Η πρώτη μορφή, επομένως, καλώντας τη μέθοδο secondForm.ReturnData(), ορίζουμε το πεδίο κειμένου της πρώτης φόρμας στην τιμή του πεδίου κειμένου της δεύτερης φόρμας.

Δουλειά αυτή τη μέθοδο, νομίζω, δεν χρειάζεται πλέον εξήγηση. Απλώς επιστρέφει το κείμενο από ένα μόνο πεδίο κειμένου, ενώ το διατηρεί ιδιωτικό.

Ως αποτέλεσμα, μεταφέραμε δεδομένα στη δεύτερη φόρμα από την πρώτη και από τη δεύτερη στην πρώτη χωρίς να παραβιάζουμε τις αρχές της ενθυλάκωσης.

Δοκιμάστε να εισαγάγετε το κείμενο "aaa" στο πεδίο κειμένου της πρώτης φόρμας και να κάνετε κλικ στο κουμπί. Θα δείτε αυτό το κείμενο στο πεδίο κειμένου στη δεύτερη φόρμα που ανοίγει. Δοκιμάστε να αλλάξετε το κείμενο σε "aaa ppp" και κάντε κλικ στο κουμπί. Θα δείτε πώς, αφού κλείσετε τη δεύτερη φόρμα, αυτό το κείμενο θα εμφανιστεί στο πεδίο κειμένου της κύριας φόρμας.

Τώρα, νομίζω ότι θα μπορείτε να μεταφέρετε δεδομένα μεταξύ των φορμών πιο σωστά. Σε επόμενο άρθρο θα μιλήσουμε για το πώς να το κάνουμε σε εφαρμογές ASP.NET.

Τελευταία ενημέρωση: 31/10/2015

Για να προσθέσετε μια άλλη φόρμα στο έργο, κάντε δεξί κλικ στο όνομα του έργου στο παράθυρο Εξερεύνηση λύσεων και επιλέξτε Προσθήκη-> Φόρμα Windows...

Ας δώσουμε στη νέα φόρμα κάποιο όνομα, για παράδειγμα, Form2.cs:

Έτσι, προσθέσαμε μια δεύτερη φόρμα στο έργο μας. Τώρα ας προσπαθήσουμε να εφαρμόσουμε την αλληλεπίδραση μεταξύ δύο μορφών. Ας πούμε ότι η πρώτη φόρμα θα καλέσει τη δεύτερη φόρμα όταν πατηθεί το κουμπί. Αρχικά, ας προσθέσουμε ένα κουμπί στην πρώτη φόρμα, Form1, και κάνουμε διπλό κλικ στο κουμπί για να μεταβούμε στο αρχείο κώδικα. Έτσι, θα μεταφερθούμε στον χειριστή συμβάντων κλικ του κουμπιού, ο οποίος δημιουργείται από προεπιλογή αφού κάνετε διπλό κλικ στο κουμπί:

Κουμπί ιδιωτικού κενού1_Κλικ(αποστολέας αντικειμένου, EventArgs e) ( )

Τώρα ας προσθέσουμε τον κωδικό για την κλήση της δεύτερης φόρμας σε αυτήν. Η δεύτερη φόρμα μας ονομάζεται Form2, οπότε πρώτα δημιουργούμε ένα αντικείμενο αυτής της κλάσης και μετά για να το εμφανίσουμε στην οθόνη καλούμε τη μέθοδο Show:

Ιδιωτικό void button1_Click(object sender, EventArgs e) ( Form2 newForm = new Form2(); newForm.Show(); )

Τώρα ας κάνουμε το αντίθετο - έτσι ώστε η δεύτερη μορφή να επηρεάσει την πρώτη. Ενώ η δεύτερη μορφή δεν γνωρίζει για την ύπαρξη της πρώτης. Για να το διορθώσετε αυτό, πρέπει να μεταφέρετε με κάποιο τρόπο πληροφορίες σχετικά με την πρώτη φόρμα στη δεύτερη φόρμα. Για να το κάνουμε αυτό, θα χρησιμοποιήσουμε τη μετάδοση ενός συνδέσμου στη φόρμα στον κατασκευαστή.

Ας προχωρήσουμε λοιπόν στη δεύτερη φόρμα και πάμε στον κώδικά της - κάντε δεξί κλικ στη φόρμα και επιλέξτε Προβολή κώδικα. Προς το παρόν είναι κενό και περιέχει μόνο έναν κατασκευαστή. Εφόσον η C# υποστηρίζει υπερφόρτωση μεθόδων, μπορούμε να δημιουργήσουμε πολλές μεθόδους και κατασκευαστές με διαφορετικές παραμέτρους και να καλέσουμε μία από αυτές ανάλογα με την περίσταση. Λοιπόν, ας αλλάξουμε το αρχείο κώδικα της δεύτερης φόρμας ως εξής:

Στην πραγματικότητα, μόλις προσθέσαμε εδώ νέος κατασκευαστής public Form2(Form1 f) στην οποία παίρνουμε την πρώτη μορφή και ορίζουμε το φόντο της σε κίτρινο. Τώρα ας προχωρήσουμε στον κώδικα της πρώτης φόρμας, όπου καλέσαμε τη δεύτερη φόρμα και την αλλάξαμε ως εξής:

Ιδιωτικό void button1_Click(object sender, EventArgs e) ( Form2 newForm = new Form2(this); newForm.Show(); )

Εφόσον σε αυτήν την περίπτωση η λέξη-κλειδί αυτό αντιπροσωπεύει μια αναφορά στο τρέχον αντικείμενο - το αντικείμενο Form1, τότε κατά τη δημιουργία της δεύτερης φόρμας θα τη λάβει (το σύνδεσμο) και θα ελέγξει την πρώτη φόρμα μέσω αυτής.

Τώρα, αφού κάνετε κλικ στο κουμπί, θα δημιουργηθεί μια δεύτερη φόρμα, η οποία θα αλλάξει αμέσως το χρώμα της πρώτης φόρμας.

Μπορούμε επίσης να δημιουργήσουμε αντικείμενα της τρέχουσας μορφής:

Κουμπί ιδιωτικού κενού1_Click(αποστολέας αντικειμένου, EventArgs e) ( Form1 newForm1 = new Form1(); newForm1.Show(); Form2 newForm2 = new Form2(newForm1); newForm2.Show();

Όταν εργάζεστε με πολλές φόρμες, πρέπει να λάβετε υπόψη ότι μία από αυτές είναι η κύρια - η οποία εκκινείται πρώτη στο αρχείο Program.cs. Αν έχουμε ταυτόχρονα ανοιχτό ένα σωρό φόρμες, τότε όταν κλείνουμε την κύρια, κλείνει ολόκληρη η εφαρμογή και μαζί με αυτήν όλες οι άλλες φόρμες.

Παρά το γεγονός ότι η γνώμη μου για το Visual Studio της Microsoft εξακολουθεί να είναι η ίδια, μερικές φορές πρέπει να κάνετε κάτι σε αυτό. Εάν συμβιβαζόμαστε με το γεγονός ότι στην πραγματικότητα γράφουμε όχι σε C++, αλλά στη λεγόμενη C++/CLI, η εργασία με γνωστά οπτικά στοιχεία δεν θα είναι τόσο διαφορετική από τα ίδια περιβάλλοντα Borland. Αλλά μπορεί να δημιουργήσει προβλήματα, σε σύγκριση με το Builder. Ας εξετάσουμε 3 τυπικές καταστάσεις εργασίας με μια εφαρμογή που περιέχει περισσότερες από μία φόρμες. Το παράδειγμα περιβάλλοντος είναι δωρεάν Visual C++ 2010 Express, υποτίθεται ότι η κύρια φόρμα έχει το προεπιλεγμένο όνομα Form1.

Ένα παράδειγμα κατασκευής και προγραμματικής κλήσης μιας φόρμας

Αυτός ο κώδικας μπορεί να εκτελεστεί, για παράδειγμα, κάνοντας κλικ σε ένα κουμπί στην κύρια φόρμα Form1.

Form^form2 = gcnew Form(); Button^ button2 = gcnew Button(); button2->Text = L"OK"; button2->Location = Point(10,10); form2->Text = L"Το παράθυρό μου"; form2->HelpButton = true; form2->FormBorderStyle = Σύστημα::Windows::Forms::FormBorderStyle::FixedDialog; form2->StartPosition = FormStartPosition::CenterScreen; form2->Controls->Add(button2); form2->ShowDialog();

Για να προσθέσετε ένα πρόγραμμα χειρισμού κλικ για ένα κουμπί κουμπιού που δημιουργείται μέσω προγραμματισμού2, απλώς γράψτε πριν από την τελευταία γραμμή κώδικα:

Button2->Click += gcnew System::EventHandler(this, &Form1::button2_Click);

Πριν κληθεί η μέθοδος form2->ShowDialog() ή form2->Show().

Σε αυτήν την περίπτωση, ο κωδικός χειριστή βρίσκεται στην τρέχουσα ενότητα Form1.h:

Ιδιωτικό: Σύστημα::Κενό κουμπί2_Κλικ(Σύστημα::Αντικείμενο^ αποστολέας, Σύστημα::EventArgs^ e) (Πλαίσιο μηνυμάτων::Εμφάνιση("Εδώ"); )

Καλέστε μια άλλη φόρμα από την κύρια φόρμα

Στο μενού, επιλέξτε Έργο - Προσθήκη νέο στοιχείο- Έντυπο - όνομα Έντυπο2

Ας προσθέσουμε έναν τελεστή

#include "Form2.h"

πριν από τον πρώτο χώρο ονομάτων στο Form1.h (δηλαδή στην αρχή του αρχείου).

Ας συμπεριλάβουμε έναν δείκτη στην παρουσία κλάσης στη δημόσια ενότητα της κλάσης Form1:

Form2^F2;

Ας προσθέσουμε τον κώδικα όπου πρέπει να δημιουργήσουμε και ας καλέσουμε τη δεύτερη φόρμα:

F2=gcnewForm2(); F2->Εμφάνιση();

Για να διαγράψετε μέσω προγραμματισμού τη δεύτερη φόρμα, είναι κατάλληλος ο ακόλουθος κώδικας:

Διαγραφή F2;

Πρέπει να σημειωθεί ότι ο δείκτης αποθηκεύει τη διεύθυνση μόνο μιας φόρμας, αυτής που δημιουργήθηκε τελευταία. Εάν δημιουργήσουμε διαδοχικά πολλές φόρμες χρησιμοποιώντας αυτόν τον κωδικό, μόνο η τελευταία θα διαγραφεί. Εναλλακτικά, δοκιμάστε τον πίνακα σχημάτων που περιγράφεται παρακάτω.

Ας περιγράψουμε τα απαραίτητα δεδομένα στην κλάση φόρμας Form1 (εδώ το όνομα και ο χώρος ονομάτων του έργου Tabulator, εάν χρειάζεται, αντικαταστήστε το με το δικό σας):

Static const int MAX_FORMS = 100; //Μέγιστος αριθμός φορμών int FormCount; //Form μετρητή πίνακα ^F2; //Δείκτης σε μια σειρά από φόρμες

Στη συνέχεια αρχικοποιούμε τα δεδομένα χρησιμοποιώντας το συμβάν Load της κύριας φόρμας:

FormCount=0; F2 = gcnew πίνακα (MAX_FORMS);

Στη συνέχεια θα εφαρμόσουμε τον κώδικα για να δημιουργήσουμε την επόμενη φόρμα

Εάν (FormCount Προβολή(); ) else MessageBox::Show("Πάρα πολλές φόρμες!");

και την αφαίρεσή του:

Εάν (FormCount) (διαγραφή F2, FormCount--; )

Εάν θέλουμε να δημιουργήσουμε θυγατρικές φόρμες όχι ξεχωριστά, αλλά μέσα στη γονική φόρμα, τότε στις ιδιότητες της φόρμας1 πρέπει να υποδείξουμε ότι είναι «πρόγονος» (ορίστε την ιδιότητα IsMdiParent = true) και πριν δείξουμε τη θυγατρική φόρμα χρησιμοποιώντας το F2->Εμφάνιση() τελεστή, επισημάνετε τον ως θυγατρικό Form1:

F2->MdiParent = αυτό;

Καλέστε μια μέθοδο γονικής φόρμας από μια θυγατρική φόρμα

Δύσκολα μπορούμε να κάνουμε χωρίς να χρησιμοποιήσουμε αρχεία .cpp, κάτι που δεν είναι κακό - η σύνταξη κώδικα σε αρχεία .h γενικά σπάει το σωστό σύστημα C :)

Ας περιγράψουμε τη διαδικασία βήμα προς βήμα.

1) Υπάρχουν 2 φόρμες - Form1 και Form2, στη Form1 υπάρχει ένα Button (κουμπί1, θα ανοίξει η δεύτερη φόρμα) και Label (label1, εδώ θα αλλάξουμε το κείμενο). Στο Form2 - button1, όταν κάνετε κλικ, το κείμενο στην ετικέτα1 θα αλλάξει.

2) Εφόσον πρέπει να έχουμε πρόσβαση από την πρώτη φόρμα στη δεύτερη και από τη δεύτερη στην πρώτη, θα προκύψει το πρόβλημα των παραπομπών (όταν το Form1.h αναφέρεται στο Form2.h, το οποίο με τη σειρά του αναφέρεται και πάλι προς Μορφή1.η) . Για να το αποφύγουμε αυτό, θα μετακινήσουμε τον κωδικό της πρώτης φόρμας (Form1), που θα έχει πρόσβαση στη δεύτερη φόρμα (Form2), από το αρχείο .h στο αρχείο .cpp. Επομένως, πρέπει να δημιουργήσετε ένα αρχείο Form1.cpp.

3) Δηλώστε μια δημόσια μέθοδο Set στο Form1.h ώστε να μπορείτε να αλλάξετε το κείμενο του label1 (ο κώδικας μπορεί να γραφτεί στο τέλος του αρχείου, μετά το #pragma endregion):

Public: void Set(String^ text) ( label1->Text = text; )

4) Στο αρχείο Form2.h συμπεριλαμβάνουμε το Form1.h (στην αρχή):

#include "Form1.h"

και δημιουργήστε έναν κατασκευαστή που θα δέχεται και θα αποθηκεύει έναν σύνδεσμο προς την πρώτη φόρμα για περαιτέρω χρήση:

Form2(Form1^ parent) ( InitializeComponent(); parentForm = parent; ) //μπορείτε να γράψετε έναν σύνδεσμο αμέσως παρακάτω: private: Form1^ parentForm;

5) Κάνοντας κλικ στο κουμπί στο Form2, θα καλέσουμε τη μέθοδο Set της γονικής φόρμας:

Ιδιωτικό: Σύστημα::Κενό κουμπί1_Click(System::Object^ αποστολέας, System::EventArgs^ e) ( parentForm->Set("hello from form2"); parentForm->Show(); this->Hide(); )

6) Απομένει να ανοίξουμε τη δεύτερη φόρμα στην πρώτη φόρμα. Για να το κάνουμε αυτό, μετακινούμε τον χειριστή κλικ του κουμπιού από το Form1.h στο Form1.cpp και στο αρχείο .h αφήνουμε μόνο τη δήλωσή του.

Μερικές φορές είναι απαραίτητο να έχετε πρόσβαση στα στοιχεία μιας φόρμας από μια άλλη κατά την εκτέλεση του προγράμματος. Για παράδειγμα, υπάρχει μια φόρμα Form1, από αυτήν ανοίγουμε μια άλλη Form2 και τώρα, δουλεύοντας στη Form2, πρέπει να αποκτήσουμε πρόσβαση στα στοιχεία της μητρικής φόρμας Form1. Βρήκα αρκετούς τρόπους για να το κάνω αυτό.

1η μέθοδος. Διαβίβαση αναφοράς σε δημόσια μεταβλητή.

Χώρος ονομάτων WindowsApplication1 ( δημόσια μερική κλάση Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(); frm.but1 = this.button1; // send σύνδεσμος προς το κουμπί με τη μορφή Form2 frm.ShowDialog(); ) ) )

Στο Form2, η μεταβλητή στην οποία μεταβιβάστηκε ο σύνδεσμος θα αντιστοιχεί πλέον στο button1 από το Form1

Χώρος ονομάτων WindowsApplication1 ( δημόσια μερική κλάση Form2: Form ( public Button but1; // αυτή η μεταβλητή θα περιέχει έναν σύνδεσμο προς το button1 από το Form1 public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( but1. Text = "δοκιμή"; // αλλάξτε το κείμενο στο κουμπί κουμπιού1 της Φόρμας1 ) ) )

2η μέθοδος. Διαβίβαση του συνδέσμου στη φόρμα του παιδιού.

Η ουσία είναι περίπου η ίδια στην 1η μέθοδο. Όταν ανοίγουμε το Form2, περνάμε σε αυτό έναν σύνδεσμο προς το στοιχείο που σκοπεύουμε να αλλάξουμε αργότερα.

Χώρος ονομάτων WindowsApplication1 ( δημόσια μερική κλάση Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(this.button1); // περάστε έναν σύνδεσμο στο κουμπί στη φόρμα Form2 frm.ShowDialog(); ) ) )

Τώρα στο Form2 πρέπει να δημιουργήσουμε μια μεταβλητή που θα περιέχει έναν σύνδεσμο προς αυτό το κουμπί και μέσω αυτής θα έχουμε πρόσβαση στο κουμπί στο Form1 (γραμμές 5,7,9 και 15).

Χώρος ονομάτων WindowsApplication1 ( δημόσια μερική κλάση Form2: Form ( private Button but1; // αυτή η μεταβλητή θα περιέχει έναν σύνδεσμο προς το κουμπί button1 από τη φόρμα Form1 public Form2(Button but) // λάβετε έναν σύνδεσμο προς το κουμπί στη μεταβλητή αλλά ( but1 = αλλά )

3η μέθοδος. Πρόσβαση σε ολόκληρη τη γονική φόρμα.

Για να γίνει αυτό, πρέπει να κάνετε αλλαγές σε πολλά αρχεία, αλλά ταυτόχρονα θα έχουμε πρόσβαση σε όλα τα στοιχεία της γονικής φόρμας και δεν χρειάζεται να περάσουμε σύνδεσμο σε κάθε στοιχείο, όπως στη μέθοδο 1.

Βήμα 1.Στο αρχείο Program.csδημιουργήστε μια δημόσια μεταβλητή f1 (γραμμή 5).

Χώρος ονομάτων WindowsApplication1 ( στατική κλάση Πρόγραμμα ( δημόσια στατική Form1 f1; // μεταβλητή που θα περιέχει έναν σύνδεσμο προς τη φόρμα Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1( )))))))

Βήμα 2.Ανοιγμα Form1.Designer.csκαι σε αυτό, για στοιχεία που θα χρειαστεί πρόσβαση από άλλη φόρμα, αλλάζουμε ιδιωτικόςεπί δημόσιο. Για παράδειγμα, ας κάνουμε το κουμπί1 στη Φόρμα1 διαθέσιμο για αλλαγές.

Public System.Windows.Forms.Button button1; // αντικαταστάθηκε το ιδιωτικό με το δημόσιο

Βήμα 3. Κατά τη δημιουργία Form1, εκχωρούμε στη μεταβλητή f1 έναν σύνδεσμο σε αυτήν τη φόρμα (γραμμή 7)

Χώρος ονομάτων WindowsApplication1 ( δημόσια μερική κλάση Form1: Form ( public Form1() ( Program.f1 = this; // τώρα το f1 θα είναι ένας σύνδεσμος προς τη φόρμα Form1 InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(); frm.ShowDialog(); ) ) )

Βήμα 4.Τώρα από απολύτως οποιαδήποτε φόρμα ή από οποιαδήποτε κλάση μπορείτε να έχετε πρόσβαση στο στοιχείο button1 που βρίσκεται στο Form1 ως εξής: Program.f1.button1. Για παράδειγμα, αφήστε το κουμπί στο Form2 να αλλάξει το κείμενο του κουμπιού στο Form1:

Χώρος ονομάτων WindowsApplication1 ( δημόσια μερική κλάση Form2: Form ( public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Program.f1.button1.Text = "test"; // Αλλάξτε το κείμενο στο κουμπί φόρμας Φόρμα 1 ) )

Από admin.

Η εκμάθηση της C# είναι αργή. αλλά συνεχίζει πιστά. Μόλις πρόσφατα εγώ
έδωσε ένα παράδειγμα για το πώς να ανοίξετε μια άλλη από μια φόρμα στο Visual C#. Κατ 'αρχήν, όλα είναι απλά.

Σήμερα εμφανίστηκε η ακόλουθη εργασία: εκκίνηση μιας modal φόρμας από την κύρια φόρμα της εφαρμογής· όταν είναι κλειστή, αυτή η φόρμα πρέπει να μεταβιβάσει ορισμένα δεδομένα (κείμενο, τιμές ιδιοτήτων κ.λπ.) στα στοιχεία ελέγχου της κύριας φόρμας. Δεν είναι δυνατό να λυθεί αυτό το πρόβλημα χρησιμοποιώντας τη μέθοδο που περιγράφηκε στην προηγούμενη ανάρτηση σχετικά με τις φόρμες, επειδή σε αυτήν την περίπτωση απλά δημιουργούμε ένα νέο αντικείμενο φόρμας με νέες τιμές για όλες τις ιδιότητες. Ευτυχώς, η C# έχει έναν υπέροχο συλλέκτη σκουπιδιών... Αλλά το θέμα δεν είναι ο συλλέκτης, αλλά πώς να ανοίξετε μια θυγατρική φόρμα σε C# και μετά να επιστρέψετε στην κύρια φόρμα από αυτήν;

Αρχικά, ας ορίσουμε τα αρχικά (αρχικά) δεδομένα.

Ετσι. Έχουμε την κύρια φόρμα αίτησης:

Αυτή η φόρμα περιέχει επίσης ένα TextBox με το όνομα TBDialog και ένα κουμπί στο οποίο πρέπει να κάνουμε κλικ:

Αξία πρόσβασης Ιδιότητες κειμένουαπό το TBDialog στο TBMain.
Κλείσιμο fDialog;

Τώρα ας δούμε όλη τη διαδικασία με τη σειρά.

Πρώτον, αξίζει πάντα να θυμόμαστε ότι από προεπιλογή σε όλες τις ιδιότητες, τις μεταβλητές και τις μεθόδους στο C# εκχωρείται ένας τροποποιητής ιδιωτικός– επομένως, για να φτάσουμε από τη δεύτερη φόρμα στο στοιχείο ελέγχου της πρώτης, πρέπει να ορίσουμε έναν τροποποιητή για το TBMain δημόσιομόνος του. Για να το κάνετε αυτό, επιλέξτε το στοιχείο TBMain στον σχεδιαστή φόρμας, μεταβείτε στο παράθυρο ιδιοτήτων και αλλαγή της αξίας του ακινήτου Τροποποιητές Με ιδιωτικόςεπί δημόσιο

Τώρα το TBMain θα είναι ορατό σε άλλα αντικείμενα. Ας προχωρήσουμε. Για να ανοίξουμε τη φόρμα σε λειτουργία modal, πρέπει να χρησιμοποιήσουμε μία από τις δύο επιλογές για τη μέθοδο ShowDialog():

public DialogResult ShowDialog() ; public DialogResult ShowDialog(κάτοχος παραθύρου IWin32) ;

Στην πρώτη περίπτωση, η μέθοδος εμφανίζει τη φόρμα ως ένα παράθυρο διαλόγου με το τρέχον ενεργό παράθυρο που έχει οριστεί ως κάτοχος και στη δεύτερη, μπορούμε να καθορίσουμε ανεξάρτητα ποια φόρμα θα γίνει ο κάτοχος του παραθύρου μας.

Για παράδειγμα, ας χρησιμοποιήσουμε τη δεύτερη έκδοση της μεθόδου ShowDialog() και ας εμφανίσουμε τη δεύτερη φόρμα modally. Για να γίνει αυτό, θα γράψουμε τα εξής:

Εδώ εκμεταλλεύτηκα ξανά λέξη-κλειδί Αυτό , που δείχνει στο τρέχον αντικείμενο, δηλ. ορίστε την κύρια φόρμα ως κάτοχο ( fΚύρια). Τώρα ας προχωρήσουμε απευθείας στην επίλυση του προβλήματός μας και ας απαντήσουμε στην ερώτηση: Πώς να μεταβιβάσετε την τιμή από τη μια φόρμα στην άλλη;Κάθε στοιχείο ελέγχου έχει μια αξιοσημείωτη ιδιότητα Ιδιοκτήτης – που δείχνει προς τον γονέα:

Τώρα μπορείτε να εκτελέσετε το έργο και να βεβαιωθείτε ότι το κείμενο από το TextBox στη θυγατρική φόρμα μεταφέρεται τέλεια στο TextBox της πρώτης. Σε κάθε περίπτωση, δημοσιεύω τον πηγαίο κώδικα του έργου που συζητήθηκε στο παράδειγμα.