.NET Framework .NET C# VB.NET LINQ ASP.NET Web API REST SignalR Windows Forms WPF WCF RabbitMQ PHP SQL Server MySQL PostgreSQL MariaDB SQLite MongoDB ADO.NET ORM Entity Framework Dapper XML JSON HTML5 CSS3 Bootstrap JavaScript jQuery Angular React TypeScript NPM Blazor UI/UX Responsive Web Design Redis Elasticsearch GraphQL Grafana Agile Scrum Kanban Windows Server IIS PowerShell Active Directory TFS Azure Automation Software Reverse Engineering Performance Optimization Git Jira/Confluence CI/CD TeamCity SOLID KISS DRY YAGNI
Always will be ready notify the world about expectations as easy as possible: job change page

How getting Lazy in C#

Created: Aug 9, 2021
Source: source
Views: 374

If you’re anything like me, you’ve looked for ways of making your applications faster. In this article, I’ll show you a somewhat unknown class in the .NET framework that makes lazy creation of objects easy to do and thread safe.

The Old Way

Before we get to the fun stuff, let’s take a look at how you might try to do these things without .NET’s Lazy<T> classes.

Typically when you design a class, you might start with code like this:

You might eventually find that as the number of things you need to instantiate grows, the performance degrades significantly on creation of the object.

In that case, you might make a decision to lazy load components of the Starship class. That is, you might make a decision to only instantiate them when they’re needed.

A typical version of that would look like this:

Lots of lines there. Thankfully, this can be compressed a bit:

Well, that’s at least concise, though it might not be extremely easy to read.

Both the expanded and the concise version of this do have a threading issue, however.

If two callers are trying to get a property, it’s possible that one might get past the null check and then its thread sleeps while another thread also passes that null check. In this case, two instances of ExpensiveWarpCore are created and then assigned to _warpCore. This may be a non-issue, or it may be significant.

In order to fully work around this limitation, you need to do something like the following:

While this is technically safer, you can start to see how doing this several times over in your class as you introduce new lazy-loaded properties would become tedious and make people tend to skim the code.

Introducing Lazy<T>

.NET provides a generic class called Lazy which allows you to lazily instantiate objects the first time their value is requested.

Let’s take a look at the same code using Lazy<T>:

Interestingly, we moved the complexity out of the property getter and put it in the backing field.

Let’s take a look at that lazy initializer:

new Lazy<WarpCore>(() => new ExpensiveWarpCore(), true)

First, we’re invoking the constructor on Lazy and providing a generic type argument telling the class that it will provide a WarpCore instance.

Next, we pass in a Func<WarpCore> argument that is invoked to create the instance we need. In this case, we’re just calling the ExpensiveWarpCore constructor. Note that if we were just invoking the default constructor on WarpCore instead of ExpensiveWarpCore, we wouldn’t even need to specify this Func value.

Finally, we’re passing in a true boolean value to the final parameter indicating that this instance should be thread safe.

Closing Thoughts

You can see in just a few lines how you can use Lazy<T> to safely and concisely instantiate objects exactly when they’re first used, and can do so in a thread safe manner if you choose to.

As with anything, there are tradeoffs to using Lazy. Primarily, these tradeoffs involve syntax which may be hard to read for newer developers.

All in all, Lazy is something I would strongly recommend adding to your standard practices. The downsides are minimal and the ability to standardize on simple patterns is a big win.

Sep 11, 2023
Author: Artem A. Semenov
When crafting elegant and scalable software in C#, a keen understanding of Dependency Injection (DI) is more than a luxury — it’s a necessity. It’s a design pattern that underpins many modern .NET applications, providing a solid foundation for managing...
Feb 3, 2022
Author: Satish Chandra Gupta
What if programming languages were stocks? And you had to make a portfolio to fetch good returns in 2022?You probably have seen various surveys and analyses listing the most popular programming languages. Those cover the universe of programming languages, like...
May 8, 2023
Author: Waqas Ahmed
Dapper is a lightweight ORM (Object-Relational Mapping) framework for .NET Core and is commonly used to query databases in .NET Core applications. Here are some of the advanced features of Dapper in .NET Core: Multi-Mapping: Dapper allows...
Jan 16, 2023
C# AngleSharp tutorial shows how to parse HTML in C# with AngleSharp library.The library can also parse SVG, MathML, or XML.AngleSharp GitHub: Object Model (DOM) is a standard tree structure, where each node contains one of the components from...
Send message
Your name

© 1999–2023 WebDynamics
1980–... Sergey Drozdov
Area of interests: .NET | .NET Core | C# | ASP.NET | Windows Forms | WPF | Windows Phone | HTML5 | CSS3 | jQuery | AJAX | MS SQL Server | Transact-SQL | ADO.NET | Entity Framework | IIS | OOP | OOA | OOD | WCF | WPF | MSMQ | MVC | MVP | MVVM | Design Patterns | Enterprise Architecture | Scrum | Kanban
GitHub profile