Ultima actualizare: 31.10.2015

Pentru a adăuga un alt formular la proiect, faceți clic dreapta pe numele proiectului din fereastra Solution Explorer și selectați Add->Windows Form...

Să dăm formă nouă un nume, de exemplu, Form2.cs:

Deci, am adăugat un al doilea formular la proiectul nostru. Acum să încercăm să implementăm interacțiunea între două forme. Să presupunem că primul formular va apela al doilea formular atunci când se apasă butonul. Mai întâi, să adăugăm un buton la primul formular, Form1, și să facem dublu clic pe buton pentru a merge la fișierul de cod. Deci, vom fi direcționați către gestionarea evenimentelor de clic al butonului, care este creat implicit după dublu clic pe butonul:

Private void button1_Click(expeditor obiect, EventArgs e) ( )

Acum să adăugăm codul pentru apelarea celui de-al doilea formular. Al doilea formular se numește Form2, așa că mai întâi creăm un obiect din această clasă, iar apoi pentru a-l afișa pe ecran numim metoda Show:

Privat void button1_Click (expeditor obiect, EventArgs e) ( Form2 newForm = new Form2(); newForm.Show(); )

Acum să facem invers - astfel încât a doua formă să o afecteze pe prima. În timp ce a doua formă nu știe despre existența primei. Pentru a remedia acest lucru, trebuie să transferați cumva informații despre primul formular în al doilea formular. Pentru a face acest lucru, vom folosi transmiterea unui link către formular în constructor.

Deci, să trecem la al doilea formular și să mergem la codul său - faceți clic dreapta pe formular și selectați Vizualizare cod. Deocamdată este gol și conține doar un constructor. Deoarece C# acceptă supraîncărcarea metodelor, putem crea mai multe metode și constructori cu parametri diferiți și putem apela una dintre ele în funcție de situație. Deci, să schimbăm fișierul de cod al celei de-a doua forme în următorul:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.ComponentModel; folosind System.Data; folosind System.Drawing; folosind System.Linq; folosind System.Text; folosind System.Threading.Tasks; folosind System.Windows.Forms; namespace HelloApp ( clasă parțială publică Form2: Form ( public Form2() ( InitializeComponent(); ) public Form2(Form1 f) ( InitializeComponent(); f.BackColor = Color.Yellow; ) ) )

De fapt, tocmai am adăugat aici nou constructor public Form2(Form1 f) , în care obținem prima formă și îi setăm fundalul pe galben. Acum să trecem la codul primei forme, unde am apelat a doua formă și am schimbat-o în următoarea:

Privat void button1_Click(expeditor obiect, EventArgs e) ( Form2 newForm = new Form2(this); newForm.Show(); )

Din moment ce în în acest caz, cuvântul cheie this reprezintă o referință la obiectul curent - obiectul Form1, apoi la crearea unui al doilea formular îl va primi (linkul) și va controla primul formular prin intermediul acestuia.

Acum, după ce faceți clic pe butonul, va fi creat un al doilea formular, care va schimba imediat culoarea primului formular.

De asemenea, putem crea obiecte de forma curentă:

Privat void button1_Click (expeditor obiect, EventArgs e) ( Form1 newForm1 = new Form1(); newForm1.Show(); Form2 newForm2 = new Form2(newForm1); newForm2.Show(); )

Când lucrați cu mai multe formulare, trebuie să țineți cont de faptul că unul dintre ele este cel principal - care este lansat mai întâi în fișierul Program.cs. Dacă avem o grămadă de formulare deschise în același timp, atunci când îl închidem pe cel principal, întreaga aplicație se închide și odată cu ea toate celelalte formulare.

Uneori este necesar să accesați elementele unui formular dintr-un altul în timpul execuției programului. De exemplu, există un formular Form1, de pe acesta deschidem un alt Form2 și acum, lucrând în Form2, trebuie să accesăm elementele formularului părinte Form1. Am găsit mai multe modalități de a face asta.

1a metoda. Transmiterea unei referințe la o variabilă publică.

