ASP.NET Core integration testing 101

There is testing, and then there is testing. Some of it feels like a chore, and some of it just feels like it makes sense.

When I started integration testing my ASP.NET API:s, it felt like one of those things that just made sense! I was able to quickly and easily call an API endpoint, and verify the result. Something that makes my life as a developer a lot easier. And on top of that, it not only gives me confidence that my API works as it should, it also makes sure that any changes I make are backwards compatible. Not to mention that the tests actually become pretty great documentation of how to use the API as well. Giving me all the things tests are supposed to give, but I never really felt like unit tests gave me. It's a win-win-win thing.

However, there are some challenges that we need to address before we end up at this utopia. Things like being able to use a database during the tests. Handling security. Mocking 3rd party dependencies that can't be used during testing. But these are all things that we can overcome.

In this talk Chris will show you how to solve these things and set up an easy to use integration testing environment for your ASP.NET Core API:s.

Improving your dev experience with .NET Aspire

Building applications today is a lot more complicated than it used to be, as we tend to shy away from monoliths and build, at least somewhat, distributed applications. On top of that, they tend to be dependent on a bunch of external services like Redis, SQL, Service Buses and Kafka. All of them, things that make your application development a more complicated.

Sure, a lot of it can be handled by a bunch of configuration, conventions and Docker. But it still takes time, is sometimes overly complicated, and causes quite a few headaches. What if it didn't have to?

.NET Aspire is built to simplify your development in these kinds of scenarios. The goal is to allow you to orchestrate your solution using code, and have the framework sort out things like service discovery, telemetry, logging, resiliency and more.

In this presentation you will get an introduction to what .NET Aspire can do for you! It will also try to explain a bit about how it actually works, instead of just showing the new and shiny stuff and saying that it is the result of many sacrificed chickens and black magic!

Exposing the not-so-secret practices of the cult of DDD

For decades, the followers of the Legend of the Ubiquitous Language, have been successfully implementing software solutions in complex domains. Using the not-so-secret practices outlined by the cult of DDD, they merge the realms of development and business to create understandable and manageable software.

But even if these powerful practices aren't secret, they are shrouded in mystery and complex language. Making them tools used almost exclusively by developers who have studied the ancient book of Evans. A book filled with incantations like "bounded context", "value object" and "anti-corruption layer".

But that ends today! In this session, we will expose some of the most useful DDD practices for what they are. And we will also show you how they can become powerful tools in your developer toolbelt. Even if you do not want to bend your knee to the craftspeople of old, and spend the rest of your career trying to explain the legend of the ubiquitous language to everyone around you.

Stop using Entity Framework as just a DTO provider!

Entity Framework is a great tool to retrieve your data from the database. However, it is also a bit complicated, and requires that you read a bit more than just the "Getting Started with EF" page. Unfortunately, this seems to be what most developers do.

At least I think that is why I keep seeing people using it to replicating the database structure in their code with DTO:s. This is not the way it was intended to be used. It was intended to persist and retrieve data for you C# object. Not just DTO:s.

And if one more person tells me "we used a micro-ORM for this project, since it does the same thing as EF but without the complexity", I will blow a gasket!

Why not join me, Chris Klug, for a look at how we can do better? In this talk, I will show you how we can use proper OOP and still use EF to persist and retrieve our objects.

Introduction to Actor-based Development with Project Orleans

There are some domains that are really hard to model using your standard n-tier architecture. Domains like real time vehicle tracking, auctions and many IoT scenarios. Sure, they might look easy enough, and “work on my machine”, but when you start throwing some load at it, it can start to crumble quite quickly. And going down the good ol’ “Eventual Consistency Road” isn’t always an option, as consistency is actually important in some cases.

However, these aren’t new problems, and smart people have already created solutions for them. Solutions like the Actor pattern, which solves the problem by using in-memory “actors” to make life simpler. Unfortunately, the Actor pattern introduces another set of challenges. Things like instance proxying, state management, clustering, actor distribution and so on. Topics that most of us don’t feel like solving on our own. Luckily, Microsoft has already built all of this for us, in something they call Project Orleans.

Why not join Chris Klug, as he explains how Project Orleans can help you to solve scenarios like the ones described above. It might be worth noting though, that if you like slide heavy presentations with lots of theory and little practice, you should probably stay away. This session uses lots of demos to show you the practicalities of getting started building solutions using Project Orleans, and the features is offers. So please come well rested, and ready for a lot of coding.

I'm just trying to keep my head above water

I'm a lucky guy, and I know it! I'm a middle-aged white male with a good job, a great wife, and all of that. Life is pretty good! Or at least it should be...

The other side of the story is that I have spent most of my career struggling mentally. I've not only questioned myself professionally since day one, but I have also had to take time off work because I couldn't even get out of bed in the morning. Still, most people around me don't have a clue about my situation. When they find out, they generally go "What? You? I would never have thought that"... A response that probably indicates how well I manage to hide it from the world. But I am more and more certain that that is not the right way to handle it...

