Unit testing can make you a faster developer. Good tests let us move forward more confidently, give us instant feedback when checking regression, and help us pinpoint bugs when things go wrong. In this workshop, we'll look at the qualities of good tests, including isolation, repeatability, runnability, and more. And we'll look at specific techniques that make our tests easy to ready, easy to write, and easy to run.

We'll go hands-on with TDD (Test-Driven Development) to see the red-green-refactor cycle in action. Some code is tricky to test: we'll look at how to test for exceptions and error states, and we'll use a mocking framework to create mocks and stubs. Tools include MSTest and NUnit (for testing) and MOQ (for mocking), but the skills easily translate to other frameworks.

Objectives 1. Why Unit Test? Getting the actual benefits 2. Characteristics of a good unit test and how to implement them (including isolation, repeatability, runnability, and more) 3. Basics of TDD 4. Parameterizing tests 5. Techniques for testing exceptions 6. Using a mocking framework to isolate dependencies

Pre-Requisites Basic understanding of C# and object-oriented programming (classes, inheritance, methods, and properties). In addition, experience with interfaces and other forms of abstraction is very helpful. No prior experience with unit testing is necessary; we'll take care of that as we go.

In this beginner level talk we'll go over the common asynchronous patterns available in .NET. We'll focus on the Thread Parallel Library (TPL), Parallel Linq (PLINQ) and the new async/await keywords introduced in .NET 4.5. We'll discuss when to use these patterns and when not to.

This talk will focus on the basics of the thread parallel library, the async/await keywords, and PLINQ (parallel LINQ). We'll offer an explanation of when to use each method in the real world, the possible pitfalls to using each, and various tips to a successful implementation. We will also go over the general benefits of asynchronous code to user's application and the types of benefits they can expect to see. Finally, attendees will be warned of ways to avoid deadlocks and performance issues when using asynchronous .NET code as well as the basics of debugging asynchronous code.

Learn common patterns and strategies to effectively unit test your code in C#. We’ll go over design principles and ways to effectively ensure your code can be easily tested as well as how to use common testing tools such as Moq, Autofixture, & MsTest to help remove some of the drudgery of testing.

Testable code is a widely advocated industry standard but the barrier to entry is incredibly high. In this talk, we’ll go over not just how to unit test your code using MsTest, Moq, & AutoFixture but the patterns & processes to ensure your code can be unit tested. We will touch on the basics of dependency injection and common patterns such as avoiding the use of static classes but also more advanced topics such as SOLID design principles and how they relate to testing.

We’ll give the attendees a wide variety of examples on how to test common C# projects such as web api and console applications and different scenarios such as how to test databases and external method calls. Many real world tips & tricks on dealing with common patterns and scenarios will be included to make your life easier. Most importantly, attendees will be given a good idea of how to start testing, how to measure the effectiveness of their tests, and what not to test.

This session introduces the various requirements for a system or application to support an elastically scalable environment. The session goes on to detail architecture and design features to support scalability. Finally, we'll dive into some of the details of implementing the features--with examples in .NET--that make a system or application scalable, some areas of difficulty, and how to be more successful.

Ever wondered how Azure provides a scalable environment for thousands of applications? This session takes an intermediate look at Azure Service Fabric. You’ll see how Azure uses established patterns and principles to provide an environment that is massively scalable. You’ll also see how that environment is made available to the public as the Service Fabric platform. The session includes some examples of implementing services in the fabric, the various types of services, and recommendations on how to approach creating and architecting services to support scalability and make the most of Service Fabric.

Creating a solid architecture for any system we design can be a challenging process. The frameworks we use often include some opinion about how our software should be designed but these guidelines may not always be the best for the long-term health of our application. How can we build our applications to ensure they are both maintainable and extensible in the future?

In this talk, we'll discuss how taking a feature based approach to our application architecture can help us clearly structure applications that scale well over time. Additionally, we will talk about how we can apply these concepts to both the front-end and back-end to promote a consistent mindset across the entire tech stack. All examples will be using .NET Core and React but the concepts apply well beyond these technologies.

Come to listen about .NET Standard and how it makes writing .NET code and libraries targetting multiple platforms easier.

We'll go over how the .NET Standard compares to .NET Framework and .NET Core. We will learn how to check .NET Standard compatibility for existing assemblies. We will also do some hands-on trying to implement a library to be used from multiple platforms.

Have you ever heard of a “magic mirror”? And no, I’m not talking about Snow White. I’m talking about a real-world mirror, with smarts… Lend me some of your time and I’ll walk you through my experiences of developing my magic mirror. It’s running Windows 10 IoT Core, on a Raspberry Pi 3. It was written in C# as a Universal Windows Platform (UWP) application. My magic mirror boasts facial recognition and the Microsoft Cognitive Services (Emotion APIs), plays music, updates with current local weather and forecasts, displays a clock, and your upcoming aggregated calendar events.

• IEvangelist, blog post
• Channel 9 -- On .NET Interview

Wait. What? A talk on LINQPad? Isn’t that just the .NET scratchpad thing? How can there be a talk on that? Well, LINQPad may often be referred to as the “Ultimate Scratchpad for C#, F#, and VB” but chances are that if you’ve used it you weren’t using it to its full potential. LINQPad is chock full of hidden features that on their own don’t amount to much but taken together can truly boost your productivity. Whether you’re exploring a problem space or simply want to query some data LINQPad is a great utility and this session will help you get the most out of it by introducing important features like password management, caching, output customization, and much more.

Have you ever been at the grocery store trying to decide what to buy for dinner? Well you are in luck! No more wandering around the market wondering what you should buy for your next meal, when you can build a bot that can pick your dinner for you! In this session we will dive into the Microsoft Bot Framework; where you will learn the basics of building a simple chat bot in C#, how to publish it on the proper bot platform and how to upgrade its natural language processing using LUIS (Language Understanding Intelligent Service). After leaving this session, you will have all the resources you need to build your very own FridgeBot. Your FridgeBot will be a handy chat bot that will help you find a recipe based on the available ingredients you already have! All you will have to do is tell it you are hungry, give it a list of ingredients you have at home and it will recommend a dish containing those ingredients!

Ever wonder how a code obfuscator works? Are you curious to see what happens when it alters the compiled code of an application? We’ll look at one of the most popular .NET obfuscators, Dotfuscator Professional from Preemptive Solutions. It has a lot of features found in other similar applications like code injection, method renaming, and string encryption, and we’ll look at how those affect the code along with problems they cause. Along with this, there are new features which help prevent tampering and debugging we’ll explore in additional seeing how it can phone home in the event of an attack. Of course, no talk on security would be complete if we didn’t explore how to bypass some of those counter measures too!

F# is a rich, expressive, general purpose, functional-first language designed with the stated goal of allowing developers to write simple code to solve complex problems. While The Book of F# provides a comprehensive tour of the language this session will focus on several of the primary ways F# accomplishes that goal. In just 60 minutes we'll discuss what it means to be functional-first, the advantages of the functional-first paradigm, and several key language features including curried functions, partial function application, record types, discriminated unions, pattern matching, units of measure, type providers, and computation expressions.