Pattern is; pattern relazionali e logici (emulazione in C# 6)
Emulate i pattern di base in C# 6: controlli di tipo con is, verifiche di intervalli e relazioni e composizione logica tramite piccoli helper di predicati.
Pattern is; pattern relazionali e logici (emulazione in C# 6) è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 3 lezioni in totale.
Idee per i pattern in C# 6
Obiettivo: usare C# 6 per emulare pattern comuni.
- Pattern di tipo: is + cast
- Relazionali: controlli di guardia (ad es. >, <)
- Logici: combinare piccoli predicati (AND/OR/NOT)
Pattern di tipo con is + cast
Emulare un pattern di tipo con is più un cast esplicito per «associare» una variabile locale.
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));
}
}
«Pattern» relazionali come controlli di guardia
Creare piccoli metodi di guardia per i controlli relazionali: hanno l'aspetto di pattern e sono facili da riutilizzare.
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
}
}
Composizione logica dei controlli di guardia
Combinare piccoli predicati per emulare i pattern logici: 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)
}
}
Emulazione del pattern di tipo + relazionale
Associare il valore con is + cast, quindi applicare una condizione di guardia — un sostituto diretto del moderno pattern «di tipo + relazionale».
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
}
}
Suggerimenti e limiti
Suggerimenti:
- Dare nomi chiari ai metodi di guardia (IsBetween, IsNonEmpty, ecc.).
- Preferire controlli puri; evitare effetti collaterali.
- Mantenere ridotta la composizione dei predicati per favorire la leggibilità.
Limite: la sintassi dei pattern più recente è più concisa, ma queste tecniche di C# 6 esprimono lo stesso intento.
Come emulare un pattern di tipo + relazionale
Riepilogo
Riepilogo: in C# 6, combinare is + cast per associare i valori, usare piccoli controlli di guardia per le verifiche relazionali e comporre i predicati per i pattern logici.
Impara C# con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 93
- Lezioni
- 346
Domande Frequenti
La lezione «Pattern is; pattern relazionali e logici (emulazione in C# 6)» è gratuita?
Sì — il testo completo di «Pattern is; pattern relazionali e logici (emulazione in C# 6)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 3 lezioni in totale.
Cosa imparerò in «Pattern is; pattern relazionali e logici (emulazione in C# 6)»?
Emulate i pattern di base in C# 6: controlli di tipo con is, verifiche di intervalli e relazioni e composizione logica tramite piccoli helper di predicati. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare C# Academy?
Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.
Quanto tempo richiede la lezione «Pattern is; pattern relazionali e logici (emulazione in C# 6)»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione C# Academy?
Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Pattern is; pattern relazionali e logici (emulazione in C# 6)
- Espressioni switch; controlli di esaustività con when (emulazione in C# 6)
- Modellazione del dominio con unioni discriminate (record) — emulazione in C# 6