Pinakabagong update: 31.10.2015

Upang magdagdag ng isa pang form sa proyekto, mag-right click sa pangalan ng proyekto sa window ng Solution Explorer at piliin ang Add->Windows Form...

Pagbigyan natin bagong anyo ilang pangalan, halimbawa, Form2.cs:

Kaya, nagdagdag kami ng pangalawang form sa aming proyekto. Ngayon, subukan nating ipatupad ang pakikipag-ugnayan sa pagitan ng dalawang anyo. Sabihin nating tatawagin ng unang form ang pangalawang form kapag na-click ang button. Una, magdagdag tayo ng button sa unang form, Form1, at i-double click ang button para pumunta sa code file. Kaya, dadalhin tayo sa tagapangasiwa ng kaganapan sa pag-click ng button, na ginawa bilang default pagkatapos i-double click ang button:

Pribadong void button1_Click(tagapadala ng object, EventArgs e) ( )

Ngayon, idagdag natin ang code para sa pagtawag sa pangalawang form dito. Ang aming pangalawang form ay tinatawag na Form2, kaya una kaming lumikha ng isang bagay ng klase na ito, at pagkatapos ay upang ipakita ito sa screen na tinatawag namin ang Show method:

Pribadong void button1_Click(object sender, EventArgs e) ( Form2 newForm = new Form2(); newForm.Show(); )

Ngayon gawin natin ang kabaligtaran - upang ang pangalawang anyo ay makakaapekto sa una. Habang ang pangalawang anyo ay hindi alam ang tungkol sa pagkakaroon ng una. Upang ayusin ito, kailangan mong ilipat ang impormasyon tungkol sa unang form sa pangalawang form. Upang gawin ito, gagamitin namin ang pagpasa ng isang link sa form sa constructor.

Kaya't lumipat tayo sa pangalawang form at pumunta sa code nito - i-right-click sa form at piliin ang View Code. Sa ngayon ito ay walang laman at naglalaman lamang ng isang constructor. Dahil sinusuportahan ng C# ang overloading ng pamamaraan, maaari tayong lumikha ng ilang mga pamamaraan at konstruktor na may iba't ibang mga parameter at tumawag sa isa sa mga ito depende sa sitwasyon. Kaya, baguhin natin ang code file ng pangalawang form sa sumusunod:

Paggamit ng System; gamit ang System.Collections.Generic; gamit ang System.ComponentModel; gamit ang System.Data; gamit ang System.Drawing; gamit ang System.Linq; gamit ang System.Text; gamit ang System.Threading.Tasks; gamit ang System.Windows.Forms; namespace HelloApp ( public partial class Form2: Form ( public Form2() ( InitializeComponent(); ) public Form2(Form1 f) ( InitializeComponent(); f.BackColor = Color.Yellow; ) ) )

Sa katunayan, dinagdag lang namin dito bagong constructor pampublikong Form2(Form1 f) kung saan nakukuha natin ang unang form at itinakda ang background nito sa dilaw. Ngayon ay lumipat tayo sa code ng unang form, kung saan tinawag namin ang pangalawang form at baguhin ito sa sumusunod:

Pribadong void button1_Click(tagapadala ng object, EventArgs e) ( Form2 newForm = new Form2(this); newForm.Show(); )

Since in sa kasong ito ang keyword na ito ay kumakatawan sa isang link sa kasalukuyang object - ang Form1 object, pagkatapos kapag lumilikha ng pangalawang form ay matatanggap nito ito (ang link) at kontrolin ang unang form sa pamamagitan nito.

Ngayon, pagkatapos ng pag-click sa pindutan, isang pangalawang form ay malilikha, na agad na magbabago sa kulay ng unang form.

Maaari din tayong lumikha ng mga bagay ng kasalukuyang anyo:

Pribadong void button1_Click(tagapadala ng object, EventArgs e) ( Form1 newForm1 = bagong Form1(); newForm1.Show(); Form2 newForm2 = bagong Form2(newForm1); newForm2.Show(); )

Kapag nagtatrabaho sa ilang mga form, dapat mong isaalang-alang na ang isa sa mga ito ay ang pangunahing isa - na unang inilunsad sa Program.cs file. Kung mayroon kaming isang grupo ng mga form na bukas nang sabay-sabay, pagkatapos ay kapag isinara namin ang pangunahing isa, ang buong aplikasyon ay magsasara at kasama nito ang lahat ng iba pang mga form.

