Today, let's dive into the somewhat unpredictable and potentially risky behavior of the "Using Declaration" feature. As always, no boring long introduction paragraphs; let's get straight to the point! C# 8.0 What is Using Declaration? In C# 7.0 we did this: public void SuperMethod()
{
    using (var myVariable = new SomeDisposable())
    {
        // use myVariable
    } // myVariable will be disposed here
} Since C# 8.0, we can write this as follows: public void SuperMethod()
{
    using var myVariable = new SomeDisposable();
    // use myVariable
} // myVariable will be disposed here The lifetime of will extend to the end of the scope in which it is declared (in this case — containing method). myVariable SuperMethod Looks marvelous! But only until we combine it with object initializers... The Problem First, we're going to take a look at this tiny piece of code: using var response = new HttpResponseMessage
{
    Content = new StringContent("Hello, World!")
};
// some other code At first glance, it looks perfectly fine: we create an instance of a disposable type and initialize one of its properties. When the program execution reaches the end of the method that contains this code, our object will be disposed of (the same goes for when "some other code" throws an exception). In other words, we could expect this behavior: response var response = new HttpResponseMessage();
try
{
    response.Content = new StringContent("Hello, World!");
    // some other code
}
finally
{
    response.Dispose();
} While intuition and common sense might lead us to expect this, the reality is quite different. To understand what happens, let's check the " " and IL for the first code snippet that we started with: Low-Level C# Now we can see what is wrong with this lovely Using Declaration construction: if we use an object initializer on our instance, the values will be assigned to the properties the try-catch block. Thus, if one of these setters throws an exception, we will end up with an allocated instance of a disposable type that is not going to be disposed of by the (in the try-catch block). before using Frankly, this implementation and design choice caught me off guard. Solution As you might have guessed, the workaround is straightforward: first, instantiate a disposable object using "Using Declaration," and then initialize its properties — avoid using object initializers. Example using var response = new HttpResponseMessage();
response.Content = new StringContent("Hello, World!");
// some other code Bonus If you use an advanced IDE (JetBrains Rider) or an amazing plugin for Visual Studio (Resharper), it will warn you about this code issue: initialize object properties inside the 'using' statement to ensure that the object is disposed if an exception is thrown during initialization That's all for now. Thank you for reading; I hope it helps! Cheers! Also published . here

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

How FIFO Mechanisms in Message Brokers Ensure Message Order

Mastering AI: How to Make ChatGPT Write Code Your Way

Check out my tech blog!

Hire Me

Buy Me a Coffee

Support Me On Patreon

Newsletter

Too Long; Didn't Read

Make resilience your competitive advantage

Beware of 'Using Declarion' in C# 8.0: A Real Example

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

90% of Developers Were Outperformed by GPT-4

The Noonification: Will ChatGPT Change Coding Interviews Forever? (12/24/2022)

46 Stories To Learn About C

6 Best C# Programming Books Ranked by Review Score

6 Best C Programming Books Ranked by Review Scores

90% of Developers Were Outperformed by GPT-4

The Noonification: Will ChatGPT Change Coding Interviews Forever? (12/24/2022)

46 Stories To Learn About C

6 Best C# Programming Books Ranked by Review Score

6 Best C Programming Books Ranked by Review Scores

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps