DEV Community: Nuriddin

SOLID tamoillari

Nuriddin — Wed, 03 Aug 2022 12:32:56 +0000

S.O.L.I.D. - obyektga yo'naltirilgan dasturlashda dasturlarni loyihalashning 5 asosiy tamoyilidir. Bu loyihalashda qo'llanilishi mumkin bo'lgan va dasturchi uchun shu loyihada qo'shimchalar, kengaytirishlar, ish jarayoni chiqgan xatolarni to'g'illashni osonlashtiradigan tamoyillardir. Bu tamoyillarni qo'llash va qo'llamaslik dasturchining xohishiga bog'liq. Lekin, bu asosiy tamoyillar loyihalashda loyiga tadbiq qilinsa, ish sifati ancha yuqori bo'ladi. loyiha kodida tartib bo'ladi. Va shu bilan birga bu tamoyillar kodda keraksiz qatorlar va modul, komponentlar bo'lishidan, bir xil kod bir necha marta takrorlanishidan, qoleversa ba'zi hollarda kodni ko'p marotaba refaktoring qilishdan saqlab qoladi.

Demak, asosiy 5 tamoyil izohlari bilan quyida keltirilgan:

SRP (Single responsibility principle)

yagona javobgarlik tamoyili, bunda har bir class uchun faqat bitta vazifa yuklanadi. Bu classda metodlar bir nechta bo'lishi mumkin. Bu prinsipni asosiy maqsadi har bir ishni malum bir vazifa bajaradigan alohida classlarga bo'lib bajarish. Shunda dastur kodini malum bir qismiga o'zgartirish kiritsak,faqatgina shu klassdagina o'zgarish bo'ladi, boshqa klasslarga tasir qilmaydi. Klassni o'zgartirishga faqat bitta sabab bo'lishi kerak. Test qilishga ham qulay.

OCP(Open/closed principle)

open for extension, closed for modification ya'ni base klassda extension olib yengi featurelar qo'shsa bo'ladi, lekin base klassni modifikatsa(o'zgartirish) mumkin emas.

LSP(Liskov substitution principle)

Liskovning o'rin almashtirish tamoyili, bu tamoyil ilk bor amerikalik olima Barbara Liskov tomonidan e'lon qilingan bo'lib, dasturda obyektlarni shu obyekt klassining bola klasslaridan olingan nusxalari bilan almashtirish mumkin bo'ladi va bu dastur natijasini o'zgartirmasligi kerak. Shuning uchun parent klass abstrakt qilib yozilishi kerek.

ISP(Interface segregation principle)

interfeyslarga bo'lish tamoyili, hamma holat uchun umumy bo'lgan interfeysdan, har bir mijoz uchun alohida bo'lgan ko'plab interfeyslar yaxshi. Vaqt o'tishi bilan Sizning loyihangiz kengayadi, unga yangi funksiyalar, imkoniyatlar qo'shiladi. Bunda, loyiha boshidan loyiha strukturasi ustidan kuchi nazorat olib borilmasa, loyiha boshida aniq bir funksiyani bajaruvchi metodlar, loyiha oxiriga borib umuman boshqa vazifani bajarishi mumkin;

DIP(Dependency inversion principle)

tobelarni almashtirish tamoyili, abstraksiya aniq bir obyektga bog'liq bo'lmasligi kerak, Aksincha, obyekt abstraksiyani qoidalariga bo'ysinishi kerak.

Enumeration types as bit flags

Nuriddin — Mon, 06 Jun 2022 05:40:03 +0000

Enumeration typelar kombinatsiyasini ifodalashini xohlasek, ushbu tanlovlar uchun enum a'zolarini belgilashimiz kere. Ya'ni, bu enum a'zolarining bog'langan qiymatlari ikkining vakolatlari bo'lishi kerak. Keyin, siz bitli mantiqiy operatorlardan foydalanishingiz mumkin | yoki & mos ravishda tanlovlarni birlashtirish yoki tanlovlar birikmalarini kesish uchun. Sanoq turi bit maydonlarini e'lon qilishini ko'rsatish uchun unga Flags atributini qo'llang:

