DEV Community: Farkhodbek Kamolov

Natural type of Method group

Farkhodbek Kamolov — Thu, 30 May 2024 05:30:38 +0000

Method group haqida qisqacha:
Method group - bu bir xil nomga ega, ammo parametrlari va qaytish turlari(qisqacha sintaksis) bo'yicha farq qilishi mumkin bo'lgan funksiyalar to'plami. Method grouplar odatda delegatlar, hodisalar(event) va LINQ ifodalari bilan bog'liq vaziyatlarda qo'llaniladi. Batafsil malumot -> link.

C# tilidagi method group natural type(tabiy turi) kompilyator tomonidan guruh ichidagi methodlar sintaksiga mos keladigan delegat turiga ishora qiladi. C#-dagi natural type method guruhlarini ishlatish jarayonini soddalashtiradi, delegatlarni talab qiladigan kontekstlarda metod guruhlarini to'g'ridan-to'g'ri va yashirin foydalanishga imkon berish orqali kodni o'qish va samaradorlikni oshiradi. Bu, ayniqsa, LINQ so'rovlari va hodisa(event)larni boshqarish bilan bog'liq stsenariylarda foydalidir. Qisqa qilib aytganda natural type(tabiy tur) kompilyator tomonidan yashirincha delegatga o'giriladi, delegatlar esa o'z vaqtida, o'zining shartlarini qoniqtirgan funksiyani overloadini method groupdan tanlab oladi. Yaniy bu feature(natural type) delegatlarni ochiqchasiga(explecitly) yaratishga xojat qoldirmaydi, kontekstga qarab kompilyator o'zi yaratadi.

Delegatlar qanday ishlashini tushunish uchun kichik bir misol:

Action<string> writeLineString = Console.WriteLine;
writeLineString("Hello, World!");
// output -> Hello, World!

Birinchi qatorda writeLineString delegati yaratildi, va unga WriteLine method group o'zlashtirdi. Keyingi qatorda writeLineString delegatiga string malumot tipni argument sifatida joylandi, chunki bizning(kontekstda) delegatni sharti, faqat string qabul qiladigon funksiyalarni talab qiladi(Action<string>). Kompilyatorni o'zi delegatdan foydalanib, WriteLine guruhidan kerakli overloadni topib ishga tushiradi. Qisqacha delegatlar qanday ishlashi haqidaham tushib oldik

Endi esa C# da natural type tushunchasi kirib kelamagunicha bolgan holat:

var numbers = new[] { 1, 2, 3, 4, 5 };

Func<int, bool> isEvendelegate = IsEven;
var evenNumbers = numbers.Where(isEvendelegate).ToList();
Action<int> writeLineInt = Console.WriteLine;

Console.WriteLine("Even numbers:");
foreach (var num in evenNumbers)
    writeLineInt(num);

static bool IsEven(int number) => number % 2 == 0;

Output

Even numbers:
2
4

Func<int, bool> xuddi Action<string> kabi ishlaydi, lekin biroz farq qiladi. Func T1 delegatimizga o'zlashtiriladigon method groupga keladigon argument tipi, T2 esa shu methodimiz qaytaradigon malumot turi. Action<T> esa harqanday void qaytaradigon lekin T qabul qiladigon method guruhlar uchun ishlatiladi.

Kodda ko'rganimizdek numbers array bor(1dan 5gacha qiymatlari bilan), isEvenDelegati vakili(delegati) int type qabul qiluvchi va bool qaytarubchi method groupni qabul qiladi, bu shartni esa IsEven methodi qiniqtiradi, shung uchun ushbu metodni delegatimizga o'zlashtirdik. Keyingi qatorda LINQ funksiyalaridan bolmish Where() metodini delegatimiz unga argument qilib chaqirdik, bu metod esa faqatgina juft sonlardan tashkil topgan arrayni evenNumbers o'zgaruvchisiga o'zlashtirdi. Etibor qilgan bolsangiz birinchi misolimizdan ozgina farq qiladigon ko'dniham ishlatdik.

Endi esa huddi o'sha kodni faqat natural type bilan modify qilamiz:

var numbers = new[] { 1, 2, 3, 4, 5 };

var evenNumbers = numbers.Where(IsEven).ToList();

Console.WriteLine("Even numbers:");
evenNumbers.ForEach(Console.WriteLine);


bool IsEven(int number) => number % 2 == 0;

Output

Even numbers:
2
4

Ushbu misolimizda ko'rishingiz mumkin hechqanday Func<T1,T2> yoki Action<T> delegatlari yoq. Delegatlarni o'rniga tog'ridan to'g'ri method groupni ishlatdik, va natija esa birxil. Yana bir etibor qilishimiz kerak bolgan joyi, Where() funksiyasi bu safar ToList() qaytardi, bunday qilishga sabab, ForEach() metodi faqat list uchun ishlaydi, va bu funksiyaga Console.WriteLine method groupini delegat ishlatmasdan yubordik.

Aslida bu funksianal "natural type" C# da ~ 10 versiyadan beri bor, lekin o'sha damlardan beri bu optimal emas edi, yaniy kompilyator har bir methodga alohida qarab chiqar edi, hatto bazi funksiyala ochiqchasiga delegat shartini qoniqtirmasaham(boshqa tiplar qabul qilsaham, ko'proq yoki ozroq argumentlar soni bolsaham).
C# 13 da natural typeni ishlash prinsipini to'g'irlandi, endi kompilyator *scope ichidagi tog'ri kelmagan methodlarni tashlab yuboradi.
Agar methodlar generic bolsa yoki yetlicha/ortiqcha argumentlar soni. Agar kerakli method ushbu scopeda topilmasa, qidiruv kelgusi scope ga o'tadi, taqdim etilgan scopelardan birontasida kerakli shartni qoniqtira oladigon methodni topa olmasa, method group natural type-ga ega emas deb hisoblanadi, va compile-time error otadi. Oddiy qilib aytganda, kompilyator endi barcha mumkin bo'lgan methodlarni oldindan ko'rib chiqish o'rniga, har bir scope-ni tekshirganda, qo'llanilmaydigan/keraksiz methodlarni darhol chiqarib tashlash orqali method guruhidan qaysi overloaddan foydalanishni samaraliroq aniqlaydi. Bu esa o'z vaqtida jarayonni tezlashtiradi.

scope deb methodlar implement qilinga kontekstni class, import qilingan namespace larni nazarda tudadi.

Natural type of Method group

Farkhodbek Kamolov — Thu, 30 May 2024 05:30:38 +0000

Delegatlar qanday ishlashini tushunish uchun kichik bir misol:

Action<string> writeLineString = Console.WriteLine;
writeLineString("Hello, World!");
// output -> Hello, World!

Endi esa C# da natural type tushunchasi kirib kelamagunicha bolgan holat:

var numbers = new[] { 1, 2, 3, 4, 5 };

Func<int, bool> isEvendelegate = IsEven;
var evenNumbers = numbers.Where(isEvendelegate).ToList();
Action<int> writeLineInt = Console.WriteLine;

Console.WriteLine("Even numbers:");
foreach (var num in evenNumbers)
    writeLineInt(num);

static bool IsEven(int number) => number % 2 == 0;

Output

Even numbers:
2
4

Func<int, bool> xuddi Action<string> kabi ishlaydi, lekin biroz farq qiladi. Func T1 delegatimizga o'zlashtiriladigon method groupga keladigon argument tipi, T2 esa shu methodimiz qaytaradigon malumot turi. Action<T> esa harqanday void qaytaradigon lekin T qabul qiladigon method guruhlar uchun ishlatiladi.

Endi esa huddi o'sha kodni faqat natural type bilan modify qilamiz:

var numbers = new[] { 1, 2, 3, 4, 5 };

var evenNumbers = numbers.Where(IsEven).ToList();

Console.WriteLine("Even numbers:");
evenNumbers.ForEach(Console.WriteLine);


bool IsEven(int number) => number % 2 == 0;

Output

Even numbers:
2
4

scope deb methodlar implement qilinga kontekstni class, import qilingan namespace larni nazarda tudadi.

C# dagi Method overload va Method group.

Farkhodbek Kamolov — Thu, 30 May 2024 00:51:59 +0000

Method group va Method overload tushunchalarni farqlash uchun event, delegate yoki LINQ, shulardan hech bolmaganda kamida bir donasini bilish tavsiya qilinadi. Bu feature(xususiyat)lar, dasturchilarga bir vaqtning o'zida bir xil nomli birnechta methodlarni yaratishga imkon beradi. Ushbu o'xshash nomli methodlarni bir biridan farqi, ular qaytaradigon malumot tiplari hamda qabul qiluvchi argumentlar soni bir-biridan farq qilishidadur. Qishqacha qilib aytganda birxil ish bacharuvchi methodlarni bir nom ostida jamlash uchun ishlatilinadi.

NOTE: bu ikkala feature/tushuncha bir-biriga uzviy bog'liq!

Misol tariqasida Add() methodini yaratamiz:

static int Add(int a, int b) => a + b;
static long Add(long a, long b) => a + b;
static double Add(double a, double b) => a + b;

private static void Main(string[] args)
{
   int i = 1, j = 2;
   var sumOfInt = Add(i, j);
   Console.WriteLine($"Intlar summasi: {sumOfInt}");

   long l = 10, m = 20;
   var sumOfLong = Add(l, m);
   Console.WriteLine($"Longlar summasi: {sumOfLong}");

   double d = 1.102, s = 3.14;
   var sumOfDouble = Add(d, s);
   Console.WriteLine($"Doublelar summasi: {sumOfDouble}");
}

