നിങ്ങൾക്ക് ഒന്നിലധികം ഇനങ്ങൾക്ക് ദീർഘമായ ഒരു ഫോം ഉണ്ടെങ്കിൽ, ചില ഇനങ്ങളിൽ ഒന്നിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ കാണുന്നതിന് നിങ്ങൾക്ക് ഡാറ്റയിലേക്ക് വേഗത്തിൽ തുളച്ചുകയറേണ്ടി വന്നേക്കാം. ആക്‌സസിൽ, ഇതിന് നിരവധി ഘടകങ്ങൾക്കുള്ള ഫോമും ഒരു വ്യക്തിഗത ഘടകത്തിനായുള്ള ഫോമും തമ്മിൽ ഒരു ലിങ്ക് സ്ഥാപിക്കേണ്ടതുണ്ട്. നിങ്ങൾ ഒരു മൾട്ടി-ഇനം ഫോമിൽ ഒരു ഇനം തിരഞ്ഞെടുക്കുമ്പോൾ, വ്യക്തിഗത ഇനം ഫോം തുറന്ന് അധിക വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നു.

കുറിപ്പുകൾ:

ഫോമുകൾ സൃഷ്ടിക്കുന്നു

മിക്ക കേസുകളിലും, വിശദമായ കോൺഫിഗറേഷനിലെ രണ്ട് ഫോമുകൾ ഒരേ ടേബിളിനെയോ അന്വേഷണത്തെയോ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. നിങ്ങൾക്ക് ഇതിനകം തന്നെ രണ്ട് ഫോമുകൾ ഉപയോഗിക്കാനുണ്ടെങ്കിൽ (അതിൽ ഒന്ന് ഒരു പട്ടിക അല്ലെങ്കിൽ ഒന്നിലധികം ഇനം ഫോം ആണ്, മറ്റൊന്ന് ഒരൊറ്റ ഇനം അല്ലെങ്കിൽ വിശദമായ ഫോം), നിങ്ങൾക്ക് ഈ വിഭാഗം ഒഴിവാക്കാം. അല്ലെങ്കിൽ, അവ സൃഷ്ടിക്കാൻ ഇനിപ്പറയുന്ന നടപടിക്രമങ്ങൾ ഉപയോഗിക്കുക.

ഒന്നിലധികം ഘടകങ്ങളുള്ള ഒരു ടേബിൾ ഫോം അല്ലെങ്കിൽ ഒരു ഫോം സൃഷ്ടിക്കുക

നാവിഗേഷൻ പാളിയിൽ, നിങ്ങൾ പട്ടിക രൂപത്തിൽ പ്രദർശിപ്പിക്കാൻ ആഗ്രഹിക്കുന്ന ഡാറ്റ അടങ്ങുന്ന പട്ടിക അല്ലെങ്കിൽ ചോദ്യം തിരഞ്ഞെടുക്കുക.

ഇനങ്ങൾ തിരഞ്ഞെടുക്കുക സൃഷ്ടി > മറ്റ് രൂപങ്ങൾ, തുടർന്ന് - ഒന്നിലധികം ഘടകങ്ങൾഅഥവാ മേശആവശ്യമായ ഫോമിൻ്റെ തരം അനുസരിച്ച്.

ഫോം സംരക്ഷിച്ച് അടയ്ക്കുക.

ഒന്നിലധികം ഇനം ഫോമുകളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, ഒന്നിലധികം ഇനങ്ങളുടെ ടൂൾ ഉപയോഗിച്ച് ഒരു ഫോം സൃഷ്‌ടിക്കുക എന്നത് കാണുക.

ഒരൊറ്റ ഇനം അല്ലെങ്കിൽ വിശദമായ ഫോം സൃഷ്‌ടിക്കുക

നാവിഗേഷൻ പാളിയിൽ, വിശദാംശ ഫോമിൽ പ്രദർശിപ്പിക്കാൻ ആഗ്രഹിക്കുന്ന ഡാറ്റ അടങ്ങുന്ന പട്ടികയിലോ അന്വേഷണത്തിലോ ക്ലിക്ക് ചെയ്യുക. മിക്കവാറും, ആദ്യ ഫോമിനായി നിങ്ങൾ ഉപയോഗിച്ച അതേ പട്ടികയോ അതേ ചോദ്യമോ ആയിരിക്കും ഇത്.