[Flags]
public enum Days
{
    None      = 0b_0000_0000,  // 0
    Monday    = 0b_0000_0001,  // 1
    Tuesday   = 0b_0000_0010,  // 2
    Wednesday = 0b_0000_0100,  // 4
    Thursday  = 0b_0000_1000,  // 8
    Friday    = 0b_0001_0000,  // 16
    Saturday  = 0b_0010_0000,  // 32
    Sunday    = 0b_0100_0000,  // 64
    Weekend   = Saturday | Sunday
}

public class FlagsEnumExample
{
    public static void Main()
    {
        Days meetingDays = Days.Monday | Days.Wednesday | Days.Friday;
        Console.WriteLine(meetingDays);
        // Output:
        // Monday, Wednesday, Friday

        Days workingFromHomeDays = Days.Thursday | Days.Friday;
        Console.WriteLine($"Join a meeting by phone on {meetingDays & workingFromHomeDays}");
        // Output:
        // Join a meeting by phone on Friday

        bool isMeetingOnTuesday = (meetingDays & Days.Tuesday) == Days.Tuesday;
        Console.WriteLine($"Is there a meeting on Tuesday: {isMeetingOnTuesday}");
        // Output:
        // Is there a meeting on Tuesday: False

        var a = (Days)37;
        Console.WriteLine(a);
        // Output:
        // Monday, Wednesday, Saturday
    }
}

yesli cho' Enumeration types as bit flags

Nondesructive mutation (buzib bo'lmaydigan mutatsiya )

Nuriddin — Sun, 05 Jun 2022 10:02:46 +0000

C# 10 dan boshlab, struct va recordda new kalit so'zini iwlatmasdan turib obyektyasash imkoniyati paydo bo'ldi. Bunda avval yasalgan obyektdan nusxa olib , agar xoxlasak uni property va fieldlarini o'zgartirib yangi obyekt yasashimiz mumkin. Buning uchun with ifodasidan foydalanishimiz kerak. Quyidagi misolda ko'rsatilganidek, qaysi a'zolarni o'zgartirish va ularning yangi qiymatlarini belgilash uchun ob'ektni ishga tushirish sintaksisidan foydalanamiz:

public record Point
{
    public string Name { get; init; }

    public int Age { get; init; }

    public Point(string name, int age)
    {
        Name = name;
        Age = age;   
    }

    public override string ToString() => $" {Name} , {Age}";

}



    public static void Main()
    { 
        var x1 = new Point("jeki", 22);
        Console.WriteLine(x1);

        var x2 = x1 with{Age = 12};
        Console.WriteLine(x2);

        var x3 = x2 with {Name = "ok",  Age = 33};
        Console.WriteLine(x3);

    }

"Property pattern"lar haqida...

Nuriddin — Mon, 30 May 2022 07:45:20 +0000

C# 8 dan boshlab ifodani property yoki fieldarini 'property pattern' orqali solishtirish mumkin bo'ldi:

static bool IsConferenceDay(DateTime date) => date is { Year: 2020, Month: 5, Day: 19 or 20 or 21 };

Property pattern - ifoda natijasi null bo'lmaganda ifodaga mos keladi va har bir ichki o'rnatilgan pattern ifoda natijasining tegishli xususiyati yoki maydoniga mos keladi.

Console.WriteLine(TakeFive("Hello, world!"));  // output: Hello
Console.WriteLine(TakeFive("Hi!"));  // output: Hi!
Console.WriteLine(TakeFive(new[] { '1', '2', '3', '4', '5', '6', '7' }));  // output: 12345
Console.WriteLine(TakeFive(new[] { 'a', 'b', 'c' }));  // output: abc

static string TakeFive(object input) => input switch
{
    string { Length: >= 5 } s => s.Substring(0, 5),
    string s => s,

    ICollection<char> { Count: >= 5 } symbols => new string(symbols.Take(5).ToArray()),
    ICollection<char> symbols => new string(symbols.ToArray()),

    null => throw new ArgumentNullException(nameof(input)),
    _ => throw new ArgumentException("Not supported input type."),
};

Property pattern - rekursiv patterndir. Ya'ni, har qanday patternni ichki pattern sifatida ishlatishingiz mumkin. Quyidagi misolda ko'rsatilganidek, ma'lumotlar qismlarini ichki o'rnatilgan patternlarga moslashtirish uchun property patterndan foydalanilgan:

public record Point(int X, int Y);
public record Segment(Point Start, Point End);

static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start: { Y: 0 } } or { End: { Y: 0 } };

