Is your application feeling sluggish? Is memory usage steadily climbing? Are you rebooting services or servers just to “fix” performance problems without ever finding the real cause?

If so, there’s a good chance disposable types are at the heart of the problem.
After decades of working with millions of lines of .NET code in real-world systems, I’ve seen one issue surface again and again as a silent performance killer: improper handling of disposable resources. Streams, database connections, file handles, HTTP clients, and many other types rely on correct disposal. When they’re mishandled, your application doesn’t leak memory in the traditional sense—but it does suffer from virtual memory leaks, resource starvation, and performance degradation that quietly cripple your system.

.NET is incredibly powerful, but its memory and resource management model is often misunderstood. Developers assume the garbage collector will “take care of everything,” and that assumption leads to:

• Excessive memory usage
• Slower response times
• Unstable services
• Costly infrastructure scaling
• Mysterious reboots that treat symptoms instead of the disease

In this session, I’ll show you exactly how and why disposable types become a hidden epidemic in .NET applications. Using real production examples backed by metrics, you’ll see how small mistakes can snowball into major performance and stability problems—and how simple, disciplined coding practices can prevent them entirely.

You’ll learn:

• How to correctly dispose of objects and why timing matters
• How to properly implement IDisposable in your own custom types
• Common anti-patterns that silently drain memory and system resources
• Tools and diagnostic techniques to identify disposal-related issues
• How to design code that is safe, clean, and resource-efficient from day one

This session focuses on prevention, not damage control. Fixing these problems early in your code saves countless hours of debugging, avoids costly post-deployment firefighting, and dramatically improves application stability and performance.

This content draws directly from the 20th Anniversary Edition of my book, Rock Your Code: Coding Standards for Microsoft .NET, available on Amazon: https://bit.ly/CodingStandards20th

After this session, you won’t just understand disposable types—you’ll master them. You’ll leave armed with proven techniques and practical tools that help you write safer, faster, and more reliable .NET applications.

Welcome to the next level. It’s time to evolve into a Code Shark™ and take full control of your application’s performance and resource management.

Sluggish performance, rising memory usage, and mysterious service restarts are often caused by improper handling of disposable types. Many .NET developers assume the garbage collector will manage everything, but unmanaged resources must be explicitly released or serious performance and stability issues follow.

In this session, you’ll learn how to correctly use and implement IDisposable, avoid common anti-patterns, and identify disposal-related problems using practical tools and techniques. Walk away with the skills to prevent virtual memory leaks, improve application stability, and make your .NET applications faster and more reliable.