I wonder if someone with more knowlage then me about the following can check, and possibly clear up that i'm coding the following correct.

The following code is a code fragment, and it shows how I implement my own Dispose method, as you can see from the class it's inheriting the IDisposable interface. I have two questions.

A) First could someone check over this code and make sure everything appears correct, I check over I'm refering to the Dispose methods, contructor and deconstructer.

B) Second i'm a little unclear what resources should be released inside 'performDisposeManaged'. I'm under the impression it's any resource thats managed, and is a reference type. Value types, such as strings and integer etc do not need to be cleared up.

public class Template : IDisposable

{ // Added for responses protected

static int m_listboxId; protected string m_rawXML;

string m_appPath;

protected string m_viewTemplate;

string m_htmlTemplate;

protected XMLTemplate m_xmlTemplate;

XMLFunctions m_xmlFunctions;

int m_templateId;

protected WorkflowDataAccess m_workflowDataAccess;

protected ParameterControl m_parameterControl;

object m_syncBlock;

bool m_isDisposed = false;

 public Template()

{

m_workflowDataAccess = new WorkflowDataAccess();

m_parameterControl = new ParameterControl();

m_xmlFunctions = new XMLFunctions();

m_syncBlock = new object();

}

protected virtual void Dispose(bool disposing)

{

// Use a syncBlock to protect against multiple disposing of objects in multi threaded enviroment. lock (m_syncBlock)

{

if (!m_isDisposed)

{

if (disposing == true)

{

   performDisposeUnmanaged();

}

   else

{

   performDisposeManaged();

 }

m_isDisposed = true;

GC.SuppressFinalize(this);

}

else

{

   //throw new ObjectDisposedException(RetError("Template", "Dispose", "Object    already disposed"));

RetError("Template", "Dispose", "Object already disposed");

 }

}

 }

~Template()

{

Dispose(false);

 }

protected virtual void performDisposeUnmanaged()

{ // Release any unmanaged resources

if (m_workflowDataAccess != null)

{ m_workflowDataAccess.Dispose();

m_workflowDataAccess = null;

}

}

private void performDisposeManaged()

{ // Release any managed resources

if (m_xmlFunctions != null)

 { m_xmlFunctions = null;

 }

if (m_parameterControl !=null)

{ m_parameterControl = null;

}

}

public void Dispose()

{

Dispose(true);

 }

}

You can move the code in performDisposeUnmanaged to performDisposeManaged. You don't need the performDisposeUnmanaged method or the finalizer since you don't directly encapsulate any native resources.

Thanks for your reply, but I don't understand why your saying to remove the performDisposeUnmanaged method, as the m_workflowDataAccess object is using database connections. I thought anything that used database connections (unmanaged finite) resource had to be placed in the performDisposeUnmanged.

As regard to the finalizer this was left in as a fail safe incase Dispose was not called by one of my implementing functions.

Is the above not correct?

I'm still unsure about releasing managed resources, and if I should be realising anything thats a reference type?

Jason-Massey wrote:

Thanks for your reply, but I don't understand why your saying to remove the performDisposeUnmanaged method, as the m_workflowDataAccess object is using database connections. I thought anything that used database connections (unmanaged finite) resource had to be placed in the performDisposeUnmanged.

What resources it uses internally is an implementation detail the user of the class shouldn't have to care about. All you should do is call the Dispose method if there is one when you're done with the object.

Jason-Massey wrote:

As regard to the finalizer this was left in as a fail safe incase Dispose was not called by one of my implementing functions. Is the above not correct?

By the time your finalizer runs it's usually too late to call Dispose. If you're the only one holding a reference to the workflow object, it will probably be eligible for garbage collection and finalized at the same time.

Jason-Massey wrote:

I'm still unsure about releasing managed resources, and if I should be realising anything thats a reference type?

No you really only have to make sure you call Dispose on objects you own that provides such a method.

But what happens about reference type objects that don?? have a Dispose method.  I?? under the belief that if I turn of the garbage collector as in the above code, then these objects will not be released from memory with the garbage collector disabled, and I should at least set these objects to null.

Any light you can shed on the above I would be gratefull.

Objects that don't have a Dispose method don't need any additional cleanup. You haven't turned off the garbage collector, that's not possible.

Thanks for your help. Maybe i'm getting confused with what GC.SuppressFinalize actually does, I presumed this turned off the garbage collection for the whole object including any reference objects that had been declared. This meaning any reference objects must be set to null before the scope of the object is lost.

Coule you please clarify the above.