Conference sessions

Below you can find the list of confirmed sessions. There will be 33 sessions of this during .NET DeveloperDays 2021 (30 regular sessions and 3 keynotes).

  • Advanced testing scenarios for ASP.NET Core

    Coded and automated tests are the key to software quality, however creating an isolated unit test, with all your mocked dependencies, isn't always the best option.

    What if you need to test a complex Entity Framework query? or your authorisation logic? Sometimes writing tests that involve your dependencies is imperative to achieve the level of reliability that unit tests alone cannot guarantee.

    During this talk we'll run through a journey in which, lead by examples, we'll learn when and how we can safely run reproducible integration tests with ASP.NET Core, we'll investigate alternative approaches such as BDD and we'll see how these concepts can all be automated within an Azure DevOps pipeline

  • Async streams in C#

    To refresh our memory, we will first explain the benefits of using async streams and examples of available APIs. We will continue by creating an async stream implementation ourselves and look at the potential reasons for doing so. We will conclude by comparing async streams to observables from Reactive extensions.

  • Azure Functions: a guide to getting started

    Working with an existing system and its architecture can be a challenge, especially when it comes to adopting newer technologies. What may originally have been an appropriate architecture, may not now easily accommodate these newer technologies

    Do we tackle the problem by refactoring our system, or do we need an overhaul?

    More often than not, business critical features don't allow for a rewrite nor a rebuild, so we are faced with shoehorning new features into the existing project using the older framework or architecture.

    This is where serverless technologies, such as Azure Functions, can come to the rescue.

    By using Azure Functions you can create solutions using modern .NET/C# features without necessarily touching older parts of our existing software.

    In this session I will show you how to build a service using Azure Functions.

    We will use a variety of function triggers such as HTTP and Queue, combining them together into a self contained service that can co-exist with our existing project.

    We'll also cover security, developing functions locally, architecture and much more.

  • Best practices for using async and await

    The async and await keywords have been a part of the C# programming language for a long time. Despite that, they still hide traps that not only beginners but also more experienced developers occasionally fall into.
    In this talk, I will present some of the most common mistakes we can make when writing asynchronous code and show ways to avoid them. Key topics:
    - async void is dangerous
    - wrapping events into async methods
    - avoiding deadlocks

  • Building a microservice architecture with ASP.NET Core

    Microservices are all the hype right now. You see and hear a lot of teams talking about it and it seems that everyone is doing microservices right now. But… how do you even get started with this type of setup? Maybe you’ve been building regular ASP.NET MVC applications so far… It all seems to be far-fetched to get started with this.

    In this talk, we will explore a sample microservice architecture fully based on ASP.NET Core 3.0 that highlights all the important building blocks in a practical manner. Not just words, but code! A lot of it!

    After watching this session, you’ll walk away with a proposed approach to start building your next application based on microservices as well.

  • Building intuitive command-line interfaces in .NET

    The cross-platform story for .NET continues. More and more tooling uses a command-line interface to make it easy to execute complex tasks from a script or console. Microsoft has invested in this area for their own tooling, such as the dotnet CLI or project Tye. You can benefit from their efforts by using System.CommandLine to build your own CLI or parametrize your application startup with arguments and options.
    The Microsoft .NET libraries hold a number of great packages to create intuitive CLIs, with commands that have features such as suggestions with tab-completion and typocorrections.
    In this session you will learn how to implement commands, with arguments and options, and leverage the build-in functionality such as binding, validation, middle-ware, command-hierarchies, parsing and much more. We are going to cover practical examples and use-cases, plus tips and tricks for efficient development and debugging.
    After this session you can are ready to go and build CLIs for your own .NET applications and tooling with minimal effort.

  • Clean architecture with ASP.NET Core

    Building an ASP.NET Core application is simple. File  New Project and BOOM, you’re on your way. But is that really always the best approach for real-life applications? Shouldn’t you spend some time thinking about how to set up a good and maintainable architecture for your applications and APIs?
    If YES is your answer to that questions, why don’t you join Gill in this session? Gill has done a lot of thinking about how we can build a solid foundation for our .NET Core apps and in this session, we’ll take a look at a finished application architecture, based on the concepts of clean architecture. We’ll dive deep in why some decisions were made and yes, please bring your own opinion and questions as this might spark conversation!
    You’ll walk away with an architecture (download of the demo application) that you can use in your own ASP.NET Core projects.

  • Dependency Injection in ASP.NET Core. Why and How?

    In this session Technical Evangelist Don Wibier will tell you why you should use Dependency Injection (DI) in your applications.
    He will next tell about how this is done in .NET Core and by coding examples, he’ll show you how easy it is to start using this yourself.

  • DLL Injection in Windows

    DLL Injection sounds like some black magic used only by hackers. However, it is used widely in the Windows ecosystem by multiple antiviruses and system utilities. During the presentation I show how we can use it to change 3rd party applications and how to write simple keylogger in 20 lines of code.

  • Exploring Source Generators

    T4 is no longer the only way for c# code generation. Roslyn Source Generators is a handy tool for making day-to-day work quicker and automating build processes with direct compiler integration.
    In this session, we‘ll look into what they are can or could be used for and implement a custom source generator.

  • Getting started with Kubernetes for your .NET Application

    Kubernetes is the new hotness for deploying your applications, promising to give a consistent way to define and deploy your application structure across various cloud vendors as well as on-premise infrastructures.
    This session will make you familiar with the basic features of Kubernetes, show how to deploy a containerized ASP.NET Core application to an Azure Kubernetes Service (AKS) cluster using Helm.

  • Go (con)figure - making sense of the .NET configuration system

    By properly configuring your applications you can make them behave in a flexible manner in different environments. This is an essential enabler to do proper CI/CD while adopting a DevOps way of working. .NET offers a hierarchical configuration system able to layer and structure multiple configuration value providers and dealing with changes during operations. Understanding the specifics of this system will allow you to get the most out of configuring your cloud-based solutions. In this session we will look at the details of the configuration system of .NET Core and beyond and how to incorporate it in various scenarios, such as container hosted .NET applications, from development to production environments. Also, you will learn how to keep your configuration values securely stored using key vaults, container clusters and in pipeline based deployments and releases.

  • Had I Only Known: Content Security Policy, The Right Way

    Content Security Policy is the most effective browser measure for web application security in a decade, and one of the reasons why browser developers start removing other security safeguards like their Cross-Site Scripting auditor. But creating an effective Content Security Policy is not always trivial. This session will give a thorough introduction to Content Security Policy and discuss lessons learned from many CSP projects: what is working, where are issues, and what features can we look forward to?

  • Having fun with Generics and Abstract classes in C#

    Join Technical Evangelist Don Wibier to bring your C# coding skills to the next level. He will show you one of his own personal killer combis: Generics and Abstract classes.

    With a lot of coding examples, you will learn how to optimize and re-use your code to the max and lay down a solid and flexible foundation for your applications.

  • How I put .NET into Firebird database engine

    Firebird is a database engine similar to MS SQL, Postgres, DB2 and others. The latest iteration also allows writing plugins. I took this capability and put .NET into it. It allows you to write stored procedures, functions, ... in .NET and have all this code executed in the context (address space, transaction, ...) of database engine. In this session I'll describe what hurdles I had to overcome, how I did it and how I'm hunting best possible performance.

  • Implementing async with coroutines and fibers - project Loom in C#

    Async has multiple problems. It requires specific return type, can switch thread any time, causes deadlocks, uses global state. Can we do better? Can we do async/await without all its mess?

    In this talk we will learn how async is implemented, see what problems it creates, and explore other possible approaches. We will reimplement some of its features with monads, coroutines, and fibers to see how it could look like in an alternative world. We'll see if we can do better than the thread-pool based approach.

    This is loosely related to project Loom in JVM world which explores fibers to improve threading.

    Level 300.

  • Infrastructure as Real Code - An Intro to Pulumi

    Infrastructure as code has been a thing for quite some time now. Being able to version control the definition of infrastructure that you are running your system on is great! However, as a developer, I'm not sure I agree with the "code" part of the name when it comes to a lot of the tools out there.

    Yeah, sure, it is kind of code... But it is often not so much code, as a bunch of configuration in JSON. And honestly, I'd call that "Infrastructure as Config".

    Take Azure for example. Their solution to the whole thing is ARM templates. A technology that does the job, but it is pretty hard to understand, and not very flexible. And Terraform isn't much better in my opinion. Both technologies depend on a huge chunk of configuration that can be in source control. It is better than nothing. But it isn't code to me.

    Pulumi takes a different approach to the problem. Instead of chunks of configuration, you get to write REAL code. You get to define your infrastructure in TypeScript. This opens up a whole heap of possibilities that a JSON-based DSL can't really compete with.

    So why not come and have a look at what Pulumi can do for you?

  • Level-up your productivity and testing with Visual Studio 2022

    Get the most out of Visual Studio productivity and testing tools in .NET! We'll cover performance improvements like hot reload and the latest IntelliCode advances bringing AI into your inner dev loop. Learn new tips to help you understand code at a glance and the tooling improvements around razor, code style, diagnostics, refactorings, and much more! Join this session to get tips on new features that speed up your inner development flow and discover the latest in cross-platform development with remote testing on linux and asynchronous web UI testing with Playwright.

  • Microservices Made Easy: Getting Started with DAPR

    Get an introduction to DAPR a distributed application runtime that simplifies cloud-native application development. Spend less time focusing on the distractions and more time focused on adding value. DAPR does all the heavy lifting so you can write code that runs on-prem, in the cloud or on the edge with no code changes!

  • Microsoft Identity for ASP.NET Core and Blazor

    If you are building software for the enterprise, you must make sure that your applications are compliant with its security infrastructure, can adhere to its policies and can safely integrate with the rest of the services in the organisastional landscape.

    The good news is that Microsoft Identity platform does all of the heavy lifting for you, either if you are targeting a single organisation, or you want to build SaaS products.

    During this talk we'll start from the basic concepts, and we'll gradually ramp up the complexity of the examples, to show how you can leverage the platform to secure your ASP.NET Core and Blazor applications and which advantages it brings in supporting scenarios such as Single-Sign-On or Multi-Factor authentication.

    As a last step, we'll demonstrate how, thanks to Azure Active Directory, you can implement complex authentication flows to integrate your applications with other Azure services and Office 365.

  • Microsoft Q# and Azure Quantum

    In the last couple of years, there has been a lot of talk about quantum computing. This year, Microsoft has released their preview of Azure Quantum. So today, you cannot only write quantum programs on a simulated environment with Q# and .NET, but you can also write your Q# and target a physical quantum computer on Azure Quantum.
    This presentation will give you an overview of Azure Quantum and Microsoft Q#, but very quickly it will dive deeper into a more complex simulated Q# algorithm and I will show you how to run Q# programs on Azure Quantum by using the Azure CLI. Finally, I will talk about the Microsoft Quantum Inspired Optimization platform available with Azure Quantum and how to use it from Python.

  • Performance with Span< T > for dummies (should I care?)

    Span< T >, although not exactly brand new, is still new kind on the block. In this session I'll show you what the Span< T > (and Memory< T >) is, how it works and the concepts behind. All explained using plain simple C# constructs.

  • The top 10 best new features in C# version 6 to 9

    There is a lot of cool, and usable new features being added to C#. However, way too many of us are too busy building stuff, and fixing/creating bugs, to have the time to sit down and look take it all in. So why not let Chris Klug walk you through his top 10 new features that have been added in C# version 6 to 9.

    Sure, C# has gotten a LOT more than 10 new things since version 6. But if you are a busy developer, like most of us are, getting an introduction to the top 10 ones in just an hour, could be a great start.

    In this talk, Chris will show, and explain, his personal top 10 favorite features that have been added to C# in the last few years. Everything from awesome time savers and stability contributors, to syntax changes that allows your code to be denser and/or easier to read.

  • What is new in .NET 6 and the future of .NET

    November 2021 marks the release of .NET 6. In this session, I will talk about what is new in the latest version of .NET and what the future will bring for the .NET platform in general. What is the difference between .NET Framework, .NET Core and .NET 6? Expect a number of new features and examples of those features.

Agenda Management powered by icon-company icon-blog icon-linkedin icon-other icon-twitter