C hapni një aplikacion tjetër në formular. Hapja e një formulari të dytë dhe kalimi i të dhënave në formularin kryesor

Nga admin.

Mësimi i C# është i ngadalshëm. por vazhdon me besnikëri. Kohët e fundit unë
dha një shembull se si të hapet një tjetër nga një formë në Visual C#. Në parim, gjithçka është e thjeshtë.

Sot u shfaq detyra e mëposhtme: lëshoni një formular modal nga forma kryesore e aplikacionit kur mbyllet, ky formular duhet të kalojë disa të dhëna (tekst, vlera të vetive, etj.) te kontrollet në formularin kryesor; Nuk është e mundur të zgjidhet ky problem duke përdorur metodën e përshkruar në postimin e mëparshëm në lidhje me format, sepse në këtë rast ne thjesht krijojmë një objekt të formës së re me vlera të reja për të gjitha vetitë. Për fat të mirë, C# ka një grumbullues të mrekullueshëm mbeturinash... Por çështja nuk është mbledhësi, por si të hapësh një formular fëmijësh në C# dhe më pas të kthehesh në formën kryesore prej tij?

Për të filluar, le të vendosim të dhënat fillestare (fillestare).

Kështu që. Ne kemi formularin kryesor të aplikimit:

Ky formular përmban gjithashtu një TextBox me emrin TBDialog dhe një buton Butoni në të cilin duhet të klikojmë:

1. Kaloni vlerën e vetive Text nga TBDialog në TBMain;
2. Mbyll fDialog;

Tani le të shohim të gjithë procesin me radhë.

Së pari, ia vlen të kujtohet gjithmonë se si parazgjedhje të gjitha vetitë, variablat dhe metodat në C# u caktohen një modifikues private– prandaj, për të kaluar nga forma e dytë në kontrollin në të parën, duhet të vendosim një modifikues për TBMain publike më vete. Për ta bërë këtë, zgjidhni elementin TBMain në projektuesin e formularit, shkoni te dritarja e vetive dhe ndryshoni vlerën e pasurisë Modifikuesit Me private në publike

Tani TBMain do të jetë i dukshëm në objekte të tjera. Le të vazhdojmë. Për të hapur formularin në modalitet, duhet të përdorim një nga dy opsionet për metodën ShowDialog():

Në rastin e parë, metoda e shfaq formularin si një kuti dialogu modale me dritaren aktuale aktive të vendosur si pronar, dhe në të dytën, ne mund të specifikojmë në mënyrë të pavarur se cila formë do të bëhet pronar për dritaren tonë modale.

Për shembull, le të përdorim versionin e dytë të metodës ShowDialog() dhe të tregojmë formën e dytë në mënyrë modale. Për ta bërë këtë, ne do të shkruajmë sa vijon:

Këtu kam përdorur përsëri fjalën kyçe kjo , e cila tregon për objektin aktual, d.m.th. vendos formën kryesore si pronar ( fKryesore). Tani le të kalojmë drejtpërdrejt në zgjidhjen e problemit tonë dhe t'i përgjigjemi pyetjes: si të kalohet vlera nga një formë në tjetrën?Çdo kontroll ka një veti të jashtëzakonshme Pronari – që tregon prindin:

Tani mund ta ekzekutoni projektin dhe të siguroheni që teksti nga TextBox në formularin e fëmijës të transferohet në mënyrë të përsosur në TextBox në të parën. Për çdo rast, unë po postoj kodin burimor të projektit të diskutuar në shembull.

Pyetja e trajtuar në këtë artikull ka më shumë gjasa të lidhet me temën e ndërtimit të një arkitekture aplikacioni, dhe jo në mënyrë specifike me problemin në shqyrtim. Transferimi i të dhënave nga një formë në tjetrën nuk është aspak e vështirë. Për ta bërë këtë, mjafton të hapim kontrollin, të dhënat e të cilit duam t'i marrim, domethënë ta shënojmë me modifikuesin publik. Gjithashtu, një opsion tjetër është i mundur. Për shembull, në formën e parë ne krijojmë një objekt të formës së dytë duke kaluar një referencë për veten tonë te konstruktori, domethënë duke kaluar një referencë tek e para nga forma e parë në të dytën.
SecondForm secondForm = i ri SecondForm(this);
Natyrisht, para se ta bëni këtë, duhet të kujdeseni për krijimin e një mbingarkese për konstruktorin e formës së dytë.

