Annak ellenére, hogy a véleményem a microsoftról vizuális Stúdió mégis néha tenni kell rajta valamit. Ha megbékélünk azzal, hogy ebben az esetben nem C ++-ban írunk, hanem az úgynevezett C ++ / CLI-ben, akkor a szokásos vizuális komponensekkel való munka nem fog annyira különbözni az azonostól. Borland környezet. De problémákat okozhat a Builderhez képest. Nézzünk meg 3 tipikus helyzetet, amikor egy több űrlapot tartalmazó alkalmazással dolgozunk. A példakörnyezet ingyenes Visual C ++ 2010 Express, feltételezzük, hogy a fő űrlap alapértelmezett neve Form1.
Példa egy űrlap létrehozására és programozott meghívására
Ez a kód végrehajtható például egy gomb megnyomásával a Form1 fő űrlapon.
Form^form2 = gcnew Form(); Button^button2 = gcnewButton(); button2->Szöveg = L"OK"; gomb2->Helyszín = Pont(10,10); form2->Szöveg = L"Saját ablak"; form2->HelpButton = igaz; form2->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog; form2->StartPosition = FormStartPosition::CenterScreen; form2->Controls->Add(button2); form2->ShowDialog();
Ha kattintáskezelőt szeretne hozzáadni a programozottan előállított button2-hez, írja be a kód utolsó sora elé:
Button2->Click += gcnew System::EventHandler(this, &Form1::button2_Click);
A form2->ShowDialog() vagy form2->Show() metódus meghívása előtt;
Ezzel egyidejűleg a kezelőkód az aktuális Form1.h modulba kerül:
Privát: System::Vid button2_Click(Rendszer::Object^ feladó, System::EventArgs^ e) ( Üzenetdoboz::Megjelenítés("Itt"); )
Hívjon egy másik űrlapot a fő űrlapról
A menüben válassza a Projekt - Új elem hozzáadása - Űrlap - Név Űrlap2 menüpontot
Adjunk hozzá egy operátort
#include "Form2.h"
a Form1.h első névtér előtt (vagyis a fájl legelején).
Tegyünk egy mutatót az osztálypéldányra a Form1 osztály nyilvános szakaszában:
Form2^F2;
Adjuk hozzá a kódot, ahol létre kell hoznunk és hívjuk meg a második űrlapot:
F2=gcnew Form2(); F2->Megjelenítés();
A második űrlap programozott törléséhez a kód alkalmas
F2 törlése;
Megjegyzendő, hogy a mutató csak egy űrlap címét tárolja, az utoljára létrehozott űrlap címét. Ha ezzel a kóddal több űrlapot hoztunk létre egymás után, csak az utolsó törlődik. Alternatív megoldásként próbálkozzon az alábbiakban ismertetett alakzatok tömbjével.
Írjuk le a szükséges adatokat a Form1 űrlaposztályban (itt a Tabulator projekt neve és névtere, ha szükséges, cserélje ki a sajátjára):
static const int MAX_FORMS = 100; // Maximális összeg forms int FormCount; // Űrlapszámláló tömb
Ezután inicializáljuk az adatokat a fő űrlap Load eseményén:
FormCount=0; F2 = gcnew tömb
Ezután implementáljuk a kódot a következő űrlap létrehozásához
If(FormCount
és eltávolítása:
Ha (FormCount) ( F2 törlése; FormCount--; )
Ha nem külön-külön, hanem a szülőűrlapon belül szeretnénk gyermekalakokat létrehozni, akkor a Form1 tulajdonságoknál jelezni kell, hogy "ős"-ről van szó (az IsMdiParent tulajdonságot állítsa be = true), és mielőtt az utódűrlapot az F2-vel megjelenítené. ->Show() operátor, jelölje meg gyermekként Form1:
F2->MdiParent = ez;
A szülő űrlap metódusának hívása a gyermek űrlapból
Aligha tehetjük meg a .cpp fájlok bevonását, ami nem rossz – a megfelelő C "shnik .h fájljaiba írt kód általában megszakad :)
Bontsuk le a folyamatot lépésről lépésre.
1) 2 űrlap van - Form1 és Form2 , a Form1-en a Button (button1 , megnyitja a második űrlapot) és a Label (label1 , itt megváltoztatjuk a szöveget). Űrlapon - gomb1 , amelyre kattintva megváltozik a felirat1 szövege.
2) Mivel az első formából hozzá kell férnünk a másodikhoz, a másodikhoz pedig az elsőhöz, felvetődik a kereszthivatkozások problémája (amikor a Form1.h Form2.h-re hivatkozik, ami viszont ismét hivatkozik az 1.h) űrlaphoz. Ennek elkerülése érdekében az első űrlap (Form1) kódját, amely hozzáfér a második űrlaphoz (Form2), áthelyezzük a .h fájlból a .cpp fájlba. Ezért létre kell hoznia egy Form1.cpp fájlt.
3) Deklaráljon egy nyilvános Set metódust a Form1.h-ban, hogy módosítsa a label1 szövegét (a kód a fájl végére, a #pragma endregion után írható):
Nyilvános: void Set(String^ szöveg) ( címke1->Szöveg = szöveg; )
4) A Form2.h fájlban szerepeltetjük a Form1.h fájlt (az elején):
#include "Form1.h"
és hozzon létre egy konstruktort, amely elfogadja és tárolja az első űrlap hivatkozását későbbi használatra:
Form2(Form1^ parent) ( InitializeComponent(); parentForm = szülő; ) //egy hivatkozást közvetlenül az alábbiakban adhatsz hozzá: private: Form1^ parentForm;
5) A Form2-ben a gombra kattintva meghívjuk a szülőűrlap Set metódusát:
Privát: System::Void button1_Click(Rendszer::Object^ feladó, System::EventArgs^ e) ( parentForm->Set("hello from form2"); parentForm->Show(); this->Hide(); )
6) Marad az első formában, hogy elkészítse a második forma nyitását. Ehhez vigye át a gombkattintáskezelőt a Form1.h-ből a Form1.cpp-be, és csak a deklarációját hagyja meg a .h fájlban.
Admin által
A C# tanulása lassú. de megy tovább. Nemrég én
példát adott arra, hogyan lehet egy másik űrlapot megnyitni Visual C#-ban. Elvileg minden egyszerű.
Mára a következő feladat jelent meg: indítsunk el egy modális űrlapot az alkalmazás főlapjáról, ennek az űrlapnak bezárva kell átvinnie minden adatot (szöveg, tulajdonságértékek stb.) a főlapon lévő vezérlőkhöz. Ezt a problémát nem lehet az előző űrlapokról szóló bejegyzésben leírt módon megoldani. ebben az esetben egyszerűen létrehozunk egy új űrlapobjektumot új értékekkel az összes tulajdonsághoz. Szerencsére a C #-nek csodálatos szemétgyűjtője van... De a lényeg nem a gyűjtőben van, hanem abban, hogyan lehet C #-ben megnyitni egy gyermekűrlapot, és onnan visszajutni a főbe?
Kezdésként állítsuk be a kezdeti (kezdeti) adatokat.
Így. Megtaláltuk a fő jelentkezési űrlapot:
Ez az űrlap tartalmaz egy TBDialog nevű TextBox-ot és egy gombot is, amelyre kattintva:
- Adja át a Text tulajdonság értékét a TBDialogból a TBMainnek;
- fDialog bezárása;
Most tekintse meg az egész munkafolyamatot rendben.
Először is mindig ne feledje, hogy alapértelmezés szerint a C# minden tulajdonságához, változójához és metódusához módosító van hozzárendelve. magán- ezért ahhoz, hogy a második űrlapról az első vezérlőjére jussunk, be kell állítani a módosítót a TBMain nyilvános egymaga. Ehhez válassza ki a TBMain elemet az űrlapkonstruktorban, lépjen a tulajdonságok ablakba és megváltoztatni az ingatlan értékét Módosítók
Val vel magán tovább nyilvános.
Most a TBMain látható lesz más objektumokban. Továbbmegyünk. Az űrlap modális módban történő megnyitásához a ShowDialog() metódus két lehetőségének egyikét kell használnunk:
| public DialogResult ShowDialog() ; public DialogResult ShowDialog(IWin32Window tulajdonos) ; |
Az első esetben a metódus modális párbeszédpanelként jeleníti meg az űrlapot, amelynek tulajdonosa az aktuális aktív ablak, a második esetben pedig önállóan megadhatjuk, hogy melyik űrlap legyen a tulajdonosa a modális ablakunknak.
Például használjuk a ShowDialog() metódus második változatát, és mutassuk meg modálisan a második formát. Ehhez a következőket írjuk:
Itt ismét a kulcsszót használtam ez , amely az aktuális objektumra mutat, azaz. állítsa be a fő űrlapot tulajdonosként ( fMain). Most közvetlenül a problémánk megoldásához megyünk, és válaszolunk a kérdésre: hogyan lehet értéket átadni egyik formáról a másikra? Mindegyik vezérlőnek van egy csodálatos tulajdonsága Tulajdonos - ami a szülőre mutat:
Most már futtathatja a projektet, és megbizonyosodhat arról, hogy a gyermekűrlap TextBox szövege tökéletesen átkerül az első szövegdobozba. Minden esetre közzéteszem a példában szereplő projekt forráskódját.
Néha a program végrehajtása során egy másik űrlap elemeire kell hivatkozni. Például van egy Form1 űrlap, ahonnan megnyitunk egy másik Form2-t és most a Form2 űrlapon dolgozva el kell érnünk a Form1 szülőűrlap elemeit. Ennek több módját is találtam.
1. mód. Hivatkozás átadása nyilvános változóra.
Névtér WindowsApplication1 ( nyilvános részleges osztály Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(); frm.but1 = this.button1; // pass link a gombra Form2 frm.ShowDialog(); ) ) )
A Form2-ben az a változó, amelyre a hivatkozást átadták, most megfelel a Form1-ből származó button1-nek
Névtér WindowsApplication1 ( nyilvános részleges osztály Form2: Form ( public Button but1; // ez a változó hivatkozást fog tartalmazni a Button1 gombra a Form1-ből public Form2() ( InitializeComponent(); ) ) private void button1_Click(objektum küldője, EventArgs e) ( but1 . Szöveg = "teszt"; // módosítsa a szöveget az 1. űrlap 1. gomb gombján ) ) )
2. út. Hivatkozás átadása gyermekűrlapra.
A lényeg megközelítőleg ugyanaz, akkor az 1. módszerben. A Form2 űrlap megnyitásakor átadunk egy hivatkozást arra az elemre, amelyet később módosítani tervezünk.
Névtér WindowsApplication1 ( nyilvános részleges osztály Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(this.button1); // gombhivatkozás átadása a Form2 űrlaphoz frm.ShowDialog(); ) ) )
Most a Form2-ben létre kell hozni egy változót, amely tartalmazni fogja a gombra mutató hivatkozást, és ezen keresztül elérjük a Form1 gombot (5, 7, 9 és 15 sorok).
Névtér WindowsApplication1 ( nyilvános részleges osztály Form2: Form ( private Button but1; // ez a változó hivatkozást fog tartalmazni a Button1 gombra a Form1-ből public Form2(Button but) // hivatkozást kap a változóban lévő gombra ( de1 = de ; // most a but1 link lesz a button1 InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( but1.Text = "teszt"; // módosítsa a Form1 button1 gombjának szövegét ) ) )
3. út. Hozzáférés a teljes szülői űrlaphoz.
Ehhez több fájlban is módosítanunk kell, ugyanakkor a szülőűrlap minden eleméhez hozzá fogunk férni és nem kell minden elemhez linket átadnunk, mint az 1. metódusnál.
1. lépés. Fájlban Program.cs hozzon létre egy nyilvános f1 változót (5. sor).
Névtér WindowsApplication1 ( statikus osztály Program ( nyilvános statikus Form1 f1; // változó, amely a Form1 static void Main() hivatkozást tartalmazza ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1())) ; ) ) )
2. lépés Nyitunk Form1.Designer.csés benne azokhoz az elemekhez, amelyeket egy másik űrlapról kell majd elérni, változtatunk magán tovább nyilvános. Például tegyük elérhetővé az 1. gombot az 1. űrlap módosításához.
Nyilvános System.Windows.Forms.Button button1; // privátról nyilvánosra változott
3. lépés. A Form1 űrlap létrehozásakor az f1 változóhoz egy hivatkozást rendelünk ehhez az űrlaphoz (7. sor)
Névtér WindowsApplication1 ( nyilvános részleges osztály Form1: Form ( public Form1() ( Program.f1 = ez; // most az f1 hivatkozás lesz a Form1 InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(); frm.ShowDialog(); ) ) )
4. lépés Most teljesen bármilyen űrlapról vagy bármely osztályból elérheti a Form1-en található button1 elemet így: Program.f1.button1. Például legyen egy gomb a Form2-ben, és módosítsa a gomb szövegét Form1-re:
Névtér WindowsApplication1 ( nyilvános részleges osztály Form2: Form ( public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Program.f1.button1.Text = "teszt"; // Módosítsa a szöveget a űrlap gomb Form1 ) ) )
A jelen cikkben tárgyalt probléma inkább az alkalmazásarchitektúra témájához kapcsolódik, nem pedig a vizsgált konkrét problémához. Az adatok egyik űrlapról a másikra való átadása egyáltalán nem nehéz. Ehhez elég azt a vezérlőt, amelynek az adatait fogadni szeretnénk, megnyitni, vagyis a publikus módosítóval megjelölni. Ezenkívül egy másik lehetőség is lehetséges. Például az első formában úgy hozunk létre egy második formájú objektumot, hogy magunkra való hivatkozást adunk át a konstruktornak, vagyis az első formáról a második alakra átadunk egy hivatkozást az elsőre.
SecondForm secondForm = new SecondForm(this);
Természetesen, mielőtt ezt megtenné, gondoskodnia kell a második űrlapkonstruktor túlterheléséről.
És ez a módszer meglehetősen gyakori. Azonban egyszerűségével számos lehetséges problémát hoz, amelyek közül a fő a tokozás elvének megsértése. Egyszóval a második forma ne tudjon semmit az első létezéséről, és még inkább ne tudjon befolyásolni.
A probléma megoldása meglehetősen egyszerű. Menjünk közvetlenül a kódhoz. A tervezőben elkészítjük a fő űrlapot (az alkalmazás indulásakor elindul). Tegyünk egyet szövegdoboz, címkeÉs gomb.
A gombra kattintva megnyílik a második űrlap, és a fő űrlap szövegmezőjéből a szöveg átkerül a második űrlap szövegmezőjébe. Kezdetben a második forma így néz ki:
Az elsőhöz hasonlóan ez is ugyanazokkal a vezérlőkkel rendelkezik. Nincs szükségünk többre. Az alkalmazás belépési pontja elindítja a fő űrlapot:
Rendszer használata; a System.Collections.Generic használatával; a System.Linq; a System.Windows.Forms használatával; névtér From1FormTo2 ( static class Program ( // Az alkalmazás fő belépési pontja. static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) ) )
A fő űrlapkód így néz ki:
Rendszer használata; a System.Collections.Generic használatával; a System.ComponentModel használatával; a System.Data használatával; a System.Drawing használatával; a System.Linq; a System.Text használatával; a System.Windows.Forms használatával; névtér From1FormTo2 ( publikus részleges osztály MainForm: Form ( //második űrlap SecondForm secondForm; //konstruktor public MainForm() ( InitializeComponent(); ) //adatátviteli eseménykezelő //a főűrlapról a második privát voidba btn_mainForm_Click(object feladó, EventArgs e) ( secondForm = new SecondForm(tb_mainForm.Text.Trim()); secondForm.ShowDialog(); if (secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = secondForm.ReturnData());
Ennek megfelelően ne felejtse el csatlakoztatni a gombot az eseményhez Kattintson. Itt, a főforma osztályban van egy mező SecondForm secondForm A, amely a második alakzat objektumot képviseli. A „Küldés” gombra kattintva létrejön egy második űrlap (a túlterhelt konstruktor meghívásra kerül, később elkészítjük), és a metódussal elindul. ShowDialog(). Ebben az esetben ez a módszer megfelel nekünk. Sőt, ezek után mindenképpen ellenőrizzük, hogy nem zártuk-e be a második űrlapot, hanem kattintottunk a gombjára. Ha a második űrlapon egy gombra kattintott, akkor az első űrlap a másodiktól kap adatokat. Ez a metódus meghívásával történik ReturnData() a második formában.
Most a legérdekesebb rész a második űrlap kódja:
Rendszer használata; a System.Collections.Generic használatával; a System.ComponentModel használatával; a System.Data használatával; a System.Drawing használatával; a System.Linq; a System.Text használatával; a System.Windows.Forms használatával; névtér From1FormTo2 ( nyilvános részleges osztály SecondForm: Form ( //túlterhelt konstruktor public SecondForm(string data) ( InitializeComponent(); tb_secondForm.Text = data; ) ) //adatátviteli eseménykezelő //a második űrlapról a főűrlapra private void btn_secondForm_Click (objektum küldője, EventArgs e) ( this.DialogResult = DialogResult.OK; ) //nyilvános metódus az űrlap szövegmezőjének elérésére //. ReturnData() ( return (tb_secondForm.Text.Trim()); ) ) )
Amint látható, a konstruktor egyetlen túlterheltsége van, amely elfogad egy karakterlánctípust. Ne feledje, hogy szöveget szövegdobozból próbálunk átadni. A konstruktorban a komponensek inicializálása ütemezve van, és a szövegmező szövege az első űrlapról átadott értékre van beállítva. Következő: feliratkozás az eseményre Kattintson a második űrlap gombjához létrehoztunk egy kezelőt btn_secondForm_Click, amely bármely párbeszédpanel "Ok" gombjának működését szimulálja. Így a „Küldés” gombra kattintva (a második űrlapon) végrehajtjuk a feltételt
(secondForm .DialogResult == DialogResult .OK)
Az első forma tehát a módszert hívja secondForm.ReturnData(), az első űrlap szövegmezőjét a második űrlap szövegmezőjének értékére állítjuk be.
Munka ez a módszer Azt hiszem, nem kell további magyarázat. Egyszerűen visszaadja a szöveget egyetlen szövegmezőből, miközben magánjellegű marad.
Ennek eredményeként az elsőről a második űrlapra, a másodikról pedig az elsőre vittünk át adatokat anélkül, hogy megsértettük volna a tokozás elveit.
Próbálja meg beírni az "aaa" szöveget az első űrlap szövegmezőjébe, és kattintson a gombra. A megnyitott második formában ezt a szöveget a szövegdobozában fogja látni. Módosítsa a szöveget "aaa ppp"-re, és kattintson a gombra. A második űrlap bezárása után látni fogja, hogyan adott szöveget megjelenik a fő űrlap szövegmezőjében.
Most úgy gondolom, hogy helyesebben fogja végrehajtani az adatátvitelt az űrlapok között. A következő cikkben arról fogunk beszélni, hogyan működik az ASP.NET alkalmazásokban.
Utolsó frissítés: 2015.10.31
Ha másik űrlapot szeretne hozzáadni a projekthez, kattintson a projekt nevére a Megoldásböngésző ablakban (Solution Explorer) Jobb klikk egérrel, és válassza a Hozzáadás(Hozzáadás)->Windows űrlap...
Adjunk nevet az új űrlapnak, pl. Form2.cs:
Tehát hozzáadtunk egy második űrlapot a projekthez. Most próbáljuk meg megvalósítani a két forma közötti interakciót. Tegyük fel, hogy az első űrlap meghívja a második űrlapot, amikor a gombra kattintanak. Először adjunk hozzá egy gombot az első Form1 űrlaphoz, és kattintson duplán a gombra a kódfájl eléréséhez. Így belépünk a gombkattintás eseménykezelőjébe, amely alapértelmezés szerint a gombra dupla kattintás után jön létre:
Privát void button1_Click(objektum feladó, EventArgs e) ( )
Most adjuk hozzá a második űrlap hívókódját. A második űrlapunkat Form2-nek hívják, így először létrehozunk egy objektumot ebből az osztályból, majd meghívjuk a Show metódust, hogy megjelenítsük a képernyőn:
Privát void button1_Click(objektum feladó, EventArgs e) ( Form2 newForm = new Form2(); newForm.Show(); )
Most tegyük az ellenkezőjét – úgy, hogy a második forma az elsőt érintse. Míg a második forma nem tud az első létezéséről. Ennek kijavításához valahogyan át kell vinnie az első űrlapra vonatkozó információkat a második űrlapra. Ehhez az űrlapra mutató hivatkozást fogunk átadni a konstruktorban.
Tehát menjünk tovább a második űrlapra, és térjünk át annak kódjára - kattintson a jobb gombbal az űrlapra, és válassza a Kód megtekintése (Kód megtekintése) lehetőséget. Míg üres és csak konstruktort tartalmaz. Mivel a C# támogatja a metódusok túlterhelését, több metódust és konstruktort is létrehozhatunk különböző paraméterekkel, és a helyzettől függően egyet meghívhatunk belőlük. Tehát változtassuk meg a második űrlap kódfájlját a következőre:
Rendszer használata; a System.Collections.Generic használatával; a System.ComponentModel használatával; a System.Data használatával; a System.Drawing használatával; a System.Linq; a System.Text használatával; a System.Threading.Tasks használatával; a System.Windows.Forms használatával; névtér HelloApp ( nyilvános részleges osztály Form2: Form ( public Form2() ( InitializeComponent(); ) public Form2(Form1 f) ( InitializeComponent(); f.BackColor = Color.Yellow; ) ) )
Valójában egy új publikus Form2(Form1 f) konstruktort adtunk ide, amelyben megkapjuk az első űrlapot, és sárgára állítjuk a hátterét. Most menjünk az első űrlap kódjához, ahol meghívtuk a második űrlapot, és változtassa meg a következőre:
Privát void button1_Click(objektum feladó, EventArgs e) ( Form2 newForm = new Form2(this); newForm.Show(); )
Mert ebben az esetben kulcsszó ez egy hivatkozást jelent az aktuális objektumra - a Form1 objektumra, majd a második űrlap létrehozásakor megkapja azt (a hivatkozást), és ezen keresztül kezeli az első űrlapot.
Most a gombra kattintás után létrehozunk egy második űrlapot, amely azonnal megváltoztatja az első űrlap színét.
Az aktuális űrlaphoz objektumokat is létrehozhatunk:
Privát void button1_Click(objektum küldő, EventArgs e) ( Form1 newForm1 = new Form1(); newForm1.Show(); Form2 newForm2 = new Form2(newForm1); newForm2.Show(); )
Ha több űrlappal dolgozik, ne feledje, hogy az egyik a fő – amely először indul el a Program.cs fájlban. Ha egy csomó űrlapunk van egyszerre nyitva, akkor a fő bezárásakor a teljes alkalmazás bezárul, és ezzel együtt az összes többi űrlap is.
Betöltés...