Jeremy Bytes

Business applications are all about data, and laying out that data is critical to creating a good user experience. Silverlight has several tools, including Data Templates and Value Converters, that make this easier for the business developer to manage. By the time we're done, you will have a good understanding of the basics of both of these valuable tools.

Silverlight 4 / Visual Studio 2010:

Silverlight 3 / Visual Studio 2008:

Additional Resources:

Blog Article: Metrocizing XAML: Part 1 - Data Templates
Blog Article: Metrocizing XAML: Part 2 - Control Templates
Metrocizing XAML: Code Download

Introduction to XAML: Don't Fear the Markup

Understanding XAML (eXtensible Application Markup Language) is a key to creating the latest .NET user experiences in WPF, Silverlight and Windows Phone. We will introduce the basic concepts around XAML and take a look at various features such as namespaces, elements, properties, events, attached properties and some basic layout. We’ll create a simple WPF / Silverlight application that covers these fundamentals. Although you will probably end up doing most of your UI design with a drag-and-drop tool such as Expression Blend, knowing the internals gives you a leg up in making the final tweaks to ensure an excellent user experience.

NOTE: This demo is available in both WPF and Silverlight versions. The same XAML features are covered in each environment.

WPF / Visual Studio 2010:

Silverlight 4 / Visual Studio 2010:

WPF / Visual Studio 2008:

Additional Resources:

Blog Article: XAML Namespaces and Default Properties
Blog Article: Ticker Class - Ready for Production?
Blog Article: Intro to XAML Questions
Additional Demo: Target Practice - Silverlight 3 / XAML Sample
Additional Demo: Target Practice - WFP / XAML Sample

Get Func<>-y: Delegates in .NET

Delegates are the gateway to functional programming. So let's understand delegates and how we can change the way we program by using functions as parameters, return values, variables, and properties. In addition, we'll see how the built-in delegate types (Func and Action) are waiting to make our lives easier. By looking at code, we'll see how delegates can add elegance, extensibility, and safety to our programming.

Visual Studio 2022 / Visual Studio Code / .NET 7.0:

GitHub Repo: jeremybytes/func-action-delegates
Recorded Presentation Recorded at NDC London January 2017

Visual Studio 2015 / 2017:

Walkthrough (PDF)
Presentation Slides (PDF)
GitHub Repo: jeremybytes/delegates-and-func

YouTube Video Series:

Code Download: Delegate Video Samples
Video Playlist: C# Delegates
Video: C# Delegates - Part 1: Basics
Video: C# Delegates - Part 2: Get Func<>-y (+ Lambdas)
Video: C# Delegates - Part 3: Action<> & Multicast Delegates

Additional Resources:

Video: Anatomy of a Lambda Expression
Video: C# Generics (Playlist)
Additional Demo: Learn to Love Lambdas (and LINQ, too)
Blog Article: Exceptions in Multi-Cast Delegates
Blog Article: More Delegate Exception Handling
Blog Article (Higher-Order Functions): Recognizing Higher-Order Functions in C#
Blog Article (Anonymous vs Named Delegates): Named Delegates Compared to Anonymous Delegates

Keep Your UI Responsive with the BackgroundWorker Component

Long running processes are a user experience killer. How many times have you had an application "lock up" while trying to do some function? The BackgroundWorker component in .NET allows you to spawn those long running processes in the background and keep your WPF, Silverlight or WinForms user interfaces responsive. We'll take a look at the features of the BackgroundWorker in a WPF application including running a background process, updating the progress in the UI, and cancelling the process before it has completed.

Visual Studio 2022 / .NET 6:

Code on GitHub

Visual Studio 2010 (expanded material Jan 2011):

Visual Studio 2008:

Additional Resources:

Pluralsight Course (authored by me): Introduction to the .NET BackgroundWorker Component
Blog Article: BackgroundWorker Component Compared to .NET Tasks
Code Sample: BackgroundWorker and Tasks
Article Series: Exploring Task, Await, and Asynchronous Methods
Blog Article: Overview of the MVVM Design Pattern
Blog Article: BackgroundWorker Component and MVVM
Code Sample: BackgroundWorker w/ MVVM
Blog Article: BackgroundWorker Component: "I'm Not Dead, Yet!"
Blog Article: BackgroundWorker Session Questions
Blog Article: BackgroundWorker Component Questions
Blog Article: Task.Run() vs. Task.Factory.StartNew()

Design Patterns: Not Just for Architects

Design patterns are not just for architects. In fact, you already use Design Patterns but probably don't know it. Observer, Facade, Iterator, Proxy - these are all patterns that allow us to better communicate our ideas with other developers. And once we understand the patterns, we can use solutions that people way smarter than us have already implemented. In this session, we'll take a look at several Gang of Four patterns that we regularly use without realizing it. Don't know who the Gang of Four is? Join us to find out.

Visual Studio 2022:

Visual Studio 2015:

Visual Studio 2012 / 2013:

Presentation Slides (PDF)
Code Download
Recorded Presentation recorded live at Silicon Valley Code Camp (Oct 2015)

Additional Resources:

Pluralsight Course (authored by me): Design Patterns On-Ramp
Bookshelf: Design Pattern Books
Blog Article: The Use and Misuse of Design Patterns
Blog Article: Design Patterns: Understand Your Tools
Demo (Factory Method Pattern & Inversion of Control Pattern): IEnumerable, ISaveable, IDontGetIt: Interfaces in .NET
Blog Article (MVVM Pattern): Overview of the MVVM Design Pattern
Blog Article (Iterator Pattern): Next, Please! - A Closer Look at IEnumerable (Part 1)
Blog Article (Strategy Pattern): Next, Please! - A Closer Look at IEnumerable (Part 4)
Recorded Presentation: Learn the Lingo: Design Patterns recorded live at Silicon Valley Code Camp (Oct 2015)

Learn to Love Lambdas (and LINQ, Too!)

Lambda expressions in C# can be confusing the first time you walk up to them. But once you get to know them, you’ll see that they are a great addition to your toolbox. Used properly, they can add elegance and simplicity to your code. And some .NET constructs (such as LINQ) lend themselves to lambda expressions. In addition, lambdas let us scope our variables more appropriately with captured variables. We’ll take a look at how lambda expressions work and see them in action. We’ll also see how LINQ can help us move from imperative programming to declarative programming (a gateway to functional-style programming).

