Need a Practical Examples about IDisposable - C#

[ShervanN]

Hello,

Since Managed and Unmanaged Memory is an important topic in C#, In my opinion, this chapter should include several practical and comprehensive examples.
In Chapter 13, pages 347 and 348, I didn't see programs on these topics. You only explained and wrote the pattern.

Thanks

[christiannagel]

It depends on your applications how important this really is.

Here are some simple rules:

If your class contains a member that implements IDisposable, your class should implement IDisposable as well. From the implementation of the Dispose method, the Dispose member of the member should be invoked.

In this case you don't need to deal with the finalizer, don't need to create a destructor. Next for the more complex version which most applications don't need:

If your class uses unsafe code, allocates native memory (e.g. by using platform invoke), you need to release the native memory. This is not dealt with by the garbage collector. Here it's required to implement a finalizer and the IDisposable interface (including GC.SuppressFinalize.

To summarize, for most applications just an implementation of the IDisposable version is needed.

[ShervanN]

Thank you,
I have written an example. Number 1:
Do you mean I should implement IDisposable for the Program class like this? (Number 2)

Number 1:

using System;

class Car
{
    public string Name { get; set; }
}
class Peugeot : Car, IDisposable
{
    public int Gear { get; set; }

    public void Dispose()
    {
        Console.WriteLine("From Peugeot...");
    }
}

internal class Program 
{
    static void Main(string[] args)
    {
        Peugeot P206 = new() { Name = "206", Gear = 5 };

    }
}

Number 2:

using System;

class Car
{
    public string Name { get; set; }
    public virtual void InCar() { }
}
class Peugeot : Car, IDisposable
{
    public int Gear { get; set; }
    public override void InCar() => Console.WriteLine($"{Name} with {Gear} ");
    public void Dispose()
    {
        Console.WriteLine($"Dispose From {Name}...");
    }
}

internal class Program : IDisposable
{
    static void Main(string[] args)
    {
        Program myProgram = new();
        myProgram.Run();
    }
    public void Run()
    {
        Peugeot P206 = null;
        try
        {
            P206 = new() { Name = "Peugeot", Gear = 5 };
            P206.InCar();
        }
        finally
        {
            P206.Dispose();
            Dispose();
        }
    }
    public void Dispose()
    {
        Console.WriteLine("Dispose From Program");
    }
}

[christiannagel]

In case the Peugeot class has a member that is disposable, yes. You can use the using statement or the using declaration in the Run method instead of using try/finally. using does exactly that - creating a try/finally.

You could also declare the Peugeot class sealed to avoid future issues when the implementation changes.

[ShervanN]

Thank you, You wrote
In case the Peugeot class has a member that is disposable, yes.

The Peugeot class or Program class? The Program class has a member (Peugeot) that is implemented disposable. So we should implement IDisposable for the Program class.

[christiannagel]

The Peugeot class is disposable, yes, but it doesn't have a member that is disposable. With the small sample it's ok, but with the implementation of Dispose typically you want to do invoke the Dispose method of an inner object instead of writing a message to the console:

• create a field of a type that implements IDisposable within the Peugeot class
• Instantiate an object that's referenced by the inner field in the constructor
• From the Dispose method of the Peugeot class, invoke the Dispose method of the object referenced by the field

[ShervanN]

Thank you.