Skip to main content

Posts tagged with 'advent'

The Fourth Annual C# Advent

October 23, 2020 mgroves 0 Comments
Tags: csadvent csharp

This year's Advent is going to be a little different that the Advents in 2019, 2018, and 2017.

This year, the C# Advent has its very own site!

Not only that, but the process is more automated this year. Gone are the days of me having to maintain an Excel spreadsheet.

Step 1:

Go to www.csadvent.christmas. Find an open spot in the Advent, and click to claim it. You will need to login with GitHub. There are two spots every day, for a total of 50 spots.

Advent Step 1

Step 2: 

Fill out the request form. You'll need a name and email at least. You can also supply a URL for the link for your name (e.g. if people click "Matthew Groves", I want it to go to my Twitter). You can also add an optional comment. Only the Name and URL will appear publicly! Click submit.

Advent step 2

Step 3:

You should get a confirmation email. I will get an email too, so I can go in and approve your request (approval is a necessary, because there could be a date conflict, or there could be spammers, etc).

Advent step 3

Step 4:

When approved, you will get another email. Approval should be pretty quick if I'm awake (I'm in the eastern US time zone).

Advent step 4

Step 5:

Create your content. Don't publish it until the day you selected. Make sure to link back to www.csadvent.christmas. At any point, you can login to the Contributors Area to supply a link and title of your content.

Advent step 5

You do NOT have to do this until the day you picked. However! You will receive an automated email reminder 2 days ahead of time.

Step 6:

When it's your day, tell everyone about your article and the C# Advent! Tweet them! Submit others to Reddit! Facebook! LinkedIn! Whatever else! Let's show the world how great the C# community is! Please use the #csadvent hash tag when applicable.

Advent step 6

Thank you! Looking forward to another great Advent in 2020.

Note from Matt: This is a guest post by James Bender for the Third Annual C# Advent.

For those who don’t know me, I’m that guy. You know the type; the ones who is super OCD about their code, stresses component-based architecture that encourages reuse, and who’s into Unit Testing. I think a lot of problems in the world could be solved if we all just practiced Test Driven Development.

So, when Matt reached out to me about writing this post, the first thing I thought of was unit testing! And so that’s what this post will be about!

Everyone: GROOOAAAANNN

Hey! When you all start unit testing, I’ll stop harping about it!

While I prefer the idea of TDD, I understand that it isn’t always an option. People who are just starting off with unit testing might not feel comfortable with the “test-first” paradigm, which is totally understandable and completely fine. Some people (like myself) often inherit codebases where the code is already there, but there is not a test to be found. Sometimes, if feels like it would take a miracle to make these code bases even testable!

Behold, a Christmas Miracle!

Well, I may be overselling the whole “miracle” aspect, but this will still be pretty cool. We’re going to take some code and refactor it to make it more testable.

Here is our starting point:

This is an amalgamation of a lot of the problems I see with code that limit its testability. To be fair, this code as a lot of issues, but today we’ll just deal with the ones that limit its testability.

There are a variety of ways to deal with refactoring this, and not everyone will approach it the same way. In my case, the first thing I’m noticing is that the function we’ll be refactoring (ProcessDataExtract) doesn’t return a value. This can make it difficult to determine if my test passes; if I don’t have any output, how can I verify the method worked? Yeah, I could create a mock of the exportChannel object and ask it if its Save method was called, and what data it was called with. But this isn’t the best approach. I’m relying on a supporting object (the mock) to provide basic functionality that my test should be able to do without help. And what happens if there’s a change to ExportChannel causing me to change my mock? This makes this test difficult to maintain. So, for my first refactoring, I’ll be changing the return type:

On line 10, I change the function signature to return an IList of type string. I added a return statement on line 33 to return the results list that is sent to the Save method of the ExportChannel. This enables me to interrogate the results list directly to verify my test. It also makes ProcessDataExtract itself more useable by being able to provide (return) data as opposed to seemingly swallow it up.

The next thing I notice (frankly, it’s kind of hard to miss), is that I have some static dependencies. On line 8 I have a class-level reference to the DataStore service, and at line 12 (in the method body) I have another one to ExportChannel. These have got to go!