Output:

Intlar summasi: 3
Longlar summasi: 30
Doublelar summasi: 4.242

Yuqorida keltirilga ko'd asosan Metod overload tushunchasiga to'gri keladi, lekin method group sintaksisiham huddi shunday. Ularni farqi haqida sal pastroqda gaplashamiz.

Uchala Add() methodimizga etibor bersangiz, ular qabul qilayotgan argumentlar hamda, o'sha argumentlar ustida o'tqazilgan operatsiyadan so'ng qaytarishi kerak bolgan malumot turi(return type) bir biridan farq qiladi. C# kompilyatori shunchali aqillikiy, kelayotgan argument turiga asoslanib kerakli bolgan methodni o'zi chaqirib xisob kitobni amalga oshiradi.

Yana bir yaqqol misol tariqasida biz bilgan Console klasidan keluvchi WriteLine() methodini aytishimiz mumkin, har bir overloadi(nusxasi) void qaytargani bilan, methodlarni qabul qiluvchi argumentlar soni va ularni turlari har-hil. Qo'shimcha qilib aytamanki har kim o'z xo'xshiga ko'ra koplab kombinatsiyalarni amalga oshirishi mumkin, demoqchi bolganim method qaytaradigon type qolgan overloadlarinikiga o'xshash bolsaxam, qabul qiladigon typelar soni va turlari farq qilsa bolgani ishlayveradi. Shu jumladan teskarisigaham ishlayveradi, argumentlar birhil bolsada qatrariladigon tur boshqacha bolsa overload hisoblanadi. Lekin extiyot bo'lish zarur!!!

Method/funksiyalar qanday va qaysi payt ishga tushishi xaqida biroz tushuncha olsak: Harqanday methodga murojat qilinganda i.e. WriteLine agar () qavslarni qo'yilmasa bu funksiyamiz ishga tushmaydi. Yaniy () qavslari bor method kod run bolganida navbat o'sha funksiyaga kelishi bilanoq ishaga tushadi. Albatta bu tushuntirish abstrakt bolib toliq va mutloq to'g'ri bolgan misol emas. Lekin oz bolsada xaqiqatga yaqin.

Endi method group ga to'xtaladigon bolsak, postni cho'zib kod bilan misollarni keltirib o'tirmayman. Qisqacha qilib aytganda method group hamda method overload implementation(yaratilishi)ni syntaksisi birxil. Lekin bu ikkala tushunchani ishlatilish jarayoni va maqsadlari turlicha.

Method overload hamda method group qayerda va qanday ishlashi haqida batafsil gaplashsak.

Method overload - asosan kodni o'qish/tushunish uchun hamda eslab qolish uchun osonroq qiladigon feature xisoblanadi, yuqorida keltirilgan ko'dga yuzlansak, C# da agar overload qilish xususiyati bolmaganda harbir tip uchun boshqa boshqa nom o'ylab topish va uni qanday ish bajarishini yodda tutishimiz kerak bolar edi. Misol uchun int type uchun IntAdd(...), double uchun esa DoubleAdd(...) va hokazo. Overload qilingan methodlar turgan class filega yangiliklar kiritilganda, shu yangiliklarni handle(qayta ishlash) qilish uchun yana bir overload qo'shilsa bas. API lar yaratilganidaham juda qo'l kelishi mumkin.

Method groupni esa ko'pincha methodni darhol chaqirmasdan, uning nomiga gina murojaat qilib eventlarni handle qilish(qayta ishlash) hamda methodlarni parametrlar (delegatlar) sifatida o'tkazishda va LINQ expression(iboralari)ni islatilyotkanida foydalidur. Aniqroq qilib aytganda kod yozish paytida kerakli bolgan methodni nominigina yozib ketiladi va kod runtime(ishga tushgan)paytda, chaqiriladigan methodni keyinroq aniqlanashga imkon beradi. Bundan nima naf?! Yuqorida aytganimizdek methodlarni chaqirishimiz bilanoq ular ishga tushib keradi, bazi holatlarda esa bu narsa ko'dimizni flexibility(moslashuvchanlik)ga tasir ko'rsatadi. Misol uchun assinxron dastur tuzganimizda, dasturimiz ishga tushishi bilanoq, methodlarni o'sha zaxoti ishga tushishi, bizni dastur uchun ajratilgan resurslar(xotira)ni egallab qo'yishi, va bu o'z vaqtida hatoliklar yoki, xisob-kitobda kutilmagan natijalarga olib kelishi mumkin.

Misol:

// delegat
Action<string> writeLineString = Console.WriteLine; 
writeLineString("Hello, World!");