Yuqoridagi misolda C# 9.0 va undan keyingi versiyalarida mavjud bo'lgan ikkita xususiyatdan foydalaniladi: or pattern combinator va record types.

C# 10 dan boshlab, siz ichki xususiyatlar yoki maydonlarga to'gridan-to'g'ri murojaat qilishingiz mumkin. Masalan, oldingi misoldagi usulni quyidagi ekvivalent kodga qayta tiklashingiz mumkin:

static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start.Y: 0 } or { End.Y: 0 };

Usha gap uncha chunmagan bosela mamittan ko'rvorurasila property pattern!

C# da ifodalarni tekshirishning ustuvorligi va tartibi

Nuriddin — Mon, 30 May 2022 06:46:49 +0000

Quyidagi roʻyxatda pattern kombinatorlarinig ustuvorligi kamayib borish tartibida ko'rsatilgan:

not
and
or

Quyidagi misolda ko'rsatilganidek, ustuvorlikni aniq belgilash uchun qavslardan foydalanilgan:

static bool IsLetter(char c) => c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z');

Qo'shimcha malumot olish uchun pattern combinators bo'limiga qarang.

"Logical pattern"lar haqida..

Nuriddin — Mon, 30 May 2022 06:24:21 +0000

C# 9.0 dan boshlab, biz quyidagi 'logical pattern'ni yozish uchun not, and , va or pattern kombinatorlaridan foydalanamiz:

Negated(inkor) not pattern :

if (input is not null)
{
    // ...
}

Conjunctive and pattern - ikkala qolip ham ifodaga mos kelganda ishlatiladi:

Console.WriteLine(Classify(13));  // output: High
Console.WriteLine(Classify(-100));  // output: Too low
Console.WriteLine(Classify(5.7));  // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -40.0 => "Too low",
    >= -40.0 and < 0 => "Low",
    >= 0 and < 10.0 => "Acceptable",
    >= 10.0 and < 20.0 => "High",
    >= 20.0 => "Too high",
    double.NaN => "Unknown",
};

Disjunctive or pattern - har qanday qolip ifodaga mos kelganda ishlatiladi:

Console.WriteLine(GetCalendarSeason(new DateTime(2021, 1, 19)));  // output: winter
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 10, 9)));  // output: autumn
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 5, 11)));  // output: spring

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    3 or 4 or 5 => "spring",
    6 or 7 or 8 => "summer",
    9 or 10 or 11 => "autumn",
    12 or 1 or 2 => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

Yuqoridagi misoldan ko'rinib turibdiki, siz pattern kombinatorlarini pattern ichida qayta-qayta ishlatishingiz mumkin.

"Relational pattern"lar haqida...

Nuriddin — Mon, 30 May 2022 05:09:41 +0000

C# 9.0 dan boshlab, switchga parametr qilib berilgan qiymatni aniq qiymatlar bilanmasde malum bir diapazondigi qiymatla bilan solishtiraish uchun relational patterndan foydalanamiz:

Console.WriteLine(Classify(13));  // output: Too high
Console.WriteLine(Classify(double.NaN));  // output: Unknown
Console.WriteLine(Classify(2.4));  // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -4.0 => "Too low",
    > 10.0 => "Too high",
    double.NaN => "Unknown",
    _ => "Acceptable",
};

Relational patterda siz <, >, <= yoki >= kabi solishtirish operatorlaridan foydalanishingiz mumkin. Relational patternning o'ng tomoni constant ifoda bo'lishi kerak.
Constant qiymat int, float, char yoki enum tipidagi bo'lishi mumkin.

Ifodaning natijasi ma'lum diapazonda ekanligini tekshirish uchun uni "conjunctive and pattern" bilan moslang :

Console.WriteLine(GetCalendarSeason(new DateTime(2021, 3, 14)));  // output: spring
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 7, 19)));  // output: summer
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 2, 17)));  // output: winter

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    >= 3 and < 6 => "spring",
    >= 6 and < 9 => "summer",
    >= 9 and < 12 => "autumn",
    12 or (>= 1 and < 3) => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

Agar ifoda natijasi null bo'lsa yoki constant qiymatni nullable qiymatga convert qilish imkoni bo'lmasa relational pattern ifodaga mos kelmaydi.
Qo'shimcha ma'lumot olish uchun relational pattern bo'limiga qarang.

Constant pattern haqida...

Nuriddin — Mon, 30 May 2022 04:34:45 +0000

