Dispose-Muster in C#: Implementieren von Dispose und GC.SuppressFinalize ⇐ C#

[Anonymous]

Ich studiere das Dispose-Muster in C# und verstehe, dass die Dispose-Methode verwendet wird, wenn nicht verwaltete Ressourcen vorhanden sind. Wenn ich beispielsweise eine nicht verwaltete Ressource in FirstClass habe und FirstClass in einer Node-Klasse enthalten ist, muss ich die Dispose-Methode für beide implementieren, oder?
Was ich nicht verstehe Das Wichtigste ist, ob ich GC.SuppressFinalize(this) aufrufen muss. in jeder Dispose-Methode.
GC.SuppressFinalize(this); weist den Garbage Collector an, nicht zu finalisieren, aber bedeutet dies, dass GC.SuppressFinalize(this); ist in der Dispose-Methode nur erforderlich, wenn die Klasse über einen Finalizer verfügt? Wenn das der Fall ist, wäre es meiner Meinung nach sowohl in der Node-Klasse als auch in der BaseClass erforderlich. Da die Node-Klasse jedoch auch verwaltete Mitglieder hat, ist es in diesem Fall akzeptabel, den Finalizer zu unterdrücken?
Ich bin verwirrt, weil es verschachtelte Klassen mit Dispose-Methoden gibt. public class Node : IDisposable
{
public Node Next { get; set; } = null;
public Node Child { get; set; } = null;

public FirstClass CppInstance { get; set; } = null;

public Node()
{
CppInstance = new FirstClass();
}

~Node()
{
this.Dispose();
}

public void Dispose()
{
this.CppInstance?.Dispose();
}
}

public class FirstClass : BaseClass
{
private List _nameList = [];

public FirstClass()
{
CreateCppData( out _instance );// C++ Function create
_nameList.Add("A");
_nameList.Add("B");
_nameList.Add("C");
}

protected override void Dispose( Boolean disposing )
{
if( !disposedValue )
{
if( disposing )
{
// Managed resource release
_nameList.Clear();
_nameList = null;
}

// Unmanaged resource release
DeleteCppData( ref _instance ); // C++ Function delete
disposedValue = true;
}
}

}

public class BaseClass :IDisposable
{
protected Boolean disposedValue = false;

protected IntPtr _instance; // ● Unmanaged Data

~BaseClass()
{
Dispose( false );
}

protected virtual void Dispose( Boolean disposing )
{
}

public void Dispose()
{
this.Dispose( disposing: true );
GC.SuppressFinalize( this );
}

public virtual void Run()
{
}
}


C# Ich habe es basierend auf dem Rat neu geschrieben.
public class Node : IDisposable
{
public Node Next { get; set; } = null;
public Node Child { get; set; } = null;

public FirstClass FirstClassInstance { get; set; } = null;
protected Boolean disposedValue = false;

public Node()
{
FirstClassInstance = new FirstClass();
}

~Node()
{
this.Dispose( false );
}

public void Dispose()
{
this.Dispose( true );
GC.SuppressFinalize( this );
}

protected virtual void Dispose( Boolean disposing )
{
if( !disposedValue )
{
this.FirstClassInstance?.Dispose();
this.FirstClassInstance = null;
disposedValue = true;
}
}
}

public class FirstClass : BaseClass
{
private List _nameList = [];

public FirstClass()
{
_nameList.Add("A");
_nameList.Add("B");
_nameList.Add("C");
}

protected override void Dispose( Boolean disposing )
{
if( !disposedValue )
{
if( disposing )
{
// Managed resource release
_nameList.Clear();
_nameList = null;
}

base.Dispose( disposing ); // BaseClass Dispose
}
}

protected override void CreateCppInstance()
{
CreateCppData( out _instance ); // C++ Function create
}

protected override void DeleteCppInstance()
{
DeleteCppData( ref _instance ); // C++ Function delete
}
}

public class BaseClass :IDisposable
{
protected Boolean disposedValue = false;

protected IntPtr _instance; // ● Unmanaged Data

public BaseClass()
{
CreateCppInstance();
}

~BaseClass()
{
Dispose( false );
}

protected virtual void CreateCppInstance()
{
throw new Exception();
}

protected virtual void DeleteCppInstance()
{
throw new Exception();
}

protected override void Dispose( Boolean disposing )
{
if( !disposedValue )
{
if( disposing )
{
// Managed resource release
}
// Unmanaged resource release
DeleteCppInstance();
disposedValue = true;
}
}

public void Dispose()
{
this.Dispose( disposing: true );
GC.SuppressFinalize( this );
}
}