Enabled - RadioButton ning yoqilgan/o'chirilgan holati.
 
BackColor

Enabled - RadioButton ning yoqilgan/o'chirilgan holati.
BackColor - RadioButton ning fon rangi.
ForeColor - RadioButton ning matn rangi.
Font - RadioButton da foydalaniladigan shrift.
GroupName - RadioButton larning guruhlanishi uchun ishlatiladigan nom.
3. CheckBox
CheckBox komponenti foydalanuvchiga bir yoki bir nechta variantlarni tanlash imkonini beradi. CheckBox komponentining asosiy xususiyatlari quyidagilar:
Text - CheckBox ustida ko'rsatiladigan matn.
Checked - CheckBox ning belgilangan yoki belgilanmagan holati.
Enabled - CheckBox ning yoqilgan/o'chirilgan holati.
BackColor - CheckBox ning fon rangi.
ForeColor - CheckBox ning matn rangi.
Font - CheckBox da foydalaniladigan shrift.
Bu komponentlardan foydalanish uchun Windows Forms loyihasida ularni komponent panelidan Form ga tortish va kerakli xususiyatlarini sozlash kifoya. Shuningdek, C# yoki VB.NET kabi dasturlash tillarida koddan ham ulantirilishi mumkin.
4) NET platformasidagi ma'lumot turlari bilan ishlashda Convert sinfi juda foydali bo'lib, turli xil ma'lumot turlarini bir-biriga oson o'tkazish imkonini beradi. Convert sinfi System namespace'idan olinadi va u quyidagi asosiy usullarni taqdim etadi:
ToBoolean(): Argument qiymatini mantiqiy qiymatga aylantiradi.
ToByte(): Argumentni byte ma'lumot turiga aylantiradi.
ToChar(): Argumentni character ma'lumot turiga aylantiradi.
ToDateTime(): Argumentni DateTime ma'lumot turiga aylantiradi.
ToDecimal(): Argumentni o'nli son Decimal ma'lumot turiga aylantiradi.
ToDouble(): Argumentni o'nli son Double ma'lumot turiga aylantiradi.
ToInt16(): Argumentni 16-bitli butun son Int16 ma'lumot turiga aylantiradi.
ToInt32(): Argumentni 32-bitli butun son Int32 ma'lumot turiga aylantiradi.
ToInt64(): Argumentni 64-bitli butun son Int64 ma'lumot turiga aylantiradi.
ToSByte(): Argumentni 8-bitli ichki butun son SByte ma'lumot turiga aylantiradi.
ToSingle(): Argumentni o'nli son Single ma'lumot turiga aylantiradi.
ToString(): Argumentni satr String ma'lumot turiga aylantiradi.
ToUInt16(): Argumentni 16-bitli butun son UInt16 ma'lumot turiga aylantiradi.
ToUInt32(): Argumentni 32-bitli butun son UInt32 ma'lumot turiga aylantiradi.
ToUInt64(): Argumentni 64-bitli butun son UInt64 ma'lumot turiga aylantiradi.
Quyida Convert sinfining ba'zi misollarni ko'rib chiqamiz:
// String to int
int age = Convert.ToInt32("25");
Console.WriteLine(age); // Output: 25
// Boolean to string
bool isStudent = true;
string studentStatus = Convert.ToString(isStudent);
Console.WriteLine(studentStatus); // Output: True
// Double to decimal
double price = 19.99;
decimal discountedPrice = Convert.ToDecimal(price);
Console.WriteLine(discountedPrice); // Output: 19.99
// Char to int
char ch = 'A';
int asciiValue = Convert.ToInt32(ch);
Console.WriteLine(asciiValue); // Output: 65
// DateTime to string
DateTime currentDate = DateTime.Now;
string dateString = Convert.ToString(currentDate);
Console.WriteLine(dateString); // Output: 2023-06-03 11:23:45
Yuqoridagi misollardan ko'rishimiz mumkinki, Convert sinfi ma'lumot turlarini oson va tez o'tkazish uchun juda qulay. U ma'lumotlarni to'g'ridan-to'g'ri bir ma'lumot turidan boshqasiga aylantirish imkonini beradi.
5 C#'da shart operatorlari quyidagilar:
1. **if-else operatori**:
- Sintaksisi: `if (shart) { ... } else { ... }`
- Shart bajarilsa, `if` bloki bajariladi, aks holda `else` bloki bajariladi.
- Masalan:
```csharp
int age = 18;
if (age >= 18)
{
Console.WriteLine("You are an adult.");
}
else
{
Console.WriteLine("You are a minor.");
}
```
2. **switch-case operatori**:
- Sintaksisi: `switch (ifoda) { case value1: ...; break; case value2: ...; break; default: ...; }`
- Ifodaning qiymati bilan switch operatorining har bir case qiymati solishtirilib, mos kabellar bajariladi.
- Masalan:
```csharp
int dayOfWeek = 3;
switch (dayOfWeek)
{
case 1:
Console.WriteLine("Monday");
break;
case 2:
Console.WriteLine("Tuesday");
break;
case 3:
Console.WriteLine("Wednesday");
break;
default:
Console.WriteLine("Invalid day");
break;
}
```
3. **Ternary operatori**:
- Sintaksisi: `(shart) ? valueIfTrue : valueIfFalse;`
- Shart bajarilsa, `valueIfTrue` qiymati qaytariladi, aks holda `valueIfFalse` qiymati qaytariladi.
- Masalan:
```csharp
int num = 10;
string result = (num % 2 == 0) ? "Even" : "Odd";
Console.WriteLine(result); // Output: Even
```
Shart operatorlaridan foydalanish misollar:
```csharp
// if-else
int age = 25;
if (age >= 18)
{
Console.WriteLine("You can vote.");
}
else
{
Console.WriteLine("You cannot vote.");
}
// switch-case
int dayOfWeek = 3;
switch (dayOfWeek)
{
case 1:
Console.WriteLine("Monday");
break;
case 2:
Console.WriteLine("Tuesday");
break;
case 3:
Console.WriteLine("Wednesday");
break;
default:
Console.WriteLine("Invalid day");
break;
}
// ternary operator
int num = 7;
string evenOrOdd = (num % 2 == 0) ? "Even" : "Odd";
Console.WriteLine(evenOrOdd); // Output: Odd
```
Shart operatorlari shartlarni tekshirish va tegishli kodlarni bajarish uchun keng qo'llaniladi. Shart operatorlaridan to'g'ri foydalanish dasturning mantiqiy tuzilishi va oqimini yaxshilash uchun muhimdir.
6 C#'da qo'llaniladigan takrorlash operatorlari (loops) quyidagilar:
1. **for operatori**:
- Sintaksisi: `for (start; condition; increment) { ... }`
- Shart bajarilgacha blok takrorlanadi.
- Masalan:
```csharp
for (int i = 0; i < 5; i++)
{
Console.WriteLine($"Iteration {i}");
}
```
2. **while operatori**:
- Sintaksisi: `while (shart) { ... }`
- Shart bajarilgacha blok takrorlanadi.
- Masalan:
```csharp
int count = 0;
while (count < 3)
{
Console.WriteLine($"Count: {count}");
count++;
}
```
3. **do-while operatori**:
- Sintaksisi: `do { ... } while (shart);`
- Blok kamida bir marta bajariladi, so'ngra shart tekshiriladi va agar shart bajarilsa, blok qayta bajariladi.
- Masalan:
```csharp
int num = 0;
do
{
Console.WriteLine($"Number: {num}");
num++;
} while (num < 3);
```
4. **foreach operatori**:
- Sintaksisi: `foreach (type item in collection) { ... }`
- Kolleksiyoning har bir elementini ketma-ket takrorlaydi.
- Masalan:
```csharp
string[] names = { "John", "Jane", "Bob" };
foreach (string name in names)
{
Console.WriteLine(name);
}
```
Takrorlash operatorlaridan foydalanish misollar:
```csharp
// for loop
for (int i = 0; i < 5; i++)
{
Console.WriteLine($"Iteration {i}");
}
// while loop
int count = 0;
while (count < 3)
{
Console.WriteLine($"Count: {count}");
count++;
}
// do-while loop
int num = 0;
do
{
Console.WriteLine($"Number: {num}");
num++;
} while (num < 3);
// foreach loop
string[] names = { "John", "Jane", "Bob" };
foreach (string name in names)
{
Console.WriteLine(name);
}
```
Takrorlash operatorlaridan dasturlash jarayonlarini avtomatlashtirish, massivlar, kolleksiyalar va boshqa ma'lumotlar strukturalarini aylana-aylanaga harakatlantirish uchun keng foydalaniladi. Turli xil shart va takrorlash operatorlarini to'g'ri tanlash va ulardan oqilona foydalanish dasturni samarali va tushunarliroq qiladi.
7 Windows Forms-da konteyner komponentalar quyidagilar:
1. **GroupBox**:
- Xususiyatlari:
- `Text`: Konteynerning sarlavhasini o'rnatadi.
- `AutoSize`: Konteyner o'zining ichidagi komponentlarga moslashishi uchun true qiymatiga o'rnatiladi.
- `Padding`: Konteyner ichidagi komponentlar va konteyner chegarasi o'rtasidagi masofa.
- `ForeColor`: Konteyner sarlavhasining rangini o'rnatadi.
- `BackColor`: Konteyner fonining rangini o'rnatadi.
- Foydalanish:
```csharp
GroupBox groupBox = new GroupBox();
groupBox.Text = "Settings";
groupBox.AutoSize = true;
groupBox.Padding = new Padding(10);
groupBox.ForeColor = Color.Blue;
groupBox.BackColor = Color.LightGray;
this.Controls.Add(groupBox);
```
2. **Panel**:
- Xususiyatlari:
- `AutoSize`: Panelning o'lchamini ichidagi komponentlarga moslashtirish.
- `Dock`: Panelning ota-konteyner ichidagi joylashuvini belgilaydi.
- `BorderStyle`: Panelning chegarasi uchun chiziq turini o'rnatadi.
- `BackColor`: Panelning fon rangini o'rnatadi.
- Foydalanish:
```csharp
Panel panel = new Panel();
panel.AutoSize = true;
panel.Dock = DockStyle.Top;
panel.BorderStyle = BorderStyle.FixedSingle;
panel.BackColor = Color.LightGray;
this.Controls.Add(panel);
```
3. **FlowLayoutPanel**:
- Xususiyatlari:
- `FlowDirection`: Komponentlarni qanday joylashtirishni belgilaydi (Horizontal yoki Vertical).
- `WrapContents`: Komponentlar sig'mayo qolsa, yangi qatorga o'tish.
- `AutoScroll`: Komponentlar sig'maydigan bo'lsa, scrollbar paydo bo'ladi.
- Foydalanish:
```csharp
FlowLayoutPanel flowPanel = new FlowLayoutPanel();
flowPanel.FlowDirection = FlowDirection.LeftToRight;
flowPanel.WrapContents = true;
flowPanel.AutoScroll = true;
this.Controls.Add(flowPanel);
Button button1 = new Button { Text = "Button 1" };
Button button2 = new Button { Text = "Button 2" };
Button button3 = new Button { Text = "Button 3" };
flowPanel.Controls.Add(button1);
flowPanel.Controls.Add(button2);
flowPanel.Controls.Add(button3);
```
Bu konteyner komponentalar grafik interfeys yaratishda muhim rol o'ynaydi. Ular komponentlarni guruhlash, joylashtirishda, shuningdek, panellar va scrollbarlar qo'llashda yordamlashadi.
8 Yana bir nechta Windows Forms konteyner komponentalari:
1. **ComboBox**:
- Xususiyatlari:
- `Items`: Kombo box-ga qo'shilgan elementlar ro'yxati.
- `SelectedItem`: Tanlangan elementni olish yoki o'rnatish.
- `DropDownStyle`: Kombo box-ning ochilish uslubini belgilaydi.
- `AutoCompleteMode`: Foydalanuvchining kiritishini avtomatik to'ldirish usulini belgilaydi.
- Foydalanish:
```csharp
ComboBox comboBox = new ComboBox();
comboBox.Items.AddRange(new[] { "Option 1", "Option 2", "Option 3" });
comboBox.SelectedIndex = 0;
comboBox.DropDownStyle = ComboBoxStyle.DropDownList;
comboBox.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
this.Controls.Add(comboBox);
```
2. **TabControl**:
- Xususiyatlari:
- `TabPages`: Teglar ro'yxati.
- `SelectedTab`: Tanlangan tegni olish yoki o'rnatish.
- `Alignment`: Teglarning joylashuv yo'nalishini belgilaydi.
- `Appearance`: Teglarning ko'rinishini belgilaydi.
- Foydalanish:
```csharp
TabControl tabControl = new TabControl();
TabPage page1 = new TabPage("Page 1");
TabPage page2 = new TabPage("Page 2");
tabControl.TabPages.Add(page1);
tabControl.TabPages.Add(page2);
tabControl.SelectedTab = page1;
tabControl.Alignment = TabAlignment.Top;
tabControl.Appearance = TabAppearance.FlatButtons;
this.Controls.Add(tabControl);
```
3. **SplitContainer**:
- Xususiyatlari:
- `Panel1` va `Panel2`: Konteynerning ikkita paneli.
- `SplitterDistance`: Panellar o'rtasidagi qisqartma masofasini o'rnatadi.
- `SplitterWidth`: Panellarni ajratuvchi splitterni o'rnatadi.
- `Orientation`: Panellarning joylashuv yo'nalishini belgilaydi.
- Foydalanish:
```csharp
SplitContainer splitContainer = new SplitContainer();
splitContainer.Panel1.Controls.Add(new Button { Text = "Panel 1" });
splitContainer.Panel2.Controls.Add(new Button { Text = "Panel 2" });
splitContainer.SplitterDistance = 200;
splitContainer.SplitterWidth = 10;
splitContainer.Orientation = Orientation.Horizontal;
this.Controls.Add(splitContainer);
```
Bu komponentalar grafik interfeys dizayni uchun juda muhimdir. Ular foydalanuvchi interfeysini tashkil etishda, tizimli va tushunarliroq qilishda yordamlashadi.
9 Tamam, quyida Windows Forms konteyner komponentalardan yana uchta tashkil etuvchining xususiyatlari va foydalanish misollarini keltirib o'tamiz:
1. **GroupBox**:
- Xususiyatlari:
- `Text`: Konteynerning sarlavhasini o'rnatadi.
- `AutoSize`: Konteyner o'zining ichidagi komponentlarga moslashishi uchun true qiymatiga o'rnatiladi.
- `Padding`: Konteyner ichidagi komponentlar va konteyner chegarasi o'rtasidagi masofa.
- `ForeColor`: Konteyner sarlavhasining rangini o'rnatadi.
- `BackColor`: Konteyner fonining rangini o'rnatadi.
- Foydalanish:
```csharp
GroupBox groupBox = new GroupBox();
groupBox.Text = "Settings";
groupBox.AutoSize = true;
groupBox.Padding = new Padding(10);
groupBox.ForeColor = Color.Blue;
groupBox.BackColor = Color.LightGray;
this.Controls.Add(groupBox);
```
2. **TabControl**:
- Xususiyatlari:
- `TabPages`: Teglar ro'yxati.
- `SelectedTab`: Tanlangan tegni olish yoki o'rnatish.
- `Alignment`: Teglarning joylashuv yo'nalishini belgilaydi.
- `Appearance`: Teglarning ko'rinishini belgilaydi.
- Foydalanish:
```csharp
TabControl tabControl = new TabControl();
TabPage page1 = new TabPage("Page 1");
TabPage page2 = new TabPage("Page 2");
tabControl.TabPages.Add(page1);
tabControl.TabPages.Add(page2);
tabControl.SelectedTab = page1;
tabControl.Alignment = TabAlignment.Top;
tabControl.Appearance = TabAppearance.FlatButtons;
this.Controls.Add(tabControl);
```
3. **CheckedListBox**:
- Xususiyatlari:
- `Items`: Elementlar ro'yxati.
- `CheckedItems`: Belgilangan elementlarni olish/o'rnatish.
- `CheckOnClick`: Foydalanuvchi elementni tiklash/belgilash uchun bosishi kerakmi.
- `SelectedItem`: Tanlangan elementni olish/o'rnatish.
- Foydalanish:
```csharp
CheckedListBox checkedListBox = new CheckedListBox();
checkedListBox.Items.AddRange(new[] { "Option 1", "Option 2", "Option 3" });
checkedListBox.SetItemChecked(0, true);
checkedListBox.CheckOnClick = true;
checkedListBox.SelectedIndex = 1;
this.Controls.Add(checkedListBox);
```
Bu komponentalar grafik interfeys yaratishda juda foydali bo'lib, foydalanuvchi interfeysini tashkil etish, navigatsiya qilish, ma'lumotlarni tanlash imkonini beradi.
10 Yaxshi, quyida yana uchta Windows Forms konteyner komponentalarning xususiyatlari va foydalanish misollarini keltirib o'tamiz:
1. **Panel**:
- Xususiyatlari:
- `BackColor`: Panelning orqa fon rangini o'rnatadi.
- `BorderStyle`: Panelning chekka chiziqlarining uslubini o'rnatadi.
- `Dock`: Panelning joylashishini belgilaydi.
- `AutoScroll`: Panel ichidagi elementlar agar sig'may qolsa, skrollni yoqadi.
- Foydalanish:
```csharp
Panel panel = new Panel();
panel.BackColor = Color.LightGray;
panel.BorderStyle = BorderStyle.FixedSingle;
panel.Dock = DockStyle.Left;
panel.AutoScroll = true;
this.Controls.Add(panel);
```
2. **FlowLayoutPanel**:
- Xususiyatlari:
- `FlowDirection`: Elementlarning joylashuv yo'nalishini belgilaydi.
- `WrapContents`: Agar elementlar sig'may qolsa, ularni yangi qatorga o'tkazadi.
- `Padding`: Paneldagi elementlar va chekka oralig'i.
- Foydalanish:
```csharp
FlowLayoutPanel flowLayoutPanel = new FlowLayoutPanel();
flowLayoutPanel.FlowDirection = FlowDirection.LeftToRight;
flowLayoutPanel.WrapContents = true;
flowLayoutPanel.Padding = new Padding(10);
flowLayoutPanel.Controls.Add(new Button { Text = "Button 1" });
flowLayoutPanel.Controls.Add(new Button { Text = "Button 2" });
flowLayoutPanel.Controls.Add(new Button { Text = "Button 3" });
this.Controls.Add(flowLayoutPanel);
```
3. **ListBox**:
- Xususiyatlari:
- `Items`: Elementlar ro'yxati.
- `SelectedItem`: Tanlangan elementni olish/o'rnatish.
- `SelectedIndex`: Tanlangan elementning indeksini olish/o'rnatish.
- `SelectionMode`: Foydalanuvchining tanlash usulini belgilaydi.
- Foydalanish:
```csharp
ListBox listBox = new ListBox();
listBox.Items.AddRange(new[] { "Item 1", "Item 2", "Item 3" });
listBox.SelectedIndex = 0;
listBox.SelectionMode = SelectionMode.MultiExtended;
this.Controls.Add(listBox);
```
Bu komponentalar grafik interfeys loyihalashda juda foydali bo'lib, ma'lumotlarni tashkil etish, joylashtirib ko'rsatish, navigatsiya va boshqa funksiyalarni amalga oshirishda qo'l keladi.
11 Yaxshi, quyida yana uchta Windows Forms konteyner komponentalarning xususiyatlari va foydalanish misollarini keltirib o'tamiz:
1. **Panel**:
- Xususiyatlari:
- `BackColor`: Panelning orqa fon rangini o'rnatadi.
- `BorderStyle`: Panelning chekka chiziqlarining uslubini o'rnatadi.
- `Dock`: Panelning joylashishini belgilaydi.
- `AutoScroll`: Panel ichidagi elementlar agar sig'may qolsa, skrollni yoqadi.
- Foydalanish:
```csharp
Panel panel = new Panel();
panel.BackColor = Color.LightGray;
panel.BorderStyle = BorderStyle.FixedSingle;
panel.Dock = DockStyle.Left;
panel.AutoScroll = true;
this.Controls.Add(panel);
```
2. **ComboBox**:
- Xususiyatlari:
- `Items`: Elementlar ro'yxati.
- `SelectedItem`: Tanlangan elementni olish/o'rnatish.
- `SelectedIndex`: Tanlangan elementning indeksini olish/o'rnatish.
- `DropDownStyle`: Kombo-box uslubini belgilaydi.
- Foydalanish:
```csharp
ComboBox comboBox = new ComboBox();
comboBox.Items.AddRange(new[] { "Option 1", "Option 2", "Option 3" });
comboBox.SelectedIndex = 0;
comboBox.DropDownStyle = ComboBoxStyle.DropDownList;
this.Controls.Add(comboBox);
```
3. **SplitContainer**:
- Xususiyatlari:
- `Panel1` va `Panel2`: Konteynerning chap va o'ng panellari.
- `Orientation`: Konteynerning yo'nalishini belgilaydi.
- `SplitterDistance`: Panellar o'rtasidagi masofa.
- `SplitterWidth`: Panellarni ajratib turuvchi splitterni kengligini belgilaydi.
- Foydalanish:
```csharp
SplitContainer splitContainer = new SplitContainer();
splitContainer.Panel1.Controls.Add(new Button { Text = "Button 1" });
splitContainer.Panel2.Controls.Add(new Button { Text = "Button 2" });
splitContainer.Orientation = Orientation.Horizontal;
splitContainer.SplitterDistance = 200;
splitContainer.SplitterWidth = 10;
this.Controls.Add(splitContainer);
```
Bu komponentalar grafik interfeys loyihalashda juda foydali bo'lib, ma'lumotlarni tashkil etish, joylashtirib ko'rsatish, navigatsiya va boshqa funksiyalarni amalga oshirishda qo'l keladi.
12 Yaxshi, quyida Windows Forms ro'yxat komponentalarining xususiyatlari va foydalanish misollarini keltirib o'tamiz:
1. **ListBox**:
- Xususiyatlari:
- `Items`: Elementlar ro'yxati.
- `SelectedItem`: Tanlangan elementni olish/o'rnatish.
- `SelectedIndex`: Tanlangan elementning indeksini olish/o'rnatish.
- `SelectionMode`: Foydalanuvchining tanlash usulini belgilaydi.
- Foydalanish:
```csharp
ListBox listBox = new ListBox();
listBox.Items.AddRange(new[] { "Item 1", "Item 2", "Item 3" });
listBox.SelectedIndex = 0;
listBox.SelectionMode = SelectionMode.MultiExtended;
this.Controls.Add(listBox);
```
2. **ComboBox**:
- Xususiyatlari:
- `Items`: Elementlar ro'yxati.
- `SelectedItem`: Tanlangan elementni olish/o'rnatish.
- `SelectedIndex`: Tanlangan elementning indeksini olish/o'rnatish.
- `DropDownStyle`: Kombo-box uslubini belgilaydi.
- Foydalanish:
```csharp
ComboBox comboBox = new ComboBox();
comboBox.Items.AddRange(new[] { "Option 1", "Option 2", "Option 3" });
comboBox.SelectedIndex = 0;
comboBox.DropDownStyle = ComboBoxStyle.DropDownList;
this.Controls.Add(comboBox);
```
3. **CheckedListBox**:
- Xususiyatlari:
- `Items`: Elementlar ro'yxati.
- `CheckedItems`: Belgilangan elementlarni olish/o'rnatish.
- `CheckedIndices`: Belgilangan elementlarning indekslarini olish/o'rnatish.
- `CheckOnClick`: Elementni bir marta bosish bilan belgilash/belgilanish xususiyatini o'zgartirishni yoqadi.
- Foydalanish:
```csharp
CheckedListBox checkedListBox = new CheckedListBox();
checkedListBox.Items.AddRange(new[] { "Item 1", "Item 2", "Item 3" });
checkedListBox.SetItemChecked(0, true);
checkedListBox.SetItemChecked(2, true);
checkedListBox.CheckOnClick = true;
this.Controls.Add(checkedListBox);
```
Bu komponentalar foydalanuvchilarga ma'lumotlarni tanlash va boshqarish imkonini beradi. Ular grafik loyihalarda ma'lumotlar kiritish, navigatsiya va boshqa interaktiv funksiyalarni amalga oshirishda qo'l keladi.
13 Yaxshi, C# dasturlash tilida massivlar va ulardan foydalanish haqida ma'lumot beramiz.
**Massiv (Array)** - bu bir xil turdagi ma'lumotlar to'plami bo'lib, ular indeks raqamlari orqali kiritiladi va olinadi.
C# da massivni e'lon qilish uchun quyidagi sintaksisdan foydalaniladi:
```csharp
dataType[] arrayName = new dataType[size];
```
Masalan:
```csharp
int[] numbers = new int[5];
string[] names = new string[3];
```
Massiv elementlariga murojaat qilish uchun indeks raqamlaridan foydalaniladi:
```csharp
numbers[0] = 10;
names[1] = "John";
```
Massiv elementlarini ko'rish yoki o'zgartirish uchun `for` tsikli yoki `foreach` operatori ishlatiladi:
```csharp
for (int i = 0; i < numbers.Length; i++)
{
Console.WriteLine(numbers[i]);
}
foreach (string name in names)
{
Console.WriteLine(name);
}
```
Quyida massivlar ustida bajarilishi mumkin bo'lgan ba'zi amallar keltirilgan:
1. **Massiv uzunligini olish**: `numbers.Length`
2. **Massiv elementlarini tartiblash**: `Array.Sort(numbers);`
3. **Massivni teskari tartibga keltirib olish**: `Array.Reverse(numbers);`
4. **Massivda ma'lum qiymatni qidirib topish**: `Array.IndexOf(names, "John");`
5. **Massiv elementlarini nusxalash**: `int[] copy = (int[])numbers.Clone();`
Massivlar turli xil vazifalarni hal qilishda keng qo'llaniladi, masalan, ma'lumotlarni saqlash, jadvallar, graflar va boshqa murakkab ma'lumot tuzilmalarini yaratish.
14 C# dasturlash tilida ko'p o'lchovli massivlar (Multidimensional Arrays) ham qo'llaniladi. Ular ikki yoki undan ortiq o'lchov (indeks) ga ega bo'lgan massivlar hisoblanadi.
**Ko'p o'lchovli massivning asosiy xususiyatlari:**
1. **Deklaratsiya**: Ko'p o'lchovli massivlar quyidagi sintaksisda e'lon qilinadi:
```csharp
dataType[,] arrayName = new dataType[size1, size2];
dataType[,,] arrayName = new dataType[size1, size2, size3];
```
Masalan:
```csharp
int[,] matrix = new int[3, 4];
string[,,] cube = new string[2, 3, 2];
```
2. **Indeksga murojaat**: Ko'p o'lchovli massivlarga murojaat qilish uchun har bir o'lcham uchun alohida indeks beriladi:
```csharp
matrix[0, 1] = 10;
cube[1, 2, 0] = "value";
```
3. **Uzunlik**: Ko'p o'lchovli massivlarning uzunligi `GetLength(index)` metodi orqali olinadi, bunda `index` o'lcham raqamini bildiradi:
```csharp
int rows = matrix.GetLength(0); // 3
int cols = matrix.GetLength(1); // 4
int depth = cube.GetLength(2); // 2
```
4. **Iteratsiya**: Ko'p o'lchovli massivlarni aylanib o'tish uchun `for` tsikllari qo'llaniladi:
```csharp
for (int i = 0; i < matrix.GetLength(0); i++)
{
for (int j = 0; j < matrix.GetLength(1); j++)
{
Console.WriteLine(matrix[i, j]);
}
}
```
Ko'p o'lchovli massivlardan quyidagi hollarda foydalaniladi:
- Matritsalar (2D) - matematik va muhandislik hisob-kitoblari
- Kub (3D) - uchlik koordinatalar, rangli tasvirlar
- Ko'p o'lchovli ma'lumotlar - geografik ma'lumotlar, rastrli tasvir ma'lumotlari
Umumiy qilib aytganda, ko'p o'lchovli massivlar murakkab ma'lumotlarni saqlash va ular ustida amallar bajarish uchun qo'l keladi.
15 C# dasturlash tilida kolleksiyalar (Collections) ma'lumotlarni saqlash va boshqarishda keng qo'llaniladi. Kolleksiyalar massivlarga qaraganda ancha moslashuvchan va qulaydir. Ular turli xil ma'lumotlar tiplari va o'lchamdagi ob'ektlarni saqlashi mumkin.
**C# da asosiy kolleksiya turlari:**
1. **List** - dinamik indekslangan ma'lumotlar to'plami. Qo'shish, o'chirish, izlash kabi operatsiyalarni bajarish mumkin.
2. **Dictionary** - kalitlar va qiymatlar juftligidan iborat kolleksiya. Kalit orqali qiymatga tez kirib olish imkonini beradi.
3. **HashSet** - takrorlanmaydigan yagona qiymatlar to'plami. Tez qidiruv va unikallash imkonini beradi.
4. **Queue** - FIFO (First In First Out) tartibini saqlagan kolleksiya. Qo'shish va chiqarish operatsiyalarini bajarish mumkin.
5. **Stack** - LIFO (Last In First Out) tartibini saqlagan kolleksiya. Qo'shish va chiqarish operatsiyalarini bajarish mumkin.
Kolleksiyalar bilan ishlash uchun quyidagi asosiy amallardan foydalaniladi:
1. **Yaratish**: `List numbers = new List();`
2. **Qo'shish**: `numbers.Add(10);`
3. **Olib tashlash**: `numbers.Remove(10);`
4. **Indeks orqali kiritish**: `numbers[0] = 20;`
5. **Uzunlikni olish**: `numbers.Count;`
6. **Elementlarni aylanib o'tish**: `foreach (int num in numbers) { ... }`
Kolleksiyalar umumiy ma'lumotlarni saqlash, taxlash, tartiblash va boshqarishda katta qulaylik yaratadi. Ular turli xil ma'lumot tiplari (butun sonlar, satrlar, ob'ektlar) bilan ishlash imkonini beradi. Shuningdek, C# LINQ kutubxonasi kolleksiya ustida turli xil so'rovlarni bajarish imkonini beradi.
16 C# Windows Forms platformasida forma (Form) dasturning asosiy interfeysi hisoblanadi. Formalar bir qator xususiyatlari va xossalari bilan tavsiflanadi:
1. **Nomi (Name)**: Formanmg unikal nomi. Bu nom kodni yozishda va formanm boshqa elementlari bilan o'zaro aloqada bo'lishda ishlatiladi.
2. **Sarlavha (Text)**: Formanmg yuqori qismida ko'rsatiladigan sarlavha matnl.
3. **O'lchamlari (Size)**: Formanmg uzunlik va kengligi. Oddiy formalar uchun 800x600 piksel tavsiya etiladi.
4. **Joylashuvi (Location)**: Formanmg ekranda joylashgan koordinatalari (X, Y).
5. **Stil (WindowState)**: Forma oynasining holati: oddiy (Normal), katta (Maximized) yoki kichik (Minimized).
6. **Yopib yuborish (FormClosedEventHandler)**: Forma yopilganda yuz beradigan hodisa. Bunda dastur yakunlanishi yoki boshqa navbatdagi forma ochilishi mumkin.
7. **Yuklarish (Load)**: Forma yuklanishi paytida yuz beradigan hodisa. Bunda elementlar, ma'lumotlar va boshqa foydalanuvchi interfeysini tayyor qilish mumkin.
8. **Panjaraga joylashish (StartPosition)**: Forma ekranda qaerda joylashishi kerakligi: ekran o'rtasida, ekran burchagida yoki boshqa koordinatalarda.
9. **Panjaraga olish (Enabled)**: Forma interfeysining foydalanuvchiga mavjudligi. Agar false bo'lsa, forma o'zaro muloqotga kirishib bo'lmaydi.
10. **Qoplamasini o'zgartirish (BackColor, ForeColor)**: Forma foni va yozuv (matn) rangini o'zgartirish.
Formalar ushbu xususiyatlar va yana boshqa ko'plab xususiyatlarga ega bo'lib, ulardan foydalanish orqali dasturlar uchun turli xil interfeys yaratish, shakllantirish va boshqarish imkoniyati mavjud.
17 C# Windows Forms platformasida asosiy va keng qo'llaniladigan komponentalar quyidagilar:
1. **Button (Tugma)**:
- Xususiyatlari: Text, Enabled, BackColor, ForeColor, Font va boshqalar.
- Hodisalari: Click - tugma bosilganda yuz beradi.
- Foydalanish: `button1.Click += Button1_Click;` va `private void Button1_Click(object sender, EventArgs e) { ... }`.
2. **Label (Yorliq)**:
- Xususiyatlari: Text, Enabled, BackColor, ForeColor, Font va boshqalar.
- Hodisalari: yoq.
- Foydalanish: `label1.Text = "Salom, Dunyo!";`.
3. **TextBox (Matn kiritish qutisi)**:
- Xususiyatlari: Text, Enabled, BackColor, ForeColor, Font, ReadOnly va boshqalar.
- Hodisalari: TextChanged - matn o'zgarganda yuz beradi, KeyPress - klaviaturadan harf kiritilganda yuz beradi.
- Foydalanish:
```csharp
textBox1.TextChanged += TextBox1_TextChanged;
private void TextBox1_TextChanged(object sender, EventArgs e)
{
label1.Text = textBox1.Text;
}
```
Misollar:
```csharp
// Button
private void Button1_Click(object sender, EventArgs e)
{
label1.Text = "Tugma bosildi!";
}
// Label
label1.Text = "Salom, Dunyo!";
// TextBox
private void TextBox1_TextChanged(object sender, EventArgs e)
{
label1.Text = textBox1.Text;
}
```
Ushbu komponentalar dasturlarning asosiy interfeys elementlari bo'lib, ulardan foydalanish orqali foydalanuvchi bilan interaktiv ravishda muloqot qilish, ma'lumot kiritish/chiqarish, funksiyalarni bajarish va boshqa amallarni amalga oshirish mumkin.
18 Yana bir qator foydalanish uchun qo'l keluvchi Windows Forms komponentalari quyidagilar:
1. **MaskedTextBox (Matnni maskali kiritish qutisi)**:
- Xususiyatlari: Mask, Text, Enabled, BackColor, ForeColor, Font va boshqalar.
- Hodisalari: MaskInputRejected - foydalanuvchi matnni kiritish talablariga mos kelmagan holda kiritganda yuz beradi, TextChanged - matn o'zgarganda yuz beradi.
- Foydalanish:
```csharp
maskedTextBox1.Mask = "(999) 000-0000";
maskedTextBox1.TextChanged += MaskedTextBox1_TextChanged;
private void MaskedTextBox1_TextChanged(object sender, EventArgs e)
{
label1.Text = maskedTextBox1.Text;
}
```
2. **RadioButton (Tanlov belgisi)**:
- Xususiyatlari: Text, Checked, Enabled, BackColor, ForeColor, Font va boshqalar.
- Hodisalari: CheckedChanged - tugma holati (belgilangan/belgilanmagan) o'zgarganda yuz beradi.
- Foydalanish:
```csharp
radioButton1.CheckedChanged += RadioButton1_CheckedChanged;
private void RadioButton1_CheckedChanged(object sender, EventArgs e)
{
if (radioButton1.Checked)
label1.Text = "Birinchi tanlov tanlandi";
else
label1.Text = "Birinchi tanlov tanlangan emas";
}
```
3. **CheckBox (Belgilash belgisi)**:
- Xususiyatlari: Text, Checked, Enabled, BackColor, ForeColor, Font va boshqalar.
- Hodisalari: CheckedChanged - tutgich holati (belgilangan/belgilanmagan) o'zgarganda yuz beradi.
- Foydalanish:
```csharp
checkBox1.CheckedChanged += CheckBox1_CheckedChanged;
private void CheckBox1_CheckedChanged(object sender, EventArgs e)
{
if (checkBox1.Checked)
label1.Text = "Belgilangan";
else
label1.Text = "Belgilanmagan";
}
```
Bu kabi komponentalar foydalanuvchi interfeysini boyitish, turli xil kiritish ma'lumotlarini olish va boshqa amallarni amalga oshirish uchun qo'l keladi.
19 Windows Forms platformasidagi tugma (Button), radio tugma (RadioButton) va belgilash belgisi (CheckBox) komponentlarining hodisalari va ulardan foydalanish misollarini keltiramiz:
1. **Button (Tugma):**
- Hodisasi: Click - tugma bosilganda yuz beradi.
- Foydalanish:
```csharp
private void Button1_Click(object sender, EventArgs e)
{
label1.Text = "Tugma bosildi!";
}
```
2. **RadioButton (Radio Tugma):**
- Hodisasi: CheckedChanged - radio tugma holati (belgilangan/belgilanmagan) o'zgarganda yuz beradi.
- Foydalanish:
```csharp
private void RadioButton1_CheckedChanged(object sender, EventArgs e)
{
if (radioButton1.Checked)
label1.Text = "Birinchi radio tugma tanlandi";
else
label1.Text = "Birinchi radio tugma tanlangan emas";
}
```
3. **CheckBox (Belgilash Belgisi):**
- Hodisasi: CheckedChanged - belgilash belgisining holati (belgilangan/belgilanmagan) o'zgarganda yuz beradi.
- Foydalanish:
```csharp
private void CheckBox1_CheckedChanged(object sender, EventArgs e)
{
if (checkBox1.Checked)
label1.Text = "Belgilangan";
else
label1.Text = "Belgilanmagan";
}
```
Ushbu misollardan ko'rinib turibdiki, har bir komponent o'z xususiyatlari va hodisalariga ega. Hodisalar yordamida foydalanuvchi bilan interaktiv ravishda muloqot qilish, ma'lumotlarni olish va ularni ishlatish mumkin.
Masalan, tugma (Button) komponenti Click hodisasi yordamida foydalanuvchi tugmani bosganida biror amal bajarish, radio tugma (RadioButton) va belgilash belgisi (CheckBox) komponentlarining CheckedChanged hodisalari orqali ularning holati o'zgarganda biror harakatni amalga oshirish mumkin.
20 Windows Forms platformasidagi konteyner komponentalar quyidagilar:
1. **GroupBox (Guruh Qutisi):**
- Xususiyatlari: Text, Enabled, BackColor, ForeColor, Font va boshqalar.
- Hodisalari: yoq.
- Foydalanish:
```csharp
groupBox1.Text = "Qo'shimcha sozlamalar";
```
2. **Panel (Oyna):**
- Xususiyatlari: BackColor, BorderStyle, Enabled, Visible va boshqalar.
- Hodisalari: Resize - oyna o'lchamlari o'zgarganda yuz beradi.
- Foydalanish:
```csharp
private void Panel1_Resize(object sender, EventArgs e)
{
label1.Location = new Point(panel1.Width / 2 - label1.Width / 2,
panel1.Height / 2 - label1.Height / 2);
}
```
3. **FlowLayoutPanel (Oqim Joylashuv Paneli):**
- Xususiyatlari: FlowDirection, WrapContents, AutoScroll va boshqalar.
- Hodisalari: ControlAdded - yangi element qo'shilganda, ControlRemoved - element o'chirilganda yuz beradi.
- Foydalanish:
```csharp
private void FlowLayoutPanel1_ControlAdded(object sender, ControlEventArgs e)
{
label1.Text = $"Panelga {e.Control.Name} elementi qo'shildi";
}
```
Konteyner komponentlar boshqa komponentlarni o'z ichiga oladi va ularni joylashtirib, tartibga solish uchun xizmat qiladi. Masalan, GroupBox ichida radio tugmalar yoki CheckBox-lar, Panel ichida boshqa komponentlar, FlowLayoutPanel esa komponentlarni avtomatik ravishda joylashtirib beradi.
Hodisalari orqali konteyner ichidagi o'zgarishlarni kuzatish va tegishli harakatlarni bajarish mumkin. Masalan, Panel resize bo'lganda uning o'rtasiga joylashgan elementni markazlash, FlowLayoutPanel ga yangi element qo'shilganda uni e'lon qilish.
21 Tushunganlaringiz juda yaxshi. Endi qolgan konteyner komponentlar: ComboBox, TabControl va SplitContainer haqida ma'lumot berayin.
1. **ComboBox (Birlashtirish Qutucha):**
- Xususiyatlari: Items, SelectedItem, SelectedIndex, Text, Enabled, Visible va boshqalar.
- Hodisalari: SelectedIndexChanged - tanlangan element o'zgarganda yuz beradi.
- Foydalanish:
```csharp
comboBox1.Items.Add("Birinchi element");
comboBox1.Items.Add("Ikkinchi element");
comboBox1.SelectedIndex = 0; // Birinchi elementni tanlash
private void ComboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
label1.Text = "Tanlangan element: " + comboBox1.SelectedItem;
}
```
2. **TabControl (Varaq Boshqaruvchi):**
- Xususiyatlari: SelectedTab, TabPages, Alignment, Appearance va boshqalar.
- Hodisalari: SelectedIndexChanged - tanlangan varaq o'zgarganda yuz beradi.
- Foydalanish:
```csharp
tabControl1.TabPages.Add("Birinchi varaq");
tabControl1.TabPages.Add("Ikkinchi varaq");
tabControl1.SelectedIndex = 0; // Birinchi varaqni tanlash
private void TabControl1_SelectedIndexChanged(object sender, EventArgs e)
{
label1.Text = "Tanlangan varaq: " + tabControl1.SelectedTab.Text;
}
```
3. **SplitContainer (Bo'lingan Konteyner):**
- Xususiyatlari: Panel1, Panel2, SplitterDistance, Orientation va boshqalar.
- Hodisalari: SplitterMoved - bo'linuvchi joylashishi o'zgarganda yuz beradi.
- Foydalanish:
```csharp
splitContainer1.Orientation = Orientation.Horizontal;
splitContainer1.SplitterDistance = 200;
private void SplitContainer1_SplitterMoved(object sender, SplitterEventArgs e)
{
label1.Text = $"Bo'linuvchan masofasi: {splitContainer1.SplitterDistance}";
}
```
Bu komponentlar orqali foydalanuvchiga yanada interaktiv va moslanadigan interfeys yaratish mumkin. Masalan, ComboBox komponentidan tanlov qilish, TabControl komponentidan varaqlar orasida naviqatsiya qilish, SplitContainer komponentidan ekran maydonini moslashtirish uchun foydalanish mumkin.
22 Albatta, Windows Forms konteyner komponentalaridan GroupBox, TabControl va CheckedListBox haqida batafsil ma'lumot beraman.
1. **GroupBox (Guruh Qutisi):**
- Xususiyatlari: Text, Enabled, BackColor, ForeColor, Font va boshqalar.
- Hodisalari: yo'q.
- Foydalanish:
```csharp
groupBox1.Text = "Qo'shimcha sozlamalar";
groupBox1.BackColor = Color.LightGray;
```
2. **TabControl (Varaq Boshqaruvchi):**
- Xususiyatlari: SelectedTab, TabPages, Alignment, Appearance va boshqalar.
- Hodisalari: SelectedIndexChanged - tanlangan varaq o'zgarganda yuz beradi.
- Foydalanish:
```csharp
tabControl1.TabPages.Add("Birinchi varaq");
tabControl1.TabPages.Add("Ikkinchi varaq");
tabControl1.SelectedIndex = 0; // Birinchi varaqni tanlash
private void TabControl1_SelectedIndexChanged(object sender, EventArgs e)
{
label1.Text = "Tanlangan varaq: " + tabControl1.SelectedTab.Text;
}
```
3. **CheckedListBox (Belgilanadigan Ro'yxat Qutucha):**
- Xususiyatlari: CheckedItems, CheckedIndices, Items, Sorted, Enabled va boshqalar.
- Hodisalari: ItemCheck - element belgilanganda/belgilanmaganda yuz beradi.
- Foydalanish:
```csharp
checkedListBox1.Items.Add("Birinchi element");
checkedListBox1.Items.Add("Ikkinchi element");
checkedListBox1.Items.Add("Uchinchi element");
private void CheckedListBox1_ItemCheck(object sender, ItemCheckEventArgs e)
{
label1.Text = $"'{checkedListBox1.Items[e.Index]}' {(e.NewValue == CheckState.Checked ? "belgilandi" : "belgilanmadi")}";
}
```
Bu komponentlar foydalanuvchilarga ma'lumotlarni guruhlar, varaqlar va belgilanadigan ro'yxatlar orqali tashkil qilish imkonini beradi. GroupBox komponentidan konteyner sifatida foydalanish, TabControl komponentidan sahifalar orasida o'tish, CheckedListBox komponentidan esa ko'p tanlash imkonini beruvchi ro'yxatni yaratish mumkin.
Hodisalar orqali ushbu komponentlarda ro'y beradigan o'zgarishlarni kuzatish va tegishli harakatlarni bajarish imkoniyati mavjud. Masalan, TabControl uchun SelectedIndexChanged hodisasi tanlangan varaqning o'zgarishini ko'rsatadi, CheckedListBox uchun ItemCheck hodisasi element belgilanishi/belgilanmasligi haqida ma'lumot beradi.
23 Yaxshi, siz so'ragan Windows Forms konteyner komponentalaridan Panel, FlowLayoutPanel va ListBox haqida ma'lumot beraman.
1. **Panel (Panel):**
- Xususiyatlari: BackColor, BorderStyle, Enabled, Visible va boshqalar.
- Hodisalari: yo'q (lekin panel ichidagi komponentlar uchun hodisalar mavjud).
- Foydalanish:
```csharp
panel1.BackColor = Color.LightGray;
panel1.BorderStyle = BorderStyle.FixedSingle;
// Panel ichiga boshqa komponentlarni qo'shish
panel1.Controls.Add(button1);
panel1.Controls.Add(textBox1);
```
2. **FlowLayoutPanel (Oqim Joylashtirish Paneli):**
- Xususiyatlari: FlowDirection, WrapContents, AutoScroll va boshqalar.
- Hodisalari: yo'q (lekin panel ichidagi komponentlar uchun hodisalar mavjud).
- Foydalanish:
```csharp
flowLayoutPanel1.FlowDirection = FlowDirection.LeftToRight;
flowLayoutPanel1.WrapContents = true;
// Panel ichiga boshqa komponentlarni qo'shish
flowLayoutPanel1.Controls.Add(button1);
flowLayoutPanel1.Controls.Add(button2);
flowLayoutPanel1.Controls.Add(button3);
```
3. **ListBox (Ro'yxat Qutucha):**
- Xususiyatlari: SelectedItem, SelectedItems, SelectedIndex, Items, Sorted, Enabled va boshqalar.
- Hodisalari: SelectedIndexChanged - tanlangan element o'zgarganda yuz beradi.
- Foydalanish:
```csharp
listBox1.Items.Add("Birinchi element");
listBox1.Items.Add("Ikkinchi element");
listBox1.Items.Add("Uchinchi element");
listBox1.SelectedIndex = 0; // Birinchi elementni tanlash
private void ListBox1_SelectedIndexChanged(object sender, EventArgs e)
{
label1.Text = "Tanlangan element: " + listBox1.SelectedItem;
}
```
Panel komponentidan konteyner sifatida foydalanish, FlowLayoutPanel komponentidan joylashuv tartibini boshqarish, ListBox komponentidan esa ro'yxat yaratish uchun foydalanish mumkin.
Hodisalar orqali ushbu komponentlarda ro'y beradigan o'zgarishlarni kuzatish va tegishli harakatlarni bajarish imkoniyati mavjud. Masalan, ListBox uchun SelectedIndexChanged hodisasi tanlangan element o'zgarishini ko'rsatadi.
24 Yaxshi, siz so'ragan Windows Forms konteyner komponentalaridan Panel, ComboBox va SplitContainer haqida ma'lumot beraman.
1. **Panel (Panel):**
- Xususiyatlari: BackColor, BorderStyle, Enabled, Visible va boshqalar.
- Hodisalari: yo'q (lekin panel ichidagi komponentlar uchun hodisalar mavjud).
- Foydalanish:
```csharp
panel1.BackColor = Color.LightGray;
panel1.BorderStyle = BorderStyle.FixedSingle;
// Panel ichiga boshqa komponentlarni qo'shish
panel1.Controls.Add(button1);
panel1.Controls.Add(textBox1);
```
2. **ComboBox (Kombinatsiya Qutucha):**
- Xususiyatlari: SelectedItem, SelectedIndex, Items, Sorted, Enabled va boshqalar.
- Hodisalari: SelectedIndexChanged - tanlangan element o'zgarganda yuz beradi.
- Foydalanish:
```csharp
comboBox1.Items.Add("Birinchi element");
comboBox1.Items.Add("Ikkinchi element");
comboBox1.Items.Add("Uchinchi element");
comboBox1.SelectedIndex = 0; // Birinchi elementni tanlash
private void ComboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
label1.Text = "Tanlangan element: " + comboBox1.SelectedItem;
}
```
3. **SplitContainer (Bo'lingan Konteyner):**
- Xususiyatlari: SplitterDistance, Panel1, Panel2, Orientation va boshqalar.
- Hodisalari: SplitterMoved - bo'lingan konteyner o'lchamlarining o'zgarishi yuz berganda.
- Foydalanish:
```csharp
splitContainer1.Orientation = Orientation.Horizontal;
splitContainer1.SplitterDistance = 200;
// Bo'lingan konteynerlar ichiga boshqa komponentlarni qo'shish
splitContainer1.Panel1.Controls.Add(label1);
splitContainer1.Panel2.Controls.Add(button1);
private void SplitContainer1_SplitterMoved(object sender, SplitterEventArgs e)
{
label2.Text = $"Splitter manzili: {splitContainer1.SplitterDistance}";
}
```
Panel komponentidan konteyner sifatida foydalanish, ComboBox komponentidan tanlash qutucha yaratish, SplitContainer komponentidan esa bo'lingan konteynerlar yaratish uchun foydalanish mumkin.
Hodisalar orqali ushbu komponentlarda ro'y beradigan o'zgarishlarni kuzatish va tegishli harakatlarni bajarish imkoniyati mavjud. Masalan, ComboBox uchun SelectedIndexChanged hodisasi tanlangan element o'zgarishini ko'rsatadi, SplitContainer uchun SplitterMoved hodisasi bo'lingan konteyner o'lchamlarining o'zgarishini ko'rsatadi.
25 Yaxshi, siz so'ragan Windows Forms ro'yxat komponentalaridan ListBox, ComboBox va CheckedListBox haqida ma'lumot beraman.
1. **ListBox (Ro'yxat Qutucha):**
- Xususiyatlari: SelectedItem, SelectedItems, SelectedIndex, Items, Sorted, Enabled va boshqalar.
- Hodisalari: SelectedIndexChanged - tanlangan element o'zgarganda yuz beradi.
- Foydalanish:
```csharp
listBox1.Items.Add("Birinchi element");
listBox1.Items.Add("Ikkinchi element");
listBox1.Items.Add("Uchinchi element");
listBox1.SelectedIndex = 0; // Birinchi elementni tanlash
private void ListBox1_SelectedIndexChanged(object sender, EventArgs e)
{
label1.Text = "Tanlangan element: " + listBox1.SelectedItem;
}
```
2. **ComboBox (Kombinatsiya Qutucha):**
- Xususiyatlari: SelectedItem, SelectedIndex, Items, Sorted, Enabled va boshqalar.
- Hodisalari: SelectedIndexChanged - tanlangan element o'zgarganda yuz beradi.
- Foydalanish:
```csharp
comboBox1.Items.Add("Birinchi element");
comboBox1.Items.Add("Ikkinchi element");
comboBox1.Items.Add("Uchinchi element");
comboBox1.SelectedIndex = 0; // Birinchi elementni tanlash
private void ComboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
label1.Text = "Tanlangan element: " + comboBox1.SelectedItem;
}
```
3. **CheckedListBox (Tekshirilgan Ro'yxat Qutucha):**
- Xususiyatlari: CheckedItems, CheckedIndices, Items, Sorted, Enabled va boshqalar.
- Hodisalari: ItemCheck - element tekshirilganda yuz beradi.
- Foydalanish:
```csharp
checkedListBox1.Items.Add("Birinchi element");
checkedListBox1.Items.Add("Ikkinchi element");
checkedListBox1.Items.Add("Uchinchi element");
checkedListBox1.SetItemChecked(0, true); // Birinchi elementni tekshirilgan qilish
private void CheckedListBox1_ItemCheck(object sender, ItemCheckEventArgs e)
{
label1.Text = "Tekshirilgan element: " + checkedListBox1.CheckedItems[e.Index];
}
```
ListBox komponentidan ro'yxat yaratish, ComboBox komponentidan tanlash qutucha yaratish, CheckedListBox komponentidan esa tekshirilgan ro'yxat yaratish uchun foydalanish mumkin.
Hodisalar orqali ushbu komponentlarda ro'y beradigan o'zgarishlarni kuzatish va tegishli harakatlarni bajarish imkoniyati mavjud. Masalan, ListBox uchun SelectedIndexChanged hodisasi tanlangan element o'zgarishini ko'rsatadi, ComboBox uchun SelectedIndexChanged hodisasi tanlangan element o'zgarishini ko'rsatadi, CheckedListBox uchun ItemCheck hodisasi element tekshirilishini ko'rsatadi.
26 Yaxshi, siz so'ragan Windows Forms konteyner komponentalaridan radioButton, ComboBox va CheckedListBox haqida ma'lumot beraman.
1. **RadioButton (Radio Tugma):**
- Xususiyatlari: Checked, Text, TabIndex, Enabled va boshqalar.
- Hodisalari: CheckedChanged - radio tugma holatining o'zgarishida yuz beradi.
- Foydalanish:
```csharp
radioButton1.Text = "Birinchi variant";
radioButton1.Checked = true;
radioButton2.Text = "Ikkinchi variant";
radioButton2.Checked = false;
private void RadioButton1_CheckedChanged(object sender, EventArgs e)
{
if (radioButton1.Checked)
label1.Text = "Tanlangan variant: Birinchi variant";
else
label1.Text = "Tanlangan variant: Ikkinchi variant";
}
```
2. **ComboBox (Kombinatsiya Qutucha):**
- Xususiyatlari: SelectedItem, SelectedIndex, Items, Sorted, Enabled va boshqalar.
- Hodisalari: SelectedIndexChanged - tanlangan element o'zgarganda yuz beradi.
- Foydalanish:
```csharp
comboBox1.Items.Add("Birinchi element");
comboBox1.Items.Add("Ikkinchi element");
comboBox1.Items.Add("Uchinchi element");
comboBox1.SelectedIndex = 0; // Birinchi elementni tanlash
private void ComboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
label1.Text = "Tanlangan element: " + comboBox1.SelectedItem;
}
```
3. **CheckedListBox (Tekshirilgan Ro'yxat Qutucha):**
- Xususiyatlari: CheckedItems, CheckedIndices, Items, Sorted, Enabled va boshqalar.
- Hodisalari: ItemCheck - element tekshirilganda yuz beradi.
- Foydalanish:
```csharp
checkedListBox1.Items.Add("Birinchi element");
checkedListBox1.Items.Add("Ikkinchi element");
checkedListBox1.Items.Add("Uchinchi element");
checkedListBox1.SetItemChecked(0, true); // Birinchi elementni tekshirilgan qilish
private void CheckedListBox1_ItemCheck(object sender, ItemCheckEventArgs e)
{
label1.Text = "Tekshirilgan element: " + checkedListBox1.CheckedItems[e.Index];
}
```
RadioButton komponentidan bir nechta tanlovdan birini tanlash uchun foydalanish mumkin, ComboBox komponentidan tanlash qutucha yaratish uchun, CheckedListBox komponentidan esa tekshirilgan ro'yxat yaratish uchun foydalanish mumkin.
Hodisalar orqali ushbu komponentlarda ro'y beradigan o'zgarishlarni kuzatish va tegishli harakatlarni bajarish imkoniyati mavjud. Masalan, RadioButton uchun CheckedChanged hodisasi radio tugma holatining o'zgarishini ko'rsatadi, ComboBox uchun SelectedIndexChanged hodisasi tanlangan element o'zgarishini ko'rsatadi, CheckedListBox uchun ItemCheck hodisasi element tekshirilishini ko'rsatadi.
27 Yaxshi, siz so'ragan Windows Forms konteyner komponentalaridan GroupBox, FlowLayoutPanel va CheckBox haqida ma'lumot beraman.
1. **GroupBox (Guruh Qutucha):**
- Xususiyatlari: Text, Controls, Enabled, Visible va boshqalar.
- Hodisalari: yoq.
- Foydalanish:
```csharp
GroupBox groupBox1 = new GroupBox();
groupBox1.Text = "Guruh 1";
groupBox1.Location = new Point(20, 20);
groupBox1.Size = new Size(200, 100);
RadioButton radioButton1 = new RadioButton();
radioButton1.Text = "Birinchi variant";
radioButton1.Location = new Point(10, 20);
groupBox1.Controls.Add(radioButton1);
RadioButton radioButton2 = new RadioButton();
radioButton2.Text = "Ikkinchi variant";
radioButton2.Location = new Point(10, 50);
groupBox1.Controls.Add(radioButton2);
```
2. **FlowLayoutPanel (Oqim Maketi Paneli):**
- Xususiyatlari: WrapContents, FlowDirection, AutoSize, Padding va boshqalar.
- Hodisalari: yoq.
- Foydalanish:
```csharp
FlowLayoutPanel flowLayoutPanel1 = new FlowLayoutPanel();
flowLayoutPanel1.FlowDirection = FlowDirection.TopDown;
flowLayoutPanel1.WrapContents = false;
flowLayoutPanel1.Location = new Point(20, 20);
flowLayoutPanel1.Size = new Size(200, 100);
Button button1 = new Button();
button1.Text = "Birinchi tugma";
flowLayoutPanel1.Controls.Add(button1);
Button button2 = new Button();
button2.Text = "Ikkinchi tugma";
flowLayoutPanel1.Controls.Add(button2);
```
3. **CheckBox (Belgilash Qutucha):**
- Xususiyatlari: Checked, Text, TabIndex, Enabled va boshqalar.
- Hodisalari: CheckedChanged - belgilash holatining o'zgarishida yuz beradi.
- Foydalanish:
```csharp
checkBox1.Text = "Birinchi variant";
checkBox1.Checked = true;
checkBox2.Text = "Ikkinchi variant";
checkBox2.Checked = false;
private void CheckBox1_CheckedChanged(object sender, EventArgs e)
{
if (checkBox1.Checked)
label1.Text = "Tanlangan: Birinchi variant";
else
label1.Text = "Tanlangan: Ikkinchi variant";
}
```
GroupBox komponentidan birlashtirilgan komponentlarni guruhlash uchun foydalanish mumkin, FlowLayoutPanel komponentidan tarkibidagi elementlarni yonma-yon joylashtirib, oqim tarzida joylashtirish uchun foydalanish mumkin, CheckBox komponentidan esa ikkita variant orasidan birini tanlash uchun foydalanish mumkin.
Hodisalar orqali ushbu komponentlarda ro'y beradigan o'zgarishlarni kuzatish va tegishli harakatlarni bajarish imkoniyati mavjud. Masalan, CheckBox uchun CheckedChanged hodisasi belgilash holatining o'zgarishini ko'rsatadi.
28 C# dasturlash tilida "for" takrorlash operatori ancha keng qo'llaniladi. U belgilangan shart bajarilguncha ma'lum blok kodlarni takrorlaydi.
"for" operatorining sintaksisi quyidagicha:
```csharp
for (initialization; condition; iteration)
{
// code block to be executed
}
```
Bu yerda:
- `initialization` - ushbu qism takrorlash boshlanishida bajariladi va siklni boshlab beradi.
- `condition` - shart qismi bo'lib, agar shart bajarilsa, kod bloki bajariladi.
- `iteration` - siklni har bir marta bajarish tugagandan so'ng bajariladi, odatda o'zgaruvchining qiymati o'zgartiriladi.
"for" operatoridan foydalanish misollar:
1. Oddiy for tsikli:
```csharp
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Raqam: " + i);
}
```
Natija:
```
Raqam: 0
Raqam: 1
Raqam: 2
Raqam: 3
Raqam: 4
```
2. Juft raqamlarni chiqarish:
```csharp
for (int i = 0; i <= 10; i += 2)
{
Console.WriteLine("Juft raqam: " + i);
}
```
Natija:
```
Juft raqam: 0
Juft raqam: 2
Juft raqam: 4
Juft raqam: 6
Juft raqam: 8
Juft raqam: 10
```
3. Teskari sana:
```csharp
for (int i = 10; i >= 1; i--)
{
Console.WriteLine("Raqam: " + i);
}
```
Natija:
```
Raqam: 10
Raqam: 9
Raqam: 8
Raqam: 7
Raqam: 6
Raqam: 5
Raqam: 4
Raqam: 3
Raqam: 2
Raqam: 1
```
4. Masiv elementlarini chiqarish:
```csharp
string[] names = { "John", "Jane", "Bob", "Alice" };
for (int i = 0; i < names.Length; i++)
{
Console.WriteLine("Name: " + names[i]);
}
```
Natija:
```
Name: John
Name: Jane
Name: Bob
Name: Alice
```
"for" operatori juda qulay va keng qo'llaniladi. U takrorlash sikllarini yaratish uchun foydali bo'ladi va har xil ehtiyojlarga moslashtiriladigan qilib yozilishi mumkin.
29 C# dasturlash tilida "while" takrorlash operatori ham keng qo'llaniladi. U shart bajarilgungacha ma'lum blok kodlarni takrorlaydi.
"while" operatorining sintaksisi quyidagicha:
```csharp
while (condition)
{
// code block to be executed
}
```
Bu yerda:
- `condition` - shart qismi bo'lib, agar shart bajarilsa, kod bloki bajariladi.
"while" operatoridan foydalanish misollar:
1. Odatiy while tsikli:
```csharp
int i = 0;
while (i < 5)
{
Console.WriteLine("Raqam: " + i);
i++;
}
```
Natija:
```
Raqam: 0
Raqam: 1
Raqam: 2
Raqam: 3
Raqam: 4
```
2. Foydalanuvchidan ma'lumot olish:
```csharp
int number;
bool isValid = false;
while (!isValid)
{
Console.Write("Iltimos, 1 dan 10 gacha son kiriting: ");
string input = Console.ReadLine();
if (int.TryParse(input, out number) && number >= 1 && number <= 10)
{
isValid = true;
Console.WriteLine("Siz kiritgan son: " + number);
}
else
{
Console.WriteLine("Xato! Qaytadan urinib ko'ring.");
}
}
```
Natija:
```
Iltimos, 1 dan 10 gacha son kiriting: 5
Siz kiritgan son: 5
```
3. Bexabar tsikl:
```csharp
bool shouldContinue = true;
while (shouldContinue)
{
Console.WriteLine("Bu bexabar tsikl. Chiqish uchun 'exit' yozing.");
string input = Console.ReadLine();
if (input.ToLower() == "exit")
{
shouldContinue = false;
}
}
Console.WriteLine("Siz dasturdan chiqding.");
```
Natija:
```
Bu bexabar tsikl. Chiqish uchun 'exit' yozing.
hello
Bu bexabar tsikl. Chiqish uchun 'exit' yozing.
world
Bu bexabar tsikl. Chiqish uchun 'exit' yozing.
exit
Siz dasturdan chiqding.
```
"while" operatori shartga asoslangan takrorlash tsikllarini yaratish uchun foydali. U shart bajarilguncha takrorlashni davom ettiradi. Bundan tashqari, "do...while" operatoridan ham foydalanish mumkin, bu operatorga ko'ra kod bloki kamida bir marta bajariladi, keyin esa shartga asoslanib takrorlash davom etadi.
30 C# dasturlash tilida "switch" tanlash operatori keng qo'llaniladi. U bir nechta "case" shartlarini tekshirish va mos kelgan blok kodlarni bajarish imkonini beradi.
"switch" operatorining sintaksisi quyidagicha:
```csharp
switch (expression)
{
case value1:
// code block
break;
case value2:
// code block
break;
...
default:
// code block
break;
}
```
Bu yerda:
- `expression` - tekshirilayotgan ifoda.
- `case value1`, `case value2`, ... - turli qiymatlarga mos keladigan "case" shartlari.
- `break` - mos kelgan "case" blokini bajarganidan so'ng, "switch" operatoridan chiqish uchun qo'llaniladi.
- `default` - agar hech qaysi "case" shart bajarilmasa, bajariladi.
"switch" operatoridan foydalanish misollar:
1. Oddiy switch operatori:
```csharp
int day = 3;
string dayName;
switch (day)
{
case 1:
dayName = "Monday";
break;
case 2:
dayName = "Tuesday";
break;
case 3:
dayName = "Wednesday";
break;
default:
dayName = "Invalid day";
break;
}
Console.WriteLine("Today is " + dayName);
```
Natija:
```
Today is Wednesday
```
2. String qiymatli switch operatori:
```csharp
string fruit = "apple";
string message;
switch (fruit.ToLower())
{
case "apple":
message = "An apple a day keeps the doctor away.";
break;
case "banana":
message = "Bananas are rich in potassium.";
break;
case "orange":
message = "Oranges are a good source of vitamin C.";
break;
default:
message = "I don't know much about that fruit.";
break;
}
Console.WriteLine(message);
```
Natija:
```
An apple a day keeps the doctor away.
```
3. Switch operatorida break operatorini qo'llamaslik:
```csharp
int month = 3;
string season;
switch (month)
{
case 12:
case 1:
case 2:
season = "Winter";
break;
case 3:
case 4:
case 5:
season = "Spring";
break;
case 6:
case 7:
case 8:
season = "Summer";
break;
case 9:
case 10:
case 11:
season = "Fall";
break;
default:
season = "Invalid month";
break;
}
Console.WriteLine("The current season is " + season);
```
Natija:
```
The current season is Spring
```
"switch" operatori tanlash va qaror qabul qilish uchun juda qulay. U qiymatlarni tekshirish va mos keladigan blok kodlarni bajarish imkonini beradi. Shuningdek, bu operatordan o'zgaruvchan ma'lumotlar bilan ham ishlash mumkin.
31 Tabiiyki, C# Windows Forms dasturlashida bir qator komponentalar mavjud bo'lib, ular orasidan radioButton, ListBox va ComboBox komponentalari ham keng qo'llaniladi. Ularning asosiy xususiyatlari va ishlash printsiplari quyidagicha:
1. RadioButton:
- Xususiyatlari:
- `Text` - tugmachaning matnini belgilaydi.
- `Checked` - tugmachaning holatini (belgilangan/belgilanmagan) belgilaydi.
- `GroupName` - tugmachalarni birlashtirib, ulardan faqat bittasini tanlash imkonini beradi.
- Ishlash prinsipi:
- Bir guruhga tegishli radioButton komponentalaridan faqat bittasi tanlanishi mumkin.
- `Checked` xususiyati `true` bo'lgan radioButton tanlab olinadi.
- `GroupName` xususiyati bir xil radioButtonlarni bir guruhga birlashtiradi.
2. ListBox:
- Xususiyatlari:
- `Items` - listboxda ko'rsatiladigan elementlarni belgilaydi.
- `SelectedItem` - tanlangan elementning qiymatini olish uchun ishlатiladi.
- `SelectedIndex` - tanlangan elementning indeksini olish uchun ishlатiladi.
- Ishlash prinsipi:
- Listboxda ko'rsatiladigan elementlarni `Items` orqali belgilash mumkin.
- Foydalanuvchi listboxdan bitta yoki bir nechta elementni tanlaydi.
- Tanlangan elementning qiymati `SelectedItem` orqali, indeksi esa `SelectedIndex` orqali olinadi.
3. ComboBox:
- Xususiyatlari:
- `Items` - comboboxda ko'rsatiladigan elementlarni belgilaydi.
- `SelectedItem` - tanlangan elementning qiymatini olish uchun ishlатiladi.
- `SelectedIndex` - tanlangan elementning indeksini olish uchun ishlатiladi.
- Ishlash prinsipi:
- Comboboxda ko'rsatiladigan elementlarni `Items` orqali belgilash mumkin.
- Foydalanuvchi comboboxdan bitta elementni tanlaydi.
- Tanlangan elementning qiymati `SelectedItem` orqali, indeksi esa `SelectedIndex` orqali olinadi.
Ishlash misollar:
```csharp
// RadioButton
RadioButton rbMale = new RadioButton();
rbMale.Text = "Male";
rbMale.Checked = true;
RadioButton rbFemale = new RadioButton();
rbFemale.Text = "Female";
rbFemale.GroupName = "Gender";
// ListBox
ListBox lstColors = new ListBox();
lstColors.Items.Add("Red");
lstColors.Items.Add("Green");
lstColors.Items.Add("Blue");
int selectedIndex = lstColors.SelectedIndex;
string selectedColor = (string)lstColors.SelectedItem;
// ComboBox
ComboBox cmbFruits = new ComboBox();
cmbFruits.Items.Add("Apple");
cmbFruits.Items.Add("Banana");
cmbFruits.Items.Add("Orange");
int selectedFruitIndex = cmbFruits.SelectedIndex;
string selectedFruit = (string)cmbFruits.SelectedItem;
```
Bu komponentalar foydalanuvchi interfeysi yaratish va foydalanuvchidan ma'lumot olish uchun juda qo'l keladi. Ulardan to'g'ri va oqilona foydalanish asosida ilovalar yaratish mumkin.
|