I have spent a LOT of time trying to find ways to cope with the struggles in my life. Trying to balance my private life and work. Something that is much harder than it sounds in our industry. And I think we need to talk about it.

I want to talk about some of the things I have experienced, and some of the things I have done to try and make my life…well…a life for me. I also want to explain how getting a book about living with ADHD from my parents when I was 40 became a life altering experience. Not to mention what I think we as an industry could do to make life better for the people in it.

The not-so-SOLID Principles of Software Development

Most developers have probably, at some point, been told that the SOLID principles are the foundation that all good software stands on top of. The presenter of this session has even traveled around the world and told thousands of people this at various conferences and usergroups. However, is it really so?

After years of talking about, and thinking about the SOLID principles, Chris Klug has started to question the validity of them. Are these principles still valid 20+ years after they were formulated? Or have we moved beyond these principles and found other "truths" or pillars to build our software on top of?

In this talk, Chris will walk you through each one of the principles and explain what they are supposed to mean, as well as what they actually mean. He will also try to shed some light on whether they may or may not be valid anymore. And as you might have guessed by now, telling developers to strictly follow the SOLID principles might not be the most solid advice anymore.

ASP.NET Core Beyond the Basics

There are a lot of “getting started” talks in the ASP.NET Core world, but they won’t take you very far in the real world. What if you already know what the Startup class does, how configuration is handled, and what Kestrel is? Well, that’s where this talk might become interesting.

Instead of covering the basics of how to get up and running, this talk will have a look at some of the more…how to put it…complex areas of ASP.NET Core. Instead of looking at how you build a basic Hello World website, it looks at things like building custom middlewares and model binders, how we can do URL rewriting and run background tasks. And more!

With all the demos to be presented, and the limited amount of time to do it in, there will be no introduction to ASP.NET Core. There will be no “this template includes…”. Instead there will be a quick jump right into the deep end, and a big focus on expanding you knowledge of some of the more advanced abilities built into the framework!

SOLID – The five commandments of good software

The SOLID principles. The five commandments of the software world. Forgotten for years, as developers focused on JavaScript frameworks with stupid names and complicated patterns. Not grasping that the SOLID principles transcend beyond frameworks and patterns.
The SOLID principles are the foundation of building good software. They are the breakers of monoliths. The decouplers of coupling. The squashers of regression bugs. One might even say that they are the creators of maintainable code.
Unless you already a believer, you need to attend this session and get on the right path. Chris, the bringer of SOLID knowledge, will go through each one of the principles, explaining what it means, what it will do for you, and why you should stop breaking it. You will even be shown C# code that explains how they help you, and what problems will haunt you if you ignore them and are faced with their wrath.

Microsoft Web Development Masterclass

The web development area of the Microsoft stack has grown exponentially in the last few years. Supporting more and more business scenarios and offering more and more ways to solve your development needs. However, in this ever-evolving environment, it can be hard to know what you can, and sometimes should be doing. And how to do it.

In this one day masterclass, Chris Klug, a Microsoft developer with over 20 years of experience (and 14 MVPs), will show you how you can leverage ASP.NET Core to build large scale business applications. It will be a fast paced walkthrough of topics ranging from the more "basic", but really important things, like setting up authentication and authorization, to service communication and reverse proxying. Not to mention some slightly more "esoteric" topics like Project Orleans and FastEndpoints. And since developing a multi-service environment often has some "interesting", a.k.a annoying, challenges when running locally. It will also cover how you can leverage Docker and .NET Aspire to make this a whole lot easier.

On top of that, since very few solutions can do without automated testing, we will also have a quick look at this topic, so that we can make sure that once we deploy it, it is less likely to introduce bugs or regressions.

During the day, you will see how to set up a multi-service application using (among other things)

- ASP.NET Core MVC and minimal API:s
- gRPC
- YARP
- Entity Framework Core
- Project Orleans
- .NET Aspire
- FastEndpoints
- Duende Identity Server
- Azure
- Docker
- and more

The day is also intended to be as interactive as possible to make sure that you get the information that you need. So, come well-rested, curios and prepared learn and and ask questions.

This masterclass is targeted at .NET developers with experience in ASP.NET. It will be fairly fast paced, as there are a lot of things to cover in a "short" amount of time. However, there will also be plenty of opportunity to ask questions throughout the day.

25 years of Web Development with Microsoft

It's been 25 years, give or take, since Microsoft released .NET Framework to the world. A release that has come to be the foundation for a very large amount of developers around the world. And, it might be time to take a walk down memory lane and look at what has happened between then and now for us web developers.

For some of us, this talk is likely to be a nostalgic recap of all the pain and joy that we have gone through over the years as developers. All the things we have had to learn. All the things we probably shouldn't have learnt. All the things we loved working with. And all the things we wish we didn't know as much about, as we do for different painful reasons.

For others, mostly the newer generation, it will be a great opportunity to see, not only what we older developers have had to live through, but also why some things are the way they are today.

All in all, this session is a fun, and emotional, look in the developer rear view mirror by Chris Klug. A Microsoft developer for the last 25 years (give or take), and an MVP awardee for the last 14 years.