VB.NET Course with the SVILUPPATORE MIGLIORE method
The programme for teams working with Visual Basic .NET who want to bring their applications to the next level, without starting from scratch.
1-on-1 Mentor On YOUR code Measurable results
Your team works with VB.NET. Maybe by choice, maybe by historical legacy. Either way, you have applications that work, generate revenue and must continue to evolve.
The problem is that the VB.NET world has changed: .NET Core, .NET 10, new architectural patterns, Entity Framework Core, dependency injection, and the team risks falling behind if it does not update its skills.
This programme is designed for those who work with VB.NET in production and want to modernise skills and architectures without having to rewrite everything in C#.
What you learn: the complete programme
2 phases, 8 modules of intensive training on YOUR code.
2 phases, 8 modules of intensive training on YOUR code.
PHASE 1: Modern VB.NET Foundations (Weeks 1-4)
- 1
Modern VB.NET and .NET Features
VB.NET on modern .NET is a different language from the one you use on .NET Framework. The features are there, but almost no team uses them because the documentation is all in C#. Here we close the gap starting from the real code you write every day.
Programma
- Idiomatic Async/AwaitHow to write asynchronous operations without blocking the interface, eliminating the freezes that frustrate users
- Advanced LINQHow to replace nested for loops with expressive queries that the compiler optimises automatically
- Pattern matchingHow to simplify Select Case and type conversions reducing code by more than a third
- Nullable reference typesHow to eliminate NullReferenceException with Option Strict On and explicit annotations
- Tuples and interpolationHow to return multiple values and build strings without redundant StringBuilder
- .NET 10 featuresHow to access platform innovations directly from your VB.NET code
Risultato
Modern, idiomatic VB.NET code. This is not the VB.NET of 2008, it is professional code that leverages .NET to its full potential.
- 2
Advanced OOP in VB.NET
Object-oriented programming is identical in VB.NET and C#, but VB.NET codebases rarely apply it well. 3,000-line monoliths and God Classes that do everything are the norm, not the exception in inherited VB projects. Here we correct course with concrete examples on the code you have in production.
Programma
- Applied SOLIDHow to rewrite classes that do everything into components with a single, clear responsibility
- Interfaces and abstract classesHow to design contracts that make code replaceable and testable
- GenericsHow to eliminate code duplication by leveraging compiler type safety
- Design patternsHow to apply Factory, Strategy, Observer and Decorator in VB.NET with real examples
- Dependency injectionHow to invert dependencies and make components independent of each other
- Progressive refactoringHow to move from procedural code to clean OOP without rewriting everything
Risultato
Clean architecture even in VB.NET. The code is modular, dependencies are managed and refactoring is safe.
- 3
Entity Framework Core with VB.NET
EF Core works perfectly with VB.NET, but the documentation is almost entirely in C#. Those who still use ADO.NET with manually concatenated SQL queries pay a huge technical debt with every schema change. Here we bridge the gap: all EF Core patterns translated to VB.NET with runnable examples.
Programma
- DbContext designHow to structure the context and configuration in VB.NET correctly
- Fluent APIHow to map entities, relationships and constraints without polluting models with attributes
- MigrationsHow to generate, apply and manage schema conflicts in a versioned way
- Query optimisationHow to use projections and Include to avoid the N+1 problem and slow queries
- From ADO.NET to EF CoreHow to plan a progressive migration without interrupting production
- Connection poolingHow to configure the DbContext lifecycle and manage connections correctly
Risultato
Professional data access with EF Core. The database is versioned, queries are performant and type-safe.
- 4
Modern Windows Forms
Your WinForms application is probably a monolith with thousands of lines in code-behind. Every change becomes a risky surgical operation because UI, logic and data access are all mixed together. Here you learn to separate, structure and modernise without starting from scratch.
Programma
- Advanced data bindingHow to connect UI and data with BindingSource and INotifyPropertyChanged without manual code
- MVP patternHow to separate presentation logic from UI making the code testable
- UI refactoringHow to extract logic from code-behind into dedicated classes with clear responsibility
- Custom controlsHow to build reusable components that standardise the application interface
- Threading and async in WinFormsHow to keep the UI responsive during long operations without freezes
- Progressive modernisationHow to update the interface module by module without stopping development
Risultato
Maintainable desktop applications. The UI is separated from the logic, the code is testable and forms are no longer monoliths.
PHASE 2: Quality and Migration (Weeks 5-8)
- 5
Testing in VB.NET
VB.NET codebases almost always have zero automated tests. Every change is a leap in the dark because you have no safety net that signals regressions. Here we build that net, starting from legacy code that was never designed to be tested.
Programma
- NUnit in VB.NETHow to write unit tests, fixtures and assertions that verify real behaviour
- Mocking dependenciesHow to isolate components from databases, external services and the filesystem
- Integration testsHow to verify data access and complete flows without touching production
- Regression testsHow to cover existing legacy code without modifying it before refactoring
- Code coverageHow to read the metrics that really matter and ignore the misleading ones
- CI integrationHow to run tests automatically on every commit and block merges that break something
Risultato
Code tested with confidence. Refactoring is safe and you find regressions before your customer does.
- 6
Architecture and Service Layer
Structuring a VB.NET application with clean layers is possible and necessary if it needs to last another ten years. The lack of separation between UI, logic and data is the main cause of high maintenance costs in legacy projects. Here we build the right architecture, starting from what you already have.
Programma
- Layered architectureHow to organise presentation, business and data in layers with clear boundaries
- Dependency injectionHow to configure Microsoft.Extensions.DI in a VB.NET desktop or console application
- Service layerHow to extract business logic from the UI into services with clear responsibility
- Configuration managementHow to read settings from configuration files without hardcoded strings
- Structured loggingHow to use ILogger to track operations with useful context in production
- Centralised error handlingHow to manage exceptions uniformly without scattered try/catch blocks
Risultato
Application structured with clean layers. Each component has a clear responsibility and the code is easy to navigate.
- 7
Migration from .NET Framework to .NET 10
.NET Framework no longer receives new features and is destined for maintenance only. Staying on .NET Framework means giving up the performance, security and features that .NET 10 provides out of the box. The migration must be planned methodically, not improvised on a production project.
Programma
- .NET Upgrade AssistantHow to use the Microsoft tool to analyse breaking changes before touching the code
- Compatibility analyserHow to identify incompatible APIs and estimate migration effort
- Progressive strategyHow to migrate one project at a time while keeping the application running
- NuGet packagesHow to find compatible alternatives for .NET 10 for every package no longer supported
- Windows Compatibility PackHow to use the compatibility package for missing APIs during the transition
- Multi-targetingHow to support both frameworks during the transition to reduce risk
Risultato
Application ready for .NET 10. The migration is planned, tested and the risk is under control.
- 8
Deploy and Continuous Modernisation
After the migration you need a process to keep the application up to date and deploy it reliably. A manual deploy is an endless source of human errors that repeat themselves with every release. Here we automate the process and define the roadmap for the next steps.
Programma
- CI/CD for VB.NETHow to build automated pipelines that compile, test and publish the application
- Packaging and distributionHow to choose between ClickOnce, MSIX and self-contained based on your scenario
- Semantic versioningHow to manage releases with clear numbering and automatic changelogs
- Production monitoringHow to collect metrics and diagnostics without direct server access
- Modernisation roadmapHow to plan the next interventions with priorities based on real risk
- VB.NET to C# transitionHow to evaluate costs, timelines and scenarios where planning it makes sense
Risultato
Reliable deploy process and a clear roadmap. The application is ready for the future, whatever direction you choose.
The method: Progressive Mastery Architecture
We work on your existing VB.NET code. We do not ask you to rewrite everything in C#, we teach you to modernise VB.NET with current best practices, and when it makes sense, to plan a gradual transition.
Who this programme is for
CTO with VB.NET applications in production
The applications work but the team struggles to evolve them. You want a programme that modernises skills without interrupting productivity and without rewriting everything.
VB.NET developer who wants to stay competitive
VB.NET is not dead, but the market rewards those who know modern best practices. This programme brings you to the next level with current patterns and architectures.
Team planning the transition to C#
You want a gradual path: first modernise VB.NET with best practices, then when it makes sense plan the transition to C# without trauma.
Who is Matteo Migliore
What professionals who have followed the programme say
Those who study with Matteo have the opportunity to access a very meaningful and concrete experience, entering the world of software development with a reliable and competent guide.
His training is a real opportunity for young people who want to pursue a career as a software architect.
I definitely recommend him, especially for the professionalism he has always shown and his ability to explain numerous topics that are normally not covered in these types of courses.
The WPF course I had the fortune to take with Matteo Migliore literally opened up an incredible world for me, allowing me to acquire all the techniques that will enable me to tackle increasingly important projects.
I definitely recommend Matteo for the technical content and the experience he brings; the training journey was also rich in anecdotes where he shared his experiences going all the way back to when he was a child.
I recommend Matteo's course especially to beginners and anyone who needs to learn how to structure an application, because this way you can start already with a correctly built architecture.
One difference I notice compared to other courses is a great passion for training, understood in a very broad sense. It is a mission for them, and beyond the specific WPF course topics, I always find tips and suggestions on cross-cutting subjects like design, software control and testing — which gives me something extra in my overall development approach.
Often there is little time and great difficulty managing on your own the issues you encounter daily, and if you tend to limit yourself to your own knowledge you end up stuck in your own mistakes.
Going back over things I had studied at university, explained step by step in a new language I had not studied before, was extremely useful.
I turned to our consultant, Matteo Migliore, to enter this new world.
Thanks to the course I learned a programming approach built in a much more sensible way than what I was doing before.
I recommend Matteo because he is a very competent person who loves his work and cares about helping others, making them more productive and more capable of mastering technology.
What I liked most was the new management of the project structure: separating the UI from the design layer, and in particular not writing code directly in the UI but structuring it properly.
Matteo doesn't simply read from a pre-prepared script but is able to go deeper into syntactic elements and design patterns, perfectly following the needs of whoever is learning.
Investment and programme
Programmes are tailored to the number of participants, duration and project complexity.
Fill in the form to receive the complete programme and a personalised quote based on your specific needs.
Individual Programme
1 participant, personalised mentoring
- 8 complete modules
- Biweekly live 1-to-1 sessions
- Platform access for 12 months
- Continuous chat support
Team Programme
2-3 participants, department transformation
- 8 complete modules
- Work on the company codebase
- VB.NET modernisation plan
- Platform access for 12 months for all
Intensive Workshop
1-2 days on specific topics
- Focus on specific modules of your choice
- Up to 5 participants
- Complete training materials
- Follow-up session at 30 days
Ready to modernise your VB.NET code?
Fill in the form and receive all the information about the VB.NET programme. We analyse your scenario and the best path for you or your team.
Free analysis We assess the state of the VB.NET code and the modernisation options
Talk to one of our tutors Not a salesperson, but a real expert who will guide you
Practical advice You receive useful guidance even if you decide not to continue