Dhe kjo metodë është mjaft e zakonshme. Sidoqoftë, me thjeshtësinë e tij, ajo mbart shumë probleme të mundshme, kryesore është një shkelje e parimit të kapsulimit. Me një fjalë, forma e dytë nuk duhet të dijë asgjë për ekzistencën e së parës dhe aq më tepër, nuk duhet të jetë në gjendje të ndikojë në të.

Zgjidhja e këtij problemi është mjaft e thjeshtë. Le të shohim drejtpërdrejt kodin. Në projektues, ne krijojmë formën kryesore (ajo do të hapet kur të fillojë aplikacioni). Le të vendosim një Kuti teksti, Etiketa Dhe Butoni.

Duke klikuar në butonin, do të hapet forma e dytë dhe teksti nga fusha e tekstit të formularit kryesor do të transferohet në fushën e tekstit të formularit të dytë. Fillimisht, forma e dytë duket kështu:

Ngjashëm me të parën, ka të njëjtat kontrolle. Nuk na duhet më. Pika e hyrjes së aplikacionit hap formën kryesore:

Përdorimi i Sistemit; duke përdorur System.Collections.Generic; duke përdorur System.Linq; duke përdorur System.Windows.Forms; hapësira e emrave From1FormTo2 ( Programi i klasës statike ( // Pika kryesore e hyrjes për aplikacionin. static void Main() (Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) )

Kodi kryesor i formës duket si ky:

Përdorimi i Sistemit; duke përdorur System.Collections.Generic; duke përdorur System.ComponentModel; duke përdorur System.Data; duke përdorur System.Drawing; duke përdorur System.Linq; duke përdorur System.Text; duke përdorur System.Windows.Forms; hapësira e emrit From1FormTo2 ( klasa publike e pjesshme MainForm: Form ( //forma e dytë SecondForm secondForm; //konstruktor publik MainForm() ( InitializeComponent(); ) //trajtësi i ngjarjeve të transferimit të të dhënave //nga forma kryesore në voidin e dytë privat btn_mainForm_Click(objekt dërguesi, EventArgs e) ( secondForm = new SecondForm(tb_mainForm.Text.Trim()); secondForm.ShowDialog(); if (secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = secondForm.ReturnData())))

Prandaj, mos harroni të lidhni butonin me ngjarjen Klikoni. Këtu në klasën e formës kryesore ka një fushë SecondForm secondForm, që përfaqëson objektin e formës së dytë. Kur klikoni në butonin "Dërgo", krijohet një formë e dytë (konstruktori i mbingarkuar quhet, ne do ta krijojmë më vonë) dhe niset duke përdorur metodën ShowDialog(). Në këtë rast, kjo metodë është e përshtatshme për ne. Për më tepër, pas kësaj ne sigurohemi që të kontrollojmë nëse formulari i dytë ishte i mbyllur, por klikuar në butonin e tij. Nëse një buton është klikuar në formularin e dytë, atëherë formulari i parë duhet të pranojë të dhëna nga i dyti. Kjo ndodh duke thirrur metodën Të dhënat e kthimit () në formën e dytë.

Tani pjesa më interesante është kodi i formës së dytë:

Përdorimi i Sistemit; duke përdorur System.Collections.Generic; duke përdorur System.ComponentModel; duke përdorur System.Data; duke përdorur System.Drawing; duke përdorur System.Linq; duke përdorur System.Text; duke përdorur System.Windows.Forms; hapësira e emrit From1FormTo2 ( klasa publike e pjesshme SecondForm: Form ( //ndërtues i mbingarkuar publik SecondForm(të dhëna string) ( InitializeComponent(); tb_secondForm.Text = të dhëna; ) //trajtuesi i ngjarjeve të transferimit të të dhënave //nga forma e dytë në atë kryesore, zbrazëti private btn_secondForm_Click (dërguesi i objektit, EventArgs e) ( this.DialogResult = DialogResult.OK; ) //metoda publike për qasjen //fushën e tekstit të kësaj forme string publik ReturnData() ( return (tb_secondForm.Text.Trim()); ) )

Siç mund ta shihni, ekziston një mbingarkesë e vetme e konstruktorit që pranon një lloj vargu. Mos harroni se ne po përpiqemi të transferojmë tekst nga një TextBox. Në konstruktor, komponentët planifikohen të inicializohen dhe teksti i fushës së tekstit vendoset në vlerën e transmetuar nga forma e parë. Më pas, duke u abonuar në ngjarje Klikoni për butonin e formës së dytë, krijuam një mbajtës btn_secondForm_Click, i cili simulon funksionimin e butonit "Ok" të çdo dialog box. Kështu, duke klikuar në butonin “Dërgo” (të formës së dytë), ekzekutojmë kushtin

(secondForm .DialogResult == DialogResult .OK)

Forma e parë, pra, duke e quajtur metodën secondForm .ReturnData(), ne vendosim fushën e tekstit të formës së parë në vlerën e fushës së tekstit të formës së dytë.

Funksionimi i kësaj metode, mendoj, nuk kërkon më shpjegim. Ai thjesht e kthen tekstin nga një fushë e vetme teksti, duke e mbajtur atë private.

Si rezultat, ne transferuam të dhënat në formën e dytë nga e para dhe nga e dyta në të parën pa shkelur parimet e kapsulimit.

Provoni të futni tekstin "aaa" në fushën e tekstit të formularit të parë dhe të klikoni butonin. Këtë tekst do ta shihni në fushën e tekstit në formën e dytë që hapet. Provoni ta ndryshoni tekstin në "aaa ppp" dhe klikoni në butonin. Do të shihni se si, pas mbylljes së formularit të dytë, ky tekst do të shfaqet në fushën e tekstit të formularit kryesor.

Tani, mendoj se do të jeni në gjendje t'i transferoni të dhënat midis formularëve më saktë. Në artikullin vijues do të flasim se si ta bëjmë atë në aplikacionet ASP.NET.

Përkundër faktit se mendimi im për Visual Studio të Microsoft është ende i njëjtë, ndonjëherë duhet të bësh diçka për të. Nëse pajtohemi me faktin se ne shkruajmë, në fakt, jo në C++, por në të ashtuquajturën C++/CLI, puna me komponentë vizuale të njohura nuk do të jetë aq e ndryshme nga të njëjtat mjedise Borland. Por mund të krijojë probleme, në krahasim me Builder, le të shqyrtojmë 3 situata tipike të punës me një aplikacion që përmban më shumë se një formë.

Një shembull i ndërtimit dhe thirrjes programatike të një forme

Ky kod mund të ekzekutohet, për shembull, duke klikuar një buton në formën kryesore Form1.

Form^form2 = gcnew Form(); Butoni^ button2 = gcnew Button(); button2->Text = L"OK"; butoni2->Vendndodhja = Pika(10,10); form2->Text = L"Dritarja ime"; form2->HelpButton = e vërtetë; form2->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog; form2->StartPosition = FormStartPosition::CenterScreen; forma2->Kontrollet->Shto(butoni2); form2->ShowDialog();

Për të shtuar një mbajtës për klikim të një butoni të krijuar në mënyrë programore2, thjesht shkruani përpara rreshtit të fundit të kodit:

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

Përpara se të thirret metoda form2->ShowDialog() ose form2->Show();

Në këtë rast, kodi i mbajtësit ndodhet në modulin aktual Form1.h:

Privat: Sistemi:: Butoni i zbrazët2_Klikoni(Sistemi::Objekti^ dërguesi, Sistemi::EventArgs^ e) (Kutia e mesazheve:: Shfaq ("Këtu"); )

Thirrni një formë tjetër nga forma kryesore

Në meny, zgjidhni Projekt - Shto një element të ri - Forma - Emri Form2

Le të shtojmë një operator

#include "Form2.h"

përpara hapësirës së parë të emrave në Form1.h (d.m.th., në fillim të skedarit).

Le të përfshijmë një tregues për shembullin e klasës në seksionin publik të klasës Form1:

Forma2^F2;

Le të shtojmë kodin ku duhet të krijojmë dhe të thërrasim formularin e dytë:

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

Për të fshirë në mënyrë programore formën e dytë, kodi i mëposhtëm është i përshtatshëm:

F2 F2;

Duhet të theksohet se treguesi ruan adresën e vetëm një formulari, atij që është krijuar i fundit. Nëse krijojmë në mënyrë sekuenciale disa forma duke përdorur këtë kod, vetëm i fundit do të fshihet. Përndryshe, provoni grupin e formave të përshkruar më poshtë.

Le të përshkruajmë të dhënat e nevojshme në klasën e formularit Form1 (këtu emri dhe hapësira e emrit të projektit Tabulator, nëse është e nevojshme, zëvendësojeni me tuajin):

Const statike int MAX_FORMS = 100; //Numri maksimal i formularëve në FormCount; //Formoni një grup numërues ^F2; //Treguesi drejt një grupi formash

Pastaj ne inicializojmë të dhënat duke përdorur ngjarjen Load të formës kryesore:

FormCount=0; F2 = grup gcnew (MAX_FORMA);

Pastaj ne implementojmë kodin për të krijuar formularin tjetër

Nëse (FormCount Shfaqje(); ) else MessageBox::Show("Shumë forma!");

dhe heqja e tij:

Nëse (FormCount) (fshini F2; FormCount--;)

Nëse duam të krijojmë forma fëmijë jo veçmas, por brenda formës prind, atëherë në vetitë e Form1 duhet të tregojmë se është një "paraardhës" (vendosni vetinë IsMdiParent = e vërtetë), dhe përpara se të shfaqim formën e fëmijës duke përdorur F2->Trego operatorin(), shënojeni si fëmijë Form1:

F2->MdiParent = kjo;

Thirrni një metodë të formularit prind nga një formular fëmijë

Vështirë se mund të bëjmë pa përdorur skedarë .cpp, gjë që nuk është e keqe - shkrimi i kodit në skedarët .h në përgjithësi thyen sistemin e duhur C :)

Le të përshkruajmë procesin hap pas hapi.

1) Ka 2 forma - Form1 dhe Form2, në Form1 ka një Buton (buton1, do të hapë formën e dytë) dhe Label (label1, këtu do të ndryshojmë tekstin). Në Form2 - butonin1, kur të klikohet, teksti në label1 do të ndryshojë.

2) Meqenëse duhet të kemi akses në të dytin nga forma e parë, dhe nga e dyta në të parën, do të lindë problemi i referencave të kryqëzuara (kur Form1.h i referohet Form2.h, i cili, nga ana tjetër, i referohet përsëri tek Forma1.h) . Për të shmangur këtë, kodin e formularit të parë (Form1), i cili do të ketë akses në formën e dytë (Form2), do ta zhvendosim nga skedari .h në skedarin .cpp. Kështu, ju duhet të krijoni një skedar Form1.cpp.

3) Deklaroni një metodë publike Set në Form1.h në mënyrë që të mund të ndryshoni tekstin e label1 (kodi mund të shkruhet në fund të skedarit, pas #pragma endregion):

Publike: grup i pavlefshëm (String^ tekst) ( label1->Text = tekst; )

4) Në skedarin Form2.h përfshijmë Form1.h (në fillim):

#include "Form1.h"

dhe krijoni një konstruktor që do të pranojë dhe ruajë një lidhje në formën e parë për përdorim të mëtejshëm:

Form2(Form1^ prind) ( InitializeComponent(); prindForm = prind; ) //mund të shkruani një lidhje menjëherë më poshtë: private: Form1^ prindForm;

5) Duke klikuar butonin në Form2, ne do të thërrasim metodën Set të formularit prind:

Privat: Sistemi::Butoni i zbrazët1_Klikoni(Sistemi::Object^ dërguesi, Sistemi::EventArgs^ e) ( prindForm->Set("përshëndetje nga forma2"); parentForm->Shfaq(); this->Fshih(); )

6) Mbetet të hapet forma e dytë në formën e parë. Për ta bërë këtë, lëvizim mbajtësin e klikimeve të butonit nga Form1.h në Form1.cpp, dhe në skedarin .h lëmë vetëm deklaratën e tij.