Video Series

Video Playlist: Lambda Expressions & LINQ in C#
Part 1: Lambda Expression Basics
Part 2: Demystifying LINQ Methods
Part 3: Declarative Programming with LINQ
Bonus: Captured Variables and For Loops
Bonus: Deciphering the Join Method
Code Download: GitHub: jeremybytes/lambdas-and-linq

Visual Studio 2019 / .NET Core 3.x:

Presentation Slides (PDF)
Code Download: GitHub: jeremybytes/lambdas-and-linq-core30

Additional Resources

Video: Anatomy of a Lambda Expression
Blog Article (var Keyword): Demystifying the "var" Keyword in C#
Blog Article (Captured Variables): Lambda Expressions, Captured Variables, and For Loops: A Dangerous Combination
Blog Article (Type Inference): "dynamic" Type Inference with Lambda Expressions
Blog Article (Functional Programming): LINQ and the Functional Approach
Blog Article (Higher-Order Functions): Recognizing Higher-Order Functions in C#
Blog Article (Anonymous vs Named Delegates): Named Delegates Compared to Anonymous Delegates
Blog Article (LINQ): LINQ Methods With or Without Predicates: What's the Difference?
Blog Article (More LINQ): The LINQ OfType<TResult> Method: Cast or Filter?
Blog Article (Even More LINQ): The LINQ "Join" Method: Deciphering the Parameters
Blog Article: Learn to Love Lambdas Session Questions
Additional Demo: Get Func<>-y: Delegates in .NET
Additional Demo: Quick Byte: Extension Methods
Video (Extension Methods): Extension Methods in C#

Earlier Versions:

Walkthrough (PDF)
Presentation Slides (PDF)
Visual Studio 2012 / 2013 (WPF): Code Download
Visual Studio 2010 (Silverlight): Code Download
Visual Studio 2008: Code Download

LINQ - It's Not Just for Databases

LINQ (Language Integrated Query) is mostly associated with Entity Framework and database access. But it can be used for much more. LINQ lets us sort, filter, and aggregate data all in memory without needing to make another database call. In this session, we will build up an application that manages my book collection, including filtering, grouping, sorting, and even controlling how items are sorted. We will use the LINQ fluent syntax to combine functions and make a great user experience.

Visual Studio 2022 / .NET 7:

Resources

Additional Resources

Article: LINQ Methods With or Without Predicates: What's the Difference?
Article: The LINQ "Join" Method: Deciphering the Parameters
Article: LINQ and the Functional Approach
Additional Demo: Learn to Love Lambdas in C# (and LINQ, Too!)
Additional Demo: Get Func<>-y: Delegates in .NET
Video (Extension Methods): Extension Methods in C#

Safer Code: Nullabilty and Null Operators in C#

New projects in C# have nullable reference types enabled by default. This helps make the intent of our code more clear, and we can catch potential null references before they happen. But things can get confusing, particularly when migrating existing projects. In this session, you will learn about the safeguards that nullability provides as well as the problems you still need to watch out for yourself. In addition, you will learn the various null operators in C# (including null conditional, null coalescing, and null forgiving operators). These can make your code more expressive and safe.

Visual Studio 2022 / .NET 7:

Resources

Meet the Next Code Camp Speaker: You!

Ever wonder where the speakers for Code Camp come from? Just look in the mirror. Everyone has something to share. Take the next step and sign up as a speaker. In this informal session, we'll talk about some practical tips to make your session successful.

Additional Resources

ZoomIt tool: ZoomIt v4.2

IEnumerable, ISaveable, IDontGetIt: Understanding .NET Interfaces

You want code that is easy to maintain, extend, and test. C# interfaces are here to help. In this session, you will learn we to use interfaces effectively in your code, starting at the beginning ("What are interfaces?") and then exploring why and when to use them. Along the way you'll learn how to use existing interfaces, implement your own interfaces, and also use interfaces for unit testing and dependency injection. The result is code that is easier to maintain, extend, and test.

Note: There were a lot of changes to interfaces in C# 8 (released Sep 23, 2019) and a few more in C# 11. Be sure to take a look at the "C# 8" articles listed below for details as well as the separate topic "Catching Up with C# Interfaces: What You Know May Be Wrong".

Visual Studio 2019 / .NET 5.0 (with cross-platform console and web apps):

Code & Slides: GitHub: jeremybytes/understanding-interfaces-net50
Article: C# 8 Interfaces are a Bit of a Mess
Article: A Closer Look at C# 8 Interfaces
Article: Dyamically Loading .NET Standard Assemblies in .NET Core
Article: Dynamically Loading Types in .NET Core with a Custom Assembly Load Context

Visual Studio 2019 / .NET Core 3.0 / .NET Standard 2.1:

Code & Slides: GitHub: jeremybytes/understanding-interfaces-core30
Article: C# 8 Interfaces are a Bit of a Mess
Article: A Closer Look at C# 8 Interfaces
Article: Dyamically Loading .NET Standard Assemblies in .NET Core
Article: Dynamically Loading Types in .NET Core with a Custom Assembly Load Context

Visual Studio 2019 / .NET Framework 4.7 / .NET Core 2.2 / .NET Standard 2.0:

Code & Slides: GitHub: jeremybytes/understanding-interfaces
Pluralsight Course (authored by me): C# Interfaces

Visual Studio 2015 / 2017:

Visual Studio 2012 / 2013:

Visual Studio 2010:

Courses & Workshops

Pluralsight Course (authored by me): C# Interfaces
Full-Day Workshop: Getting Better at C#: Interfaces and Dependency Injection

Additional Resources

Topic: What's New in C# 8 Interfaces (and how to use them effectively)
Blog Article: Drawbacks to Abstraction
Blog Article: Abstraction: The Goldilocks Principle
Blog Article: Explicit Interface Implementation
Blog Article: Updating an Interface Implementation
Blog Article: Explained: Properties in .NET
Blog Article: LINQ and the Functional Approach

T, Earl Grey, Hot: Generics in .NET

