.NET in pillole
By Andrea Dottor
Listen to a podcast, please open Podcast Republic app. Available on Google Play Store and Apple App Store.
Image by Andrea Dottor
Category: Technology
Open in Apple Podcasts
Open RSS feed
Open Website
Rate for this podcast
Subscribers: 14
Reviews: 0
Episodes: 313
Description
Un modo alternativo per rimanere aggiornati sul mondo .NET e tutto ciò che ci gira attorno: dai nuovi rilasci, ad articoli e post che troveremo particolarmente interessanti. Non mancheranno sicuramente le community ed i loro eventi. Ed un pizzico di architetture e problematiche di tutti i giorni.
| Episode | Date |
|---|---|
|
313 - Dal codice alla gestione progetti: cosa puoi fare con i server MCP
|
Oct 06, 2025 |
|
312 - Insegna a GitHub Copilot il tuo stile di codice
|
Sep 29, 2025 |
|
311 - AI e programmatori alle prime armi: alleato o scorciatoia pericolosa?
|
Sep 22, 2025 |
|
310 - Visual Studio 2026 Insider è qui! AI, velocità e UI moderna
|
Sep 15, 2025 |
|
309 - .NET in pillole compie 6 anni: cosa abbiamo imparato insieme
|
Sep 08, 2025 |
|
308 - Da HTML a PDF e scraping: il potere di PuppeteerSharp
|
Sep 01, 2025 |
|
307 - Wolverine: non quello con gli artigli, ma quasi! Una libreria di messaggistica per le nostre app
|
Aug 25, 2025 |
|
306 - Magic.IndexedDB: Linq incontra IndexedDB in Blazor
|
Aug 18, 2025 |
|
305 - TickerQ, un'ottima idea di base, ma potrà competere con Hangfire e Quartz?
|
Aug 11, 2025 |
|
304 - Dalle password alle passkey: l’evoluzione di ASP.NET Identity
|
Aug 04, 2025 |
|
303 - Dal caos al controllo: riduci il rumore nei log con .NET 9
|
Jul 28, 2025 |
|
302 - CQRS in .NET con Brighter e Darker: alternativa a MediatR?
|
Jul 21, 2025 |
|
301 - Arrivata la versione commerciale di Mediatr e AutoMapper, che fare ora?
|
Jul 14, 2025 |
|
300 - UnitsNet: gestire le unità di misura in .NET non è mai stato così facile
|
Jul 07, 2025 |
|
299 - Parallelismo e zero allocazioni: LINQ non è mai stato così veloce
|
Jun 30, 2025 |
|
298 - Stop! In nome del Token - La cancellazione cooperativa in C#
|
Jun 23, 2025 |
|
297 - Task Parallel Library: metti il turbo al tuo codice C#
|
Jun 16, 2025 |
|
296 - L’arte dell’attesa: async e await senza segreti
|
Jun 09, 2025 |
|
295 - C# si fa leggero! Scripting in C#: un file, nessun progetto, zero scuse
|
Jun 02, 2025 |
|
294 - Liste, dizionari e collezioni: tutto il mondo .NET in una puntata
|
May 26, 2025 |
|
293 - Diagnosi senza stress: tracciare le operazioni in .NET con ActivitySource e Activity
|
May 19, 2025 |
|
292 - Quanto è veloce il tuo codice? Misuralo con BenchmarkDotNet
|
May 12, 2025 |
|
291 - C# ad alte prestazioni: la potenza di Span e ReadOnlySpan
|
May 05, 2025 |
|
290 - Alla scoperta dei Channels...poco conosciuti, ma indispensabili!
|
Apr 28, 2025 |
|
289 - Pipeline di build in C# con Nuke. Ciao ciao YAML
|
Apr 21, 2025 |
|
288 - Estendere Copilot con un nostro server MCP
|
Apr 14, 2025 |
|
287 - MediatR, AutoMapper e MassTransit a pagamento per uso commerciale
|
Apr 07, 2025 |
|
286 - Cosa arriverà in ASP.NET Core 10
|
Mar 31, 2025 |
|
285 - Prompty, un playground per i nostri prompt (dentro VS Code)
|
Mar 24, 2025 |
|
284 - .NET 9.0.3 ci ha portato HybridCache!
|
Mar 17, 2025 |
|
283 - Aspire Dashboard, non credevo di usarla così tanto
|
Mar 10, 2025 |
|
282 - Migliorare i tempi di risposta delle API Rest
|
Mar 03, 2025 |
|
281 - Podman, l'alternativa più leggera e sicura a Docker
|
Feb 24, 2025 |
|
280 - OpenIddict, la libreria per implementare un proprio server OAuth 2.0/OpenID Connect
|
Feb 17, 2025 |
|
279 - Nuove funzionalità per GitHub Copilot
|
Feb 10, 2025 |
|
278 - Risolvere problemi di comunicazione con lo Standup Meeting
|
Feb 03, 2025 |
|
277 - Quando abbiamo perso le specifiche?
|
Jan 27, 2025 |
|
276 - Struttura delle solution in Visual Studio, alcuni consigli
|
Jan 20, 2025 |
|
275 - HybridCache, l'unione di IDistributedCache e IMemoryCache ma con qualcosa in più
|
Jan 13, 2025 |
|
274 - Gestire le versioni dei package NuGet in modo centralizzato
|
Jan 06, 2025 |
|
273 - Consiglio di lettura: Atomic Habits, piccole abitudini per grandi cambiamenti
|
Dec 30, 2024 |
|
272 - Il futuro di Blazor - L'intervista a Daniel Roth
|
Dec 23, 2024 |
|
271 - Text templating con Scriban
|
Dec 16, 2024 |
|
270 - Cambiamenti e migliorie per OpenAPI con .NET 9
|
Dec 09, 2024 |
|
269 - Ecco le novità arrivate in Blazor con .NET 9
|
Dec 02, 2024 |
|
268 - Le novità di NET 9 per MAUI
|
Nov 25, 2024 |
|
267 - .NET 9 è arrivato!
|
Nov 18, 2024 |
|
266 - Test Driven Development, investimento o costo?
|
Nov 11, 2024 |
|
265 - Gestire gli aggiornamenti del database con FluentMigrator
|
Nov 04, 2024 |
|
264 - Applicazioni resilienti, testiamole con Dev Proxy
|
Oct 28, 2024 |
|
263 - Respawn e Testcontainers, due comode utility per i nostri test
|
Oct 21, 2024 |
|
262 - Generare dati fake per i test con AutoFixture e Bogus
|
Oct 14, 2024 |
|
261 - Mocking con NSubstitute...e due parole sul passato infelice di Moq
|
Oct 07, 2024 |
|
260 - Moq, la più utilizzata libreria di mock...per i nostri unit-test
|
Sep 30, 2024 |
|
259 - Asserzioni fluent nei nostri test con FluentAssertions
|
Sep 23, 2024 |
|
258 - Unit test di componenti Blazor con bUnit
|
Sep 16, 2024 |
|
257 - Introduzione allo Unit Testing
|
Sep 09, 2024 |
|
256 - Restart! Playwright, un tool sempre più indispensabile
|
Sep 02, 2024 |
|
Un byte di puntate. Il podcast va in ferie
|
Jul 22, 2024 |
|
Piani d'esecuzione di Entity Framework dentro a Visual Studio con EFCoreVisualizer
|
Jul 15, 2024 |
|
Componenti di UI per Blazor, le mie disavventure con un FileManager
|
Jul 08, 2024 |
|
Il debug, questo sconosciuto
|
Jul 01, 2024 |
|
SqlClient, lo sapevi che...
|
Jun 24, 2024 |
|
Localizzazione risorse con Visual Studio
|
Jun 17, 2024 |
|
DuckDB, un SQLite con funzionalità OLAP (e molto di più)
|
Jun 10, 2024 |
|
Dalla Tabya Conf ai Smart Components
|
Jun 03, 2024 |
|
.NET Aspire rilasciato ufficialmente
|
May 27, 2024 |
|
Anche un monolite può essere scritto bene!
|
May 20, 2024 |
|
Community ed eventi, cosa possiamo fare per farli conoscere di più?
|
May 13, 2024 |
|
Organizzazione del codice con Partial Classes e Region
|
May 06, 2024 |
|
Live Share, un tool sottovalutato
|
Apr 29, 2024 |
|
Migliora o integra codice in fase di build con Fody
|
Apr 22, 2024 |
|
Sviluppare software è risolvere problemi di business
|
Apr 15, 2024 |
|
Uniformiamo la scrittura del codice con StyleCop
|
Apr 08, 2024 |
|
Bruno, l'API client che si differenzia da tutti gli altri
|
Apr 01, 2024 |
|
Microsoft Garnet, sarà il nostro prossimo cache-store?
|
Mar 25, 2024 |
|
NATS, un pub-sub e molto in più
|
Mar 18, 2024 |
|
Blazor Web App, la mia esperienza dopo 4 mesi
|
Mar 11, 2024 |
|
Semplifica la scrittura di librerie NuGet con questi tool
|
Mar 04, 2024 |
|
Siamo certi di avere API Rest sicure? Testiamole con RESTler
|
Feb 26, 2024 |
|
Introdotto il supporto alla Chaos Engineering in Polly
|
Feb 19, 2024 |
|
Dev Tunnel, testare da mobile le nostre applicazioni web o api con facilità
|
Feb 12, 2024 |
|
Ti stai avvicinando a C#? Ecco da dove iniziare
|
Feb 05, 2024 |
|
Perché .NET
|
Jan 29, 2024 |
|
Orchestrare la logica dell'applicazione con Temporal.io
|
Jan 22, 2024 |
|
Gestire l'autenticazione degli utenti con Auth0
|
Jan 15, 2024 |
|
Generare la documentazione con DocFx
|
Jan 08, 2024 |
|
Aggiornare a .NET 8? Assolutamente si!
|
Jan 01, 2024 |
|
Dati sensibili nei log, ecco come gestirli al meglio
|
Dec 25, 2023 |
|
.NET Aspire, uno degli annunci più grossi della .NET Conf
|
Dec 18, 2023 |
|
Native AOT, tanti vantaggi, ma dove sta la fregatura?
|
Dec 11, 2023 |
|
Autenticazione semplificata grazie agli Identity API endpoints e Blazor Identity UI
|
Dec 04, 2023 |
|
Novità in C# 12 che semplificano la scrittura del codice
|
Nov 27, 2023 |
|
.NET 8 è arrivato, e con lui Blazor è ora un "full-stack web UI framework"
|
Nov 20, 2023 |
|
Interoperabilità tra .NET e Node.js nello stesso processo
|
Nov 13, 2023 |
|
Analizzare e anonimizzare dati sensibili non è mai stato così facile (con Microsoft Presidio)
|
Nov 06, 2023 |
|
(Sempre più) servizi gratuiti in Microsoft Azure
|
Oct 30, 2023 |
|
Domain Event, cosa sono e a cosa servono?
|
Oct 23, 2023 |
|
Modular Architecture, il giusto compromesso tra monolite e microservizi
|
Oct 16, 2023 |
|
C# DevKit, solution explorer e molto altro arrivano in VS Code
|
Oct 09, 2023 |
|
Ricerche full-text client-side con Orama, anche da Blazor!
|
Oct 02, 2023 |
|
Generare i client di API Rest con Kiota
|
Sep 25, 2023 |
|
GitHub Copilot, cosa ne penso dopo mesi di utilizzo
|
Sep 18, 2023 |
|
Use typescript. It’s better. (cit)
|
Sep 11, 2023 |
|
Alcune novità sulle Azure Functions
|
Sep 04, 2023 |
|
Moq da uno scossone al mondo dell'open-source .NET
|
Aug 28, 2023 |
|
Data API Builder - esponiamo il nostro DB con api REST e GraphQL in tempo zero!
|
Aug 21, 2023 |
|
Clean Architecture, e per una volta non è il DB a comandare
|
Aug 14, 2023 |
|
Cloud Native Architecture
|
Aug 07, 2023 |
|
Architettura N-Layer, la prima da conoscere
|
Jul 31, 2023 |
|
Oggi architetture con AWS Architecture
|
Jul 24, 2023 |
|
Parliamo di architetture...da dove iniziare?
|
Jul 17, 2023 |
|
LiteDB, un database NoSQL standalone, semplice e veloce
|
Jul 10, 2023 |
|
Puntata 200! Ecco cosa uso per registrare il podcast
|
Jul 03, 2023 |
|
Un caso reale di migrazione da .NET Framework a .NET 6...risparmio del 30% dei costi cloud.
|
Jun 26, 2023 |
|
Full stack web UI with Blazor
|
Jun 19, 2023 |
|
Ordine e pulizia nel codice?! Assolutamente fondamentale!
|
Jun 12, 2023 |
|
Identity API endpoints, e l'interesse per .NET 8 aumenta
|
Jun 05, 2023 |
|
BDD, e forse è la volta buona che i test li facciamo
|
May 29, 2023 |
|
Qwik, un framework che si differenzia da tutti gli altri
|
May 22, 2023 |
|
Mapperly, una libreria di mapping basata sui source generator
|
May 15, 2023 |
|
Sviluppo di Web API con Visual Studio, novità in arrivo
|
May 08, 2023 |
|
Azure Cognitive Services...mi stavo perdendo un sacco di novità!
|
May 01, 2023 |
|
BlazorPlate, un template di progetto per Blazor WebAssembly davvero interessante
|
Apr 24, 2023 |
|
LiveCharts v2, una libreria (nativa) .NET anche per Blazor wasm
|
Apr 17, 2023 |
|
Le Minimal API hanno vinto
|
Apr 10, 2023 |
|
GitHub Copilot X, una chat dentro a Visual Studio
|
Apr 03, 2023 |
|
Multi-repository in Visual Studio, l'avevo sottovalutato.
|
Mar 27, 2023 |
|
Fast Blazor, una libreria di componenti direttamente da Microsoft
|
Mar 20, 2023 |
|
Feed NuGet privati, esistono e vanno usati
|
Mar 13, 2023 |
|
Un Visual Studio sempre più intelligente
|
Mar 06, 2023 |
|
.NET Upgrade Assistant (anche) come estensione per Visual Studio
|
Feb 27, 2023 |
|
Blazor United, uno sviluppo unificato per applicazioni client e server!
|
Feb 20, 2023 |
|
FastEndpoints, una valida alternativa alle Minimal API
|
Feb 13, 2023 |
|
Blazor Hybrid, riuso di componenti tra web, desktop e mobile
|
Feb 06, 2023 |
|
Ho provato Azure OpenAI
|
Jan 30, 2023 |
|
Abbiamo sfidato ChatGPT
|
Jan 23, 2023 |
|
FusionCache, una cache con qualche marcia in più
|
Jan 16, 2023 |
|
State usando ancora Identity Server 4? Facciamo il punto
|
Jan 09, 2023 |
|
Playwright, la libreria per test e2e che tanto volevo!
|
Jan 02, 2023 |
|
Spiegare il codice ad una paperella di gomma
|
Dec 26, 2022 |
|
Non sono i pattern a rendere migliore il nostro codice
|
Dec 19, 2022 |
|
Noi dev siamo una categoria strana!
|
Dec 12, 2022 |
|
Quando il serverless può dare quel qualcosa in più
|
Dec 05, 2022 |
|
Una semplice libreria per schedulare attività/codice: Coravel
|
Nov 28, 2022 |
|
Ecco le Minimal API che aspettavamo
|
Nov 21, 2022 |
|
ASP.NET Core 7.0, ecco la mia TOP 5
|
Nov 14, 2022 |
|
Prestazioni o durata del supporto? Mettiamo STS e LTS a confronto.
|
Nov 07, 2022 |
|
Blazor potrebbe funzionare ancora meglio se...
|
Oct 31, 2022 |
|
Ma quanto è noioso mappare i nostri DTO/ViewModel/DomainObject?
|
Oct 24, 2022 |
|
Collaborare, confrontarsi ed imparare (divertendosi)
|
Oct 17, 2022 |
|
E' tutta una questione di compromessi
|
Oct 10, 2022 |
|
Riuso del codice con le Razor Class Library
|
Oct 03, 2022 |
|
Portiamo blazor sul desktop e mobile grazie a MAUI Blazor App
|
Sep 26, 2022 |
|
Usare gli alias per aumentare la produttività con git
|
Sep 19, 2022 |
|
Migrare più facilmente ad ASP.NET Core con i System.Web Adapters
|
Sep 12, 2022 |
|
3 anni di podcast, e oggi vi parlo di practical-aspnetcore
|
Sep 05, 2022 |
|
Grandi novità per Blazor con la preview 7 di .NET 7
|
Aug 29, 2022 |
|
Lettura estiva: Extreme Contracts di Jacopo Romei
|
Aug 22, 2022 |
|
DevToys: una raccolta di strumenti indispensabili per uno sviluppatore
|
Aug 15, 2022 |
|
Miglioriamo la grafica delle nostre Console Application con Terminal.Gui
|
Aug 08, 2022 |
|
Lettura estiva: De/cifrare di Mark Frary
|
Aug 01, 2022 |
|
Rate Limiting con .NET 7, molto più di quello che credevo
|
Jul 25, 2022 |
|
La mia top 5 delle novità presenti nella Preview 6 di .NET 7 per ASP.NET
|
Jul 18, 2022 |
|
Unit testing, a cosa serve?
|
Jul 11, 2022 |
|
Entity Framework non è l'unica tecnologia per fare accesso ai dati
|
Jul 04, 2022 |
|
Scrivere Unit Test in modo più naturale (e comprensibile) con FluentAssertions
|
Jun 27, 2022 |
|
Testare con dati veritieri...come generarli
|
Jun 20, 2022 |
|
Componenti terze parti e mondo open-source
|
Jun 13, 2022 |
|
Minimal API, a che punto siamo?
|
Jun 06, 2022 |
|
Ho pubblicato la mia demo Blazor: Umarell!
|
May 30, 2022 |
|
Di Windows Terminal, WSL e Oh My Posh
|
May 23, 2022 |
|
Generare pdf con QuestPDF
|
May 16, 2022 |
|
Verify, una libreria per unit test basata sugli snapshot
|
May 09, 2022 |
|
Accessibility Days 2022, l'evento da non perdere
|
May 02, 2022 |
|
Riuso del codice...quanta fatica farne capire l'importanza
|
Apr 25, 2022 |
|
Ecco come ho abbandonato la carta! Merito del Supernote A5X
|
Apr 18, 2022 |
|
Il database nelle applicazioni multi-tenant
|
Apr 10, 2022 |
|
Il più grande problema di Blazor Server, e perchè ho fiducia in .NET 7
|
Mar 28, 2022 |
|
Fluent Builder Pattern, continua il percorso alla scoperta dei Design Pattern
|
Mar 21, 2022 |
|
Tutti i modi per schedulare l'esecuzione di codice
|
Mar 14, 2022 |
|
Un pò di funzionale nei nostri progetti con Reacitve UI
|
Mar 07, 2022 |
|
Eseguire operazioni in background e schedulate con Hangfire
|
Feb 28, 2022 |
|
Oggi un bel minestrone: di covid, conf e fretta
|
Feb 21, 2022 |
|
.NET compie 20 anni, buon compleanno!
|
Feb 14, 2022 |
|
Da Visual Studio 2022 a Rider
|
Feb 07, 2022 |
|
Da SignalR ad Azure Web PubSub
|
Jan 31, 2022 |
|
Alcuni piccoli pacchetti nuget (per blazor), ma davvero essenziali
|
Jan 24, 2022 |
|
Sviluppare applicazioni ibride con Blazor e MAUI
|
Jan 17, 2022 |
|
Uno sguardo alle demo della .NET Conf 2021: ".NET Podcasts"
|
Jan 10, 2022 |
|
Progetti e statistiche 2021 della .NET Foundation
|
Jan 03, 2022 |
|
Applicazioni multi-tenant con Finbuckle.MultiTenant
|
Dec 27, 2021 |
|
Avalonia sul web grazie a Blazor WebAssembly
|
Dec 20, 2021 |
|
Ma quanto è difficile scrivere del codice semplice?
|
Dec 13, 2021 |
|
JavaScript and TypeScript standalone projects - Visual Studio 2022
|
Dec 06, 2021 |
|
JavaScript per uno sviluppatore Blazor
|
Nov 29, 2021 |
|
Ho provato YARP, e mi è piaciuto un sacco
|
Nov 22, 2021 |
|
.NET Conf 2021, la mia top 5
|
Nov 15, 2021 |
|
Bosch sceglie DAPR e Microsoft Azure per Home Connect Plus
|
Nov 08, 2021 |
|
Visual Studio Code nel browser con vscode.dev
|
Nov 01, 2021 |
|
Gestire dei workflow con le Durable Functions
|
Oct 25, 2021 |
|
Silverlight è morto, lunga vita a Silverlight
|
Oct 18, 2021 |
|
Generare email html con RazorEngine
|
Oct 11, 2021 |
|
Creare ed eseguire workflow con Elsa Workflows
|
Oct 04, 2021 |
|
Migrazione a .NET 5, il caso reale di Paint.NET
|
Sep 27, 2021 |
|
Includere componenti Blazor da JavaScript
|
Sep 20, 2021 |
|
Le migliori librerie per fare richieste HTTP da .NET
|
Sep 13, 2021 |
|
YARP, un Reverse Proxy altamente performante
|
Sep 06, 2021 |
|
In dirittura d'arrivo con le ASP.NET Core Minimal API
|
Aug 30, 2021 |
|
Pattern creazionali: Factory Method e Abstract Factory
|
Aug 23, 2021 |
|
Novità in (ASP.NET Core) .NET 6 Preview 7
|
Aug 16, 2021 |
|
Semplificare le dipendenze con il Mediator Pattern
|
Aug 09, 2021 |
|
Decorator Pattern, per quando l'ereditarietà ci sta stretta
|
Aug 02, 2021 |
|
Puntata 100!! Alcune parole su Visual Studio 2022
|
Jul 26, 2021 |
|
Design Patterns, alla scoperta del Singleton
|
Jul 19, 2021 |
|
Conoscere i Design Patterns
|
Jul 12, 2021 |
|
Pair programming con l'AI (GitHub Copilot)
|
Jul 05, 2021 |
|
Imparare da un monolite. (Modular Monolith with DDD)
|
Jun 28, 2021 |
|
Alla scoperta di ABP Framework
|
Jun 21, 2021 |
|
Repository e Service: si, no, quando?
|
Jun 14, 2021 |
|
Ecco come (non) gestire gli errori
|
Jun 07, 2021 |
|
ASP.NET 6 preview 4, una preview super interessante
|
May 31, 2021 |
|
Risparmiare con Microsoft Azure. Alla scoperta dei servizi gratuiti
|
May 24, 2021 |
|
Semplificare lo sviluppo cloud-native con DAPR (Distributed Application Runtime)
|
May 17, 2021 |
|
ASP.NET Core 6 and Authentication Servers
|
May 10, 2021 |
|
Blazor vs Angular, come scegliere?
|
May 03, 2021 |
|
Di community e di come sia facile creare un'estensione per VS Code
|
Apr 26, 2021 |
|
Visual Studio Code, le 10 estensioni che uso di più
|
Apr 19, 2021 |
|
Libro Domain-Driven Design, perchè leggerlo?
|
Apr 12, 2021 |
|
IdentityServer4, non tutti sanno che...
|
Apr 05, 2021 |
|
Scopriamo le micro/minimal API di ASP.NET 6
|
Mar 29, 2021 |
|
Novità per ASP.NET Core in .NET 6 (preview 2)
|
Mar 22, 2021 |
|
Architettura a Microservizi...non per tutti
|
Mar 15, 2021 |
|
CQRS, CQS - facciamo chiarezza e sfatiamo alcuni miti
|
Mar 08, 2021 |
|
Clean Architecture Solution Template
|
Mar 01, 2021 |
|
Rispetto delle Naming Convention
|
Feb 22, 2021 |
|
Integrazione ed estensibilità con i Webhook
|
Feb 15, 2021 |
|
DDD Ubiquitous Language, l'importanza di un linguaggio condiviso
|
Feb 08, 2021 |
|
Introduzione a Micro Frontend e Web Component, una coppia vincente
|
Feb 01, 2021 |
|
Introduzione alla Infrastructure as Code
|
Jan 25, 2021 |
|
Guide su architetture e pattern per le nostre applicazioni
|
Jan 18, 2021 |
|
Miglioriamo le nostre Console Application con Spectre.Console
|
Jan 11, 2021 |
|
Testare l'invio di email con smtp4dev
|
Jan 04, 2021 |
|
Utilizzare Humanizer per visualizzare al meglio i nostri dati (strings, enums, dates, times, ...)
|
Dec 28, 2020 |
|
RulesEngine, un motore di regole/policy basato su json
|
Dec 21, 2020 |
|
Gestione dei feature flags con Microsoft.FeatureManagement
|
Dec 14, 2020 |
|
Quanto poco conoscevo i SQL Server Database Project
|
Dec 09, 2020 |
|
Novità in C# 9
|
Nov 30, 2020 |
|
RepoDB in un progetto reale, ecco i pro e contro
|
Nov 23, 2020 |
|
Novità in ASP.NET Core 5.0
|
Nov 16, 2020 |
|
(sto invecchiando) sfogo sulle librerie di UI Components
|
Nov 09, 2020 |
|
Gestire la configurazione con Azure Key Vault
|
Nov 02, 2020 |
|
ASP.NET Core #7 - Alla scoperta degli Health Check
|
Oct 26, 2020 |
|
Testare applcazioni Blazor con bUnit
|
Oct 19, 2020 |
|
Introduzione alla Persistenza Poliglotta
|
Oct 12, 2020 |
|
Azure Functions, backend perfetto per gli Azure Static Web Apps, ma non solo
|
Oct 05, 2020 |
|
Alla scoperta di Azure Static Web Apps
|
Sep 28, 2020 |
|
Blazor for ASP.NET Web Forms Developers
|
Sep 21, 2020 |
|
ASP.NET Core #6 - Middleware e Filters
|
Sep 14, 2020 |
|
1 anno di .NET in pillole - Buon compleanno con alcuni suggerimenti
|
Sep 07, 2020 |
|
Novità per Blazor in .NET 5
|
Aug 31, 2020 |
|
PWA - Progressive web apps
|
Aug 24, 2020 |
|
Ciao ciao PhoneGap - parliamo di PWA e sviluppo mobile multipiattaforma
|
Aug 17, 2020 |
|
Usiamo TypeScript (e dormiamo sereni)
|
Aug 10, 2020 |
|
Accesso ai dati con RepoDB
|
Aug 03, 2020 |
|
Aggiornare lo schema del database, tecniche e tecnologie
|
Jul 27, 2020 |
|
Gestione del tempo con la Tecnica del Pomodoro
|
Jul 20, 2020 |
|
Public Speaking
|
Jul 13, 2020 |
|
Pensieri liberi sull'open source
|
Jul 06, 2020 |
|
SOLID #5 - Dependency Inversion Principle
|
Jun 29, 2020 |
|
SOLID #4 - Interface Segregation Principle | News su gRPC-Web per .NET
|
Jun 22, 2020 |
|
SOLID #3 - Liskov Substitution Principle
|
Jun 15, 2020 |
|
SOLID #2 - Open/Closed principle
|
Jun 08, 2020 |
|
SOLID #1 - Single Responsibility Principle
|
Jun 01, 2020 |
|
Novità da Build 2020 - .NET, Visual Studio 2019, C# 9, Blazor
|
May 25, 2020 |
|
La mia agenda per Microsoft Build 2020
|
May 18, 2020 |
|
GitHub Codespaces
|
May 11, 2020 |
|
Visual Studio Codespaces
|
May 04, 2020 |
|
Due parole su Umbraco CMS (un modo per non reinventare la ruota)
|
Apr 27, 2020 |
|
E' di nuovo amore con Vue! Ma prima due parole su Github
|
Apr 20, 2020 |
|
Gestione degli errori con Polly
|
Apr 13, 2020 |
|
Sviluppare videogiochi con JavaScript
|
Apr 06, 2020 |
|
Versionamento del codice, anche se siamo da soli!
|
Mar 30, 2020 |
|
10 consigli per chi lavora da remoto
|
Mar 23, 2020 |
|
Formazione da remoto con Visual Studio Live Share
|
Mar 16, 2020 |
|
La top 10 delle librerie .NET che utilizzo
|
Mar 09, 2020 |
|
Testare api REST
|
Mar 02, 2020 |
|
Fake API REST in tempo zero con JSON Server
|
Feb 24, 2020 |
|
ASP.NET Core #5 - Realizzare API Rest
|
Feb 17, 2020 |
|
L'importanza delle community. Condivisione, crescita ed una birra in compagnia
|
Feb 10, 2020 |
|
Esperienze con i pattern di accesso ai dati, dal Factory a CQS/CQRS passando per il Repository
|
Feb 03, 2020 |
|
Mediator Pattern in .NET con MediatR
|
Jan 27, 2020 |
|
Intro speciale e novità dalla .NET Conf 2020 Focus on Blazor
|
Jan 20, 2020 |
|
Commenti nel codice, una buona pratica per noi e per gli altri
|
Jan 13, 2020 |
|
Accesso ai dati con Dapper
|
Jan 06, 2020 |
|
Grazie per questo 2019 fantastico! Considerazioni e obiettivi per il nuovo anno
|
Dec 30, 2019 |
|
Ma nel 2020 abbiamo ancora bisogno di JQuery? E poi due parole su Bulma css
|
Dec 23, 2019 |
|
.NET Core Worker Service, una console application con gli steroidi
|
Dec 16, 2019 |
|
Maledetta tracheite! Rilasciato .NET Core 3.1, è ora di aggiornare
|
Dec 11, 2019 |
|
E' l'ora di migrare? Da ASP.NET MVC o WebForm ad ASP.NET Core
|
Dec 02, 2019 |
|
ASP.NET Core #4 - Un uso consapevole della configurazione
|
Nov 25, 2019 |
|
ASP.NET Core #3 - Dependency Injection
|
Nov 18, 2019 |
|
ASP.NET Core #2 - Razor Pages vs MVC
|
Nov 11, 2019 |
|
ASP.NET Core #1 - Intro e struttura progetto
|
Nov 04, 2019 |
|
Blazor, realizzare Web UI interattive senza JavaScript
|
Oct 28, 2019 |
|
Uno sfogo su Bootstrap. Pro, contro e valide alternative
|
Oct 21, 2019 |
|
Cache con ASP.NET Core, la conosciamo veramente?
|
Oct 14, 2019 |
|
I 10 comandamenti dei Log
|
Oct 07, 2019 |
|
Un consapevole uso dei "null". Evitiamo qualche NullReferenceException
|
Sep 30, 2019 |
|
Introduzione a gRPC. Un'alternativa per far comunicare microservizi
|
Sep 23, 2019 |
|
Lettura e scrittura del codice
|
Sep 16, 2019 |
|
KISS, YAGNI e DRY...un passo verso il buon codice
|
Sep 09, 2019 |
|
.NET in pillole #0 - intro
|
Sep 02, 2019 |