Joskus on tarpeen päästä käsiksi yhden lomakkeen elementteihin toisesta ohjelman suorittamisen aikana. Esimerkiksi on olemassa lomake Form1, josta avaamme toisen Form2:n ja nyt Form2:ssa työskennellessämme on päästävä päälomakkeen Form1 elementteihin. Löysin useita tapoja tehdä tämä.
1. menetelmä. Viittauksen välittäminen julkiseen muuttujaan.
Nimiavaruus WindowsApplication1 ( julkinen osittainen luokka Lomake1: Lomake ( julkinen Form1() ( InitializeComponent(); ) yksityinen void button1_Click(objektin lähettäjä, EventArgs e) ( Form2 frm = new Form2(); frm.but1 = this.button1; // lähetä linkki painikkeeseen muodossa Form2 frm.ShowDialog(); ) ) )
Lomakkeessa 2 muuttuja, johon linkki välitettiin, vastaa nyt lomakkeen 1 button1:tä
Nimiavaruus WindowsApplication1 ( public partial class Form2: Form ( public Button but1; // tämä muuttuja sisältää linkin button1:een lomakkeesta public Form2()) ( InitializeComponent(); ) private void button1_Click(objektin lähettäjä, EventArgs e) ( but1. Text = "testaa"; // muuta lomakkeen 1 ) ) ) painikepainikkeen 1 tekstiä
2. menetelmä. Linkin välittäminen lapsilomakkeeseen.
Olemus on suunnilleen sama ensimmäisessä menetelmässä. Form2:ta avattaessa välitämme siihen linkin elementtiin, jota aiomme muuttaa myöhemmin.
Nimiavaruus WindowsApplication1 ( public partial class Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(this.button1); // välitä linkki painikkeeseen muotoon Form2 frm.ShowDialog(); ) ) )
Nyt Form2:ssa meidän on luotava muuttuja, joka sisältää linkin tähän painikkeeseen ja sen kautta pääsemme lomakkeen 1 painikkeeseen (rivit 5,7,9 ja 15).
Nimiavaruus WindowsApplication1 ( julkinen osittainen luokka Form2: Form ( private Button but1; // tämä muuttuja sisältää linkin painike button1 lomakkeesta Form1 public Form2(Button but) // saa linkin muuttujan mutta ( but1) painikkeeseen = mutta; // nyt but1 on linkki painikkeeseen painike1 InitializeComponent(); ) private void button1_Click(objektin lähettäjä, EventArgs e) ( but1.Text = "testaa"; // muuta lomakkeen 1:n painikkeen 1 tekstiä ) ) )
3. menetelmä. Pääsy koko vanhemman lomakkeeseen.
Tätä varten sinun on tehtävä muutoksia useisiin tiedostoihin, mutta samalla meillä on pääsy kaikkiin päälomakkeen elementteihin, eikä sinun tarvitse välittää linkkiä jokaiseen elementtiin, kuten menetelmässä 1.
Vaihe 1. Tiedostossa Program.cs luo julkinen muuttuja f1 (rivi 5).
Nimitila WindowsApplication1 ( staattinen luokka Ohjelma ( julkinen staattinen Form1 f1; // muuttuja, joka sisältää linkin lomakkeeseen Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1() ) ) ) ) )
Vaihe 2. Avaaminen Form1.Designer.cs ja siinä muutetaan elementtejä, joihin on päästävä toisesta lomakkeesta yksityinen päällä julkinen. Tehdään esimerkiksi lomakkeen 1 button1 muutoksille käytettävissä.
Julkinen System.Windows.Forms.Button button1; // korvattu yksityinen julkisella
Vaihe 3. Luotaessa Form1, annamme muuttujalle f1 linkin tähän lomakkeeseen (rivi 7)
Nimiavaruus WindowsApplication1 ( julkinen osittainen luokka Lomake1: Lomake ( julkinen lomake1() ( Program.f1 = tämä; // nyt f1 on linkki lomakkeeseen Form1 InitializeComponent(); ) yksityinen void button1_Click(objektin lähettäjä, TapahtumaArgs e) ( Lomake2 frm = uusi lomake2(); frm.ShowDialog(); ) ) )
Vaihe 4. Nyt täysin mistä tahansa lomakkeesta tai mistä tahansa luokasta pääset lomakkeella 1 olevaan button1-elementtiin seuraavasti: Program.f1.button1. Esimerkiksi, anna lomakkeen painikkeen muuttaa lomakkeen 1 painikkeen tekstiä:
Nimiavaruus WindowsApplication1 ( public partial class Form2: Form ( public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Program.f1.button1.Text = "test"; // Muuta tekstiä lomakepainike Lomake1 ) ) )
Tässä artikkelissa käsitelty kysymys liittyy todennäköisemmin sovellusarkkitehtuurin rakentamiseen, ei nimenomaan tarkasteltavaan ongelmaan. Tietojen siirtäminen lomakkeesta toiseen ei ole ollenkaan vaikeaa. Tätä varten riittää, että avataan ohjausobjekti, jonka tiedot haluamme saada, eli merkitään se julkisella muokkaajalla. Myös toinen vaihtoehto on mahdollinen. Esimerkiksi ensimmäisessä muodossa luomme toisen muodon objektin välittämällä viittauksen itseemme rakentajalle, eli välittämällä viittauksen ensimmäiseen ensimmäisestä muodosta toiseen
SecondForm secondForm = new SecondForm(this);
Luonnollisesti ennen kuin teet tämän, sinun tulee huolehtia ylikuormituksen luomisesta toisen muodon rakentajalle.
Ja tämä menetelmä on melko yleinen. Yksinkertaisuutensa vuoksi se sisältää kuitenkin monia mahdollisia ongelmia, joista suurin on kapselointiperiaatteen rikkominen. Sanalla sanoen, toisen muodon ei pitäisi tietää mitään ensimmäisen olemassaolosta ja varsinkin sen ei pitäisi pystyä vaikuttamaan siihen.
Ratkaisu tähän ongelmaan on melko yksinkertainen. Katsotaanpa suoraan koodia. Luomme suunnittelijassa päälomakkeen (se käynnistetään, kun sovellus käynnistyy). Laitetaan yksi Tekstilaatikko, Label Ja Painike.
Napsauttamalla painiketta avautuu toinen lomake ja teksti päälomakkeen tekstikentästä siirtyy toisen lomakkeen tekstikenttään. Aluksi toinen muoto näyttää tältä:
Kuten ensimmäisessä, siinä on samat säätimet. Emme tarvitse enempää. Sovelluksen aloituspiste käynnistää päälomakkeen:
Järjestelmän käyttö; käyttäen System.Collections.Generic; käyttäen System.Linq; käyttäen System.Windows.Forms; nimiavaruus From1FormTo2 ( staattinen luokka Ohjelma ( // Sovelluksen päätulopiste. static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) ) )
Päälomakekoodi näyttää tältä:
Järjestelmän käyttö; käyttäen System.Collections.Generic; käyttäen System.ComponentModel; käyttäen System.Data; käyttäen System.Drawing; käyttäen System.Linq; käyttäen System.Text; käyttäen System.Windows.Forms; nimiavaruus From1FormTo2 ( julkinen osaluokka MainForm: Form ( //toinen muoto SecondForm secondForm; //konstruktori public MainForm() ( InitializeComponent(); ) //tiedonsiirtotapahtumakäsittelijä //päälomakkeesta toiseen yksityiseen voidiin btn_mainForm_Click(object lähettäjä, EventArgs e) ( secondForm = new SecondForm(tb_mainForm.Text.Trim()); secondForm.ShowDialog(); if (secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = secondForm.ReturnData());
Siksi älä unohda liittää painiketta tapahtumaan Klikkaus. Täällä päälomakkeen luokassa on kenttä SecondForm secondForm, joka edustaa toista lomakeobjektia. Kun napsautat "Lähetä" -painiketta, luodaan toinen lomake (ylikuormitettu konstruktori kutsutaan, luomme sen myöhemmin) ja käynnistetään menetelmällä ShowDialog(). Tässä tapauksessa tämä menetelmä sopii meille. Lisäksi tämän jälkeen tarkistamme, oliko toinen lomake suljettu, mutta napsauttanut sen painiketta. Jos painiketta napsautettiin toisessa lomakkeessa, ensimmäisen lomakkeen pitäisi hyväksyä tiedot toisesta lomakkeesta. Tämä tapahtuu kutsumalla menetelmää Palautustiedot() toisessa muodossa.
Nyt mielenkiintoisin osa on toisen lomakkeen koodi:
Järjestelmän käyttö; käyttäen System.Collections.Generic; käyttäen System.ComponentModel; käyttäen System.Data; käyttäen System.Drawing; käyttäen System.Linq; käyttäen System.Text; käyttäen System.Windows.Forms; nimiavaruus From1FormTo2 ( julkinen osaluokka SecondForm: Form ( //ylikuormitettu konstruktori julkinen SecondForm(merkkijono data) ( InitializeComponent(); tb_secondForm.Text = data; ) //tiedonsiirtotapahtumakäsittelijä //toisesta lomakkeesta pääasialliseen yksityinen void btn_secondForm_Click (objektin lähettäjä, EventArgs e) ( this.DialogResult = DialogResult.OK; ) //julkinen tapa käyttää //tämän lomakkeen julkisen merkkijonon tekstikenttää ReturnData() ( return (tb_secondForm.Text.Trim()); ) ) )
Kuten näet, on olemassa yksi rakentajan ylikuormitus, joka hyväksyy merkkijonotyypin. Muista, että yritämme siirtää tekstiä TextBoxista. Konstruktorissa komponentit ajoitetaan alustettaviksi ja tekstikentän teksti asetetaan ensimmäisestä lomakkeesta lähetettyyn arvoon. Seuraavaksi tilaamalla tapahtuma Klikkaus toisen lomakkeen painikkeelle loimme käsittelijän btn_secondForm_Click, joka simuloi minkä tahansa valintaikkunan "Ok"-painikkeen toimintaa. Siten, napsauttamalla "Lähetä"-painiketta (toisessa lomakkeessa), suoritamme ehdon
(secondForm .DialogResult == DialogResult .OK)
Ensimmäinen muoto siis kutsuu menetelmää secondForm.ReturnData(), asetamme ensimmäisen lomakkeen tekstikentän toisen lomakkeen tekstikentän arvoon.
Tämän menetelmän toiminta ei mielestäni enää vaadi selityksiä. Se yksinkertaisesti palauttaa tekstin yhdestä tekstikentästä pitäen sen yksityisenä.
Tämän seurauksena siirsimme tiedot toiseen lomakkeeseen ensimmäisestä ja toisesta ensimmäiseen rikkomatta kapseloinnin periaatteita.
Yritä kirjoittaa teksti "aaa" ensimmäisen lomakkeen tekstikenttään ja napsauta painiketta. Näet tämän tekstin tekstikentässä toisessa avautuvassa muodossa. Yritä muuttaa tekstiksi "aaa ppp" ja napsauta painiketta. Näet kuinka toisen lomakkeen sulkemisen jälkeen tämä teksti tulee näkyviin päälomakkeen tekstikenttään.
Nyt uskon, että pystyt siirtämään tietoja lomakkeiden välillä oikein. Seuraavassa artikkelissa puhumme siitä, kuinka se tehdään ASP.NET-sovelluksissa.
Viimeksi päivitetty: 31.10.2015
Jos haluat lisätä projektiin toisen lomakkeen, napsauta hiiren kakkospainikkeella projektin nimeä Solution Explorer -ikkunassa ja valitse Lisää->Windows-lomake...
Annetaan uudelle lomakkeelle jokin nimi, esim. Lomake2.cs:
Joten olemme lisänneet projektiimme toisen lomakkeen. Yritetään nyt toteuttaa vuorovaikutus kahden muodon välillä. Oletetaan, että ensimmäinen lomake kutsuu toista lomaketta, kun painiketta napsautetaan. Lisätään ensin painike ensimmäiseen lomakkeeseen, Form1, ja kaksoisnapsauta painiketta siirtyäksesi kooditiedostoon. Joten siirrymme painikkeen napsautustapahtumakäsittelijään, joka luodaan oletuksena painikkeen kaksoisnapsautuksen jälkeen:
Yksityinen void button1_Click(objektin lähettäjä, EventArgs e) ( )
Lisätään nyt siihen koodi toisen lomakkeen kutsumiseksi. Toisen lomakkeemme nimi on Form2, joten ensin luomme tämän luokan objektin ja sitten kutsumme sen näyttämiseksi näytöllä Show-menetelmäksi:
Yksityinen void button1_Click(objektin lähettäjä, TapahtumaArgs e) ( Lomake2 uusi Lomake = uusi Lomake2(); uusi Lomake.Näytä(); )
Tehdään nyt päinvastoin - niin että toinen muoto vaikuttaa ensimmäiseen. Vaikka toinen muoto ei tiedä ensimmäisen olemassaolosta. Korjataksesi tämän, sinun on jotenkin siirrettävä ensimmäisen lomakkeen tiedot toiseen lomakkeeseen. Käytämme tätä varten linkin välittämistä lomakkeelle rakentajassa.
Joten siirrytään toiseen lomakkeeseen ja siirrytään sen koodiin - napsauta lomaketta hiiren kakkospainikkeella ja valitse Näytä koodi. Toistaiseksi se on tyhjä ja sisältää vain rakentajan. Koska C# tukee metodien ylikuormitusta, voimme luoda useita menetelmiä ja konstruktoreita eri parametreillä ja kutsua niistä yhden tilanteen mukaan. Muutetaan siis toisen lomakkeen kooditiedosto seuraavaksi:
Järjestelmän käyttö; käyttäen System.Collections.Generic; käyttäen System.ComponentModel; käyttäen System.Data; käyttämällä System.Drawingia; käyttäen System.Linq; käyttäen System.Text; käyttäen System.Threading.Tasks; käyttäen System.Windows.Forms; nimiavaruus HelloApp ( julkinen osaluokka Form2: Form ( julkinen Form2() ( InitializeComponent(); ) public Form2(Form1 f) ( InitializeComponent(); f.BackColor = Color.Yellow; ) ) )
Itse asiassa olemme juuri lisänneet tänne uuden rakentajan, julkisen Form2(Form1 f) , jossa saamme ensimmäisen lomakkeen ja asetamme sen taustan keltaiseksi. Siirrytään nyt ensimmäisen lomakkeen koodiin, jossa kutsuimme toista lomaketta ja muutamme sen seuraavaksi:
Yksityinen void-painike1_Napsauta(objektin lähettäjä, TapahtumaArgs e) ( Lomake2 uusi Lomake = uusi Lomake2(tämä); uusi Lomake.Näytä(); )
Koska tässä tapauksessa avainsana tämä edustaa viittausta nykyiseen objektiin - Form1-objektiin, niin toista lomaketta luodessaan se vastaanottaa sen (linkin) ja ohjaa ensimmäistä lomaketta sen kautta.
Nyt painikkeen painamisen jälkeen luodaan toinen lomake, joka muuttaa välittömästi ensimmäisen lomakkeen värin.
Voimme myös luoda nykyisen muodon objekteja:
Yksityinen void-painike1_Napsauta(objektin lähettäjä, TapahtumaArgit e) ( Lomake1 uusi Lomake1 = uusi lomake1(); uusi Lomake1.Näytä(); Lomake2 uusi Lomake2 = uusi lomake2(uusilomake1); uusiLomake2.Näytä(); )
Kun työskentelet useiden lomakkeiden kanssa, sinun on otettava huomioon, että yksi niistä on tärkein - joka käynnistetään ensin Program.cs-tiedostossa. Jos meillä on useita lomakkeita auki samanaikaisesti, kun suljemme päälomakkeen, sulkeutuu koko sovellus ja sen mukana kaikki muut lomakkeet.
järjestelmänvalvojan toimesta
C#:n oppiminen on hidasta. mutta se jatkuu uskollisesti. Juuri äskettäin minä
antoi esimerkin siitä, kuinka toinen avataan yhdestä lomakkeesta Visual C#:ssa. Periaatteessa kaikki on yksinkertaista.
Tänään ilmestyi seuraava tehtävä: käynnistä modaalinen lomake sovelluksen päämuodosta; kun se suljetaan, tämän lomakkeen on välitettävä joitakin tietoja (teksti, ominaisuusarvot jne.) päälomakkeen ohjaimiin. Tätä ongelmaa ei ole mahdollista ratkaista edellisessä lomakkeita koskevassa viestissä kuvatulla menetelmällä, koska tässä tapauksessa luomme yksinkertaisesti uuden lomakeobjektin uusilla arvoilla kaikille ominaisuuksille. Onneksi C#:ssa on ihana roskankerääjä... Mutta pointti ei ole keräilijä, vaan miten avataan lapsilomake C#:ssa ja päästään siitä sitten takaisin päälomakkeeseen?
Aluksi asetetaan alkuperäiset (alku)tiedot.
Niin. Meillä on päähakemuslomake:
Tämä lomake sisältää myös TextBox-nimisen TBDialog-nimisen ja Button-painikkeen, jota meidän tulee napsauttaa:
- Välitä Text-ominaisuuden arvo TBDialogista TBMainille;
- Sulje fDialog;
Katsotaan nyt koko prosessia järjestyksessä.
Ensinnäkin on aina syytä muistaa, että oletusarvoisesti kaikille C#:n ominaisuuksille, muuttujille ja menetelmille on määritetty muuntaja yksityinen– siksi päästäksemme toisesta lomakkeesta ensimmäisen ohjausobjektiin, meidän on asetettava TBMain-muunnin julkinen omillaan. Voit tehdä tämän valitsemalla lomakkeen suunnittelijassa TBMain-elementin, siirtymällä ominaisuusikkunaan ja muuttaa kiinteistön arvoa Muokkaimet
Kanssa yksityinen päällä julkinen
Nyt TBMain näkyy muissa objekteissa. Siirrytään eteenpäin. Jotta voimme avata lomakkeen modaalitilassa, meidän on käytettävä ShowDialog()-metodin kahdesta vaihtoehdosta:
| public DialogResult ShowDialog() ; public DialogResult ShowDialog(IWin32Window omistaja) ; |
Ensimmäisessä tapauksessa menetelmä näyttää lomakkeen modaalisena valintaikkunana, jonka omistajaksi on asetettu nykyinen aktiivinen ikkuna, ja toisessa voimme määrittää itsenäisesti, mistä lomakkeesta tulee modaaliikkunamme omistaja.
Käytetään esimerkiksi ShowDialog()-metodin toista versiota ja näytetään toinen muoto modaalisesti. Tätä varten kirjoitamme seuraavan:
Tässä käytin taas avainsanaa Tämä , joka osoittaa nykyiseen kohteeseen, ts. aseta päälomake omistajaksi ( fMain). Siirrytään nyt suoraan ongelmamme ratkaisemiseen ja vastataan kysymykseen: kuinka siirtää arvoa muodosta toiseen? Jokaisella säätimellä on merkittävä ominaisuus Omistaja - mikä osoittaa vanhemmalle:
Nyt voit ajaa projektin ja varmistaa, että alilomakkeen TextBox-teksti siirtyy täydellisesti ensimmäisen tekstilaatikkoon. Varmuuden vuoksi julkaisen esimerkissä käsitellyn projektin lähdekoodin.
Huolimatta siitä, että mielipiteeni Microsoftin Visual Studiosta on edelleen sama, joskus sille on tehtävä jotain. Jos hyväksymme sen tosiasian, että kirjoitamme itse asiassa emme C++:lla, vaan ns. C++/CLI:llä, työskentely tuttujen visuaalisten komponenttien kanssa ei eroa niin paljon samoista Borland-ympäristöistä. Mutta se voi aiheuttaa ongelmia Builderiin verrattuna. Tarkastellaan 3 tyypillistä työskentelytapaa useamman kuin yhden lomakkeen sisältävän sovelluksen kanssa. Esimerkkiympäristö on ilmainen Visual C++ 2010 Express, oletetaan, että päälomakkeella on oletusnimi Form1.
Esimerkki lomakkeen muodostamisesta ja ohjelmallisesta kutsumisesta
Tämä koodi voidaan suorittaa esimerkiksi napsauttamalla painiketta päälomakkeessa Form1.
Lomake^lomake2 = gcnew Lomake(); Painike^ painike2 = gcnew Button(); button2->Teksti = L"OK"; painike2->Sijainti = Piste(10,10); form2->Teksti = L"Oma ikkuna"; muoto2->OhjeButton = tosi; form2->FormBorderStyle = Järjestelmä::Windows::Forms::FormBorderStyle::FixedDialog; muoto2->AloitusPosition = FormStartPosition::CenterScreen; muoto2->Säätimet->Lisää(painike2); muoto2->NäytäDialog();
Lisää napsautuskäsittelijä ohjelmallisesti luodulle painikepainikkeelle2 kirjoittamalla ennen viimeistä koodiriviä:
Button2->Click += gcnew System::EventHandler(this, &Form1::button2_Click);
Ennen kuin muoto2->ShowDialog() tai form2->Show()-metodi kutsutaan;
Tässä tapauksessa käsittelijän koodi sijaitsee nykyisessä moduulissa Form1.h:
Yksityinen: System::Void button2_Click(System::Object^ lähettäjä, System::EventArgs^ e) ( ViestiBox::Show("Täällä"); )
Kutsu toinen lomake päälomakkeesta
Valitse valikosta Projekti - Lisää uusi elementti - Lomake - nimi Lomake2
Lisätään operaattori
#include "Form2.h"
ennen ensimmäistä nimiavaruutta muodossa Form1.h (eli aivan tiedoston alussa).
Sisällytetään osoitin luokkainstanssiin Form1-luokan julkiseen osioon:
muoto 2^F2;
Lisätään koodi, johon meidän on luotava ja kutsuttava toinen muoto:
F2=gcnewForm2(); F2->Näytä();
Toisen lomakkeen ohjelmallisesti poistamiseen sopii seuraava koodi:
Poista F2;
On huomattava, että osoitin tallentaa vain yhden lomakkeen osoitteen, viimeksi luodun lomakkeen. Jos luomme peräkkäin useita lomakkeita tällä koodilla, vain viimeinen poistetaan. Vaihtoehtoisesti voit kokeilla alla kuvattua muototaulukkoa.
Kuvataan tarvittavat tiedot lomakeluokassa Form1 (tässä Tabulator-projektin nimi ja nimiavaruus, korvaa tarvittaessa omallasi):
Staattinen vakio int MAX_FORMS = 100; //Lomakkeiden enimmäismäärä int FormCount; //Muotoile laskuritaulukko
Sitten alustamme tiedot käyttämällä päälomakkeen Lataa-tapahtumaa:
FormCount=0; F2 = gcnew array
Sitten otamme koodin käyttöön seuraavan lomakkeen luomiseksi
If(FormCount
ja sen poistaminen:
Jos (FormCount) ( poista F2; FormCount--; )
Jos haluamme luoda alilomakkeita ei erikseen, vaan päälomakkeen sisään, meidän on Form1:n ominaisuuksissa ilmoitettava, että se on "esi-isä" (asettaa IsMdiParent-ominaisuus = true), ja ennen kuin alilomake näytetään käyttämällä F2->Näytä()-operaattori, merkitse se lapsiksi Form1:
F2->MdiParent = tämä;
Kutsu ylälomakkeen menetelmä alilomakkeesta
Tuskin pärjäämme ilman .cpp-tiedostoja, mikä ei ole huono asia - koodin kirjoittaminen .h-tiedostoihin yleensä rikkoo oikean C-järjestelmän :)
Kuvataan prosessi vaihe vaiheelta.
1) Lomakkeita on 2 - Lomake1 ja Lomake2, lomakkeella 1 on Button (painike1, avaa toisen lomakkeen) ja Label (tunniste1, tässä muutamme tekstiä). Lomakkeessa 2 - button1, kun sitä napsautetaan, otsikon 1 teksti muuttuu.
2) Koska tarvitsemme pääsyn toiseen ensimmäisestä lomakkeesta ja toisesta ensimmäiseen, syntyy ristiviittausten ongelma (kun Form1.h viittaa muotoon Form2.h, joka puolestaan viittaa jälleen lomakkeelle 1.h) . Tämän välttämiseksi siirrämme ensimmäisen lomakkeen (Form1) koodin, jolla on pääsy toiseen lomakkeeseen (Form2), .h-tiedostosta .cpp-tiedostoon. Siksi sinun on luotava tiedosto Form1.cpp.
3) Ilmoita julkinen Set-metodi Form1.h:ssa, jotta voit muuttaa label1:n tekstiä (koodi voidaan kirjoittaa tiedoston loppuun, #pragma endregion -kohdan jälkeen):
Julkinen: void Set(String^ text) ( etiketti1->teksti = teksti; )
4) Form2.h-tiedostoon sisällytetään Form1.h (alkuun):
#include "Form1.h"
ja luo rakentaja, joka hyväksyy ja tallentaa linkin ensimmäiseen lomakkeeseen myöhempää käyttöä varten:
Form2(Form1^ parent) ( InitializeComponent(); parentForm = vanhempi; ) //voit kirjoittaa linkin heti alle: yksityinen: Form1^ parentForm;
5) Napsauttamalla painiketta Form2:ssa kutsumme ylälomakkeen Set-menetelmää:
Yksityinen: System::Void button1_Click(System::Object^ lähettäjä, System::EventArgs^ e) ( parentForm->Set("hei lomakkeesta2"); parentForm->Näytä(); tämä->Piilota(); )
6) Jäljelle jää avata toinen lomake ensimmäisessä muodossa. Tätä varten siirrämme painikkeen napsautuskäsittelijän Form1.h:sta muotoon Form1.cpp ja .h-tiedostoon jätämme vain sen ilmoituksen.