Let the compiler work for you. Generics shift the burden of type-safety from the developer to the compiler. To understand Generics, we'll take a look at some .NET classes from the BCL (such as List), comparing the generic and non-generic versions. Then we'll add Generics to our own methods to add flexibility and type-safety.

Visual Studio 2010 / 2012 / 2013:

YouTube Video Series:

Code Download: Generics Video Code Samples
Video Playlist: C# Generics
Video: C# Generics - Part 1: Collections
Video: C# Generics - Part 2: Interfaces
Video: C# Generics - Part 3: Methods & Delegates
Video: C# Generics - Part 4: Nested Generics
Video: C# Generics - Part 5: Generic Constraints & "default"

Additional Resources

Blog Article: Drawbacks to Abstraction
Blog Article: Abstraction: The Goldilocks Principle
Blog Article (MVVM Pattern): Overview of the MVVM Design Pattern
Session (Interfaces/Dynamic Loading): IEnumerable, ISaveable, IDontGetIt: Understanding .NET Interfaces
Session (Delegates/Func): Get Func-y: Delegates in .NET
Session (Reflection/Dynamic Loading): Practical Reflection
Session: Dependency Injection: A Practical Introduction

DI Why? Getting a Grip on Dependency Injection

Many of our modern frameworks have Dependency Injection (DI) built in. But how do you use that effectively? We need to look at what DI is and why we want to use it. We'll look at the problems caused by tight coupling. Then we'll use some DI patterns such as constructor injection and property injection to break that tight coupling. We'll see how loosely-coupled applications are easier to extend and test. With a better understanding of the basic patterns, we'll remove the magic behind DI containers so that we can use the tools appropriately in our code.

Visual 2022 / .NET 7:

Visual 2019 / .NET Core 3.0:

Visual Studio 2015 / 2017 / 2019:

Visual Studio 2012 / 2013:

Visual Studio 2010:

Courses & Workshops

Pluralsight Course (authored by me): Getting Started with Dependency Injection in .NET
Workshop Materials (from Visual Studio Live 2019): GitHub: jeremybytes/vslive-di-lab

.NET Core

ASP.NET Core DI: Using the Built-In Dependency Injection in ASP.NET Core 2.0

DI Patterns

Blog Article: Dependency Injection: The Service Locator Pattern
Blog Article: Dependency Injection: The Property Injection Pattern
Blog Article: Property Injection - Additional Unit Tests
Blog Article: Property Injection: Simple vs. Safe

Intermediate DI

Additional Resources

Book Review: Dependency Injection in .NET
Blog Article: Dependency Injection Composition Root: Are We Just Moving the Coupling?
Blog Article: Drawbacks to Abstraction
Blog Article: Abstraction: The Goldilocks Principle
Blog Article (MVVM Pattern): Overview of the MVVM Design Pattern
Session: IEnumerable, ISaveable, IDontGetIt: Understanding .NET Interfaces
Session: Get Func-y: Delegates in .NET
Miguel Castro: DI Containers: Understanding Dependency Injection and Those Pesky Containers
Steve Smith: Coupling: New is Glue

Code is for Humans

The computer understands your code just fine. But what about humans? The world is constantly changing, and your applications need to change with it. Humans make those changes; sometimes it's you, sometimes it's someone else. So let's look at some practical techniques to keep code readable, such as working in small pieces, coming up with good names for methods and objects, and avoiding "clever" code. Think about the next developer who needs to change this code. Often that developer is you from six months in the future.

Abstract Art: Getting Abstraction "Just Right"

Abstraction is awesome. And abstraction is awful. Too little, and our applications are difficult to extend and maintain. Too much, and our applications are difficult to extend and maintain. Finding the balance is the key to success. The first step is to identify your natural tendency as an under-abstractor or an over-abstractor. Once we know that, we can work on real-world techniques to dial in the level of abstraction that is "just right" for our applications.

Visual Studio 2019 / .NET Core 3:

GitHub Repository: jeremybytes/abstract-art-core3
Presentation Slides (PDF)

Visual Studio 2012 / 2013 / 2015:

Presentation Slides (PDF)
Code Download
Supplemental Video: Goldilocks and the Three Bears (with real bears)

Additional Resources

Pluralsight Course (authored by me): Abstract Art: Getting Things "Just Right"
Blog Article: Are You an Over-Abstractor or an Under-Abstractor?
Blog Article: YAGNI - Reaping the Benefits
Blog Article: Drawbacks to Abstraction
Blog Article: Abstraction: The Goldilocks Principle
Blog Article: Separating Concerns in Methods
Blog Article: Do I Really Need a Repository?
Blog Article: Unit Testing: A Journey
Blog Article: Beware of "Never" and "Always"
Session: Learn the Lingo: Design Patterns
Session: IEnumerable, ISaveable, IDontGetIt: Interfaces in .NET
Session: Dependency Injection: A Practical Introduction
Session: Clean Code: Homicidal Maniacs Read Code, Too!
Steve Smith: Coupling: New is Glue
Joel Spolsky: Leaky Abstractions: The Law of Leaky Abstractions

Practical Reflection in C#

Reflection is an extremely powerful feature of .NET. But there is a big difference between what we can do and what we should do. Several of these features are useful to the everyday developer. We'll take a quick look at what reflection is capable of and then narrow our focus to practical uses, such as making runtime decisions for features and functionality -- all while balancing flexibility, safety, and performance.

Visual Studio 2019:

Code & Slides

Visual Studio 2012 / 2013:

Additional Resources

Pluralsight Course (authored by me): Practical Reflection in .NET
Session: IEnumerable, ISaveable, IDontGetIt: Interfaces in .NET
Blog Article: Configuring ILDASM as a Visual Studio Tool
Supplemental Article: Improving Reflection Performance with Delegates
Supplemental Download: Reflection with Delegates

Shields Up! Defensive Coding in C#

Coding is easy. Making sure our code is robust and effective takes a bit of effort. By coding defensively, we prepare our applications to face the challenges of real users in the real world. We'll go through some best practices to handle errors and exceptions, validate user input, and head off the common causes of memory leaks. Our ultimate goal is to provide an excellent experience for our users regardless of the circumstances.

Visual Studio 2010 / 2012 / 2013:

Additional Resources

Video: Clean Code: The Refactoring Bits
Session: Clean Code: Homicidal Maniacs Read Code, Too!

TDD / Unit Testing / Smart Unit Tests (Jan 2015)

How do you get started with Unit Testing? A quick way is to implement some simple business rules using Test-Driven Development (TDD). This gives us a chance to understand the tools, see the importance of testing, and write code that is easy to test. We'll use Conway's Game of Life to help us get there. Tools will include MSTest, NUnit, and we'll even take a quick look at Smart Unit Tests -- a feature coming with Visual Studio 2015.

Visual Studio 2012 / 2013:

Presentation Slides (PDF)
TDD Code Download
Simple UI Code Download
Article: TDD & Conway's Game of Life
Article: Parameterized Tests with NUnit
Article: Smart Unit Tests (Preview) and Conway's Game of Life
Article: More Smart Unit Tests (Preview): Guard Clauses

Videos

Playlist: Unit Testing & TDD
Video: TDD Basics with C#
Video: TDD: Don't Turn Off Your Brain
Video: TDD Debugging & Testing Exceptions

Additional Resources

Book Review: Test-Driven Development by Example (Kent Beck)
Article Series: Coding Practice with Conway's Game of Life
Article Series: Exploring Smart Unit Tests (Preview)
Session (Interfaces for easier testing): IEnumerable, ISaveable, IDontGetIt: Understanding .NET Interfaces
Session (Break dependencies for easier testing): Dependency Injection: A Practical Introduction
Session (Importance of good unit tests): Clean Code: Homicidal Maniacs Read Code, Too!

Getting Started with Git

We all need source control, and you may already be using a centralized source control system. But let's take a look at Git -- a distributed source control system that has 100% functionality without needing a network connection. We'll take a look at how to get started using Git, some of the useful features like branching and rollbacks, and we'll also see the built-in support that is provided in Visual Studio. After seeing how easy it is, you'll wonder why you haven't been using it all along.

Visual Studio 2013:

Additional Resources:

Video: Git Basics for Visual Studio Developers
Sample Repository (from video): GitHub: jeremybytes/video-sample-git-basics-2013
Article: Git While the Gittin' is Good
Article: Git Integration in Visual Studio 2013
Article: Getting Used to Git in Visual Studio: Branches
Article: Git Stash: Saving Stuff for Later
Article: GitHub: Hand Holding Where You Need It
Article: Git Miscellany: Stuff I Didn't Know But I Do Now
Getting Started: Try Git (interactive website)
Jeremy's Repositories: GitHub: jeremybytes

Unit Testing Makes Me Faster: Convincing Your Boss, Your Co-Workers, and Yourself

Bosses hate unit testing. They see it as code that doesn't contribute to the final product. And maybe you see testing that way as well. But here's the truth: unit testing makes us faster. You'll look at specific examples of how unit tests save time in the development process by letting us code more confidently, catch bugs earlier, and minimize manual testing. With this in hand, you can show your boss (and yourself) how unit testing makes us faster.

Visual Studio 2013 / 2015 / 2017:

Presentation Slides (PDF)
Comparison Videos from presentation
Direct Video Link: Side-by-Side Test Build
Direct Video Link: Side-by-Side Regression Testing
Code Samples

Resources:

Recorded Presentation recorded at Visual Studio Live! Austin - May 2016

Additional Resources:

Book Review (Highly Recommended): The Art of Unit Testing - Roy Osherove
Book Review: Working Effectively with Legacy Code - Michael C. Feathers
Book Review: Test-Driven Development by Example - Kent Beck
Article Series (TDD & NUnit): Coding Practice with Conway's Game of Life

Why NUnit?

Parameterized Tests: Parameterized Tests with NUnit
More Parameterization Options: Getting NUnit Test Parameters from a File (or Other Source)
Visual Studio Integration: Integrating NUnit into Visual Studio Test Explorer
Exception Handling: Testing for Exceptions with NUnit

Testing Practices

Code Coverage: What Parts of Your Application Do Your Users *Not* Care About?
What to Test: My Approach to Testing: Test Public Members
Setup Methods: Unit Testing: Setup Methods or Not?
Assert Messages: Unit Testing Asserts: Skip the Message Parameter

Test-Driven Development in the Real World

Are you tired of trivial TDD examples like FizzBuzz? I am. So let's look at a real-world problem to see how Test-Driven Development (TDD) helps us think is small pieces, build provable code, and reduce the amount of unneeded code that creeps into our applications. In the real world, we have to deal with services, libraries, and dependencies. And we have to deal with strange bugs that crop up. In this session, we'll go beyond the simple examples and learn how to break down complexity, isolate dependencies with mocking, and capture expected exceptions.

Resources (Visual Studio 2022 / .NET 6):

Resources (.NET Framework):

Additional Resources:

Video Conversation: Real World Coding with Jeremy Clark & Steve Bishop
Book Review (Highly Recommended): The Art of Unit Testing - Roy Osherove
Book Review: Working Effectively with Legacy Code - Michael C. Feathers
Book Review: Test-Driven Development by Example - Kent Beck
Article Series (TDD & NUnit): Coding Practice with Conway's Game of Life
Video Series (Intro to TDD): Unit Testing & TDD

Why NUnit?

Parameterized Tests: Parameterized Tests with NUnit
More Parameterization Options: Getting NUnit Test Parameters from a File (or Other Source)
Visual Studio Integration: Integrating NUnit into Visual Studio Test Explorer
Exception Handling: Testing for Exceptions with NUnit

Testing Practices

Code Coverage: What Parts of Your Application Do Your Users *Not* Care About?
What to Test: My Approach to Testing: Test Public Members
Setup Methods: Unit Testing: Setup Methods or Not?
Assert Messages: Unit Testing Asserts: Skip the Message Parameter

Focus on the User: Making the World a Better Place

Our job as developers is to make the world a better place, whether it's connecting people, providing entertainment, or making someone's job easier. We have to know who we're building software for: our users. Understanding my users has been a key to every successful project I've worked on. I'll share some of my successes and some of my failures, and show how that's led to the approach to software that I take today. Together, we can provide our users with just what they need to make their world a bit better.

Resources:

Presentation Slides (PDF)
Recorded Presentation Recorded at NDC London January 2017

Previous Slides:

Additional Resources:

Leggo My Ego

As developers it's really easy for us to let our egos get in the way. And that's understandable. What we do is a creative process: we're problem solving and coming up with new and creative ways of doing things on a regular basis. We need to take pride in our work, but there are serious consequences when we let too much ego get involved: we can become defensive, isolated, and stubborn. Our teams can fall apart due to lack of sharing, mentoring, and communication. Let's figure out how to keep things in balance so that we are open to other ideas, helpful to other developers, and also able to take the appropriate amount of pride in the work that we do. Together, we can make the world a better place.

Resources:

Banjo & Learning: You Aren't Instantly Awesome, and That's Okay
More Banjo: You Aren't Instantly Awesome, but You Can Get Better with Practice
Conversation: When Does DRY Become ARID?
Screencasting: Jeremy's Screencast Production: Hardware, Software, and Process

I'll Get Back to You: Task, Await, and Async in C#

There's a lot of confusion about async/await, Task/TPL, and asynchronous and parallel programming in general. So let's start with the basics and look at how we can call asynchronous methods using Task and then see how the "await" operator can makes things easier for us. Along the way, we'll look at continuations, cancellation, and exception handling.

Visual Studio 2022 / .NET 8.0:

Slides: Task & Await in C#
Code Samples: GitHub: jeremybytes/using-task-dotnet8

Visual Studio 2022 / .NET 6.0:

Slides: Task & Await in C#
Code Samples: GitHub: jeremybytes/using-task-dotnet6

Visual Studio 2019 / .NET Core 3.1:

Slides: Task & Await in C#
Code Samples: GitHub: jeremybytes/using-task-core3

Visual Studio 2013 / 2015 / 2017:

Code Samples: GitHub: jeremybytes/using-task

Recorded Presentations:

Recorded Presentation recorded live at NDC London (Jan 2016)
Recorded Presentation (extended) recorded live at Central California .NET (Apr 2016)

Additional Resources:

Blog Article: Task and Await: Consuming Awaitable Methods
Blog Article: UI Considerations When Using Asynchronous Methods
Blog Article: Task and Await: Basic Exception Handling
Blog Article: Task Continuations: Checking IsFaulted, IsCompleted, and Task Status
Blog Article: Task.IsCompletedSuccessfully - YAY! (and hmmm)
Blog Article: Task and Await: Basic Cancellation
Blog Article: Brownfield Async: Converting IAsyncResult to Task
Article Series: Exploring Task, Await, and Asynchronous Methods
Book Review: Parallel Programming with Microsoft .NET
Book Review: Async in C# 5.0
Session & Video Series: Learn to Love Lambdas (and LINQ, Too!)
Session & Video Series: Get Func<>-y: Delegates in .NET

Progress Reporting:

Blog Article: Simple Progress Reporting with Task
Blog Article: Custom Progress Reporting with Task
Blog Article: When Progress Reporting Goes Bad: Incremental Progress vs. Cumulative Progress
Blog Article: Pay Attention to Where You Create Progress Objects

Video Series:

Playlist: Task and Await in C#
Part 1: Consuming Asynchronous Methods
Part 2: Basic Exception Handling
Part 3: IsFaulted, IsCompleted, and Task.Status
Part 4: Basic Cancellation

Async Experts:

Parallel Programming with Task:

Session: Run Faster: Parallel Programming in C#
Book Review: Parallel Programming with Microsoft .NET

Becoming a Social Developer: A Guide for Introverts

This is NOT a highly-interactive workshop. Now that you feel a bit safer, make the most of your time this week: talk to other developers. This is easy -- and incredibly terrifying. A few simple steps (and a bit of bravery) is all that it takes to get started. Building your developer network will boost your knowledge, your skills, and your career. Can an introvert become a social developer? YES! And we can do this while staying true to ourselves.

Resources:

Presentation Slides (PDF)
Website: Becoming a Social Developer
Recorded Presentation (YouTube): Becoming a Social Developer recorded live at NDC Oslo (Jun 2016)
Recorded Presentation (Vimeo): Becoming a Social Developer recorded live at NDC Oslo (Jun 2016)
T-Shirt: xkcd: Just Shy, Not Antisocial

Getting Started with .NET Core on macOS (works on Windows 10, Too!)

Microsoft .NET Core lets us quickly spin up services, websites, and create applications that run on a variety of platforms. In this session, we'll see how to create a self-hosted service and then consume that service in a simple application. We'll use Visual Studio Code and the command-line interface (CLI) to do all of this on macOS (and these exact same projects run on Windows, too).

Visual Studio Code:

Additional Resources:

Article: Building a WebAPI Service With .NET Core 2.0
Article: Consuming a WebAPI Service With .NET Core 2.0
Article: Using Task with .NET Core 2.0 (Success, Error, Cancellation)
Article: Using the Built-In Dependency Injection in ASP.NET Core 2.0
Article: Understanding the Microsoft Samples for .NET Core 2.0

Run Faster: Parallel Programming in C#

Want to see code run 6 times faster? Join me as we use parallel programming to make full use of our multi-core systems. We'll use techniques such as the .NET Parallel.ForEach, and we'll also spin up Tasks manually to take more control over the process. Along the way, we'll see how to write code that is easy to run in parallel (warning: it may start you down the path of functional programming). Use the hardware you have to run faster.

Slides & Code:

Slides: Run Faster
Code: Parallel Programming in C#

Additional Resources:

Task & Await: I'll Get Back to You: Task, Await, and Asychronous Programming
Digit Recognizer: Discount Machine Learning: Digit Recognition
Maze Creation: Jeremy Explores Mazes for Programmers
Conway's Game of Life: TDD & Conway's Game of Life
Book Review: Parallel Programming with Microsoft .NET
Delegates (Action): Get Func-y: Delegates in .NET
Lambda Expressions: Learn to Love Lambdas (and LINQ, Too!)

Get Comfortable with .NET and the CLI

Command-line interfaces (CLI) can be very powerful. The same is true in the .NET world. So let's get comfortable with creating, running, and testing applications using the command-line interface. We'll create a self-hosted web service and then write an application to use that service. Unit tests will make sure things work along the way. Whether you're new to .NET or have been using .NET with Visual Studio, this session will help you get up-to-speed in this powerful environment.

