# IDisposable

***

**1. File Handling**

```c#
using (var file = File.OpenRead("file.txt"))
{
    // Read file content
}
```

**2. Database Connection**

```c#
using (var connection = new SqlConnection("connectionString"))
{
    // Execute database commands
}
```

**3. Network Stream**

```c#
using (var stream = new NetworkStream(socket))
{
    // Send and receive data
}
```

**4. Event Subscription**

```c#
using (var subscription = eventSource.Subscribe(args =>
{
    // Handle event
}))
{
    // Unsubscribe when done
}
```

**5. HTTP Client**

```c#
using (var client = new HttpClient())
{
    // Send HTTP requests
}
```

**6. Web API Request**

```c#
using (var request = new HttpRequestMessage(HttpMethod.Get, "https://example.com"))
{
    // Send API request
}
```

**7. DataReader**

```c#
using (var reader = command.ExecuteReader())
{
    // Read data from database
}
```

**8. Disposable Object Pool**

```c#
class DisposablePool
{
    private readonly Stack<IDisposable> disposables;

    public DisposablePool()
    {
        disposables = new Stack<IDisposable>();
    }

    public IDisposable Rent()
    {
        lock (disposables)
        {
            if (disposables.Count > 0)
                return disposables.Pop();
            else
                return CreateNewDisposable();
        }
    }

    public void Return(IDisposable disposable)
    {
        lock (disposables)
        {
            disposables.Push(disposable);
        }
    }

    private IDisposable CreateNewDisposable()
    {
        // Create a new disposable object
        return new Disposable();
    }
}

class Disposable : IDisposable
{
    public void Dispose()
    {
        // Dispose of the object
    }
}
```

**9. StreamWriter**

```c#
using (var writer = new StreamWriter("file.txt"))
{
    // Write to file
}
```

**10. Regex Matcher**

```c#
using (var regex = new Regex("pattern"))
{
    // Use RegEx functionality
}
```

**11. Temporary Directory**

```c#
using (var tempDir = new TemporaryDirectory())
{
    // Use temporary directory
}
```

**12. Log File**

```c#
using (var logger = new Logger("file.log"))
{
    // Write to log file
}
```

**13. Background Task**

```c#
using (var task = new BackgroundTask())
{
    // Start and stop background task
}
```

**14. Thread Synchronization**

```c#
using (var lockObj = new object())
{
    // Synchronize access to shared resources
}
```

**15. Lazy Initialization**

```c#
class MyClass
{
    private Lazy<IDisposable> disposable;

    public MyClass()
    {
        disposable = new Lazy<IDisposable>(() => CreateDisposable());
    }

    private IDisposable CreateDisposable()
    {
        // Create a new disposable object
        return new Disposable();
    }

    public IDisposable Disposable
    {
        get { return disposable.Value; }
    }
}
```

**16. Disposable List**

```c#
class DisposableList<T> : IDisposable where T : IDisposable
{
    private List<T> items;

    public DisposableList()
    {
        items = new List<T>();
    }

    public void Add(T item)
    {
        items.Add(item);
    }

    public void Dispose()
    {
        foreach (var item in items)
        {
            item.Dispose();
        }
    }
}
```

**17. Disposable Stack**

```c#
class DisposableStack<T> : IDisposable where T : IDisposable
{
    private Stack<T> items;

    public DisposableStack()
    {
        items = new Stack<T>();
    }

    public void Push(T item)
    {
        items.Push(item);
    }

    public T Pop()
    {
        return items.Pop();
    }

    public void Dispose()
    {
        while (items.Count > 0)
        {
            items.Pop().Dispose();
        }
    }
}
```

**18. Disposable Queue**

```c#
class DisposableQueue<T> : IDisposable where T : IDisposable
{
    private Queue<T> items;

    public DisposableQueue()
    {
        items = new Queue<T>();
    }

    public void Enqueue(T item)
    {
        items.Enqueue(item);
    }

    public T Dequeue()
    {
        return items.Dequeue();
    }

    public void Dispose()
    {
        while (items.Count > 0)
        {
            items.Dequeue().Dispose();
        }
    }
}
```

**19. Disposable Dictionary**

