C#

devvvy wrote:

Should we make Base.Finalize (~Base really in C# syntax) virtual? Should we implement Derived.Finalize (~Derived in C# syntax)?

class A
{
    ~A() { Console.WriteLine("A"); }
}

class B : A
{
    ~B() { Console.WriteLine("B"); }
}

.class auto ansi nested private beforefieldinit A
    extends [mscorlib]System.Object
{
    .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
    {
    }

    .method family hidebysig virtual instance void Finalize() cil managed
    {
    }

}

devvvy wrote:

C++ destructor is C# destructor (or Finalizer) - now SINCE we really want to release resource (expensive ones in particular) in Dispose (deterministically, unlike ~Derived or ~Base), what really I'm asking is, why not "Virtual destructor"

devvvy wrote:

In C++, if you declared destructor virtual, and "delete oDerived", BOTH destructor from Base and Derived are invoked (~Derived then ~Base)

ref class A : public IDisposable
{
   !A() { Console::WriteLine("Dispose for A"};
};

void Main()
{
   {
   A a; // Create object with deterministic dispose semantics.
   } // !A() will be called.

   A ^a = gcnew A(); // No deterministic dispose.
}

devvvy wrote:

Just a thought, despite in IL code finalizer (or C#'s destructor) is virtual - does CLR automatically call BOTH (like in C++):
(a) ~Base
(b) ~Derived

devvvy wrote:

Also don't you think it's more clean and reliable if C# Disposable gets invoked the same way C++ virtual destructor does? That BOTH Base/Derived are invoked?

interface ISome
{
   void DoSome();
}

class BaseSome : ISome
{
   public virtual void DoSome() { Console.WriteLine("BaseSome"); }
}

class DerivedSome : BaseSome
{
   public override void DoSome() { Console.WriteLine("DerivedSome"); }
}

void Main()
{
   ISome some = new DerivedSome();
   some.DoSome();
}

S. Senthil Kumar wrote:

ref class A : public IDisposable
{
!A() { Console::WriteLine("Dispose for A"};
};

void Main()
{
{
A a; // Create object with deterministic dispose semantics.
} // !A() will be called.

ref class A{
public:
   ~A()
   {
	Console::WriteLine("~A()");
   }
protected:
   !A()
   {
	Console::WriteLine("!A()");
   }
}

int main()
{
   A^ a = gcnew A();
   delete a;

   // or the stack semantics way
   A a1;

   A^ a2 = gcnew A(); // not deleting this. So finalizer will be called.
   return 0;
}

devvvy wrote:

Unmanaged resources are freed by calling Dispose (true/false)

devvvy wrote:

managed resources are freed by call to Dispose(true).

Mark Salsbery
Microsoft MVP - Visual C++

devvvy wrote:

to point#2 whhy you said I'm wrong?

Mark Salsbery
Microsoft MVP - Visual C++

class Foo
{
   StreamReader reader;
   IntPtr handle;

   public Foo()
   {
      // Initialize reader, handle
   }
}

S. Senthil Kumar wrote:

Aren't we being a little pedantic here?

Mark Salsbery
Microsoft MVP - Visual C++

devvvy wrote:

Managed memory is freed by call to Dispose

Form2.UseMethod();

Form2 f = new Form2();
f.UseMethod();

string s = String.Format("The result is {0}", 6 * 9);

class Example
   {
   public string data;
   public int CountChars()
      {
      return data.Length;
      }
   }

...

   Example ex = new Example();
   ex.data = "ABCDEFGHIJKLM";
   int i = ex.CountChars();

...