C# 7.0 dan boshlab, switchga parametr qilib berilgan qiymatni belgilangan konstantaga teng yoki yo'qligini tekshirish uchun constant patterndan foydalanishimiz mumkinakan:

public static decimal GetGroupTicketPrice(int visitorCount) => visitorCount switch
{
    1 => 12.0m,
    2 => 20.0m,
    3 => 27.0m,
    4 => 32.0m,
    0 => 0.0m,
    _ => throw new ArgumentException($"Not supported number of visitors: {visitorCount}", nameof(visitorCount)),
};

Constant patternda switchga parametr qib berilgan qiymatni mamnaqa tipla bilan solishtirish mumkinakan anaqqisa 👇:

Integer yoki floating-point sonlar
Char yoki a string literal
Boolean qiymat true yoki false
Enum value
e'lon qilingan const maydoni yoki mahalliy nomi
null

tepadigi misoldaka qilib ko'rsataman:

  public static decimal GetGroupTicketPrice(object visitorCount) => visitorCount switch
    {
         1 => 15.0m,         // int qiymat bilan solishtirvotti
        "string" => 12.0m,   // string qiymat bilan solishtirvotti
        'a' => 20.0m,        // char qiymat bilan solishtirvotti
        true => 27.0m,       // bool qiymat bilan
        "enum" => 32.0m,     // enum qiymat 
        null => null,        // null bilan
        0 => 0.0m,           // buyam int qiymat bn soliwtirvotti
        _ => throw new ArgumentException($"Not supported number of visitors: {visitorCount}", nameof(visitorCount)),
    };

Constant patterndan nullni tekshirishda ham foydalaniladi:

if (input is null)
{
    return;
}

C# 9.0 dan boshlab, quyidagi misolda ko'rsatilgandaka, null bo'lmaganni tekshirish uchun negated null qilib tekwiriladi:

if (input is not null)
{
    // ...
}

Uncha chunmagan bo'sela mamyaqqa o'tib ko'rvosela bo'ladi constant pattern!

Declaration va type patternlar haqida...

Nuriddin — Mon, 30 May 2022 02:02:45 +0000

Biz ifodaning ish vaqti turi berilgan turga mos kelishini tekshirish uchun declaration va type patternlardan foydalanamiz.Deklaratsiya namunasi ifodaga mos kelganda, quyidagi misolda ko'rsatilganidek, bu o'zgaruvchiga aylantirilgan ifoda natijasi tayinlanadi:

object greeting = "Hello, World!";
if (greeting is string message)
{
    Console.WriteLine(message.ToLower());  // output: hello, world!
}

int? xNullable = 7;
int y = 23;
object yBoxed = y;
if (xNullable is int a && yBoxed is int b)
{
    Console.WriteLine(a + b);  // output: 30
}

Agar biz faqat ifodani turini tekshirmoqchi bo'lsak, u holda o'zgaruvchi nomi o'rniga discard_ dan foydalanishimiz mumkin:

public abstract class Vehicle {}
public class Car : Vehicle {}
public class Truck : Vehicle {}

public static class TollCalculator
{
    public static decimal CalculateToll(this Vehicle vehicle) => vehicle switch
    {
        Car _ => 2.00m,
        Truck _ => 7.50m,
        null => throw new ArgumentNullException(nameof(vehicle)),
        _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
    };
}

C# 9.0 dan boshlab, bu maqsadda siz quyidagi misolda ko'rsatilganidek, Type patterndan foydalanishingiz mumkin:

public static decimal CalculateToll(this Vehicle vehicle) => vehicle switch
{
    Car => 2.00m,
    Truck => 7.50m,
    null => throw new ArgumentNullException(nameof(vehicle)),
    _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
};

Deklaratsiya namunasi kabi, type patternda ifoda natijasi null bo'lmaganda va uning ish vaqti turi yuqorida sanab o'tilgan shartlarning istalganiga javob berganda ifodaga mos keladi. Shuningdek, siz ushbu naqshni aniq, qisqacha null tekshiruvi uchun ishlatishingiz mumkin:

if (input is not null)
{
    Console.WriteLine(input);
} else
{
    throw new ArgumentNullException(paramName: nameof(input), message: "Input should not be null");
}

Qo'shimcha ma'lumot olish uchun declaration pattern va type pattern bo'limlariga qarang.