```c#
class DisposableDictionary<TKey, TValue> : IDisposable where TKey : IDisposable where TValue : IDisposable
{
    private Dictionary<TKey, TValue> items;

    public DisposableDictionary()
    {
        items = new Dictionary<TKey, TValue>();
    }

    public void Add(TKey key, TValue value)
    {
        items.Add(key, value);
    }

    public TValue Get(TKey key)
    {
        return items[key];
    }

    public void Dispose()
    {
        foreach (var item in items)
        {
            item.Key.Dispose();
            item.Value.Dispose();
        }
    }
}
```

**20. Disposable Event Aggregator**

```c#
class DisposableEventAggregator
{
    private Dictionary<Type, List<Delegate>> handlers;

    public DisposableEventAggregator()
    {
        handlers = new Dictionary<Type, List<Delegate>>();
    }

    public void Subscribe<TEvent>(Action<TEvent> handler) where TEvent : class
    {
        List<Delegate> handlersForType;
        if (!handlers.TryGetValue(typeof(TEvent), out handlersForType))
        {
            handlersForType = new List<Delegate>();
            handlers[typeof(TEvent)] = handlersForType;
        }
        handlersForType.Add(handler);
    }

    public void Unsubscribe<TEvent>(Action<TEvent> handler) where TEvent : class
    {
        List<Delegate> handlersForType;
        if (handlers.TryGetValue(typeof(TEvent), out handlersForType))
        {
            handlersForType.Remove(handler);
        }
    }

    public void Publish<TEvent>(TEvent eventArgs) where TEvent : class
    {
        List<Delegate> handlersForType;
        if (handlers.TryGetValue(typeof(TEvent), out handlersForType))
        {
            foreach (var handler in handlersForType)
            {
                var actionHandler = handler as Action<TEvent>;
                actionHandler(eventArgs);
            }
        }
    }

    public void Dispose()
    {
        foreach (var handlersForType in handlers.Values)
        {
            handlersForType.Clear();
        }
        handlers.Clear();
    }
}
```

**21. Disposable Message Broker**

```c#
class DisposableMessageBroker
{
    private Queue<Message> messages;

    public DisposableMessageBroker()
    {
        messages = new Queue<Message>();
    }

    public void Send(Message message)
    {
        messages.Enqueue(message);
    }

    public Message Receive()
    {
        return messages.Dequeue();
    }

    public void Dispose()
    {
        messages.Clear();
    }
}

class Message
{
    public string Type { get; set; }
    public object Data { get; set; }
}
```

**22. Disposable Cache**

```c#
class DisposableCache
{
    private Dictionary<string, object> items;

    public DisposableCache()
    {
        items = new Dictionary<string, object>();
    }

    public void Set(string key, object value)
    {
        items[key] = value;
    }

    public object Get(string key)
    {
        return items[key];
    }

    public void Dispose()
    {
        items.Clear();
    }
}
```

**23. Disposable Timer**

```c#
class DisposableTimer
{
    private System.Timers.Timer timer;

    public DisposableTimer()
    {
        timer = new System.Timers.Timer();
    }

    public void Start(double interval, Action callback)
    {
        timer.Interval = interval;
        timer.Elapsed += (sender, args) => { callback(); };
        timer.Start();
    }

    public void Stop()
    {
        timer.Stop();
    }

    public void Dispose()
    {
        timer.Dispose();
    }
}
```

**24. Disposable Task**

```c#
class DisposableTask
{
    private Task task;

    public DisposableTask(Task task)
    {
        this.task = task;
    }

    public void Wait()
    {
        task.Wait();
    }

    public void Dispose()
    {
        task.Dispose();
    }
}
```

**25. Disposable Lazy**

```c#
class DisposableLazy<T> : IDisposable where T : IDisposable
{
    private Lazy<T> lazy;

    public DisposableLazy(Func<T> valueFactory)
    {
        lazy = new Lazy<T>(valueFactory);
    }

    public T Value
    {
        get { return lazy.Value; }
    }

    public void Dispose()
    {
        lazy.Value.Dispose();
    }
}
```

**26. Disposable Critical Section**

```c#
class DisposableCriticalSection
{
    private object lockObject;

    public DisposableCriticalSection()
    {
        lockObject = new object();
    }

    public void Enter()
    {
        Monitor.Enter(lockObject);
    }

    public void Exit()
    {
        Monitor.Exit(lockObject);
    }

    public void Dispose()
    {
        lockObject = null;
    }
}
```

**27. Disposable Mutex**