Slides & Code (.NET 7):

Slides & Code: .NET 7 CLI
Walkthrough: Demo Walkthrough

Slides & Code (.NET 5):

Slides: .NET 5 CLI
Code: Get Comfortable with .NET 5 and the CLI
Walkthrough: Demo Walkthrough

Slides & Code (.NET Core 3.0):

Slides: .NET Core CLI
Code: Get Comfortable with .NET Core and the CLI
Walkthrough: Demo Walkthrough

Additional Resources:

Task & Await: I'll Get Back to You: Task, Await, and Asychronous Programming

Diving Deeper into Dependency Injection

You know the basics of dependency injection (DI). Now it's time to take a closer look at how DI patterns and other design patterns can help us use DI effectively. We'll look at implementations and uses for DI patterns including constructor injection, method injection, and property injection. In addition, we'll use other design patterns to add functionality to existing objects and to manage disposable dependencies. We'll leave with several practical ways to improve the functionality and testing of our code.

Slides & Code (.NET 6):

Slides: DI-DeeperDive.pdf
Code: Diving Deeper into Dependency Injection

Slides & Code (Core 3.1):

Slides: DI-DeeperDive.pdf
Code: Diving Deeper into Dependency Injection

DI Patterns:

Blog Article: Dependency Injection: The Property Injection Pattern
Blog Article: Property Injection: Simple vs. Safe
Blog Article: Dependency Injection: The Service Locator Pattern

Decorators and Async Interfaces:

Challenges:

Static Objects: Mocking Current Time with a Simple Time Provider

Catching Up With C# Interfaces: What You Know May Be Wrong

(formerly "What's New in C# 8 Interfaces (and how to use them effectively)")

C# 8 & C# 11 brought new features to interfaces, including default implementation, access modifiers, and static members. We'll look at these features, and see where they are useful and where they should be avoided. The world of interfaces has changed; the line between interfaces and abstract classes has blurred; and C# now has multiple inheritance (sort of). With some practical tips, "gotchas", and plenty of examples, we'll see how to use these features effectively (and safely) in our code.

