Wzorce is, relacyjne i logiczne (emulacja w C# 6)
Proszę emulować podstawowe wzorce w C# 6: sprawdzanie typu za pomocą is, sprawdzanie zakresu i relacji oraz kompozycję logiczną z użyciem małych pomocników predykatów.
Wzorce is, relacyjne i logiczne (emulacja w C# 6) to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.
Pomysły na wzorce w C# 6
Cel: Naśladować typowe wzorce za pomocą C# 6.
- Wzorzec typu: is + rzutowanie
- Relacyjne: pomocnicze funkcje ochronne (np. >, <)
- Logiczne: łączenie małych predykatów (AND/OR/NOT)
Wzorzec typu za pomocą is + rzutowania
Naśladuj wzorzec typu za pomocą is oraz jawnego rzutowania, aby „powiązać” zmienną lokalną.
using System;
public class Program
{
static string Describe(object x)
{
if (x is int)
{
int i = (int)x; // bind
return "int: " + i;
}
if (x is string)
{
string s = (string)x; // bind
return "string(len=" + (s == null ? 0 : s.Length) + ")";
}
return "other";
}
public static void Main(string[] args)
{
Console.WriteLine(Describe(5));
Console.WriteLine(Describe("hi"));
Console.WriteLine(Describe(3.14));
}
}
Relacyjne „wzorce” jako warunki ochronne
Twórz małe funkcje ochronne do sprawdzania relacji; przypominają wzorce i łatwo je ponownie wykorzystywać.
using System;
public class Program
{
static bool IsBetween(int x, int minInclusive, int maxExclusive)
{
return x >= minInclusive && x < maxExclusive;
}
public static void Main(string[] args)
{
int v1 = 10, v2 = -5, v3 = 100;
Console.WriteLine(IsBetween(v1, 0, 100)); // True
Console.WriteLine(IsBetween(v2, 0, 100)); // False
Console.WriteLine(IsBetween(v3, 0, 100)); // False
}
}
Logiczne łączenie warunków ochronnych
Łącz małe predykaty, aby naśladować wzorce logiczne: AND, OR, NOT.
using System;
public class Program
{
static bool IsEven(int n) { return n % 2 == 0; }
static bool IsPositive(int n) { return n > 0; }
static bool And(Func<int,bool> a, Func<int,bool> b) { return a(4) && b(4); } // example composition (demo)
// For general composition:
static Func<int,bool> AND(Func<int,bool> a, Func<int,bool> b)
{
return delegate(int n) { return a(n) && b(n); };
}
static Func<int,bool> OR(Func<int,bool> a, Func<int,bool> b)
{
return delegate(int n) { return a(n) || b(n); };
}
static Func<int,bool> NOT(Func<int,bool> a)
{
return delegate(int n) { return !a(n); };
}
public static void Main(string[] args)
{
Func<int,bool> evenAndPositive = AND(IsEven, IsPositive);
Console.WriteLine(evenAndPositive(4)); // True
Console.WriteLine(evenAndPositive(-2)); // False
Console.WriteLine(NOT(IsEven)(3)); // True (3 is not even)
}
}
Naśladowanie wzorca typu i relacji
Powiąż wartość za pomocą is + rzutowania, a następnie zastosuj warunek ochronny — bezpośredni odpowiednik współczesnego wzorca „typu i relacji”.
using System;
public class Program
{
static string Check(object x)
{
if (x is int)
{
int i = (int)x; // bind
if (i > 0) return "positive int";
return "non-positive int";
}
return "not an int";
}
public static void Main(string[] args)
{
Console.WriteLine(Check(5)); // positive int
Console.WriteLine(Check(-3)); // non-positive int
Console.WriteLine(Check("hey")); // not an int
}
}
Wskazówki i ograniczenia
Wskazówki:
- Nazywaj pomocnicze funkcje ochronne jasno (IsBetween, IsNonEmpty itd.).
- Preferuj czyste sprawdzenia; unikaj efektów ubocznych.
- Ograniczaj łączenie predykatów, aby zachować czytelność.
Ograniczenie: Nowsza składnia wzorców jest krótsza, ale te techniki C# 6 wyrażają tę samą intencję.
Naśladowanie wzorca typu i relacji
Podsumowanie
Podsumowanie: W C# 6 łącz is z rzutowaniem, aby powiązać wartości, używaj małych funkcji ochronnych do sprawdzania relacji oraz łącz predykaty, aby tworzyć wzorce logiczne.
Często zadawane pytania
Czy lekcja „Wzorce is, relacyjne i logiczne (emulacja w C# 6)” jest bezpłatna?
Tak — pełny tekst „Wzorce is, relacyjne i logiczne (emulacja w C# 6)” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.
Co nauczysz się w „Wzorce is, relacyjne i logiczne (emulacja w C# 6)”?
Proszę emulować podstawowe wzorce w C# 6: sprawdzanie typu za pomocą is, sprawdzanie zakresu i relacji oraz kompozycję logiczną z użyciem małych pomocników predykatów. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć C# Academy?
Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.
Ile czasu zajmuje lekcja „Wzorce is, relacyjne i logiczne (emulacja w C# 6)”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?
Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Wzorce is, relacyjne i logiczne (emulacja w C# 6)
- Wyrażenia switch i sprawdzanie kompletności za pomocą when (emulacja w C# 6)
- Modelowanie domeny za pomocą sum rozłącznych (rekordy) — emulacja w C# 6