Those of you who might be new to testing might be asking why this is a problem? You’ve probably seen dozens of tutorials showing this being done. The problem is that this creates a very brittle piece of software that cannot adopt well to change. If I wanted to add a constructor argument to DataStore I would have to make a change everywhere this service is invoked. That could be dozens, if not hundreds of places. Another issue, which has a direct impact to testability, is that I may eventually have a situation where I want to use different specialized versions of this service in different situations. Creating a direct static dependency to DataStore in this manner makes that almost impossible.

In a testing environment I don’t want to use the actual production implementation of these services. They may make my test slow. Things like I/O operations, web service calls, and database access are notoriously slow. These are crucial for running the application but make testing difficult.

Another concern is that when I write a test, I ONLY want to test the specific code in my method; not the code in the dependencies, which should have their own specific tests. To solve these issues, when testing this code, I want to use mocked versions of these services. Mock are basically stand-in objects that can return canned values that the code can use to verify its logic. Mocking can be a very involved topic, and so I won’t got into a deeper discussion here. If you would like to learn more, please see the links at the end of this post.

But, with statically bound dependencies, how do I get the code to use my mock objects instead of the real ones when I want to run a test? The answer is to refactor our code to use Dependency Injection:

In this refactoring, I have added a constructor to the AppEngine class which takes a DataStore as a parameter. The consumer of this class will pass in an instance of DataStore (or an object derived from DataStore), which my class can use. Additionally, I added parameter of type ExportChannel to the method ProcessDataExtract. This again requires that the calling method provide an object of type ExportChannel. This enables me to pass in mocked objects as part of my test; my test will be the consumer of the AppEngine class and will be calling the ProcessDataExtract method.

As alluded to above, this not only enables to me to pass-in mocked values for testing, but also allows me to pass in specialized versions of those classes based on whatever my current context is, which enhances code reusability. This is especially evident with the ProcessDataExtract method. I may need to run several types of extracts with this method that would only very by the type of ExportChannel. Now, I can reuse this method and pass in whatever ExportChannel I want. This is similar to the Strategy Pattern, which you can read more about here.

So, this method is already looking a lot better. You might even think that we’re done, and there’s no way we can improve the testability of this method. But there’s still one problem. It’s subtle.

Do you see it?

Hint: What happens if I run this test now, and then run it again in an hour? Am I guaranteed to get the same results?

Look at line 17. This line creates a problem for me. The ProcessDataExtract function sorts records based on the current time. If I am using a mock of DataService to pass in a static, canned set of records the code is going to compare the current time captured on line 17 to the time in my test records. Time goes on, but my test data stands still, and eventually, my results are going to change, which could cause my test to act unpredictably.

When creating testable code, a good practice is to abstract away anything that might change. In this case, the value of DateTime.Now changes constantly. So, we need to take it out of our equation, at least for testing:

To solve this issue, I have removed the call to DateTime.Now on line 17 and made currentDate a parameter for the ProcessDataExtract function. This means that when I run my tests, I can pass in any date I want, which means I will be getting consistent test results. Like the previous refactor, it also enhances the reusability of this method. I’m no longer bound to the current date. I can run it for past dates and future dates without having to create a separate method.

And that’s it! With three easy-ish steps we took a piece of untestable legacy code and made it testable! Now, I know this was small example. But the concepts don’t care about the size of the code; there may be more work to do for some of these in larger code bases, but you will still be able to use these techniques to handle most refactoring situations.

Shameless plug: I you would like to learn more, please check out my book, which is available on Amazon.

Happy Holidays!

What is the C# Advent?

The C# Advents in 2018 and 2017 were so much fun. It's now time to sign up for 2019.

Just like last year, each day of the Advent calendar will have up to TWO blog posts. That means that there is a maximum of FIFTY slots! So, tell your C# friends and let's fill up this calendar.

A little history: I heard about the F# Advent Calendar, a tradition that's been carried on since 2010 (2014 in English). I think this is a great idea, and so I organized one for C#! (I asked Sergey Tihon for permission!). If you are running other developer advent calendars, just let me know and I will link to them here:

Let's Get Started

I need you to write a C# blog post, create a video, write an article, etc.

