În ciuda faptului că părerea mea despre Microsoft Studio vizual totuși, uneori trebuie să faci ceva cu el. Dacă ne înțelegem cu faptul că scriem în acest caz, de fapt, nu în C ++, ci în așa-numitul C ++ / CLI , lucrul cu componentele vizuale obișnuite nu va fi atât de diferit de acelaș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.Mediul exemplu este gratuit Visual C ++ 2010 Express, se presupune că formularul principal are numele implicit Form1.
Un exemplu de construire și apelare programatică a unui formular
Acest cod poate fi executat, de exemplu, prin apăsarea unui buton din forma principală Form1.
Form^form2 = gcnew Form(); Button^button2 = gcnewButton(); 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 butonul generat programatic2, 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 același timp, codul de gestionare este plasat î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 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=gcnew Form2(); F2->Show();
Pentru a șterge programatic a doua formă, codul este potrivit
Ștergeți F2;
Trebuie remarcat faptul că pointerul stochează adresa unui singur formular, cel care a fost creat ultimul. Dacă am creat succesiv mai multe formulare cu acest cod, doar ultimul va fi șters. Alternativ, încercați o serie de forme, descrise mai jos.
Să descriem datele necesare în clasa de formular 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; // Suma maximă formează int FormCount; // Formă matrice de contor
Apoi inițializam datele pe evenimentul Load din formularul principal:
FormCount=0; F2 = matrice gcnew
Apoi implementăm codul pentru a crea următorul formular
Dacă(FormCount
si eliminarea lui:
Dacă (FormCount) ( ștergeți F2; FormCount--; )
Dacă vrem să creăm formulare copil nu separat, ci în interiorul formularului părinte, atunci în proprietățile Form1 trebuie să indicăm că este un „strămoș” (setați proprietatea IsMdiParent = true), iar înainte de a arăta formularul copil cu F2 -> Operatorul Show(), marcați-l ca copil Form1:
F2->MdiParent = asta;
Apelați metoda formularului părinte din formularul copil
Cu greu ne putem descurca fără implicarea fișierelor .cpp, ceea ce nu este rău - scrierea codului în fișierele .h ale C "shnik-ului corect se rupe în general :)
Să descompunem procesul pas cu pas.
1) Există 2 forme - Form1 și Form2 , pe Form1 sunt Button (button1 , se va deschide al doilea formular) și Label (label1 , aici vom schimba textul). Pe Form2 - button1 , făcând clic pe care se va schimba textul din label1.
2) Deoarece trebuie să avem acces la a doua din prima formă ș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) Declarați o metodă publică Set în Form1.h, astfel încât să puteți modifica textul label1 (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 stoca o referință la prima formă pentru utilizare ulterioară:
Form2(Form1^ parent) ( InitializeComponent(); parentForm = parent; ) //puteți adăuga un link chiar 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 în prima formă să se facă deschiderea celei de-a doua forme. Pentru a face acest lucru, transferați manerul de clic pe buton din Form1.h în Form1.cpp și lăsați doar declarația acestuia în fișierul .h.
De către admin.
Învățarea C# este lentă. dar merge mai departe. 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ă: lansarea unui formular modal din formularul principal al aplicației, acest formular, atunci când este închis, trebuie să transfere orice date (text, valori de proprietate etc.) către controalele din formularul principal. Nu este posibilă rezolvarea acestei probleme în modul descris în postarea anterioară despre formulare. î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 în colector, ci în cum să deschideți un formular copil în C # și apoi să reveniți la cel principal din el?
Pentru început, să setăm datele inițiale (inițiale).
Asa de. Avem formularul principal de cerere:
Acest formular conține și o casetă de text numită TBDialog și un buton la clic pe care trebuie să:
- Transmiteți valoarea proprietății Text de la TBDialog la TBMain;
- Închide fDialog;
Acum luați în considerare întregul proces de lucru în ordine.
În primul rând, trebuie să vă amintiți întotdeauna că, în mod implicit, tuturor proprietăților, variabilelor și metodelor din C# li se atribuie un modificator privat- prin urmare, pentru a ajunge de la a doua formă la controlul de pe prima, trebuie să setăm modificatorul pe TBMain public pe cont propriu. Pentru a face acest lucru, selectați elementul TBMain din constructorul 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. 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() ; 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 caz, putem specifica în mod independent care formular va deveni proprietar pentru fereastra noastră modală.
De exemplu, să folosim a doua variantă a metodei ShowDialog() și să arătăm a doua formă modal. Pentru a face acest lucru, scriem următoarele:
Aici am folosit din nou cuvântul cheie acest , care indică obiectul curent, adică. setați formularul principal ca proprietar ( fPrincipal). Acum mergem direct la rezolvarea problemei noastre și răspundem la întrebarea: cum se transmite valoare de la o formă la alta? Fiecare control are o proprietate minunată Proprietar - care indică către părinte:
Acum puteți rula proiectul și vă asigurați că textul din TextBox de pe formularul copil este transferat perfect în TextBox de pe primul. Pentru orice eventualitate, postez codul sursă al proiectului considerat în exemplu.
Uneori, în timpul execuției programului, trebuie să faceți referire la elementele unei forme din alta. De exemplu, există un formular Form1, din care deschidem un alt Form2 și acum, lucrând în formularul Form2, trebuie să accesăm elementele formularului părinte Form1. Am găsit mai multe modalități de a face asta.
1-a cale. Transmiterea unei referințe la o variabilă publică.
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(); frm.but1 = this.button1; // trece link către butonul din Form2 frm.ShowDialog(); ) ) )
În Form2, variabila către care a fost transmisă legătura va corespunde acum butonului 1 din Form1
Namespace WindowsApplication1 ( clasă parțială publică Form2: Form ( public Button but1; // această variabilă va conține o referință la butonul button1 din Form1 public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( but1 . Text = "test"; // modificați textul butonului butonul 1 din Formularul1 ) ) )
a 2-a cale. Transmiterea unui link către un formular copil.
Esența este aproximativ aceeași, apoi în prima metodă. Când deschidem formularul 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(object sender, EventArgs e) ( Form2 frm = new Form2(this.button1); // trece linkul butonului la formularul Form2 frm.ShowDialog(); ) ) )
Acum, în Form2, trebuie să creați 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 o referință la butonul button1 din Form1 public Form2 (Button but) // obține o referință la butonul din variabila but ( but1 = but ; // acum but1 va fi un link către butonul 1 InitializeComponent(); ) private void button1_Click (expedător obiect, EventArgs e) ( but1.Text = "test"; // schimba textul butonului butonul 1 al Form1 ) ) )
a 3-a cale. Acces la întregul formular de părinte.
Pentru a face acest lucru, trebuie să facem 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 prima metodă.
Pasul 1.În dosar Program.cs creați o variabilă publică f1 (linia 5).
Spațiu de nume WindowsApplication1 ( clasa static Program ( public static Form1 f1; // variabilă care va conține o referință la Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1() ) ; ) ) )
Pasul 2 Deschidem Form1.Designer.cs iar în ea, pentru elementele care vor trebui accesate dintr-o altă formă, ne schimbăm privat pe public. De exemplu, să facem butonul butonul 1 disponibil pentru modificări în Form1.
Public System.Windows.Forms.Buton buton1; // schimbat privat în public
Pasul 3. La crearea formularului Form1, atribuim variabilei f1 o referință la acest formular (linia 7)
Spațiu de nume WindowsApplication1 ( clasă parțială publică Form1: Form ( public Form1() ( Program.f1 = aceasta; // acum f1 va fi o referință la formularul Form1 InitializeComponent(); ) private void button1_Click (expeditor obiect, EventArgs e) ( Form2 frm = nou Form2(); frm.ShowDialog(); ) ) )
Pasul 4 Acum, din absolut orice formular sau din orice clasă, puteți accesa elementul button1 situat pe Form1 astfel: Program.f1.button1. De exemplu, să facem ca un buton din Form2 să schimbe textul butonului în 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 ) ) )
Problema discutată în acest articol este mai mult legată de subiectul arhitecturii aplicației și nu de problema specifică luată în considerare. Trecerea 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 primim, 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 de la prima formă la a doua formă a unei referințe la prima
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 a celui de-al doilea constructor de formulare.
Și această metodă este destul de comună. Cu toate acestea, prin simplitatea sa, aduce multe probleme potențiale, principala dintre acestea 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ă mergem direct la cod. În designer, creăm formularul principal (va fi lansat când pornește aplicația). Să punem unul casetă de text, etichetaȘi buton.
Când se face 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:
Ca și primul, are aceleași comenzi. Nu avem nevoie de mai mult. Punctul de intrare în aplicație lansează formularul principal:
Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Windows.Forms; namespace From1FormTo2 ( static class 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 A care reprezintă al doilea obiect de formă. Când faceți clic pe butonul „Trimite”, este creat un al doilea formular (se apelează constructorul supraîncărcat, îl vom crea mai târziu) și este lansat prin metoda ShowDialog(). În acest caz, această metodă ni se potrivește. Mai mult, după aceea cu siguranță vom verifica dacă nu am închis al doilea formular, ci am dat clic pe butonul acestuia. Dacă, pe al doilea formular, s-a făcut clic pe un buton, atunci primul formular ar trebui să primească date de la al doilea. Acest lucru se face 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(string date) ( InitializeComponent(); tb_secondForm.Text = data; ) //manager de evenimente de transfer de date //de la a doua formă la formularul principal private void 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ă transmitem text dintr-un TextBox. În constructor, componentele sunt programate să fie inițializate, iar textul câmpului de text este setat la valoarea transmisă din primul formular. Apoi, 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.
Loc de munca aceasta metoda Cred că nu mai are nevoie de 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 faceți clic pe butonul. Veți vedea în a doua formă deschisă acest text în caseta de text. Î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 textul dat va fi afișat în câmpul de text al formularului principal.
Acum, cred că veți efectua mai corect transferurile de date între formulare. În articolul următor, vom vorbi despre cum în aplicațiile ASP.NET.
Ultima actualizare: 31.10.2015
Pentru a adăuga un alt formular la proiect, faceți clic pe numele proiectului din fereastra Solution Explorer (Solution Explorer) Click dreapta mouse-ul și selectați Add(Add)->Windows Form...
Să dăm noii forme un nume, de exemplu, Form2.cs:
Deci, am adăugat un al doilea formular la proiect. Acum să încercăm să implementăm interacțiunea dintre cele două forme. Să presupunem că primul formular va apela al doilea formular când se face clic pe 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 intra în handler-ul de evenimente de clic pe butonul, care este creat implicit după dublu clic pe butonul:
Private void button1_Click(expeditor obiect, EventArgs e) ( )
Acum să adăugăm codul de apel al 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ă și apoi apelăm metoda Show pentru a-l afișa pe ecran:
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ă trecem la codul său - faceți clic dreapta pe formular și selectați Vizualizare cod (Vizualizare cod). În timp ce 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 (clasa parțială publică Form2: Form ( public Form2() ( InitializeComponent(); ) public Form2(Form1 f) ( InitializeComponent(); f.BackColor = Color.Yellow; ) ) )
De fapt, tocmai am adăugat aici un nou constructor public Form2(Form1 f), în care obținem primul formular și îi setăm fundalul la galben. Acum să mergem 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(); )
Pentru că în acest caz cuvânt cheie aceasta reprezintă o referință la obiectul curent - obiectul Form1, apoi la crearea celui de-al doilea formular, îl va primi (linkul) și va gestiona primul formular prin intermediul acestuia.
Acum, după ce facem clic pe butonul, vom crea un al doilea formular, care va schimba imediat culoarea primei forme.
De asemenea, putem crea obiecte pentru 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, rețineți 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 cel principal este închis, întreaga aplicație se închide și odată cu ea toate celelalte formulare.
Se încarcă...