Introduction

This post explains how to utilize the using keyword.

using keyword

There are three major ways to use the using keyword,
Here we will discuss the Using Statement.

Using Statement

    • This Dispose method is working well now. But I have written only one: 'Console.WriteLine("Disposing");' We must write informative code to dispose.
      1. // adding new code with highlighted
      2. public class Car : IDisposable
      3. {
      4. public string Name { get; set; } = "Super Car";
      6. public void Dispose()
      7. {
      8. Console.WriteLine("Disposing");
      9. this.Name = null;
      10. }
      11. }
      13. class Program
      14. {
      15. static void Main(string[] args)
      16. {
      17. Car carObjWithUsing = new Car();
      18. using (carObjWithUsing)
      19. {
      20. Console.WriteLine(carObjWithUsing.Name);
      21. }
      22. // Name will be null here.
      23. Console.WriteLine(carObjWithUsing.Name);
      24. }
      25. }
      27. //Output
      28. Super Car
      29. Disposing
    • Note
      If you assign null to an object, it is only removing reference of the object from the stack. Object is not removed from the heap.
    • The following code allows multiple instances of a type in a single statement:
      1. using (Car carObjWithUsing1 = new Car(), carObjWithUsing2 = new Car())
      2. {
      4. }
    • Note
      If you use more than one type within a single statement, then an exception will occur. For example:
      1. using (Car carObj = new Car(), Animal animalObj = new Animal())
      2. {
      4. }
      6. // Here have two types, Car and Animal.So we will get a error;
      7. // Error Number: CS1044
      8. // Error Details: Cannot use more than one type in a for, using, fixed, or declaration statement
    • You can use a nested using statement.
      1. using (Customer customer = new Customer())
      2. {
      3. using (Order order = customer.Order)
      4. {
      5. Console.WriteLine(order.ItemName);
      6. }
      7. }
      9. // or you can use flowing syntax (but it's not working for old c# version):
      10. using (Customer customer = new Customer())
      11. using (Order order = customer.Order)
      12. {
      13. Console.WriteLine(order.ItemName);
      14. }
  • How does it work?

    • Defines a boundary/Scope for the object. At the end of this boundary, it's called Dispose method automatically, which is written in resource class to dipose/release resource.

  • When do we use it?

    • For resource-intensive operations, object lifetime is important to dispose.
    • Use using statement in database connection because if any error occurs, then the database connection will be closed automatically. There's no need to call connection Close() method explicity.

  • Benefits:

    • Reduces the code
      • Example:
        1. using (Car carObj = new Car())
        2. {
        3. Console.WriteLine(carObjWithUsing.Name);
        4. }
        6. // you will get same result by try-catch-finally statement.
        8. Car carObj = new Car();
        9. try
        10. {
        11. Console.WriteLine(carObj.Name);
        12. }
        13. catch(Exception ex)
        14. {
        16. }
        17. finally
        18. {
        19. if(carObj != null)
        20. ((IDisposable)carObj).Dispose();
        21. }
        23. // From the above code, it's clear that using statement is reducing code.
    • Simpler Syntax

Last Word

I would appreciate any suggestions to help improve my articles.