Birinchi qatorda delegate method groupdagi nomga ishora qiladi, lekin delegat turiga qarab maxsus overloadini chaqiradi, delegatimizda argument sifatiga stringni belgilaganmiz shuning uchun runtime paytida kompilyator WriteLine() methodini argument sifatida stringni oladigon overloadini chaqiradi.

Method group ishlash prinsipi method overloadnikiga o'xshash.

Endi LINQ bilan misolni ko'rib chiqsak:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

var evenNumbers = numbers.Where(IsEven).ToList();

evenNumbers.ForEach(Console.WriteLine); 

static bool IsEven(int number) => number % 2 == 0;

Bu code-da method group faqat IsEven funksiyasidan tashkil topgan, yaniy har-doimham qo'shimcha IsEven overloadi bo'lishi shart emas, method group deb bir dona methodniham aytsa boladi.

Kodmizda 1dan 5gacha bolgan list bor, va biz keyingi qatorga LINQ ni ishlatgan holda IsEven funksiyasini faqatgina nomini argument sifatida yuborib, faqat juft bo'lgan sonlar listini yaratyapmiz. IsEven funksiyasini agar () bilan chaqirsak bizning kod hatolik chiqaradi, chunki yuqorida aytilganidek () bilan chaqirilgan methodlar o'sha zahotiyoq ishga tushib ketadi. 3-chi qatorga etibor bersangiz ForEach() methodi WriteLine funksiyaniham faqatginaham method group nomiga murojat qilyapti, va kompilyator int type qabul qiladigon WriteLine overloadini chaqirib, sonlarni konsolga chiqarmoqda.

Method Group ga aloqador yana bir etiborga loyiq mavzu bor, uning nomi Method Group Natural Type bu mavzu xaqida esa boshqa postimda gaplashamiz.

Etibor uchun raxmat.

Yashirin indekserga kirish

Farkhodbek Kamolov — Tue, 28 May 2024 23:58:46 +0000

Bazida 0 indekslangan collectionlarni ohirgi qiymatiga murojat qilishda ko'pchiligimiz yo'l qo'yadigon oddiy bir xatolik bor array[array.Length], va hozirham oramizda bu yerda xatolikni payqamaganlarxam bo'lishi mumkin. Bu error esa o'z vaqtida judaham kichik, payqa qolish qiyin va asabga o'ynaydigon hatoliklardan deb xisoblayman (array[array.Length - 1] to'g'ri varianti).

C# 13-chi versiyasida Implicit Index Access -> yashirincha indeksga murojat degan feature qo'shildi. Bu feature ni ishlatishda bizga caret-^ operatori yordam beradi.

Misol:

int[] nums = new int[5] { 1, 2, 3, 4, 5 };
Conosle.WriteLine(nums[^1]);
// output -> 5

Implicit Index Access feature sini funksionalligi faqatgina ohirgi elementga murojat qilish bilan cheklanib qolmaydi. Bu xususiyat har-qanday 0 indekslangan collection ni oxiridan boshlab har bir qiymatiga murojat qilishda yordam beradi.

Misol:

int[] nums = [1, 2, 3, 4, 5];

for(int i = 1; i <= nums.Length; i++)
    Console.Write($"{nums[^i]} ");
// output -> 5 4 3 2 1

Etibor berish kerak bolga joyi bu funksional ^1(birdan) boshlanadi, bu degani arrayimizni uzunligi n bolsa, oxirgi qiymatning indexi n-1 ga teng, shu bilan birgalikda ^1 = n-1 yaniy eng oxirgi indeksga ko'rsatib turadi, ^2 esa oxirgidan bitta oldingi(^2 = n-2) indeksga teng, va hokazo.
Arrayni teskari o'girish misoliga boshqacharoq qilib ishlatamiz

Misol:

int[] nums = [1, 2, 3, 4, 5];

foreach (var item in ReverseArray(nums))
    Console.Write($"{item} ");

int[] ReverseArray(int[] array)
{
    int[] reversed = new int[array.Length];
    for(int i = 0; i < array.Length; i++) <---
        reversed[i] = array[^(i+1)];      <---

    return reversed;
}

// output -> 5 4 3 2 1

Bu safargi ko'dimizda i 1 ga emas 0 ga teng va array ni oxiridan murojatni boshlash uchun esa array[^(i+1)] ishlatildi.

Bundan tashqari bu feature ni harkim o'z tassavuri yetganicha va albatta C# kompilyatori ruhsat berganicha ishlata oladi. @wahidustoz aytganlaridek "Sky is the limit".

Nol indekslangan to'plamlar

Farkhodbek Kamolov — Tue, 28 May 2024 23:57:32 +0000

C# da bir nechta to'plam(collection type) turlari nol indekslangan, ya'ni ularning qiymatiga indeks 0 dan boshlab murojat qilish mumkin. Yani arrayni yoki listni 0-chi indeksga murojat qilsak, bizga 1-chi element(qiymati)ni qaytaradi.