```c#
class DisposableMutex
{
    private Mutex mutex;

    public DisposableMutex()
    {
        mutex = new Mutex();
    }

    public void WaitOne()
    {
        mutex.WaitOne();
    }

    public void ReleaseMutex()
    {
        mutex.ReleaseMutex();
    }

    public void Dispose()
    {
        mutex.Dispose();
    }
}
```

**28. Disposable Semaphore**

```c#
class DisposableSemaphore
{
    private Semaphore semaphore;

    public DisposableSemaphore(int initialCount, int maximumCount)
    {
        semaphore = new Semaphore(initialCount, maximumCount);
    }

    public void WaitOne()
    {
        semaphore.WaitOne();
    }

    public void Release()
    {
        semaphore.Release();
    }

    public void Dispose()
    {
        semaphore.Dispose();
    }
}
```

**29. Disposable Event Wait Handle**

```c#
class DisposableEventWaitHandle
{
    private EventWaitHandle eventHandle;

    public DisposableEventWaitHandle()
    {
        eventHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
    }

    public void Set()
    {
        eventHandle.Set();
    }

    public void Reset()
    {
        eventHandle.Reset();
    }

    public void Dispose()
    {
        eventHandle.Dispose();
    }
}
```

**30. Disposable AutoResetEvent**

```c#
class DisposableAutoResetEvent
{
    private AutoResetEvent autoResetEvent;

    public DisposableAutoResetEvent()
    {
        autoResetEvent = new AutoResetEvent(false);
    }

    public void Set()
    {
        autoResetEvent.Set();
    }

    public void Reset()
    {
        autoResetEvent.Reset();
    }

    public void Dispose()
    {
        autoResetEvent.Dispose();
    }
}
```

**31. Disposable ManualResetEvent**

```c#
class DisposableManualResetEvent
{
    private ManualResetEvent manualResetEvent;

    public DisposableManualResetEvent()
    {
        manualResetEvent = new ManualResetEvent(false);
    }

    public void Set()
    {
        manualResetEvent.Set();
    }

    public void Reset()
    {
        manualResetEvent.Reset();
    }

    public void Dispose()
    {
        manualResetEvent.Dispose();
    }
}
```

**32. Disposable Barrier**

```c#
class DisposableBarrier
{
    private Barrier barrier;

    public DisposableBarrier(int participantCount)
    {
        barrier = new Barrier(participantCount);
    }

    public void SignalAndWait()
    {
        barrier.SignalAndWait();
    }

    public void Dispose()
    {
        barrier.Dispose();
    }
}
```

**33. Disposable SpinLock**

```c#
class DisposableSpinLock
{
    private SpinLock spinLock;

    public DisposableSpinLock()
    {
        spinLock = new SpinLock();
    }

    public void Enter()
    {
        spinLock.Enter();
    }

    public void Exit()
    {
        spinLock.Exit();
    }

    public void Dispose()
    {
        spinLock.Dispose();
    }
}
```

**34. Disposable InterlockedCompareExchange**

```c#
class DisposableInterlockedCompareExchange<T>
{
    private InterlockedCompareExchange<T> interlockedCompareExchange;

    public DisposableInterlockedCompareExchange(T location, T value, T comparand)
    {
        interlockedCompareExchange = new InterlockedCompareExchange<T>(location, value, comparand);
    }

    public T CompareExchange(T value, T comparand)
    {
        return interlockedCompareExchange.CompareExchange(value, comparand);
    }

    public void Dispose()
    {
        interlockedCompareExchange.Dispose();
    }
}
```

**35. Disposable ReaderWriterLockSlim**

```c#
class DisposableReaderWriterLockSlim
{
    private ReaderWriterLockSlim readerWriterLockSlim;

    public DisposableReaderWriterLockSlim()
    {
        readerWriterLockSlim = new ReaderWriterLockSlim();
    }

    public void EnterReadLock()
    {
        readerWriterLockSlim.EnterReadLock();
    }

    public void ExitReadLock()
    {
        readerWriterLockSlim.ExitReadLock();
    }

    public void EnterWriteLock()
    {
        readerWriterLockSlim.EnterWriteLock();
    }

    public void ExitWriteLock()
    {
        readerWriterLockSlim.ExitWriteLock();
    }

    public void Dispose()
    {
        readerWriterLockSlim.Dispose();
    }


```