What is ADO.NET?What are the key components of ADO.NET?What are the ADO.NET namespaces?What is the meaning of object pooling?What are the differences between ADO.NET and classic ADO?Explain the architecture of ADO.NET.?What is a Connection String in ADO.NET C#??How do you establish a database connection using ADO.NET?Explain the concept of Connection Pooling in ADO.NET C#.Differentiate between Object pooling and Connection pooling in C#?What is a DataReader in ADO.NET? Explain with C# example?What is the functionality of CommandBehavior.SchemaOnly?Why CommandBehavior.SingleResult flag is used in ADO.NET?What does CommandBehavior.SingleRow do in ADO.NET?How we can get multiple results by DataReader using same connection in C#?How can we force the connection object to close after my DataReader is closed?What is a DataSet in ADO.NET? Explain with C# example?What are typed and un-typed datasets in ADO.NET C#?Write down some of the characteristic of DataSet?What is the difference between dataSet and DataReader?Why is DataSet Slower than DataReader? Explain with Example.How does DataSet handle data in a disconnected environment?What is the Difference between connected and disconnected architectire?Explain HasChanges() method of DataSet in C#.Explain GetChanges() method with detaild C# Example.Explain RejectChanges() method with C# Example.Explain AcceptChanges() method with C# Example.What are the various methods provided by DataSet for XML in C#?What is the purpose of DataAdapter in ADO.NET?Explain the steps involved in retrieving data using DataAdapter.
Previous
Next

Object Pooling in C#

Object pooling in C# is a technique used to efficiently manage and reuse objects, especially when creating and destroying objects frequently can be resource-intensive. This technique helps improve performance by reducing the overhead of creating and disposing of objects repeatedly.

Object Pooling in Simple Terms

Imagine you have a factory that produces cars. Instead of building a new car every time you need one, you maintain a parking lot where you keep a certain number of cars ready. When you need a car, you take one from the parking lot, and when you're done using it, you return it to the parking lot. This way, you save time and resources that would be spent creating and destroying cars constantly.

In C#, object pooling works similarly. Instead of creating new objects every time, you keep a pool of pre-created objects, and when you need an object, you take one from the pool. When you're done using it, you put it back in the pool for reuse.

Now, let's illustrate this concept with a C# code example:


using System;
using System.Collections.Generic;

public class ObjectPool<T>
{
    private readonly Queue<T> objectPool = new Queue<T>();
    private readonly Func<T> objectFactory;

    public ObjectPool(Func<T> objectFactory, int initialSize)
    {
        this.objectFactory = objectFactory;

        for (int i = 0; i < initialSize; i++)
        {
            objectPool.Enqueue(objectFactory());
        }
    }

    public T GetObject()
    {
        if (objectPool.Count > 0)
        {
            return objectPool.Dequeue();
        }
        else
        {
            return objectFactory();
        }
    }

    public void ReturnObject(T obj)
    {
        objectPool.Enqueue(obj);
    }
}

public class Car
{
    public void Drive()
    {
        Console.WriteLine("Car is driving.");
    }
}

class Program
{
    static void Main()
    {
        // Create an object pool of Car objects with an initial size of 3
        var carPool = new ObjectPool<Car>(() => new Car(), 3);

        // Get Car objects from the pool
        Car car1 = carPool.GetObject();
        Car car2 = carPool.GetObject();
        Car car3 = carPool.GetObject();

        // Use the cars
        car1.Drive();
        car2.Drive();
        car3.Drive();

        // Return the cars to the pool
        carPool.ReturnObject(car1);
        carPool.ReturnObject(car2);
        carPool.ReturnObject(car3);

        // Get and use another car from the pool
        Car car4 = carPool.GetObject();
        car4.Drive();
    }
}

Expected Output


Car is driving.
Car is driving.
Car is driving.
Car is driving.

In this example:

  • We create an ObjectPool class that can pool objects of any type T.
  • We create an object pool of Car objects with an initial size of 3.
  • We get three cars from the pool, use them, and return them to the pool.
  • Finally, we get another car from the pool and use it.

Object pooling can be particularly useful when dealing with expensive-to-create objects or objects that need to be reused frequently, like database connections, network sockets, or heavy computational resources, as it helps reduce resource allocation and deallocation overhead.

Previous
Next