Misol:

var nums = new int[]{1,2,3,4,5};
Console.WriteLine(nums[0]);
// output --> 1

C# da nol indeksli to'plamlar ro'yxatidan bir shingil: array, List<T>, ArrayList va hokazolar kiradi.

Yuqorida ko'rganimizdek, bizda nums nomi bilan, 1 dan 5 gacha bolgan sonlar arrayi berilgan, va biz konsolga birinchi elementi(qiymatini)ni chiqarishimiz uchun nums[0] deb murojat qildik. Keyingi elementiga murojat qilish uchun esa nums[1] deyish kifoya, va shu zaynda davom etaveradi.

0 indeksli toplamlarni ohirgi elementiga(umumiy elementlar soni n ga teng bolsa) nums[n-1] qilib murojat qilinadi. Nima uchun aynan n-1?!
Buning sababi, yuqoridagi kodga yuzlansak, u yerda qiymatlarning umumiy soni 5 ga teng(n = 5), indeks bo'ylab sanalganda esa 4 ga teng (0,1,2,3,4). Agar nums[5] qilsak, indeks bo'yicha sanalganda 5-chi indeks 6-chi elementga to'g'ri keladi, bizda esa umumiy 5ta qiymatlar bor.

indekslar -> 0 | 1 | 2 | 3 | 4
qiymatlar-> 1 | 2 | 3 | 4 | 5

Misol:

var nums = new int[]{1,2,3,4,5};
int n = nums.Length; // n = 5,
Console.WriteLine(nums[n-1]);
// output --> 5

Bu kodda nums.Length(length -> uzunligi) bizga n yaniy qiymatlar sonini topishda yordam beradi. Yuqoridagi kodimizni yanda qisqartirsak boladi.

Misol:

var nums = new int[]{1,2,3,4,5};
Console.WriteLine(nums[nums.Length - 1]);
// output --> 5

Bazida shunday holatlar boladiki ohirgi elementga murojat qilyotkanimizda nums[nums.Length] -1 ni qo'shib ketish yoddan chiqishi mumkin, bu esa o'z vaqtida hatolikga olib keladi.
C# 13-chi versiyasidan boshlab yangi feature(xususiyat) kirib keldi uning nomini
Implicit index access -> Indeksga yashirin kirish deb nomlashdi, va bu xususiyatni ishlatish uchun esa ^(caret -> karet) aperatori bilan amalga oshirish mumkin. Bu feature xaqida ushbu -> link postimda tanishib chiqsangiz boladi.

Yangi \e - escape ketma-ketligi

Farkhodbek Kamolov — Tue, 28 May 2024 04:08:42 +0000

Yangi escape ketma-ketligi(escape sequence) haqida gapirishdan oldin, o'zim uchunham yangilik bo'lgan bir tushuncha haqida aytishni shart deb bildim.
Shu kungacha, shaxsan men uchun birxil manoga ega bolgan, ko'plab dasturlash tillarida, hususan C# daham, escape belgi(character) hamda escape ketma-ketligi(sequence) degan ikkita bir-biridan farq qildigon, lekin uzviy bog'liq konsepsiyalarni farqi nimada ekanligini iloji boricha qisqacha tushuntirishga harakat qilaman.
Escape character(belgi) deb \ backslash ni aytiladi. Bu o'zi nima uchun kerak?! Hechkimga sir emaski double quotes "" hamda backslash \, maxsus belgilar hisoblanib, ularni string malumot turiga shunchaki saqlab keta olmaymiz. Sababi ushbu belgilarni kompilyatorda boshqa maqsad uchun ishlatilinadi.

Misol:

// error
string str1 = "Shoqasim "yaxshi" bola";
string str2 = "Shoqasim \yaxshi\ bola";

