Using Statement In C#

Introduction

using keyword

• Using Directive
• Using Static Directive
• Using Statement

Using Statement

• What is it?
  
  
  • A statement which contains the 'using' keyword, then it is called using a statement.
    
    
• What it does:
  
  
  • Specifies the scope or boundary of the use of a resource object (normally use curly braces, {}).
  • After the end of a scope, it's called Dispose method.
  • Note: If an exception occurs between this scope, then it's also called Dispose method (for more details please have a look in the 'How to work' section).
• The dispose method will free the resource object because it's no longer needed.
• In summary, every object has a life cycle (life cycle means creation and destroying the object). After destroying the object we have to release the destroyed object resources. It is done by CLR and you can control it by using a statement.
  
  
• Why do we need it?
  
  
  • .NET framework is designed with an automatic memory or resource management feature which disposes, releases, or frees the object automatically.
    
    
    • This process is completed through non-deterministic mode whenever the Common Language Runtime (CLR) is decided upon to perform garbage collector (GC).
      
      
      • Decision
        If you want to control this memory management, then we need to use a using statement. This time GC will be done by us, rather than CLR.
        
        
  • There are mainly two types of memory resources,
    
    
    • Managed Resource
      
      
      • Created by managed objects.
      • Managed by CLR.
      • Example: int, string bool etc variables (those are all in .NET scope).
        
      • Decision
        These manage resources are released by CLR, but if we want to release by ourselves then we need a using statement.
        
        
    • Unmanaged Resource
      
      
      • Created by unmanaged objects.
      • Not managed by CLR.
      • Example: third party libraries such as file streams, network connection, device context, database connection objects.
      • Decision
        These unmanaged resources are resource-intensive, so we have to release as quickly as possible. We can do this with a using statement.
    • Note
      Using statement is used for unmanaged resource because managed resource are released by CLR automatically.
      
      
  • Simply put, .NET framework provides a using statement for memory clean-up activities.
    
    
• How to use?
  
  
  • The using statement takes only one parameter, a resource that is represented by a class or stack.
    
    1. //
    2. // using statement syntax
    3. //
    4. using(resource, it can be a class object)
    5. {
    6. // body
    7. }
    9. // more specific syntax
    10. using (<ClassName> <VariableName> = new <ClassName>())
    11. {
    12. // body
    13. }
    14. //
    15. // using statement example
    16. //
    18. // Create a Car Class, whose has a property Name
    19. public class Car
    20. {
    21. public string Name { get; set; } = "Super Car";
    22. }
    24. // Call Car class from Main method
    25. class Program
    26. {
    27. static void Main(string[] args)
    28. {
    29. // here carObj is a resource object
    30. using (Car carObj = new Car())
    31. {
    32. Console.WriteLine(carObjWithUsing.Name);
    33. }
    34. }
    35. }
    37. // If you run this program then you will get a error
    38. // Error Number: CS1674.
    39. // Error Description: 'Car': type used in a using statement must be implicitly convertible to 'System.IDisposable' or implement a suitable 'Dispose' method.

• Why is this error showing?
  
  
  • For using statement, the resource object must be implemeted with IDisposable interface, which is from System namespace.
  • If you go to IDisposable interface you can see that here is only one method, Dispose()
    
    1. namespace System
    2. {
    3. //
    4. // Summary:
    5. // Provides a mechanism for releasing unmanaged resources.
    6. public interface IDisposable
    7. {
    8. //
    9. // Summary:
    10. // Performs application-defined tasks associated with freeing, releasing, or resetting
    11. // unmanaged resources.
    12. void Dispose();
    13. }
    14. }
• Here is full code with IDisposable
  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. }
  10. }
  13. class Program
  14. {
  15. static void Main(string[] args)
  16. {
  17. //with using statement
  18. using (Car carObjWithUsing = new Car())
  19. {
  20. Console.WriteLine(carObjWithUsing.Name);
  21. }
  22. }
  23. }
  26. //Output
  27. Super Car
  28. Disposing

• Example : see above in the code reduction example.

• Saves development time and effort.
• It ensures that Dispose is called even if an exception occurs within the using block.
  
  1. string connString = "Data Source=localhost;Integrated Security=True;Initial Catalog=Northwind;";
  3. using (SqlConnection conn = new SqlConnection(connString))
  4. {
  5. SqlCommand cmd = conn.CreateCommand();
  6. cmd.CommandText = "SELECT CustomerId, CompanyName FROM Customers";
  7. conn.Open();
  9. ....
  10. ....
  11. }
  13. // Here we dont need to write conn.Close(). It will call automatically.

• Disadvantages:
  Within the using block, the object is read-only and cannot be reassigned or modified.

Last Word