In questa puntata ti presento UnitsNet, una libreria .NET che ti permette di lavorare con grandezze fisiche in modo sicuro, leggibile e senza errori di conversione. Dalle lunghezze alla temperatura, dalla pressione alla velocità: scopri come può semplificarti la vita (e il codice). E se lavori anche in frontend, ti sorprenderà sapere che esiste anche una versione JavaScript: `unitsnet-js`!

• https://github.com/angularsen/UnitsNet
  
  
• https://github.com/haimkastner/unitsnet-js
  
  

#dotnet #unitsnet #csharp #dotnetinpillole #podcast

In questa puntata esploriamo due modi per portare LINQ al livello successivo: PLINQ, per sfruttare il parallelismo e velocizzare l'elaborazione dei dati, e ZLinq, per ottenere performance elevate senza allocazioni e con supporto AOT. Due approcci diversi, stessi obiettivi: scrivere codice più efficiente e performante.

• https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/introduction-to-plinq
• https://github.com/Cysharp/ZLinq

#dotnet #plinq #zlinq #tpl

In questa puntata parliamo di CancellationToken in C#: cos’è, come funziona e perché è fondamentale per scrivere codice asincrono e reattivo. Vediamo come usarlo per annullare operazioni in modo cooperativo, come gestire timeout, come combinare più token con LinkedTokenSource e quali errori evitare. Un episodio per chi vuole fermare le cose… nel modo giusto!

• https://learn.microsoft.com/en-us/dotnet/standard/threading/cancellation-in-managed-threads
• https://medium.com/@mitesh_shah/a-deep-dive-into-c-s-cancellationtoken-44bc7664555f
• https://learn.microsoft.com/en-us/dotnet/api/system.threading.cancellationtokensource

#dotnet #cancellationtoken #asyncawait #dotnetinpillole #podcast

In questa puntata parliamo della Task Parallel Library (TPL) in C#: cosa offre, quando usarla, e come sfruttare strumenti come Task, Parallel.For, Task.WaitAll e Task.WhenAll per scrivere codice più veloce ed efficiente. Un’introduzione pratica e discorsiva al mondo del parallelismo, con consigli su come evitare gli errori più comuni.

• https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-parallel-library-tpl
• https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/
• https://www.youtube.com/watch?v=18w4QOWGJso

#dotnet #tpl #TaskParallelLibrary #dotnetinpillole #podcast

Ok, quante volte hai scritto await senza davvero sapere cosa sta succedendo dietro? In questa puntata ci facciamo una bella chiacchierata su come funziona l’asincronia in C#: parliamo di Task, ValueTask, TaskCompletionSource. 
Ecco alcune risorse per approfondire il tutto:

• https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/blob/master/AsyncGuidance.md
• https://learn.microsoft.com/en-us/archive/msdn-magazine/2013/march/async-await-best-practices-in-asynchronous-programming
• https://github.com/meysamhadeli/awesome-dotnet-tips/blob/main/docs/csharp/async/async-and-await.md
• https://github.com/meysamhadeli/awesome-dotnet-tips/blob/main/docs/csharp/async/async-best-practice.md

Video di Marco Minerva:

• https://youtu.be/23oyxTAutsQ?si=ZC2JWTG2IU3M3X_7
• https://youtu.be/L4J-m45NWSo?si=wy2emxJwFMvBJ_63

#dotnet #asyncawait #dotnetinpillole

C# si fa leggero!
In questa puntata esploriamo 'dotnet run app.cs', la nuova funzionalità di .NET 10 che permette di scrivere ed eseguire script C# senza creare un progetto.
Un solo file .cs, niente .csproj, e puoi partire subito: perfetto per prototipi, automation e piccoli tool da riga di comando. Scopri come funziona, cosa puoi farci e perché potrebbe diventare il tuo nuovo modo di usare C#.

• https://devblogs.microsoft.com/dotnet/announcing-dotnet-run-app/
  
  
• https://youtu.be/98MizuB7i-w?si=pguTqEmNOECnssPu
• https://devblogs.microsoft.com/visualstudio/agent-mode-has-arrived-in-preview-for-visual-studio/
  
  

#dotnet #copilot #dotnetinpillole #podcast

Oggi ci tuffiamo nel fantastico (e affollatissimo) mondo delle collezioni in .NET: liste, dizionari, set, stack, queue, versioni concorrenti e persino quelle immutabili.
Ma cosa cambia tra una List e un Array? Quando ha senso usare un HashSet? E che differenza c’è tra Dictionary e ConcurrentDictionary?

In questa puntata ti spiego tutto in modo semplice e concreto.

• https://learn.microsoft.com/en-us/dotnet/api/system.collections
  
  
• https://learn.microsoft.com/en-us/dotnet/api/system.collections.immutable
  
  
• https://learn.microsoft.com/en-us/dotnet/standard/collections/thread-safe/
  
  
• https://learn.microsoft.com/en-us/dotnet/standard/collections/when-to-use-generic-collections

#dotnet  #list #collection #dictionary #dotnetinpillole

Scopri come Activity e ActivitySource ti aiutano a tracciare le operazioni all’interno delle tue applicazioni .NET in modo semplice e standard. Vedremo come usarli al meglio, quali vantaggi offrono per il monitoraggio e la diagnosi, e come si integrano facilmente con OpenTelemetry e altri sistemi di osservabilità.

• https://learn.microsoft.com/en-us/dotnet/core/diagnostics/distributed-tracing
• https://learn.microsoft.com/en-us/dotnet/core/diagnostics/distributed-tracing-instrumentation-walkthroughs
• https://www.jimmybogard.com/building-end-to-end-diagnostics-activitysource-and-open/
• https://opentelemetry.io/docs/languages/dotnet/
• https://youtu.be/3JnMfJM9K0c?si=ymc-6tcw87geqHHw

#dotnet #ActivitySource #observability #OpenTelemetry #dotnetinpillole #podcast

In questa puntata ti parlo di BenchmarkDotNet, una libreria super utile per capire quanto è veloce davvero il tuo codice.
Vediamo insieme come funziona, perché ti evita di fare ottimizzazioni a caso, e come usarla in un progetto .NET.

• https://github.com/dotnet/BenchmarkDotNet
  
  
• https://benchmarkdotnet.org
  
  
• https://learn.microsoft.com/en-us/visualstudio/profiling/profiling-with-benchmark-dotnet?view=vs-2022

#dotnet #BenchmarkDotNet #dotnetinpillole #podcast

Nel mondo delle applicazioni moderne, ogni ciclo di CPU e ogni allocazione contano. In questa puntata esploriamo Span e ReadOnlySpan, due strumenti introdotti in .NET Core 2.1 che permettono di lavorare con la memoria in modo sicuro ed estremamente efficiente.

• https://devblogs.microsoft.com/dotnet/welcome-to-c-7-2-and-span/
  
  
• https://learn.microsoft.com/en-us/dotnet/standard/memory-and-spans/memory-t-usage-guidelines
  
  
• https://learn.microsoft.com/en-us/shows/visual-studio-connect-event-2017/t125
  
  
• https://learn.microsoft.com/en-us/archive/msdn-magazine/2018/january/csharp-all-about-span-exploring-a-new-net-mainstay
  
  

#dotnet #csharp #span #dotnetinpillole #podcast