Visual Studio 2022 / Visual Studio Code / .NET 7:
(Updated to include C# 11 Static Abstract membmers)

Visual Studio 2019 / Visual Studio Code / .NET Core 3.1:

Resources:

Recording: What's New in C# 8 Interfaces (recorded Jun 24, 2020 at the Southeast Valley .NET User Group / North West Valley .NET User Group)
A Closer Look at C# 8 Interfaces
Properties and Default Implementation
Dangerous Assumptions in Default Implementation
"dynamic" and Default Implementation
Unit Testing Default Implementation
Public, Private, and Protected Members
Static Members
Static Main -- Why Not?

Microsoft Docs Samples:

Additional Topics:

A Tour of Go for the C# Developer

Learning other programming languages enhances our work in our primary language. From the perspective of a C# developer, the Go language (golang) has many interesting ideas. Go is opinionated on some things (such as where curly braces go and what items are capitalized). Declaring an unused variable causes a compile failure; the use of "blank identifiers" (or "discards" in C#) are common. Concurrency is baked right in to the language through goroutines and channels. Programming by exception is discouraged; it's actually called a "panic" in Go. Instead, errors are treated as states to be handled like any other data state. We'll explore these features (and others) by building an application that uses concurrent operations to get data from a service. These ideas make us think about the way we program and how we can improve our day-to-day work (in C# or elsewhere).

Visual Studio Code / Go 1.18 / .NET 6.0:

GitHub: Code, Slides, and Resources

Visual Studio Code / Go 1.14.5 / .NET 5.0:

GitHub: CodeTour and Code Samples
YouTube: A Tour of Go (golang) for the C# Developer

Articles:

Resources:

Learn Go interactively: A Tour Of Go
The official site: golang.org
Installation: Getting Started
Visual Studio Code extension: Go Language Extension

Getting Better at C#: Interfaces & Dependency Injection (Sep 2016)

Loosely coupled code is easier to maintain, extend, and test. Interfaces and Dependency Injection (DI) help us get there. In this workshop, we'll see what interfaces are and how they can add "seams" to our code that makes it more flexible and maintainable. From there, we'll dig into loose coupling with Dependency Injection. DI doesn't have to be complicated. With just a few simple changes to our constructors or properties, we can have code that is easy to extend and test.

If you're a C# developer who wants to get better with higher-level concepts like abstraction, loose coupling, and extensibility, then this is the workshop for you. We'll start by laying a good foundation and then ramp up throughout the day.

Visual Studio 2015:

Materials Download

Additional Resources:

Additional Session Materials: IEnumerable, ISaveable, IDontGetIt: Understanding .NET Interfaces
Additional Session Materials: DI Why? Getting a Grip on Dependency Injection
Additional Session Materials: Abstract Art: Getting Abstraction "Just Right"
Miguel Castro: DI Containers: Understanding Dependency Injection and Those Pesky Containers
Steve Smith: Coupling: New is Glue

Awesome C#: Unit Testing

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.

Visual Studio 2015/2017:

Materials Download

Additional Resources:

Article Series (TDD & NUnit): Coding Practice with Conway's Game of Life
Additional Session Materials: Unit Testing Makes Me Faster: Convincing Your Boss, Your Co-Workers, and Yourself
Video Series: Unit Testing and TDD
Video (Real TDD): Real-Time Coding with Steve Bishop & Jeremy Clark (demo starts at 18:00)
Article (Real TDD): TDD Practice: Parsing Data From a Service
Article (Real TDD): More TDD Practice: Finishing Up the Library
Article (NUnit Parameters): Getting NUnit Parameters from a File (or Other Source)
Article Series (IntelliTest): Exploring Smart Unit Tests (Preview)
Additional Session Materials: Learn to Love Lambdas (and LINQ, Too!)
Additional Session Materials: DI Why? Getting a Grip on Dependency Injection

Awesome C#: Asynchronous Programming

Asynchronous programming is a critical skill to take full advantage of today's multi-core systems. But async programming brings its own set of issues. In this workshop, we'll work through some of those issues and get comfortable using parts of the .NET Task Parallel Library (TPL).

We'll start by consuming asynchronous methods using the Task Asynchronous Pattern (TAP), including how to handle exceptions and cancellation. With this in hand, we'll look at creating our own asynchronous methods and methods that use asynchronous libraries. Along the way, we'll see how to avoid deadlocks, how to isolate our code for easier async, and why it's important to stay away from "asyc void".

Visual Studio 2015/2017 + .NET Core 2.x:

Lab Files Download

Books:

Book Review: Parallel Programming with Microsoft .NET
Book Review: Async in C# 5.0
Amazon Link: Concurrency in C# Cookbook

Additional Resources:

Additional Session Materials: I'll Get Back to You: Task, Await, and Asychronous Methods
Article Series: Exploring Task, Await, and Asynchronous Methods
Blog Article: Task and Await: Consuming Awaitable Methods
Blog Article: UI Considerations When Using Asynchronous Methods
Blog Article: Task and Await: Basic Exception Handling
Blog Article: Task Continuations: Checking IsFaulted, IsCompleted, and Task Status
Blog Article: Task and Await: Basic Cancellation
Blog Article: Brownfield Async: Converting IAsyncResult to Task
Session & Video Series: Learn to Love Lambdas (and LINQ, Too!)
Session & Video Series: Get Func<>-y: Delegates in .NET
Code - Digit Recognizer: GitHub: jeremybytes/digit-display
Code - Conway's Game of Life: GitHub: jeremybytes/conway-coding-practice
Code - Progress Reporting: GitHub: jeremybytes/progress-task

Progress Reporting:

Blog Article: Simple Progress Reporting with Task
Blog Article: Custom Progress Reporting with Task
Blog Article: When Progress Reporting Goes Bad: Incremental Progress vs. Cumulative Progress
Blog Article: Pay Attention to Where You Create Progress Objects

Video Series:

Playlist: Task and Await in C#
Part 1: Consuming Asynchronous Methods
Part 2: Basic Exception Handling
Part 3: IsFaulted, IsCompleted, and Task.Status
Part 4: Basic Cancellation

Async Experts:

Clean Code: Principles, Patterns, and Practices for Better Code (May 2014)

You already code. Now it's time to take the next steps to becoming a better developer. Those steps are not difficult; we just need to put them into practice. The end result is code that is easier to maintain, easier to test, and easier to extend. Through lots of examples and hands-on labs, we'll learn about software design principles and the patterns that help us implement them. We'll see how Dependency Injection helps us create loosely-coupled code. And we'll spend a bit of time looking at Software Craftsmanship: ensuring that our code is readable by humans while still easy to maintain and test.

Leveling Up: The Professional Coder Workshop (Sep 2014)

How can you create better software? What cutting edge practices can you employ to become a better professional? This workshop is a packed day of training and labs. Come experience how common design patterns, coding techniques and core concepts combine to make you more effective. More effective as an individual developer, more effective in a team, more insightful about how to go about things.

Visual Studio 2012 / 2013:

Lab Files (12MB) -- used during the workshop
Slides and Samples (35MB) -- reference materials

Additional Resources

Software: Visual Studio 2013 Professional (Free Trial)
Software: ReSharper (Free Trial)

Full Session - Design Patterns: Learn the Lingo: Design Patterns
Full Session - Dependency Injection: Dependency Injection: A Practical Introduction
Related Material - Interfaces: IEnumerable, ISaveable, IDontGetIt: Interfaces in .NET
Related Material - Abstraction: Abstract Art: Getting Things "Just Right"
Related Material - Craftsmanship: Clean Code: Homicidal Maniacs Read Code, Too!
Related Video - Refactoring: Clean Code: The Refactoring Bits

Quick Byte: Get Func<>-y (Jan 2011)

If you look into the LINQ extension methods, you will run across Func<T, TResult> quite a bit. If you see a Func<> in a method definition, you can treat it like a big sign that says "Put your lambda expression here." What we'll see is that Func<> is simply shorthand for creating a delegate.

Visual Studio 2010:

Quick Byte: Extension Methods (Aug 2010)

Extension methods allow you to add functionality to existing types by adding new methods -- no subtyping required. Here's a quick overview of how they work.

Visual Studio 2010:

Quick Byte: Statement Lambdas (Feb 2010)

The first time I came across a lambda expression, I was perplexed. I could tell that something important was going on, but I got stuck on the new syntax. As I studied them some more, I had an "aha" moment, and it all clicked into place. This is a brief runthrough of that process with statement lambdas.

Visual Studio 2008:

Target Practice - Silverlight 3 / XAML Sample (Sep 2009)

XAML has intrigued me ever since I took a close look at it. Previously, I created an entire WPF application using only XAML (it's trivial, yet functional). When I got started with Silverlight 2, I wanted to replicate that application. Unfortunately, there were limitations to Silverlight 2 (such as a lack of triggers) that kept me from implementing it. Silverlight 3 allowed me to implement the application entirely in XAML.

Silverlight 3 / Visual Studio 2008:

Data Templates & Value Converters - Silverlight 2 (Jun 2009)

Here's a few more useful things that I've come across. This time, it's Data Templates (which make List Boxes extremely flexible) and Value Converters. Note: this is applicable for Silverlight 3 as well (although Silverlight 3 does have some additional features that makes this easier).

Silverlight 2 / Visual Studio 2008:

User Controls and Events - Silverlight 2 (Jun 2009)

This demo shows how to split out a section of your UI as a user control. We'll also add an event to the user control that the other controls can hook into. Note: although this application uses Silverlight 2 (and Silverlight 3 has better ways of implementing this particular scenario), the concepts of eventing are still useful in other contexts.

Silverlight 2 / Visual Studio 2008:

Silverlight 2, WCF, and Lambda Expressions (May 2009)

This is an introductory demo in creating a WCF service and consuming it with a Silverlight 2 application. In addition, we'll take a look at the various ways of creating the call backs for the service (Event Handlers, Anonymous Delegates, and Lambda Expressions) and the various advantages of each. Note: this demo is applicable for Silverlight 3 as well.

Silverlight 2 / Visual Studio 2008:

Target Practice - WPF / XAML Sample (Mar 2009)

XAML has intrigued me ever since I took a close look at it. In this demo, the goal was to create an entire application using only XAML. This application is somewhat trivial, but it shows the power and flexibility of XAML and declarative programming.

Visual Studio 2008:

byte-sized chunks of .NET

Presentations

LIVE! 360 - Orlando, FL (Nov 17-22, 2024)

Techorama - Utrecht, Netherlands (Oct 7-9, 2024)

TechBash - Pocono Manor, PA (Sep 24-27, 2024)

dev up - St. Charles, MO (Aug 14-16, 2024)

Visual Studio LIVE! Microsoft HQ - Redmond, WA (Aug 5-9, 2024)

Cincy Deliver - Cincinnati, OH (Jul 26, 2024)

Denver Dev Day - Denver, CO (May 31, 2024)

Software Design & Development - London, England (May 13-17, 2024)

LIVE! 360 - Orlando, FL (Nov 12-17, 2023)

Hot Topics Developer Group - Online (Nov 7, 2023)

DevSpace - Huntsville, AL (Oct 23-24, 2023)

dev up - St. Charles, MO (Aug 28-30, 2023)

Visual Studio Live! San Diego - San Diego, CA (Aug 7-11, 2023)

Visual Studio Live! Microsoft HQ - Redmond, WA (Jul 17-21, 2023)

KCDC - Kansas City, MO (Jun 21-23, 2023)

Software Design & Development - London, UK (May 15-19, 2023)

Visual Studio LIVE! Las Vegas - Las Vegas, NV (Mar 19-24, 2023)

Live! 360 Orlando - Orlando, FL (Nov 13-18, 2022)

TechBash - Pocono Manor, PA (Nov 8-11, 2022)

Momentum Developer Conference - Cincinnati, OH (Oct 20, 2022)

Code PaLOUsa - Louisville, TN (Aug 17-19, 2022)

KCDC - Kansas City, MO (Aug 8-10, 2022)

Visual Studio LIVE! Austin - Austin, TX (Jun 13-17, 2022)

dev up - St. Charles, MO (Jun 6-8, 2022)

Software Design & Development - London, UK (May 16-20, 2022)

CodeStock - Knoxville, TN (Apr 7-8, 2022)

Hampton Roads .NET Users Group - Online (Feb 8, 2022)

.NET Conference 2022 - Online (Jan 24-26, 2022)

TDevConf 2021 - Online (Nov 5, 2021)

Code PaLOUsa - Online (Aug 18-20, 2021)

Dot Net North - Online (May 18, 2021)

Southeast Valley .NET User Group - Online (Apr 21, 2021) North West Valley .NET User Group - Online (Apr 21, 2021)

DevBoston - Online (Feb 10, 2021)

Central Ohio .NET Developer's Group (CONDG) - Online (Jan 28, 2021)

NDC London - Online (Jan 25-29, 2021)

NYC .NET Developers - Online (Nov 12, 2020)

Corporate Workshop - Online (Nov 6, 2020)

Memphis Python User Group - Online (Oct 19, 2020)

St Pete .NET - Online (Oct 13, 2020)

San Diego .NET User Group - Online (Oct 6, 2020)

TDevConf - Online (Oct 3, 2020)

Tech Con '20 - Online (Sep 30 - Oct 1, 2020)

Memphis .NET User Group - Online (Sep 24, 2020)

Visual Studio LIVE! Virtual Training (Sep 9, 2020)

Code PaLOUsa - Online (Aug 19-21, 2020)

NYC .NET Developers - Online (Aug 13, 2020)

Tulsa .NET User Group - Online (Jul 23, 2020)

Houston Xamarin Users Group - Online (Jul 22, 2020)

Southeast Valley .NET User Group - Online (Jun 23, 2020) North West Valley .NET User Group - Online (Jun 23, 2020)

Houston .NET Users Group - Online (Jun 18, 2020)

Indy Software Artisans - Online (May 21, 2020)

Dev Around the Sun - Online (May 12-13, 2020)

Enterprise Developers Guild - Online (Apr 28, 2020)

Modern Devs Charlotte - Online (Apr 14, 2020)

Visual Studio LIVE! Las Vegas - Las Vegas, NV (Mar 1-6, 2020)

Live! 360 - Orlando, FL (Nov 17-22, 2019)

dev up - St. Charles, MO (Oct 14-16, 2019)

Little Rock Tech Fest - Little Rock, AR (Oct 10-11, 2019)

Seattle Code Camp - Seattle, WA (Sep 14, 2019)

Music City Tech - Madison, TN (Sep 5-7, 2019)

Code PaLOUsa - Louisville, KY (Aug 21-23, 2019)

Visual Studio LIVE! Microsoft HQ - Redmond, WA (Aug 12-16, 2019)

KCDC - Kansas City, MO (Jul 17-19, 2019)

Visual Studio LIVE! Boston - Cambridge, MA (Jun 9-13, 2019)

Software Design & Development - London, UK (May 20-24, 2019)

Visual Studio LIVE! New Orleans - New Orleans, LA (Apr 22-26, 2019)

CodeStock - Knoxville, TN (Apr 12-13, 2019)

Boise Code Camp - Boise, ID (Mar 23, 2019)

Connectaha - Omaha, NE (Mar 8, 2019)

LIVE! 360 Orlando - Orlando, FL (Dec 2-7, 2018)

DevSpace - Huntsville, AL (Oct 12-13, 2018)

dev up - St. Charles, MO (Oct 8-10, 2018)

TechBash - Pocono Manor, PA (Oct 2-5, 2018)

Corporate Event - San Marcos, CA (Sep 17-20, 2018)

Seattle Code Camp - Seattle, WA (Sep 15, 2018)

Visual Studio LIVE! Redmond - Redmond, WA (Aug 13-17, 2018)

That Conference - Wisconsin Dells, WI (Aug 6-8, 2018)

Southeast Valley .NET User Group - Online (Apr 21, 2021)
North West Valley .NET User Group - Online (Apr 21, 2021)

Southeast Valley .NET User Group - Online (Jun 23, 2020)
North West Valley .NET User Group - Online (Jun 23, 2020)