Namespace WindowsApplication1 (clasa parțială publică Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(obiect sender, EventArgs e) ( Form2 frm = new Form2(); frm.but1 = this.button1; // trimite link la butonul sub forma Form2 frm.ShowDialog() ) );

În Form2, variabila către care a fost transmisă legătura va corespunde acum butonului 1 din Form1

Spațiu de nume WindowsApplication1 ( clasă parțială publică Form2: Form ( public Button but1; // această variabilă va conține un link către butonul 1 din Form1 public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( but1. Text = "test" // modificați textul butonului butonul 1 din Form1 ) ) )

a 2-a metoda. Trecerea linkului către formularul copil.

Esența este aproximativ aceeași în prima metodă. Când deschidem Form2, trecem în el un link către elementul pe care intenționăm să îl schimbăm mai târziu.

Spațiu de nume WindowsApplication1 ( clasă parțială publică Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click (expedător obiect, EventArgs e) ( Form2 frm = new Form2(this.button1); // transmiteți un link către buton la formularul Form2 frm.ShowDialog() ) )

Acum în Form2 trebuie să creăm o variabilă care va conține un link către acest buton și prin el vom accesa butonul de pe Form1 (liniile 5,7,9 și 15).

Namespace WindowsApplication1 ( clasă parțială publică Form2: Form ( private Button but1; // această variabilă va conține un link către butonul button1 din formularul Form1 public Form2 (Button but) // obține un link către butonul din variabila but ( but1) = but; // acum but1 va fi un link către butonul button1 InitializeComponent() private void button1_Click(object sender, EventArgs e) ( but1.Text = "test"; // modifica textul butonului1 din Form1) ) )

a 3-a metoda. Acces la întregul formular de părinte.

Pentru a face acest lucru, trebuie să faceți modificări în mai multe fișiere, dar în același timp vom avea acces la toate elementele formularului părinte și nu trebuie să transmitem un link către fiecare element, ca în metoda 1.

Pasul 1.În dosar Program.cs creați o variabilă publică f1 (linia 5).

Namespace WindowsApplication1 ( static class Program ( public static Form1 f1; // variabilă care va conține un link către formularul Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1(); ) ) ) ) )

Pasul 2. Deschidere Form1.Designer.cs iar în el, pentru elementele care vor trebui accesate dintr-o altă formă, ne schimbăm privat pe public. De exemplu, să facem butonul 1 din Form1 disponibil pentru modificări.

Public System.Windows.Forms.Buton buton1; // înlocuit privat cu public

Pasul 3. Când creăm Form1, atribuim variabilei f1 o legătură către acest formular (linia 7)

Spațiu de nume WindowsApplication1 ( clasă parțială publică Form1: Form ( public Form1() ( Program.f1 = aceasta; // acum f1 va fi un link către formularul Form1 InitializeComponent(); ) private void button1_Click(expeditor obiect, EventArgs e) ( Form2 frm = new Form2(); frm.ShowDialog();

Pasul 4. Acum din absolut orice formular sau din orice clasa puteti accesa elementul button1 situat pe Form1 astfel: Program.f1.button1. De exemplu, lăsați butonul de pe Form2 să schimbe textul butonului de pe Form1:

Spațiu de nume WindowsApplication1 ( clasă parțială publică Form2: Form ( public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Program.f1.button1.Text = "test"; // Schimbați textul pe butonul formular Form1 ) ) )

În ciuda faptului că părerea mea despre Microsoft Visual Studio este în continuare aceeași, uneori trebuie să faci ceva despre el. Dacă ne înțelegem cu faptul că scriem, de fapt, nu în C++, ci în așa-numitul C++/CLI, lucrul cu componente vizuale familiare nu va fi atât de diferit de aceleași medii Borland. Dar poate crea probleme, în comparație cu Builder Să luăm în considerare 3 situații tipice de lucru cu o aplicație care conține mai mult de un formular.

Un exemplu de construire și apelare programatică a unui formular

Acest cod poate fi executat, de exemplu, făcând clic pe un buton din formularul principal Form1.

Form^form2 = gcnew Form(); Button^ button2 = gcnew Buton(); butonul2->Text = L"OK"; butonul2->Locație = Punct(10,10); form2->Text = L"Fereastra mea"; form2->HelpButton = adevărat; form2->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog; form2->StartPosition = FormStartPosition::CenterScreen; form2->Controle->Add(button2); form2->ShowDialog();

Pentru a adăuga un handler de clic pentru un buton button2 generat programatic, scrieți înainte de ultima linie de cod:

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

Înainte ca metoda form2->ShowDialog() sau form2->Show() să fie apelată;

În acest caz, codul de gestionare se află în modulul curent Form1.h:

Privat: System::Void button2_Click(System::Object^ sender, System::EventArgs^ e) ( MessageBox::Show("Aici"); )

Apelați un alt formular din formularul principal

În meniu, selectați Proiect - Adăugați un element nou - Formular - nume Form2

Să adăugăm un operator

#include „Form2.h”

înainte de primul spațiu de nume din Form1.h (adică chiar la începutul fișierului).

Să includem un pointer către instanța clasei în secțiunea publică a clasei Form1:

Form2^F2;

Să adăugăm codul unde trebuie să creăm și să apelăm al doilea formular:

F2=gcnewForm2(); F2->Show();

Pentru a șterge programatic al doilea formular, următorul cod este potrivit:

Ștergeți F2;

Trebuie remarcat faptul că pointerul stochează adresa unui singur formular, cel care a fost creat ultimul. Dacă creăm secvențial mai multe formulare folosind acest cod, doar ultimul va fi șters. Alternativ, încercați matricea de forme descrisă mai jos.

Să descriem datele necesare în clasa de formulare Form1 (aici numele și spațiul de nume ale proiectului Tabulator, dacă este necesar, înlocuiți cu propriile dvs.):

Static const int MAX_FORMS = 100; //Număr maxim de formulare int FormCount; //Formulează matrice de contor ^F2; //Indicator catre o matrice de forme

Apoi inițializam datele folosind evenimentul Load din forma principală:

FormCount=0; F2 = matrice gcnew (MAX_FORMS);

Apoi implementăm codul pentru a crea următorul formular

Dacă(FormCount Spectacol(); ) else MessageBox::Show("Prea multe formulare!");

si eliminarea lui:

Dacă (FormCount) ( ștergeți F2; FormCount--; )

Dacă dorim să creăm formulare copil nu separat, ci în interiorul formei părinte, atunci în proprietățile Form1 trebuie să indicăm că este un „strămoș” (setați proprietatea IsMdiParent = true) și înainte de a arăta formularul copil folosind Operatorul F2->Show(), marcați-l ca copil Form1:

F2->MdiParent = asta;

Apelați o metodă de formular părinte dintr-un formular copil

Cu greu ne putem descurca fără să folosim fișiere .cpp, ceea ce nu este rău - scrierea codului în fișiere .h rupe, în general, sistemul C corect :)

Să descriem procesul pas cu pas.

1) Există 2 forme - Form1 și Form2, pe Form1 există un Button (button1, se va deschide al doilea formular) și Label (label1, aici vom schimba textul). Pe Form2 - button1, când se face clic, textul din label1 se va schimba.

2) Deoarece trebuie să avem acces de la prima formă la a doua și de la a doua la prima, va apărea problema referințelor încrucișate (când Form1.h se referă la Form2.h, care, la rândul său, se referă din nou la la Form1.h) . Pentru a evita acest lucru, vom muta codul primului formular (Form1), care va avea acces la al doilea formular (Form2), din fisierul .h in fisierul .cpp. Astfel, trebuie să creați un fișier Form1.cpp.

3) Anunțați metoda publică Setați în Form1.h astfel încât să puteți modifica textul etichetei1 (codul poate fi scris la sfârșitul fișierului, după #pragma endregion):

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

4) În fișierul Form2.h includem Form1.h (la început):

#include „Formular1.h”

și creați un constructor care va accepta și salva un link către primul formular pentru utilizare ulterioară:

Form2(Form1^ parent) ( InitializeComponent(); parentForm = parent; ) //puteți scrie un link imediat mai jos: private: Form1^ parentForm;

5) Făcând clic pe butonul din Form2, vom apela metoda Set a formularului părinte:

Privat: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) (parentForm->Set(„bună ziua de la form2”); parentForm->Show(); this->Hide(); )

6) Rămâne să deschidem a doua formă în prima formă. Pentru a face acest lucru, transferăm handlerul de clic pe buton din Form1.h în Form1.cpp , iar în fișierul .h lăsăm doar declarația acestuia.

De către admin.

Învățarea C# este lentă. dar continuă cu fidelitate. Doar recent eu
a dat un exemplu despre cum să deschideți un altul dintr-un formular în Visual C#. În principiu, totul este simplu.

Astăzi a apărut următoarea sarcină: lansați un formular modal din formularul principal al aplicației atunci când este închis, acest formular trebuie să treacă unele date (text, valori de proprietate etc.) controalelor din formularul principal; Nu se poate rezolva această problemă folosind metoda descrisă în postarea anterioară despre formulare, deoarece în acest caz, pur și simplu creăm un nou obiect formular cu noi valori pentru toate proprietățile. Din fericire, C# are un colector de gunoi minunat... Dar ideea nu este colectorul, ci cum să deschideți un formular copil în C# și apoi să reveniți la formularul principal de pe acesta?

Pentru început, să setăm datele inițiale (inițiale).

Aşa. Avem formularul principal de cerere:

Pe acest formular există și un TextBox numit TBDialog și un buton Button pe care ar trebui să facem clic:

1. Transmiteți valoarea proprietății Text de la TBDialog la TBMain;
2. Închide fDialog;

Acum să ne uităm la întregul proces în ordine.

În primul rând, merită întotdeauna să ne amintim că, implicit, tuturor proprietăților, variabilelor și metodelor din C# li se atribuie un modificator privat– prin urmare, pentru a trece de la a doua formă la controlul de pe prima, trebuie să setăm un modificator pentru TBMain public pe cont propriu. Pentru a face acest lucru, selectați elementul TBMain din designerul de formulare, accesați fereastra de proprietăți și modifica valoarea proprietatii Modificatori Cu privat pe public

Acum TBMain va fi vizibil în alte obiecte. Să mergem mai departe. Pentru a deschide formularul în modul modal, trebuie să folosim una dintre cele două opțiuni pentru metoda ShowDialog():

public DialogResult ShowDialog(proprietar IWin32Window) ;

În primul caz, metoda afișează formularul ca o casetă de dialog modală cu fereastra activă curentă setată ca proprietar, iar în al doilea, putem specifica în mod independent care formular va deveni proprietar pentru fereastra noastră modală.

De exemplu, să folosim a doua versiune a metodei ShowDialog() și să arătăm a doua formă modal. Pentru a face acest lucru, vom scrie următoarele: Aici am folosit din nou cuvântul cheie acest , care indică obiectul curent, adică. setați formularul principal ca proprietar ( fPrincipal ). Acum să trecem direct la rezolvarea problemei noastre și să răspundem la întrebarea: cum se transmite valoare de la o formă la alta? Fiecare control are o proprietate remarcabilă Proprietar

– care indică părintele:

Acum puteți rula proiectul și vă asigurați că textul din TextBox de pe formularul copil se transferă perfect în TextBox de pe primul. Pentru orice eventualitate, postez codul sursă al proiectului discutat în exemplu.
Întrebarea abordată în acest articol este mai probabil să se refere la subiectul construirii unei arhitecturi de aplicație și nu în mod specific la problema luată în considerare. Transferul datelor de la un formular la altul nu este deloc dificil. Pentru a face acest lucru, este suficient să deschidem controlul ale cărui date dorim să le obținem, adică să-l marchezi cu modificatorul public. De asemenea, este posibilă o altă variantă. De exemplu, în prima formă creăm un obiect al celei de-a doua forme prin trecerea unei referințe la noi înșine către constructor, adică prin trecerea unei referințe la prima de la prima formă la a doua.
SecondForm secondForm = new SecondForm(this);

Desigur, înainte de a face acest lucru, ar trebui să aveți grijă să creați o supraîncărcare pentru constructorul celei de-a doua forme.

Și această metodă este destul de comună. Cu toate acestea, prin simplitatea sa, are multe probleme potențiale, principala fiind o încălcare a principiului încapsulării. Într-un cuvânt, a doua formă nu ar trebui să știe nimic despre existența primei și, cu atât mai mult, nu ar trebui să o poată influența. Soluția la această problemă este destul de simplă. Să ne uităm direct la cod. În designer, creăm formularul principal (va fi lansat la pornirea aplicației). Să punem unul, TextBox Eticheta Şi.

Făcând clic pe butonul, se va deschide al doilea formular, iar textul din câmpul text al formularului principal va fi transferat în câmpul text al celui de-al doilea formular. Inițial, a doua formă arată astfel:

Similar cu primul, are aceleași comenzi. Nu mai avem nevoie de nimic. Punctul de intrare în aplicație lansează formularul principal:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Windows.Forms; namespace From1FormTo2 ( clasa static Program ( // Punctul de intrare principal pentru aplicație. static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) ) )

Codul principal al formularului arată astfel:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.ComponentModel; folosind System.Data; folosind System.Drawing; folosind System.Linq; folosind System.Text; folosind System.Windows.Forms; namespace From1FormTo2 (clasa parțială publică MainForm: Form ( //a doua formă SecondForm secondForm; //constructor public MainForm() ( InitializeComponent(); ) // handler de evenimente de transfer de date //de la formularul principal la al doilea void privat btn_mainForm_Click(object expeditor, EventArgs e) ( secondForm = nou SecondForm(tb_mainForm.Text.Trim()); secondForm.ShowDialog(); if (secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = secondForm.ReturnData(); )))

În consecință, nu uitați să conectați butonul la eveniment Clic. Aici, în clasa de formular principală există un câmp SecondForm secondForm, reprezentând al doilea obiect de formă. Când faceți clic pe butonul „Trimite”, se creează un al doilea formular (se numește constructorul supraîncărcat, îl vom crea mai târziu) și este lansat folosind metoda ShowDialog(). În acest caz, această metodă este potrivită pentru noi. Mai mult, după aceasta ne asigurăm că verificăm dacă al doilea formular a fost închis, dar a dat clic pe butonul acestuia. Dacă s-a făcut clic pe un buton pe al doilea formular, atunci primul formular ar trebui să accepte date din al doilea. Acest lucru se întâmplă prin apelarea metodei ReturnData()în a doua formă.

Acum, cea mai interesantă parte este codul celei de-a doua forme:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.ComponentModel; folosind System.Data; folosind System.Drawing; folosind System.Linq; folosind System.Text; folosind System.Windows.Forms; namespace From1FormTo2 (clasa parțială publică SecondForm: Form ( //constructor supraîncărcat public SecondForm(șir de date) ( InitializeComponent(); tb_secondForm.Text = data; ) //manager de evenimente de transfer de date //de la a doua formă la cel principal void privat btn_secondForm_Click (emițător obiect, EventArgs e) ( this.DialogResult = DialogResult.OK; ) //metoda publică de accesare //câmpul de text al acestui formular șir public ReturnData() ( return (tb_secondForm.Text.Trim()); ) ) )

După cum puteți vedea, există o singură supraîncărcare a constructorului care acceptă un tip de șir. Amintiți-vă că încercăm să transferăm text dintr-un TextBox. În constructor, componentele sunt programate să fie inițializate și textul câmpului text este setat la valoarea transmisă din prima formă. În continuare, prin abonarea la eveniment Clic pentru butonul celui de-al doilea formular, am creat un handler btn_secondForm_Click, care simulează funcționarea butonului „Ok” al oricărei casete de dialog. Astfel, făcând clic pe butonul „Trimite” (din al doilea formular), executăm condiția

(secondForm .DialogResult == DialogResult .OK)

Prima formă, deci, apelând metoda secondForm.ReturnData(), setăm câmpul text al primului formular la valoarea câmpului text al celui de-al doilea formular.

Funcționarea acestei metode, cred, nu mai necesită explicații. Pur și simplu returnează textul dintr-un singur câmp de text, păstrându-l în același timp privat.

Ca urmare, am transferat date în a doua formă de la prima și de la a doua la prima fără a încălca principiile încapsulării.

Încercați să introduceți textul „aaa” în câmpul de text al primului formular și să faceți clic pe butonul. Veți vedea acest text în câmpul de text din al doilea formular care se deschide. Încercați să schimbați textul în „aaa ppp” și faceți clic pe butonul. Veți vedea cum, după închiderea celui de-al doilea formular, acest text va apărea în câmpul de text al formularului principal.

Acum, cred că veți putea transfera datele între formulare mai corect. În articolul următor vom vorbi despre cum se face în aplicațiile ASP.NET.