Here are the rules:

  1. Reserve a slot on Twitter (with hash tag #csadvent) or leave a comment on this post. You do not have to announce your topic until the day you reserve.
  2. Prepare your content (in English).
  3. Add a link in your content that links back to here, so that your readers may find the entire advent. You can host your content anywhere you'd like: your own site, dev.to, hackernoon, medium, wordpress, youtube, dzone, etc.
  4. Publish your content on the specified date. Your content must be related to C# in some way, but otherwise the content is completely up to you. I've posted a few ideas below to get your creativity flowing.
  5. Share your post on Twitter with hashtags #csharp and #csadvent

Below are all the slots, and who has claimed each date.

I will do my best to keep this up to date. The slots will be first come first serve. I also allowed last year's authors to get first crack. I will claim the last remaining spot for myself. I will prepare a post just in case someone has to drop out.

DateClaimed byContent
Dec 1, 2019 Brant Burnett Simon Painter  IAsyncEnumerable Is Your Friend, Even In .NET Core 2.x Hacking C#: Programming for the Truly Lazy
Dec 2, 2019 Luis Antonio Beltran Chris Ayers 2FA with Twilio Authy and C# (special guest: Xamarin) Dependency Injection, Architecture, and Testing
Dec 3, 2019 Kelson Ball Morgan Kenyon An Example of Partial Function Application in C# The Difference Between IEnumerable and IQueryable Explained
Dec 4, 2019 Ryan Overton Carl Layton Default Interface Methods in C#: Love 'em or Hate 'em? The Outbox Pattern in C#
Dec 5, 2019 Dave Cook Manuel Grundner To Null, or not to Null?!? The journey of porting pretzel to .NET Core
Dec 6, 2019 Lukáš Lánský Simon Timms Coverage-Driven Test Selection Machine Learning for Boring Applications
Dec 7, 2019 Chase Aucoin Kendall Miller Aurora Serverless with Entity Framework Core Better String Formatting with String Interpolation
Dec 8, 2019 Matt Eland Jeremy Sinclair Experimental C# with Scientist .NET Creating a Simple Wizard Component with Blazor
Dec 9, 2019 Meziantou Cecilia Wirén Thread-safe observable collection in .NET Overflow on integers - count with this security risk!
Dec 10, 2019 Andrew Lock James Hickey .NET Core, Docker, and Cultures - Solving a culture issue porting a .NET Core app from Windows to Linux Modular Monoliths And Composite UIs With .NET Core Razor Class Libraries
Dec 11, 2019 DotNetCoreShow Roman Stoffel The .NET Core Podcast - Episode 40 - Noda Time with Jon Skeet C# Loves Code Patterns
Dec 12, 2019 Brian Jackett James Curran Creating a C# Azure Function to Call Microsoft Graph Cleanup Scaffolded Code with modelbuild
Dec 13, 2019 Barret Blake Ed Charbeneau, Daniel Roth, Chris Sainty, Egil Hansen The Nightmare Before Blazor Getting Started with Blazor: All There is to Know From the Experts
Dec 14, 2019 Benjamin Howarth Martin Zikmund   A Christmas C# riddle
Dec 15, 2019 Jonathan Danylko Hilary Weaver-Robb 10 More Useful C# Extension Methods for 2019 Refactoring RestSharp Sample Tests to Make Them More Maintainable
Dec 16, 2019 Shahed Chowdhuri Ian Bebbington ASP .NET Core code sharing between Blazor, MVC and Razor Pages The Seven GUIs of Christmas
Dec 17, 2019 Joe Zack Chris Sainty Streaming process output to a browser, with SignalR and C# Introduction to Blazor Component Testing
Dec 18, 2019 Garo Yeriazarian Stuart Turner Vertically Sliced Command Line Tools in C# and .NET Core 3.1 Improving Code Readability with Linq (and MoreLinq)
Dec 19, 2019 Baskar Rao Stephen Lorello How to use Subscriptions in GraphQL C# Santa’s Nexmo Helper
Dec 20, 2019 Andrea Angella Layla 15 reasons why you should learn C# in 2020 Get off the naughty list with Twilio Autopilot, Azure Functions and Table Storage
Dec 21, 2019 Muhammad Azeez Patrick Lioi How do Object Relational Mappers (like Entity Framework) work? Patterns for using Entity Framework in C# 8
Dec 22, 2019 James Bender Eric Potter Refactoring for Testability – A Christmas Miracle! C# Strings with Ranges, and Indexes
Dec 23, 2019 Andrew Craven Lee Englestone Microservices and Outside-in Tests Using C# and Docker Compose Compiling Code without Visual Studio
Dec 24, 2019 Thomas Carpe Azmat Ullah Khan   PDF Digital Signatures with Itext7, Bouncy Castle and .NET Core
Dec 25, 2019 Mike Jolley Calvin Allen Adding HATEOAS to an ASP.NET Core API C# 8 is old news. Onward, to C# 9!

Alternates:

  • IF ALL FIFTY SLOTS FILL UP, please leave a comment or tweet with #csadvent anyway and I'll put you on this standby list:
  • Standby list:
    • Myself.
    • You, if you want to be.

Some ideas/topics to help inspire you:

  1. Blazor - C# for the browser
  2. Your latest open source contribution - show the community how you contributed and why
  3. Your favorite C# language feature - it doesn't even have to be a new feature, just blog about something you love about C#
  4. Introduce your favorite NuGet package / library. Even if it's a library you take for granted, not everyone has heard about it.
  5. How to avoid a pitfall you found with performance/memory/etc
  6. Integration/deployment of a C# application with Jenkins, Docker, Kubernetes, TeamCity, Azure, etc
  7. Write a "how to" for one of the many tools discussed in an episode of the Cross Cutting Concerns podcast or the DotNetBytes podcast
  8. Interview someone about C# and post the audio or a transcript.
  9. Implement a simplified example of a design pattern in C#

Thanks to everyone who is participating!

If you were an author of a C# Advent blog post in 2018, you get a chance to sign up earlier than the general public.

Tweet #csadvent or leave a comment below with the date you want to blog on. Each day has up to TWO slots. If someone has already claimed the day you want, that day may still be available.

The general call for C# Advent authors will go out soon, so please claim your dates as soon as possible. Just like last year, you do NOT have to pick a topic right now. If you DO want to pick a topic, I will pencil it in, but you are free to change it at any time up until the date you pick.

Merry Christmas! This is the last day of the C# Advent. Make sure to check out all of the other great posts from 2017 and 2018. If you want to be involved next year, look for C# Advent 2019 author sign ups at the end of October 2019, and look for blog posts to start showing up on December 1st, 2019.

What is a background job?

A background job is some code that runs apart from the normal flow of your program. It could be run asynchronously and/or on another thread. As an ASP.NET MVC developer, I tend to think of it as any task that runs outside of an MVC action being invoked.

There’s two kinds of background jobs that I’m aware of:

  • Scheduled - a task that runs every N minutes, or every Y hours, etc. This is what I’m going to show in this post today. It’s great for making periodic checks, ingesting data from some other source, etc.

  • Fire and forget - Some other piece of code kicks off a process to run in the background. It doesn’t block the code (fire), and the code doesn’t wait for a response (forget). This is great for potentially time consuming operations like checking inventory, sending emails, etc, that you don’t need a user to wait for.

What you usually need to do to create background jobs

In my experience, I’ve seen background jobs take a few different forms.

  1. Separate Windows service (or Linux daemon, whatever). A console/service program that’s running in addition to your ASP.NET program. This works fine for scheduled jobs.

  2. Queueing mechanisms like Kafka or Rabbit. The ASP.NET program will put messages into these queues, which will then be processed by some other program. This is fine for fire-and-forget.

  3. Background jobs running within the ASP.NET process itself. In my experience, I’ve used Quartz.NET, which can run within the ASP.NET process. There’s also FluentScheduler (which I’ve not used, and doesn’t seem to come with database integration out of the box?)

With all these options in the past, I’ve experienced deployment difficulties. The wrong version of the service gets deployed, or isn’t running, or fails silently, or needs to be deployed on multiple servers in order to provide scalability/availability etc. It’s totally possible to overcome these challenges, of course. (I should also note that in my experience with Quartz.NET, I never used it in embedded form, and the last time I used it was probably 6+ years ago).

But if I just need a handful of background jobs, I’d much rather just make them part of the ASP.NET system. Yes, maybe this goes against the whole 'microservice' idea, but I don’t think it would be too hard to refactor if you decided you need to go that route. I solve my deployment problems, and as you’ll see with Hangfire (with Couchbase), it’s very easy to scale.

How hangfire works

You can find more details and documentation about Hangfire at Hangfire.io. Really, there are only three steps to setting up Hangfire with ASP.NET Core:

  1. Tell ASP.NET Core about Hangfire

  2. Tell Hangfire which database to use

  3. Start firing off background jobs

In Startup.cs, in the ConfigureServices method:

services.AddHangfire(x => x.UseCouchbaseStorage(configuration, "familyPhotos_hangfire"));

Then, in Startup.cs, in the Configure method:

app.UseHangfireServer();

I’m using Couchbase in this example, but there are options for SQL Server and other databases too. I happen to think Couchbase is a great fit, because it can easily horizontally scale to grow with your ASP.NET Core deployments. It also has a memory-first architecture for low latency storage/retrieval of job data. Generally speaking, even if you use SQL Server as your "main" database, Couchbase makes a great companion to ASP.NET or ASP.NET Core as a cache, session store, or, in this case, backing for Hangfire.

The configuration variable is to tell Hangfire where to find Couchbase:

var configuration = new ClientConfiguration
{
    Servers = new List<Uri> { new Uri("http://localhost:8091") }
};
configuration.SetAuthenticator(new PasswordAuthenticator("hangfire", "password"));

(In my case, it’s just running locally).

Steps 1 and 2 are down. Next, step 3 is to create some background jobs for Hangfire to process. I’ve created an ASP.NET Core app to assist me in the cataloging of all my family photographs. I want my application to scan for new files every hour or so. Here’s how I create that job in Hangfire:

RecurringJob.AddOrUpdate("photoProcessor", () => processor.ProcessAll(), Cron.Hourly);

Note that I didn’t have to implement an IJob interface or anything like that. Hangfire will take any expression that you give it (at least, every expression that I’ve thrown at it so far).

Step 3 done.

Hangfire is just a NuGet package and not a separate process. So no additional deployment is needed.

How do I know it’s working?

Another great thing about Hangfire is that is comes with a built-in dashboard for the web. Back in Startup.cs, in Configure, add this code:

app.UseHangfireDashboard("/hangfire", new DashboardOptions
{
    Authorization = new[] {new HangfireAuthorization()}
});

I’m using my own HangfireAuthorization implementation because Hangfire only gives permission to local users by default.

Then, you get a nice dashboard right out of the box, showing you a realtime and history graph.

Hangfire dashboard

From this dashboard, you can also look at a more detailed history of what’s run and what’s failed.

Succeeded jobs

You can even kick off recurring jobs manually.

Recurring jobs

This is only the start

If you’re thinking about adding background jobs to your ASP.NET Core solution, why not give Hangfire a try?

Some more things for you to explore:

  • Scaling: every ASP.NET Core site that gets deployed with Hangfire that points to the same database will be able to process jobs too. As your ASP.NET Core site scales out, hangfire scales out with it. This is another reason that Couchbase is a good fit, because it’s also easy to scale out as your site grows.

  • Cloud: If you are deploying your site as an app service, note that Azure will shut down ASP.NET processes if they haven’t been used in a while. This means Hangfire will shut down with them. There are a couple of ways to deal with this. Check out the Hangfire documentation.

  • Retries: Hangfire will retry failed jobs. Design your background job code to expect this.

  • Hangfire Pro: The commercial version of Hangfire is called Hangfire.Pro, and it comes with some interesting looking batch capabilities. I’ve not needed any of this functionality yet, but for more advanced cases you might need this.

  • Couchbase: a NoSQL data platform that has a built-in memory-first cache layer, SQL support, text search, analytics, and more. There are lots of options for working with Couchbase in .NET. For this post, I used the Hangfire.Couchbase library (available on NuGet).

Matthew D. Groves

About the Author

Matthew D. Groves lives in Central Ohio. He works remotely, loves to code, and is a Microsoft MVP.

Latest Comments

Twitter