ഇനങ്ങൾ തിരഞ്ഞെടുക്കുക സൃഷ്ടി > ഫോം.

ആവശ്യമായ മാറ്റങ്ങൾ വരുത്തുക, ഫോം സംരക്ഷിച്ച് അടയ്ക്കുക.

കൂടുതൽ വിവരങ്ങൾക്ക്, ഫോം ടൂൾ ഉപയോഗിച്ച് ഒരു ഫോം സൃഷ്ടിക്കുക കാണുക.

വിശദാംശ ഫോം തുറക്കാൻ ലോജിക് ചേർക്കുന്നു

വിശദമായ ഫോം തുറന്ന് ശരിയായ ഇനം പ്രദർശിപ്പിക്കുന്ന ഒരു മൾട്ടി-ഇനത്തിലേക്കോ പട്ടിക ഫോമിലേക്കോ ഒരു ചെറിയ മാക്രോ എങ്ങനെ ചേർക്കാമെന്ന് നോക്കാം.

നിങ്ങൾക്ക് മാക്രോകളിൽ കൂടുതൽ പരിചയമില്ലെങ്കിൽ വിഷമിക്കേണ്ട. ഈ ലേഖനത്തിൽ നൽകിയിരിക്കുന്ന നടപടിക്രമത്തിൽ നിന്ന് നിങ്ങൾക്ക് XML കോഡ് പകർത്തി ഒട്ടിക്കാം.

നിങ്ങൾ ഒരു ടേബിൾ ഫോമാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, അത് തുറക്കാൻ നാവിഗേഷൻ പാളിയിൽ ഡബിൾ ക്ലിക്ക് ചെയ്യുക. ഒരു മൾട്ടി-ഇനം ഫോമിനായി, നാവിഗേഷൻ പാളിയിൽ അതിൽ വലത്-ക്ലിക്കുചെയ്ത് തിരഞ്ഞെടുക്കുക ലേഔട്ട് മോഡ്.

പ്രോപ്പർട്ടീസ് വിൻഡോ ഇതിനകം തുറന്നിട്ടില്ലെങ്കിൽ അത് തുറക്കാൻ F4 അമർത്തുക.

നിങ്ങൾ മാക്രോ ചേർക്കാൻ ആഗ്രഹിക്കുന്ന കോളത്തിൽ ക്ലിക്ക് ചെയ്യുക. ഇത് ഒരു കോളം ആയിരിക്കണം, അത് ക്ലിക്ക് ചെയ്യുമ്പോൾ, മാക്രോ പ്രവർത്തിപ്പിച്ചതിന് ശേഷം വിശദാംശ ഫോം തുറക്കും. മുകളിലെ ചിത്രത്തിൽ, frmContactList നിരയിലേക്ക് മാക്രോ ചേർത്തിരിക്കുന്നു.

ഉപദേശം:(ടിപ്പ്) നിങ്ങൾക്ക് ഒന്നിലധികം നിരകളിലേക്ക് മാക്രോകൾ ചേർക്കാൻ കഴിയും.

കമ്പ്യൂട്ടർ ഡാറ്റാബേസുകളിലെ മാക്രോകളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, കാണുക

നിങ്ങൾ ഒരു ടൈപ്പ് പോയിൻ്റർ സൃഷ്ടിച്ചാൽ അത് വ്യക്തമാണ്<что там>::ഫോം പ്രവർത്തിക്കും, പക്ഷേ ബട്ടണുകൾ മുതലായവ ഉപയോഗിച്ച് എനിക്ക് ഇതിനകം സൃഷ്ടിച്ച ഒരു ഫോം ആവശ്യമാണ്. (പൊതുവേ, വ്യത്യസ്‌ത നിയന്ത്രണങ്ങളോടെ), പക്ഷേ അവ സ്വമേധയാ എഴുതാൻ ഞാൻ ആഗ്രഹിക്കുന്നില്ല (അതായത് പ്രോഗ്രമാറ്റിക്കായി) ഒരു വൃത്തിയുള്ള രൂപത്തിൽ (ധാരാളം എഴുത്തുകൾ ഉണ്ട്, നിങ്ങൾക്ക് അത് ആവശ്യമുള്ളതുപോലെ ലഭിക്കുമെന്നത് ഒരു വസ്തുതയല്ല). എന്നെ ഇപ്പോഴും ആശയക്കുഴപ്പത്തിലാക്കുന്നത് ഇതാണ്...... ഞാൻ ഇതിനകം സൃഷ്ടിച്ച പ്രോജക്റ്റിലേക്ക് ഫോം ചേർത്തപ്പോൾ, പുതിയ തലക്കെട്ട് ഫയലായ Form2.h-ൽ ഇങ്ങനെ എഴുതിയിരിക്കുന്നു:

#പ്രാഗ്മ ഒരിക്കൽ
#"Form1.h" ഉൾപ്പെടുത്തുക

നെയിംസ്പേസ് സിസ്റ്റം ഉപയോഗിച്ച്;



നെയിംസ്പേസ് സിസ്റ്റം ഉപയോഗിച്ച് ::ഡാറ്റ;

നെയിംസ്പേസ് My1 (

///
/// ഫോം2-ൻ്റെ സംഗ്രഹം



പൊതു റഫറൻസ് ക്ലാസ് ഫോം2: പൊതു സിസ്റ്റം::വിൻഡോസ്::ഫോമുകൾ::ഫോം
{
പൊതു:
ഫോം2(അസാധു)
{
InitializeComponent();

}

സംരക്ഷിത:

~ഫോം2()
{
എങ്കിൽ (ഘടകങ്ങൾ)
{
ഘടകങ്ങൾ ഇല്ലാതാക്കുക;
}
}

സ്വകാര്യം:

///
{
ഈ->ഘടകങ്ങൾ = gcnew സിസ്റ്റം::ComponentModel::Container();
ഈ-> വലിപ്പം = സിസ്റ്റം:: ഡ്രോയിംഗ്:: വലിപ്പം (300,300);
this->Text = L"Form2";
ഈ->പാഡിംഗ് = സിസ്റ്റം:: വിൻഡോസ്:: ഫോമുകൾ:: പാഡിംഗ് (0);
ഇത്->
}
#പ്രാഗ്മെൻഡ്രിജിയൻ
};
}

Form1.h-ൽ ഇത് ഇങ്ങനെ എഴുതിയിട്ടുണ്ടെങ്കിലും:

#പ്രാഗ്മ ഒരിക്കൽ
#"Form2.h" ഉൾപ്പെടുത്തുക