Minsan kinakailangan upang ma-access ang mga elemento ng isang form mula sa isa pa sa panahon ng pagpapatupad ng programa. Halimbawa, mayroong isang form na Form1, mula dito ay nagbubukas kami ng isa pang Form2 at ngayon, nagtatrabaho sa Form2, kailangan naming i-access ang mga elemento ng parent form na Form1. Nakakita ako ng ilang paraan para gawin ito.

1st method. Pagpasa ng reference sa isang pampublikong variable.

Namespace WindowsApplication1 ( public partial class Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(); frm.but1 = this.button1; // send link sa button sa form na Form2 frm.ShowDialog();

Sa Form2, ang variable kung saan naipasa ang link ay tumutugma na ngayon sa button1 mula sa Form1

Namespace WindowsApplication1 ( public partial class Form2: Form ( public Button but1; // this variable will contain a link to button1 from Form1 public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( but1. Text = "test"; // baguhin ang teksto sa button na button1 ng Form1 ) ) )

ika-2 paraan. Pagpasa ng link sa form ng bata.

Ang kakanyahan ay humigit-kumulang pareho sa 1st na paraan. Kapag binubuksan ang Form2, ipinapasa namin dito ang isang link sa elemento na plano naming baguhin sa ibang pagkakataon.

Namespace WindowsApplication1 ( public partial class Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = new Form2(this.button1); // ipasa ang isang link sa button sa form na Form2 frm.ShowDialog();

Ngayon sa Form2 kailangan nating gumawa ng variable na maglalaman ng link sa button na ito at sa pamamagitan nito ay maa-access natin ang button sa Form1 (linya 5,7,9 at 15).

Namespace WindowsApplication1 ( public partial class Form2: Form ( private Button but1; // ang variable na ito ay maglalaman ng link papunta sa button button1 mula sa form Form1 public Form2(Button but) // kumuha ng link sa button sa variable but ( but1 = but; // ngayon but1 ay magiging isang link sa button na button1 InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( but1.Text = "test"; // baguhin ang text sa button1 ng Form1 ) ) )

ika-3 paraan. Access sa buong form ng magulang.

Upang gawin ito, kailangan mong gumawa ng mga pagbabago sa ilang mga file, ngunit sa parehong oras ay magkakaroon kami ng access sa lahat ng mga elemento ng parent form at hindi na kailangang magpasa ng isang link sa bawat elemento, tulad ng sa pamamaraan 1.

Hakbang 1. Nasa file Program.cs lumikha ng pampublikong variable f1 (linya 5).

Namespace WindowsApplication1 ( static class Program ( public static Form1 f1; // variable na maglalaman ng link sa form na Form1 static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1() ) );)))

Hakbang 2. Pagbubukas Form1.Designer.cs at sa loob nito, para sa mga elemento na kailangang ma-access mula sa ibang form, nagbabago kami pribado sa pampubliko. Halimbawa, gawin nating available ang button1 sa Form1 para sa mga pagbabago.

Pampublikong System.Windows.Forms.Button button1; // pinalitan ng pribado ng pampubliko

Hakbang 3. Kapag gumagawa ng Form1, nagtatalaga kami ng variable f1 ng link sa form na ito (linya 7)

Namespace WindowsApplication1 ( public partial class Form1: Form ( public Form1() ( Program.f1 = this; // now f1 will be a link to the form Form1 InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Form2 frm = bagong Form2();

Hakbang 4. Ngayon mula sa ganap na anumang anyo o mula sa anumang klase maaari mong ma-access ang button1 na elemento na matatagpuan sa Form1 tulad nito: Program.f1.button1. Halimbawa, hayaan ang button sa Form2 na baguhin ang button na text sa Form1:

Namespace WindowsApplication1 ( public partial class Form2: Form ( public Form2() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( Program.f1.button1.Text = "test"; // Baguhin ang text sa pindutan ng form Form1 ) ) )

Sa kabila ng katotohanan na ang aking opinyon tungkol sa Visual Studio ng Microsoft ay pareho pa rin, kung minsan kailangan mong gumawa ng isang bagay dito. Kung maiintindihan natin ang katotohanang sumusulat tayo, sa katunayan, hindi sa C++, ngunit sa tinatawag na C++/CLI, ang pagtatrabaho sa mga pamilyar na visual na bahagi ay hindi magiging iba sa parehong mga kapaligiran ng Borland. Ngunit maaari itong lumikha ng mga problema, kumpara sa Builder Isaalang-alang natin ang 3 karaniwang mga sitwasyon ng pagtatrabaho sa isang application na naglalaman ng higit sa isang form.

Isang halimbawa ng pagbuo at pagtawag sa isang form gamit ang program

Maaaring isagawa ang code na ito, halimbawa, sa pamamagitan ng pag-click sa isang button sa pangunahing form na Form1.

Form^form2 = gcnew Form(); Button^ button2 = gcnew Button(); button2->Text = L"OK"; button2->Lokasyon = Point(10,10); form2->Text = L"Aking window"; form2->HelpButton = totoo; form2->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog; form2->StartPosition = FormStartPosition::CenterScreen; form2->Controls->Add(button2); form2->ShowDialog();

Upang magdagdag ng tagapangasiwa ng pag-click para sa button na nabuong programmatically2, isulat lang bago ang huling linya ng code:

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

Bago tawagin ang form2->ShowDialog() o form2->Show() na paraan;

Sa kasong ito, ang handler code ay matatagpuan sa kasalukuyang module na Form1.h:

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

Tumawag sa isa pang form mula sa pangunahing form

Sa menu, piliin ang Project - Magdagdag ng bagong elemento - Form - pangalan Form2

Magdagdag tayo ng operator

#include "Form2.h"

bago ang unang namespace sa Form1.h (iyon ay, sa pinakadulo simula ng file).

Isama natin ang isang pointer sa instance ng klase sa pampublikong seksyon ng klase ng Form1:

Form2^F2;

Idagdag natin ang code kung saan kailangan nating gumawa at tawagan ang pangalawang form:

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

Upang ma-programmatically tanggalin ang pangalawang form, ang sumusunod na code ay angkop:

Tanggalin ang F2;

Dapat tandaan na ang pointer ay nag-iimbak ng address ng isang form lamang, ang isa na huling ginawa. Kung sunud-sunod tayong gagawa ng ilang form gamit ang code na ito, ang huli lang ang tatanggalin. Bilang kahalili, subukan ang hanay ng hugis na inilarawan sa ibaba.

Ilarawan natin ang kinakailangang data sa klase ng form ng Form1 (dito ang pangalan at namespace ng proyekto ng Tabulator, kung kinakailangan, palitan ng sarili mo):

Static const int MAX_FORMS = 100; //Maximum na bilang ng mga form int FormCount; //Bumuo ng counter array ^F2; //Ituro ang isang hanay ng mga form

Pagkatapos ay sinisimulan namin ang data gamit ang kaganapan sa Pag-load ng pangunahing form:

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

Pagkatapos ay ipinatupad namin ang code upang lumikha ng susunod na form

Kung(FormCount Ipakita();

) else MessageBox::Show("Masyadong maraming form!");

at ang pagtanggal nito:

Kung (FormCount) ( tanggalin ang F2; FormCount--; )

Kung nais naming lumikha ng mga form ng bata nang hindi hiwalay, ngunit sa loob ng form ng magulang, pagkatapos ay sa mga katangian ng Form1 kailangan naming ipahiwatig na ito ay isang "ninuno" (itakda ang IsMdiParent property = true), at bago ipakita ang form ng bata gamit ang F2->Show() operator, markahan ito bilang isang bata Form1:

F2->MdiParent = ito;

Tumawag ng paraan ng form ng magulang mula sa form ng bata

Halos hindi namin magagawa nang hindi gumagamit ng mga .cpp na file, na hindi masama - ang pagsulat ng code sa mga .h na file ay karaniwang sinisira ang tamang C system :)

Ilarawan natin ang proseso nang hakbang-hakbang.

1) Mayroong 2 form - Form1 at Form2, sa Form1 ay mayroong Button (button1, magbubukas sa pangalawang form) at Label (label1, dito natin babaguhin ang text). Sa Form2 - button1, kapag na-click, magbabago ang text sa label1.

2) Dahil kailangan nating magkaroon ng access mula sa unang anyo hanggang sa pangalawa, at mula sa pangalawa hanggang sa una, ang problema ng mga cross-reference ay lilitaw (kapag ang Form1.h ay tumutukoy sa Form2.h, na, naman, ay muling tumutukoy sa Form1.h). Upang maiwasan ito, ililipat namin ang code ng unang form (Form1), na magkakaroon ng access sa pangalawang form (Form2), mula sa .h file patungo sa .cpp file. Kaya, kailangan mong lumikha ng isang file na Form1.cpp. 3) Ipahayag Itakda sa Form1.h para mapalitan mo ang text ng label1 (maaaring isulat ang code sa dulo ng file, pagkatapos ng #pragma endregion):

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

4) Sa Form2.h file isinama namin ang Form1.h (sa simula):

#include "Form1.h"

at lumikha ng isang constructor na tatanggap at magse-save ng isang link sa unang form para sa karagdagang paggamit:

Form2(Form1^ parent) ( InitializeComponent(); parentForm = parent; ) //maaari kang sumulat ng link kaagad sa ibaba: pribado: Form1^ parentForm;

5) Sa pag-click sa button sa Form2, tatawagin namin ang Set method ng parent form:

Pribado: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) ( parentForm->Set("hello from form2"); parentForm->Show(); this->Hide(); )

6) Ito ay nananatiling buksan ang pangalawang anyo sa unang anyo. Upang gawin ito, inililipat namin ang handler ng pag-click ng button mula sa Form1.h patungo sa Form1.cpp , at sa .h file ay iniiwan lamang namin ang deklarasyon nito.

Sa pamamagitan ng admin.

Ang pag-aaral ng C# ay mabagal. ngunit ito ay patuloy na tapat. Kamakailan lang ako
nagbigay ng isang halimbawa kung paano magbukas ng isa pa mula sa isang form sa Visual C#. Sa prinsipyo, ang lahat ay simple.

Ngayon ay lumitaw ang sumusunod na gawain: maglunsad ng isang modal form mula sa pangunahing anyo ng application kapag isinara, ang form na ito ay dapat magpasa ng ilang data (teksto, mga halaga ng ari-arian, atbp.) sa mga kontrol sa pangunahing form; Hindi posible na malutas ang problemang ito gamit ang pamamaraang inilarawan sa nakaraang post tungkol sa mga form, dahil sa kasong ito, lumikha lamang kami ng isang bagong form na bagay na may mga bagong halaga para sa lahat ng mga katangian. Sa kabutihang palad, ang C # ay may isang kahanga-hangang kolektor ng basura ... Ngunit ang punto ay hindi ang kolektor, ngunit kung paano buksan ang isang form ng bata sa C #, at pagkatapos ay bumalik sa pangunahing form mula dito?

Upang magsimula, itakda natin ang paunang (paunang) data.

Kaya. Mayroon kaming pangunahing form ng aplikasyon:

Sa form na ito mayroon ding TextBox na pinangalanang TBDialog at isang Button na button kung saan dapat nating i-click:

1. Ipasa ang halaga ng Text property mula sa TBDialog patungo sa TBMain;
2. Isara ang fDialog;

Ngayon tingnan natin ang buong proseso sa pagkakasunud-sunod.

Una, ito ay palaging nagkakahalaga ng pag-alala na sa pamamagitan ng default ang lahat ng mga katangian, variable, at mga pamamaraan sa C# ay itinalaga ng isang modifier pribado– samakatuwid, upang makakuha mula sa pangalawang form sa kontrol sa una, kailangan naming magtakda ng modifier para sa TBMain pampubliko sa sarili. Upang gawin ito, piliin ang elemento ng TBMain sa taga-disenyo ng form, pumunta sa window ng mga katangian at baguhin ang halaga ng ari-arian Mga modifier Sa pribado sa pampubliko.

Ngayon ang TBMain ay makikita sa iba pang mga bagay. Mag-move on na tayo. Upang mabuksan ang form sa modal mode, kailangan naming gumamit ng isa sa dalawang opsyon para sa ShowDialog() na paraan:

pampublikong DialogResult ShowDialog(IWin32Window owner) ;

Sa unang kaso, ipinapakita ng pamamaraan ang form bilang modal dialog box na may kasalukuyang aktibong window na itinakda bilang may-ari, at sa pangalawa, maaari naming independiyenteng tukuyin kung aling form ang magiging may-ari para sa aming modal window.

Halimbawa, gamitin natin ang pangalawang bersyon ng ShowDialog() na paraan at ipakita ang pangalawang anyo sa modally. Upang gawin ito, isusulat namin ang sumusunod: Dito ko ginamit muli ang keyword ito , na tumuturo sa kasalukuyang bagay, i.e. itakda ang pangunahing form bilang may-ari ( fMain ). Ngayon ay direktang lumipat tayo sa paglutas ng ating problema at sagutin ang tanong: paano ipasa ang halaga mula sa isang form patungo sa isa pa? Ang bawat kontrol ay may kahanga-hangang pag-aari May-ari

– na tumuturo sa magulang:

Ngayon ay maaari mo nang patakbuhin ang proyekto at siguraduhin na ang teksto mula sa TextBox sa form ng bata ay perpektong inililipat sa TextBox sa una. Kung sakali, pino-post ko ang source code ng proyektong tinalakay sa halimbawa.
Ang isyung tinalakay sa artikulong ito ay higit na nauugnay sa paksa ng pagbuo ng isang arkitektura ng application, at hindi partikular sa problemang isinasaalang-alang. Ang paglilipat ng data mula sa isang form patungo sa isa pa ay hindi mahirap sa lahat. Upang gawin ito, sapat na upang gawing bukas ang kontrol kung saan ang data na gusto nating makuha, iyon ay, markahan ito ng pampublikong modifier. Gayundin, posible ang isa pang pagpipilian. Halimbawa, sa unang anyo lumikha kami ng isang bagay ng pangalawang anyo sa pamamagitan ng pagpasa ng isang sanggunian sa ating sarili sa tagabuo, iyon ay, sa pamamagitan ng pagpasa ng isang sanggunian sa una mula sa unang anyo hanggang sa pangalawa
SecondForm secondForm = bagong SecondForm(ito);

Naturally, bago gawin ito, dapat mong alagaan ang paglikha ng labis na karga para sa tagabuo ng pangalawang form.

At ang pamamaraang ito ay medyo karaniwan. Gayunpaman, sa pagiging simple nito, nagdadala ito ng maraming potensyal na problema, ang pangunahing isa ay isang paglabag sa prinsipyo ng encapsulation. Sa isang salita, ang pangalawang anyo ay hindi dapat malaman ang anumang bagay tungkol sa pag-iral ng una at, higit pa, hindi ito dapat maimpluwensyahan. Ang solusyon sa problemang ito ay medyo simple. Direktang tingnan natin ang code. Sa taga-disenyo, lumikha kami ng pangunahing form (ito ay ilulunsad kapag nagsimula ang application). Maglagay tayo ng isa, TextBox Label At.

Sa pamamagitan ng pag-click sa button, magbubukas ang pangalawang form at ang text mula sa text field ng pangunahing form ay ililipat sa text field ng pangalawang form. Sa una, ang pangalawang anyo ay ganito:

Katulad ng una, mayroon itong parehong mga kontrol. Hindi na natin kailangan. Inilunsad ng entry point ng application ang pangunahing form:

Paggamit ng System; gamit ang System.Collections.Generic; gamit ang System.Linq; gamit ang System.Windows.Forms; namespace From1FormTo2 ( static class Program ( // Ang pangunahing entry point para sa application. static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); ) ) )

Ang pangunahing form code ay ganito ang hitsura:

Paggamit ng System; gamit ang System.Collections.Generic; gamit ang System.ComponentModel; gamit ang System.Data; gamit ang System.Drawing; gamit ang System.Linq; gamit ang System.Text; gamit ang System.Windows.Forms; namespace From1FormTo2 ( public partial class MainForm: Form ( //second form SecondForm secondForm; //constructor public MainForm() ( InitializeComponent(); ) //data transfer event handler //mula sa pangunahing form hanggang sa pangalawang private void btn_mainForm_Click(object nagpadala, EventArgs e) ( secondForm = bagong SecondForm(tb_mainForm.Text.Trim()); secondForm.ShowDialog(); kung (secondForm.DialogResult == DialogResult.OK) tb_mainForm.Text = secondForm.ReturnData(); ) ) )

Alinsunod dito, huwag kalimutang ikonekta ang pindutan sa kaganapan I-click. Dito sa pangunahing form na klase mayroong isang patlang SecondForm secondForm, na kumakatawan sa pangalawang anyo na bagay. Kapag nag-click ka sa pindutang "Isumite", ang pangalawang form ay nilikha (tinatawag ang overloaded na tagabuo, gagawin namin ito sa ibang pagkakataon) at inilunsad gamit ang pamamaraan. ShowDialog(). Sa kasong ito, ang pamamaraang ito ay angkop para sa amin. Bukod dito, pagkatapos nito tinitiyak naming suriin kung ang pangalawang form ay sarado, ngunit nag-click sa pindutan nito. Kung na-click ang isang button sa pangalawang form, dapat tanggapin ng unang form ang data mula sa pangalawa. Nangyayari ito sa pamamagitan ng pagtawag sa pamamaraan ReturnData() sa pangalawang anyo.

Ngayon ang pinaka-kagiliw-giliw na bahagi ay ang code ng pangalawang form:

Paggamit ng System; gamit ang System.Collections.Generic; gamit ang System.ComponentModel; gamit ang System.Data; gamit ang System.Drawing; gamit ang System.Linq; gamit ang System.Text; gamit ang System.Windows.Forms; namespace From1FormTo2 ( public partial class SecondForm: Form ( // overloaded constructor public SecondForm(string data) ( InitializeComponent(); tb_secondForm.Text = data; ) //data transfer event handler //mula sa pangalawang form hanggang sa pangunahing pribadong void btn_secondForm_Click (object sender, EventArgs e) ( this.DialogResult = DialogResult.OK; ) //pampublikong paraan para ma-access //ang text field ng form na ito public string ReturnData() ( return (tb_secondForm.Text.Trim()); ) ) )

Tulad ng nakikita mo, mayroong isang solong constructor overload na tumatanggap ng isang uri ng string. Tandaan na sinusubukan naming maglipat ng text mula sa isang TextBox. Sa constructor, ang mga bahagi ay naka-iskedyul na masimulan at ang teksto ng field ng teksto ay nakatakda sa ipinadalang halaga mula sa unang anyo. Susunod, sa pamamagitan ng pag-subscribe sa kaganapan I-click para sa button ng pangalawang form, gumawa kami ng handler btn_secondForm_Click, na ginagaya ang pagpapatakbo ng "Ok" na button ng anumang dialog box. Kaya, sa pamamagitan ng pag-click sa pindutang "Isumite" (sa pangalawang form), isinasagawa namin ang kundisyon

(secondForm .DialogResult == DialogResult .OK)

Ang unang anyo, samakatuwid, ang pagtawag sa pamamaraan secondForm .ReturnData(), itinakda namin ang field ng text ng unang form sa halaga ng field ng text ng pangalawang form.

Ang pagpapatakbo ng pamamaraang ito, sa palagay ko, ay hindi na nangangailangan ng paliwanag. Ibinabalik lang nito ang text mula sa isang field ng text, habang pinapanatili itong pribado.

Bilang resulta, inilipat namin ang data sa pangalawang anyo mula sa una at mula sa pangalawa hanggang sa una nang hindi lumalabag sa mga prinsipyo ng encapsulation.

Subukang ilagay ang text na “aaa” sa text field ng unang form at i-click ang button. Makikita mo ang text na ito sa field ng text sa pangalawang form na bubukas. Subukang baguhin ang teksto sa "aaa ppp" at i-click ang pindutan. Makikita mo kung paano, pagkatapos isara ang pangalawang form, ang tekstong ito ay lilitaw sa field ng teksto ng pangunahing form.

Ngayon, sa tingin ko ay mas makakapaglipat ka ng data sa pagitan ng mga form. Sa susunod na artikulo ay pag-uusapan natin kung paano ito gagawin sa mga aplikasyon ng ASP.NET.