Bu kodimiz hatolik keltirib chiqaradi, ushbu hatolikni oldini olish uchun, bizga \ escape -> qochish belgisi yordam beradi(hatolikdan qochishga yo'l ochib beradi).

Misol:

string str1 = "Shoqasim \"yaxshi\" bola"; 
string str2 = "Shoqasim \\yaxshi\\ bola";

Console.WriteLine(str1); --> Shoqasim "yaxshi" bola
Console.WriteLine(str2); --> Shoqasim \yaxshi\ bola

Misolda ko'rganimiz kabi qo'sh tirnoq " yoki orqa chiziq
\ belgilarini hatoliklarsiz saqlash uchun bizga escape character yordam berdi. Lekin bu yerda yana bir qo'shimcha qilish kerakki \", yoki \\ belgilari, bundan buyog'iga escape character emas balki escape sequence deyiladi. Bu bilan demoqchi bolganim shundaki escape character doimo bitta backslash \, va ushbu \ belgi, escape sequence lar yaratishga yo'l beradi. Escape sequence larni turlari ko'p, eng ko'p uchraydigonlari: \", \\, \n, \t, \r va boshqalar. Ushbu ketma-ketliklar bizga string qiymatlarini turli hil formatlash(shakllash)ga yordam beradi. Ko'proq misollar uchun -> havola.

Endi ushbu postimizni asosiy qaxramoni bo'lmish \e escape sequence ga o'tsak. Ushbu yangi sequence, 13-chi versiyadan oldingi ESCAPE belgisi(ASCII jadvali bo'yicha 27-chi)ni ifodalovchi \x1b sequence orniga kelishi kutilmoqda.
Bu belgi nimani bildiradi degan savolga kodda javob berishga harakat qilaman.

Console.WriteLine("\x1b");
// output -> Bo'm-bo'sh bolib qoladi

Outputda hich-narsa ko'rinmasligini sababi, x1b (ESC) belgisi asosan konsolga chiqishi kerak bolgan matinni manipulyatsiya qilish uchun ishlatiladi(rangini o'zgartirish, formatini o'zgartirish vaho-kazo...).

Misol:

Console.WriteLine("\x1b[31mHello \x1b[0mWorld!");
// output -> Hello(qizil rangda)  World!(defolt rangda)
Console.WriteLine("\x1bHello \x1bWorld!");
// output -> ello orld! birinchi harflar o'chib ketadi

Hattoki Microsoft o'z documentationida \x1b ishlatishni maslaxat bermaydi. Bunga sabab 1b ketma-ketligidan keyin keluvchi qiymatlar o'n oltilik sanoq tizimini qiymatiga teng bo'lib qolishi mumkin va kutilmagan natijalarni keltirib chiqarishi mumkin.

Misol:

Console.WriteLine("\x1b12");
// output -> ? belgisi

Shunaqangi kutilmagan xatoliklar oldini olish maqsadida Microsoft \x1b sequensini \e o'zgartirmoqchi. Yangi ketma-ketlikni endi ikkilanmay \e12 qilib ishlatsa bo'ladi, hechqanday ? belgisi chiqmaydi. Formatlash sistemasixam eski sequence nikidek qoladi.

Misol:

Console.WriteLine("\e12");
// output -> 2
Console.WriteLine($"\e[31m123\e[0m456");
123(qizil rangda) 456 (defolt rangda)

params key-word

Farkhodbek Kamolov — Mon, 27 May 2024 23:37:17 +0000

params - kalit so'zi avvalroq c# ning 12-chi versiyasida taqdim etilgan edi, u vaqtda params ni faqat array turiga nisbatan ishlata olardik, 13-chi versiyada esa params harqanday collection turiga nisbatan ishlatsa bo'ladi, yani harqanday IEnumerable vorislariga qollasa boladi.
params kalit so'zi o'zgaruvchan sonli(istalgan miqtorda), argumentlarni metodga o'tkazish imkonini beradi. Bu shuni anglatadiki, siz funksiyani istalgan miqdordagi argumentlar, jumladan, nol bilan chaqirishingiz mumkin. Bu kalit so'zi kompilyatorga, kelayotgan argumentlarni individual obekt sifatida emas, balki bir-butun collection sifatida ko'rib chiqilishini anglatadi.
C# ning 11-chi versiyasigacha, agar metodga biz array(yoki harqanday collection) o'tqazmoqchi bo'lsak faqatgina Print(nums); yoki Print(new int[] {1,2,3}); deb yozishimiz kerak edi, yani collection ni avval initsializatsiya qilishimiz kerak edi.

Misol:

var nums = new int[] { 1, 2, 3 };     <-- etibor qiling

Print(nums);                          <-- etibor qiling

void Print(int[] array)
{
    foreach(var item in array)
        Console.Write($"{item} ");
}
// output -> 1 2 3

params bilan esa bunday qilishga hojat yoq

Misol:

Print(1, 2, 3);                       <-- etibor qiling

void Print(params int[] array)
{
    foreach(var item in array)
        Console.Write($"{item} ");
}
// output -> 1 2 3

Va bu kalit so'zi nafaqat arraylar bilan, balki harqanday IEnumerable vorislariga qollasa boladi.

Misol:

Print(1, 2, 3);                           <-- etibor qiling

void Print(params List<int> list)         <-- etibor qiling
{
    foreach(var item in list)
        Console.Write($"{item} ");
}
// output -> 1 2 3

Params ni ishlatib boshqa tiplar bilan, turli kombinatsiyalar qilish mukin, faqat params metodni eng oxirgi argumenti bo'lishi shart.

Misol:

PrintMessageAndNumbers("uchta son yubordim: ", 1,2,3);
void PrintMessageAndNumbers(string message, params int[] numbers)
{
    Console.WriteLine(message);
    foreach (int number in numbers)
    {
        Console.Write($"{number} ");
    }
}
// output -> uchta son yubordim: 1 2 3

Shu va shunga o'xshagan ko'plab kombinatsiyalr qilish mumkin.

C# 13 dagi yangiliklar!!!

Farkhodbek Kamolov — Mon, 27 May 2024 23:35:45 +0000

Qisqacha c# dasturlash tili haqida malumotlar

C#(si sharp) multi-paradigmik, dinamik hamda C dasturlash tillari oilasiga mansub dasturlash tili bo'lib Microsoft kompaniyasidan Anders Hilsberg tomonidan ishlab chiqilgan bolib va keyinchalik 2002 yilda Ecma(ECMA-334) tomonidan xalqaro standard sifatida tastiqlangan.
Xalqaro standard sifatida tastiqlandi degani, qisqacha qilib aytganda ushbu texnologiya(yoki produkt, yoyinki biron servis vaho kazo...) dunyo tanolgan mutaxasislar, korporatsiyalar hullas kazo-kazolar tomonidan ushbu texnologiyani tekshirilib, turli-xil testlar o'tgazib va shu texnologiya uchun qollanma yozib chiqgan degani.
Hozirda C# dasturlash tilini 13-ta versiyasi bor. 13-chi versiyasi 21/05/2024 yilda preview versiyasi taqdim etildi. Va yana bir etibor talab qiladigon tarafi hozirda ushbu versiyadagi C# ni qanday yangiliklari va qulayliklari borligini ko'rib chiqmoqchishimiz uchun, avval bizga ProjectName .csproj faylimizga quyidagi kodni kiritib qo'yishimiz kerak:

<PropertyGroup>
   <LangVersion>preview</LangVersion>
</PropertyGroup>

Aks holda bazi yangi xususiyatlar(feature)larni ishlata olmaymiz!!!

Yangi feature larni ro'yxati:

1.param kalit so'zi(key word)
2.Yangi lock obyekti. <- Bu featureni o'zi uncha tushuna olmadim😅
3.Yangi escape ket-maketligi\e
4.Metod guruhining tabiiy tipini yaxshilanishi
5.yashirin indekserga kirish

P.S.
Yangi feature larni alohida postlarga bo'lib chiqishga qaror qildim, chunki bitta post uchun juda uzunlik qilar ekan. Ro'yhatdagi havolalarga bosib, o'zingizni qiziqtirgan feature ni alohida misollari bilan birga tanishib chiqishiz mumkin. :)

C#. Kasr sonlarni ifodalovchi malumot turlari

Farkhodbek Kamolov — Thu, 18 Apr 2024 17:39:54 +0000

C# dasturlash tilida davomiy yaniy kasr sonlarni ifodalash(saqlash, yoki ular ustida turihil arifmetik operatsiyalar amalga oshirish) uchun 3 hil malumot turlari mavjud. Bular: float, double va decimal tiplaridir.

FLOAT - hajmi 4byte(32-bitli) suzuvchi nuqtali raqamlarni ifodalovchi tip, taxminan 6~7 ta aniqlikgacha raqamlarni saqlay oladi, floatning taxminiy diapazoni ~ ±1.5 x 10^−45 dan ±3.4 x 10^38 gacha, bu taxminan 3.4028235E+38 ~ -3.4028235E+38.
float tipni elon qilish: float PI = 3.14159f;

Double - hajmi 8byte(64-bitli) suzuvchi nuqtli raqam turi bo'lib, taxminan 15~16 raqamli aniqlikni ta'minlaydi, doublening taxminiy diapazoni ~ ±5.0 × 10^−324 dan ±1.7 × 10^308 gacha, taxminan 1.7976931348623157E+308 ~ -1.7976931348623157E+308 dir.
double tipni elon qilish: double PI = 3.14159d;

Decimal - hajmi 16byte(128-bitli) suzuvchi nuqtali raqamlarni ifodalovchi malumot turi, taxminan 28~29 raqamli aniqlikni ta'minlaydi, bu turni taxminiy diapazoni ±1.0 x 10^-28 dan ±7.9228 x 10^28 gacha, bu esa 79228162514264337593543950335 ~ -79228162514264337593543950335 dir
decimal tipini elon qilish: decimal PI = 2.14159m;.

Bu malumot turlarini ishlatish holatlari:

float va double asosan turli hil arifmetik, fizik, kimyoviy yoki tabiat hodisalarini hisoblovchi operatsiyalar(harorat, tezlik va shunga o'xshash)da keng ishlatilinadi.
decimal esa asosan iqtisodiy hisob-kitob(Valyuta konvertatsiyasi, soliq va foizlarni hisoblash) paytida ishlatilinadi, chunki bu operatsiyalrda yuqori aniqlik talab qilinadi.

Ularning kamchilik va ustun taraflari:

float ustunligi:

Xotira samaradorligi: double va decimal turlariga qaraganda kamroq xotirani egallaydi, bu suzuvchi nuqtali raqamlarning katta massivlari bilan ishlashda foydali bo'lishi mumkin.

Tezligi: Float bilan bog'liq operatsiyalar, ayniqsa, bitta aniqlik arifmetikasi optimallashtirilgan platformalarda, double yoki decimal qaraganda tezroq bo'lishi mumkin.

Kamchiliklari:

Cheklangan aniqlik: float taxminan 7 ta aniqlikni ta'minlaydi, bu yuqori aniqlikdagi hisob-kitoblarni talab qiladigan ilovalar uchun etarli bo'lmasligi mumkin.

Cheklangan diapazon: Ikkilik va oʻnlik bilan solishtirganda koʻrsatilishi mumkin boʻlgan qiymatlarning cheklangan diapazoniga ega, bu esa maʼlum paytda toʻlib ketish(overflow) xatolariga olib kelishi mumkin.

double ustunligi:

Yuqori aniqlik: floatga nisbatan ikki barobar aniqlik ni(taxminan 15-16 raqamni) ta'minlaydi, bu esa uni ko'proq aniqlik talab etuvchi dasturlar uchun mos keladi.

Kengroq diapazon: float bilan solishtirganda ko'rsatilishi mumkin bo'lgan sonlarni ancha kengroq diapazonga ega bo'lib, to'lib ketish(overflow) xatolari ehtimolini kamaytiradi.

Kamchiliklari:

Xotiradan foydalanish: float bilan solishtirganda ko'proq xotira sarflaydi, bu xotira samaradorligi juda muhim bo'lganida muammo tug'dirishi mumkin, garchi bu ko'p ilovalarda ahamiyatsiz bo'lishi mumkin.

Yaxlitlash xatolari uchun potentsial: Double o'zining yuqori aniqligiga qaramay, juda kichik hisoblarda yaxlitlash xatolariga moil bo'lishi mumkin.

float floatSon = .3f + .3f + .3f + .1f;        
double doubleSon = .3 + .3 + .3 + .1;       <-- muamo
decimal decimalSon = .3m + .3m + .3m + .1m;

Console.WriteLine($"{floatSon:f33}");
Console.WriteLine($"{doubleSon:f33}");
Console.WriteLine($"{decimalSon:f33}");

result: 
_float_  : 1.000000000000000000000000000000000
_double_ : 0.999999999999999888977697537484346 <-- muamo
_double_ : 1.000000000000000000000000000000000

decimal ustunligi:

Yuqori aniqlik: kasr qismining aniqligi taxminan 28-29 ta sondan iborat, bu uni moliyaviy hisoblarda yaniy yuqorida aytilganidek juda aniq hisob-kitob talab qiladigan ilovalar uchun mos keladi.

Yaxlitlash xatolarining kamayishi: Yuqori aniqligi tufayli double va floatga nisbatan yaxlitlash xatolariga kamroq moyil.

Kamchiliklari:

Xotiradan foydalanish: float va double bilan solishtirganda ko'proq xotirani iste'mol qiladi, chunki u 128 bitli ma'lumotlar turi bo'lib, xotira samaradorligi juda muhim bo'lganida tashvish tug'dirishi mumkin.

Tezlik(performance): Xotiradan ko'proq joy eganlashi sabab tez ishlashi muhim bo'lgan dasturlarda bu muammo keltirib chiqarishi mumkin.

Qo'shimcha malumot:

Yuqoridagi kodlarda etiborni tortuvchi narsa bu f, d(bu qoshimchani ishlatmasaham bo'ladi) yoki m qoshimchalaridir(suffikslar). Bu qo'shimchalar hechqanday hatolik(error) keltirib chiqarmaydi, aksincha bu qo'shimchalarni ishlatmaslik, compiletime errorlaga olib keladi. Suffikslarni ishlatishdan maqsad, undan oldin keluvchi kasr sonlar qaysi malumot turiga mansubligini bildirib turivchi ishoralardir. Yaniy (by default)boshidan harqanday kasr son yaratilganida hech qanday suffikslar qoshilmasa, bu sonlar double turiga tegishli bo'lib qoladi, boshqa turdagi malumotga o'girish uchun shu qo'shimchalarni ishlatish zarur. Shunday qilib float turdagi kasr sonini yaratish uchun f suffiksi, double tipi uchu esa d(hardoimham shart emas!!!) va decimal turidagi kasr soni yaratish uchun esa m qo'shimchalarini ishlatish zarur. m suffiksi money sozidan olingan.
P.S decimal ni iqtisod(pul) bilan uzviy bog'liq dasturlarda ishlatilishi shart.

Bu postim sizlarga ozgina bolsada biron foyda keltiradi deb umid qilaman. Etiboringiz uchun katta rahmat, kelgusida ko'rishguncha🙂