നെയിംസ്പേസ് My1 (

നെയിംസ്പേസ് സിസ്റ്റം ഉപയോഗിക്കുന്നു;
നെയിംസ്പേസ് സിസ്റ്റം ഉപയോഗിച്ച്::ComponentModel;
നെയിംസ്പേസ് സിസ്റ്റം ഉപയോഗിച്ച്::ശേഖരങ്ങൾ;
നെയിംസ്പേസ് സിസ്റ്റം ഉപയോഗിച്ച്:: വിൻഡോസ്:: ഫോമുകൾ;
നെയിംസ്പേസ് സിസ്റ്റം ഉപയോഗിച്ച് ::ഡാറ്റ;
നെയിംസ്പേസ് സിസ്റ്റം ഉപയോഗിച്ച്::ഡ്രോയിംഗ്;

///
/// ഫോം1-ൻ്റെ സംഗ്രഹം
/// മുന്നറിയിപ്പ്: നിങ്ങൾ ഈ ക്ലാസിൻ്റെ പേര് മാറ്റുകയാണെങ്കിൽ, നിങ്ങൾ ഇത് മാറ്റേണ്ടതുണ്ട്
/// നിയന്ത്രിത റിസോഴ്സ് കംപൈലർ ടൂളിനുള്ള "റിസോഴ്സ് ഫയൽ നെയിം" പ്രോപ്പർട്ടി
ഈ ക്ലാസ് ആശ്രയിക്കുന്ന എല്ലാ .resx ഫയലുകളുമായും /// ബന്ധപ്പെട്ടിരിക്കുന്നു. അല്ലെങ്കിൽ,
/// ഡിസൈനർമാർക്ക് പ്രാദേശികവൽക്കരിക്കപ്പെട്ടവരുമായി ശരിയായി സംവദിക്കാൻ കഴിയില്ല
ഈ ഫോമുമായി ബന്ധപ്പെട്ട /// ഉറവിടങ്ങൾ.
പൊതു റഫറൻസ് ക്ലാസ് ഫോം1: പൊതു സിസ്റ്റം::വിൻഡോസ്::ഫോമുകൾ::ഫോം
{
പൊതു:
ഫോം1(അസാധു)
{
InitializeComponent();
//TODO: കൺസ്ട്രക്റ്റർ കോഡ് ഇവിടെ ചേർക്കുക
}

സംരക്ഷിത:
/// ഉപയോഗിക്കുന്ന ഏതെങ്കിലും ഉറവിടങ്ങൾ വൃത്തിയാക്കുക.
~ഫോം1()
{
എങ്കിൽ (ഘടകങ്ങൾ)
{
ഘടകങ്ങൾ ഇല്ലാതാക്കുക;
}
}
private: System::Windows::Forms::Button^ button1;
സംരക്ഷിത:

സ്വകാര്യം:
/// ആവശ്യമായ ഡിസൈനർ വേരിയബിൾ.
സിസ്റ്റം:: ഘടകം മോഡൽ:: കണ്ടെയ്നർ ^ഘടകങ്ങൾ;

#pragma region വിൻഡോസ് ഫോം ഡിസൈനർ കോഡ് സൃഷ്ടിച്ചു
/// ഡിസൈനർ പിന്തുണയ്‌ക്ക് ആവശ്യമായ രീതി - പരിഷ്‌ക്കരിക്കരുത്
/// കോഡ് എഡിറ്റർ ഉപയോഗിച്ച് ഈ രീതിയുടെ ഉള്ളടക്കം.
അസാധുവായ InitializeComponent(അസാധു)
{
this->button1 = (gcnew System::Windows::Forms::Button());
ഇത്->സസ്പെൻഡ്ലേഔട്ട്();
// ബട്ടൺ1
ഈ->ബട്ടൺ1->ലൊക്കേഷൻ = സിസ്റ്റം:: ഡ്രോയിംഗ്:: പോയിൻ്റ് (60, 76);
this->button1->Name = L"button1";
ഈ->ബട്ടൺ1->വലിപ്പം = സിസ്റ്റം:: ഡ്രോയിംഗ്:: വലിപ്പം (75, 23);
this->button1->TabIndex = 0;
this->button1->Text = L"button1";
this->button1->UseVisualStyleBackColor = true;
this->button1->Click += gcnew System ::EventHandler(ഇത്, &Form1::button1_Click);
//ഫോം1
this->AutoScaleDimensions = സിസ്റ്റം:: ഡ്രോയിംഗ്:: SizeF(6, 13);
this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
ഈ->ClientSize = സിസ്റ്റം:: ഡ്രോയിംഗ്:: വലിപ്പം (292, 266);
ഇത്->നിയന്ത്രണങ്ങൾ->ചേർക്കുക (ഇത്->ബട്ടൺ1);
ഈ->പേര് = L"ഫോം1";
this->Text = L"Form1";
ഇത്-> റെസ്യൂം ലേഔട്ട് (തെറ്റായ);

}
#പ്രാഗ്മെൻഡ്രിജിയൻ

സ്റ്റാറ്റിക് സിസ്റ്റം :: വിൻഡോസ് :: ഫോമുകൾ :: ഫോം ^ frm = gcnew സിസ്റ്റം :: വിൻഡോസ് :: ഫോമുകൾ :: ഫോം ();
private: System::Void button1_Click(സിസ്റ്റം::Object^ അയച്ചയാൾ, സിസ്റ്റം::EventArgs^ e) (
frm->ഷോ();
}
};
}

നെയിംസ്പേസ് കണക്ഷൻ വിവിധ സ്ഥലങ്ങളിൽ വ്യക്തമാക്കിയിരിക്കുന്നു!

അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 10/31/2015

പ്രോജക്റ്റിലേക്ക് മറ്റൊരു ഫോം ചേർക്കുന്നതിന്, സൊല്യൂഷൻ എക്സ്പ്ലോറർ വിൻഡോയിലെ പ്രോജക്റ്റ് നാമത്തിൽ വലത്-ക്ലിക്കുചെയ്ത് Add->Windows ഫോം തിരഞ്ഞെടുക്കുക...

പുതിയ ഫോമിന് കുറച്ച് പേര് നൽകാം, ഉദാഹരണത്തിന്, Form2.cs:

അതിനാൽ, ഞങ്ങളുടെ പ്രോജക്റ്റിലേക്ക് ഞങ്ങൾ രണ്ടാമത്തെ ഫോം ചേർത്തു. ഇപ്പോൾ രണ്ട് രൂപങ്ങൾ തമ്മിലുള്ള ഇടപെടൽ നടപ്പിലാക്കാൻ ശ്രമിക്കാം. ബട്ടൺ അമർത്തുമ്പോൾ ആദ്യത്തെ ഫോം രണ്ടാമത്തെ ഫോമിലേക്ക് വിളിക്കുമെന്ന് നമുക്ക് പറയാം. ആദ്യം, നമുക്ക് ആദ്യ ഫോമിലേക്ക് ഒരു ബട്ടൺ ചേർക്കുക, ഫോം1, കോഡ് ഫയലിലേക്ക് പോകാൻ ബട്ടണിൽ ഡബിൾ ക്ലിക്ക് ചെയ്യുക. അതിനാൽ, ബട്ടണിൻ്റെ ക്ലിക്ക് ഇവൻ്റ് ഹാൻഡ്‌ലറിലേക്ക് ഞങ്ങളെ കൊണ്ടുപോകും, ​​അത് ബട്ടണിൽ ഇരട്ട-ക്ലിക്കുചെയ്തതിന് ശേഷം സ്ഥിരസ്ഥിതിയായി സൃഷ്ടിക്കപ്പെടും:

സ്വകാര്യ ശൂന്യ ബട്ടൺ1_ക്ലിക്ക് (ഒബ്ജക്റ്റ് അയച്ചയാൾ, EventArgs e) ( )

ഇനി അതിലേക്ക് രണ്ടാമത്തെ ഫോം വിളിക്കുന്നതിനുള്ള കോഡ് ചേർക്കാം. ഞങ്ങളുടെ രണ്ടാമത്തെ ഫോമിനെ Form2 എന്ന് വിളിക്കുന്നു, അതിനാൽ ആദ്യം ഞങ്ങൾ ഈ ക്ലാസിൻ്റെ ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നു, തുടർന്ന് അത് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നതിന് ഞങ്ങൾ കാണിക്കുന്ന രീതി എന്ന് വിളിക്കുന്നു:

സ്വകാര്യ അസാധുവായ ബട്ടൺ1_ക്ലിക്ക് (ഒബ്ജക്റ്റ് അയച്ചയാൾ, EventArgs e) (Form2 newForm = പുതിയ Form2(); newForm.Show(); )

ഇപ്പോൾ നമുക്ക് വിപരീതമായി ചെയ്യാം - അങ്ങനെ രണ്ടാമത്തെ രൂപം ആദ്യത്തേതിനെ ബാധിക്കുന്നു. രണ്ടാമത്തെ രൂപത്തിന് ആദ്യത്തേതിൻ്റെ അസ്തിത്വത്തെക്കുറിച്ച് അറിയില്ല. ഇത് പരിഹരിക്കുന്നതിന്, ആദ്യ ഫോമിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ എങ്ങനെയെങ്കിലും രണ്ടാമത്തെ ഫോമിലേക്ക് മാറ്റേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, കൺസ്ട്രക്റ്ററിലെ ഫോമിലേക്ക് ഒരു ലിങ്ക് കൈമാറുന്നത് ഞങ്ങൾ ഉപയോഗിക്കും.

അതിനാൽ നമുക്ക് രണ്ടാമത്തെ ഫോമിലേക്ക് പോയി അതിൻ്റെ കോഡിലേക്ക് പോകാം - ഫോമിൽ വലത്-ക്ലിക്കുചെയ്ത് കോഡ് കാണുക തിരഞ്ഞെടുക്കുക. ഇപ്പോൾ അത് ശൂന്യമാണ് കൂടാതെ ഒരു കൺസ്ട്രക്റ്റർ മാത്രം അടങ്ങിയിരിക്കുന്നു. C# രീതി ഓവർലോഡിംഗിനെ പിന്തുണയ്ക്കുന്നതിനാൽ, വ്യത്യസ്ത പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് നമുക്ക് നിരവധി രീതികളും കൺസ്ട്രക്റ്ററുകളും സൃഷ്ടിക്കാനും സാഹചര്യം അനുസരിച്ച് അവയിലൊന്ന് വിളിക്കാനും കഴിയും. അതിനാൽ, രണ്ടാമത്തെ ഫോമിൻ്റെ കോഡ് ഫയൽ ഇനിപ്പറയുന്നതിലേക്ക് മാറ്റാം:

സിസ്റ്റം ഉപയോഗിക്കുന്നു; System.Collections.Generic ഉപയോഗിക്കുന്നത്; System.ComponentModel ഉപയോഗിക്കുന്നു; System.Data ഉപയോഗിക്കുന്നത്; System.Drawing ഉപയോഗിക്കുന്നു; System.Linq ഉപയോഗിക്കുന്നു; System.Text ഉപയോഗിക്കുന്നത്; System.Threading.Tasks ഉപയോഗിക്കുന്നത്; System.Windows.Forms ഉപയോഗിക്കുന്നു; നെയിംസ്പേസ് HelloApp (പബ്ലിക് ഭാഗിക ക്ലാസ് ഫോം2: ഫോം (പബ്ലിക് ഫോം2() (InitializeComponent(); ) public Form2(Form1 f) (InitializeComponent(); f.BackColor = Color.Yellow; ) )

വാസ്തവത്തിൽ, ഞങ്ങൾ ഇവിടെ ഒരു പുതിയ കൺസ്ട്രക്റ്റർ ചേർത്തു, പൊതു ഫോം2(ഫോം1 എഫ്) , അതിൽ നമുക്ക് ആദ്യ ഫോം ലഭിക്കുകയും അതിൻ്റെ പശ്ചാത്തലം മഞ്ഞയായി സജ്ജമാക്കുകയും ചെയ്യുന്നു. ഇപ്പോൾ നമുക്ക് ആദ്യ ഫോമിൻ്റെ കോഡിലേക്ക് പോകാം, അവിടെ ഞങ്ങൾ രണ്ടാമത്തെ ഫോമിലേക്ക് വിളിക്കുകയും അതിനെ ഇനിപ്പറയുന്നതിലേക്ക് മാറ്റുകയും ചെയ്യുന്നു:

സ്വകാര്യ അസാധുവായ ബട്ടൺ1_ക്ലിക്ക് (ഒബ്ജക്റ്റ് അയച്ചയാൾ, EventArgs e) ( Form2 newForm = പുതിയ Form2(ഇത്); newForm.Show(); )

ഈ സാഹചര്യത്തിൽ കീവേഡ് നിലവിലെ ഒബ്ജക്റ്റിനെ പ്രതിനിധീകരിക്കുന്നതിനാൽ - ഫോം1 ഒബ്ജക്റ്റ്, രണ്ടാമത്തെ ഫോം സൃഷ്ടിക്കുമ്പോൾ അത് (ലിങ്ക്) സ്വീകരിക്കുകയും അതിലൂടെ ആദ്യ ഫോം നിയന്ത്രിക്കുകയും ചെയ്യും.

ഇപ്പോൾ, ബട്ടൺ ക്ലിക്കുചെയ്തതിനുശേഷം, രണ്ടാമത്തെ ഫോം സൃഷ്ടിക്കപ്പെടും, അത് ആദ്യ ഫോമിൻ്റെ നിറം ഉടൻ മാറ്റും.

നിലവിലെ രൂപത്തിലുള്ള ഒബ്‌ജക്‌റ്റുകളും നമുക്ക് സൃഷ്‌ടിക്കാം:

സ്വകാര്യ അസാധുവായ ബട്ടൺ1_ക്ലിക്ക് (ഒബ്ജക്റ്റ് അയച്ചയാൾ, EventArgs e) (ഫോം1 newForm1 = പുതിയ Form1(); newForm1.Show(); Form2 newForm2 = പുതിയ Form2(newForm1); newForm2.Show(); )

നിരവധി ഫോമുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, അവയിലൊന്ന് പ്രധാനമാണെന്ന് നിങ്ങൾ കണക്കിലെടുക്കണം - ഇത് Program.cs ഫയലിൽ ആദ്യം സമാരംഭിക്കുന്നു. നമുക്ക് ഒരേ സമയം ഒരു കൂട്ടം ഫോമുകൾ തുറന്നിട്ടുണ്ടെങ്കിൽ, പ്രധാനമായത് അടയ്ക്കുമ്പോൾ, മുഴുവൻ ആപ്ലിക്കേഷനും ക്ലോസ് ചെയ്യുന്നു, അതോടൊപ്പം മറ്റെല്ലാ ഫോമുകളും.