Përditësimi i fundit: 10/31/2015

Për të shtuar një formë tjetër në projekt, kliko me të djathtën mbi emrin e projektit në dritaren e Solution Explorer dhe zgjidh Shto->Formulari i Windows...

Le t'i japim formës së re një emër, për shembull, Forma2.cs:

Pra, ne kemi shtuar një formë të dytë në projektin tonë. Tani le të përpiqemi të zbatojmë ndërveprimin midis dy formave. Le të themi se forma e parë do të thërrasë formën e dytë kur të klikohet butoni. Së pari, le të shtojmë një buton në formularin e parë, Form1, dhe klikojmë dy herë mbi butonin për të shkuar te skedari i kodit. Pra, do të çojmë te mbajtësi i ngjarjeve të klikimeve të butonit, i cili krijohet si parazgjedhje pasi klikoni dy herë butonin:

Butoni privat i zbrazët1_Click(dërguesi i objektit, EventArgs e) ( )

Tani le të shtojmë kodin për thirrjen e formularit të dytë në të. Forma jonë e dytë quhet Form2, kështu që së pari krijojmë një objekt të kësaj klase dhe më pas për ta shfaqur atë në ekran quajmë metodën Show:

Butoni privat i zbrazët1_Click(dërguesi i objektit, EventArgs e) (Form2 newForm = new Form2(); newForm.Show();

Tani le të bëjmë të kundërtën - në mënyrë që forma e dytë të ndikojë në të parën. Ndërsa forma e dytë nuk di për ekzistencën e të parit. Për ta rregulluar këtë, duhet të transferoni disi informacionin për formën e parë në formën e dytë. Për ta bërë këtë, ne do të përdorim kalimin e një lidhjeje në formular në konstruktor.

Pra, le të kalojmë te formulari i dytë dhe të shkojmë te kodi i tij - kliko me të djathtën mbi formularin dhe zgjidhni View Code. Tani për tani është bosh dhe përmban vetëm një konstruktor. Meqenëse C# mbështet mbingarkimin e metodës, ne mund të krijojmë disa metoda dhe konstruktorë me parametra të ndryshëm dhe të thërrasim njërën prej tyre në varësi të situatës. Pra, le të ndryshojmë skedarin e kodit të formës së dytë në sa vijon:

Përdorimi i Sistemit; duke përdorur System.Collections.Generic; duke përdorur System.ComponentModel; duke përdorur System.Data; duke përdorur System.Drawing; duke përdorur System.Linq; duke përdorur System.Text; duke përdorur System.Threading.Tasks; duke përdorur System.Windows.Forms; hapësira e emrave HelloApp (klasa publike e pjesshme Form2: Form (publik Form2() ( InitializeComponent(); ) Public Form2(Form1 f) (InitializeComponent(); f.BackColor = Ngjyra.Yellow; ) )

Në fakt, sapo shtuam këtu një konstruktor të ri, publik Form2(Form1 f), në të cilin marrim formën e parë dhe vendosim sfondin e tij në të verdhë. Tani le të kalojmë te kodi i formës së parë, ku thirrëm formën e dytë dhe e ndryshojmë atë në vijim:

Butoni privat i zbrazët1_Click(dërguesi i objektit, Argët e ngjarjes e) (Form2 newForm = NewForm2(this); newForm.Show();

Meqenëse në këtë rast fjala kyçe kjo paraqet një referencë për objektin aktual - objektin Form1, atëherë kur krijon një formë të dytë ai do ta marrë atë (lidhjen) dhe do të kontrollojë formën e parë përmes tij.

Tani, pasi klikoni butonin, do të krijohet një formë e dytë, e cila do të ndryshojë menjëherë ngjyrën e formularit të parë.

Ne gjithashtu mund të krijojmë objekte të formës aktuale:

Butoni privat i zbrazët1_Klikoni(dërguesi i objektit, Argët e ngjarjes e) (Form1 newForm1 = Form1 i ri(); newForm1.Show(); Form2 newForm2 = NewForm2(newForm1); newForm2.Show();

Kur punoni me disa forma, duhet të keni parasysh që njëri prej tyre është kryesori - i cili hapet së pari në skedarin Program.cs. Nëse kemi një tufë formularësh të hapur në të njëjtën kohë, atëherë kur mbyllim kryesoren mbyllet i gjithë aplikacioni dhe bashkë me të edhe të gjitha format e tjera.

Ndonjëherë është e nevojshme të aksesoni elementët e një forme nga një tjetër gjatë ekzekutimit të programit. Për shembull, ekziston një formë Form1, prej saj hapim një tjetër Form2 dhe tani, duke punuar në Form2, duhet të aksesojmë elementët e formës mëmë Form1. Kam gjetur disa mënyra për ta bërë këtë.

Metoda 1. Kalimi i një referimi në një ndryshore publike.

Hapësira e emrit WindowsApplication1 (klasa publike e pjesshme Form1: Form (publik Form1() ( InitializeComponent(); ) button private void1_Click(object sender, EventArgs e) (Form2 frm = new Form2(); frm.but1 = this.button1; // dërgo lidhje me butonin në formën Form2 frm.ShowDialog( ) )

Në Form2, ndryshorja të cilës i është kaluar lidhja tani do të korrespondojë me butonin1 nga Form1

Hapësira e emrit WindowsApplication1 ( klasa publike e pjesshme Form2: Form ( Button publik but1; // kjo variabël do të përmbajë një lidhje me butonin1 nga Form1 publike Form2() ( InitializeComponent(); = "test" // ndryshoni tekstin në butonin 1 të Formularit ) )

Metoda e 2-të. Kalimi i lidhjes në formularin e fëmijës.

Thelbi është afërsisht i njëjtë në metodën e parë. Kur hapim Form2, ne kalojmë në të një lidhje me elementin që planifikojmë ta ndryshojmë më vonë.

Hapësira e emrit WindowsApplication1 ( klasa publike e pjesshme Form1: Form ( publike Form1() ( InitializeComponent(); ) button private void1_Click(object sender, EventArgs e) (Form2 frm = New Form2(this.button1); // kaloni një lidhje te butoni në formularin Form2 frm.ShowDialog() ) )

Tani në Form2 duhet të krijojmë një variabël që do të përmbajë një lidhje me këtë buton dhe përmes tij do të aksesojmë butonin në Form1 (rreshtat 5,7,9 dhe 15).

Hapësira e emrave WindowsApplication1 ( klasa publike e pjesshme Form2: Form ( Button privat but1; // kjo ndryshore do të përmbajë një lidhje me butonin e butonit1 nga forma Form1 public Form2(Button but) // merrni një lidhje me butonin në variablin por ( but1 = but; )

Metoda e 3-të. Qasje në të gjithë formularin e prindit.

Për ta bërë këtë, ju duhet të bëni ndryshime në disa skedarë, por në të njëjtën kohë ne do të kemi akses në të gjithë elementët e formularit prind dhe nuk kemi nevojë të kalojmë një lidhje për secilin element, si në metodën 1.

Hapi 1. Në dosje Programi.cs krijoni një variabël publike f1 (rreshti 5).

Hapësira e emrave WindowsApplication1 ( Programi i klasës statike ( Publik statik Form1 f1; // variabli që do të përmbajë një lidhje me formularin Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(forma e re1( ) ) ) )

Hapi 2. Hapja Forma1.Dizajner.cs dhe në të, për elementet që do të duhet të aksesohen nga një formë tjetër, ne ndryshojmë private në publike. Për shembull, le të vendosim butonin1 në Form1 të disponueshëm për ndryshime.

Sistemi Publik.Windows.Forms.Butoni i butonit1; // zëvendësohet private me publike

Hapi 3. Kur krijojmë Form1, ne i caktojmë variablit f1 një lidhje në këtë formë (rreshti 7)

Hapësira e emrit WindowsApplication1 ( klasa publike e pjesshme Form1: Form (publik Form1() ( Program.f1 = kjo; // tani f1 do të jetë një lidhje me formularin Form1 InitializeComponent(); frm = New Form2();

Hapi 4. Tani nga absolutisht çdo formë ose nga çdo klasë mund të aksesoni elementin button1 që ndodhet në Form1 si kjo: Program.f1.button1. Për shembull, lëreni butonin në Form2 të ndryshojë tekstin e butonit në Form1:

Hapësira e emrit WindowsApplication1 ( klasa publike e pjesshme Form2: Form ( publike Form2() ( InitializeComponent(); ) button private void1_Click(object sender, EventArgs e) ( Program.f1.button1.Text = "test"; // Ndrysho tekstin në butoni i formularit Forma1)))