I am using the Memory Management while returning the data like below.
private DataSet ReturnDs()
{
using (DataSet ds = new DataSet())
{
return ds;
}
}
Query - Is there any issue in placing the 'Using' Statement while returning the data? I am Still getting the complete schema as well as the data in the receiving function?
This is definitely a wrong pattern. The only reason that it is working for you now is that DataSet.Dispose() is actually a dummy.
using (DataSet ds = new DataSet())
{
return ds;
} // there is a ds.Dispose() here but it does nothing.
If you replace the DataSet with for instance an Enitity framework DbContext then you would not see any data in the calling function.
In general terms, disposing an object you are about to return is an error: your code hasn't finished with that object, and yo will be handing a broken object to the caller.
So indeed: don't Dispose() that, which means: don't use using on an object you will return. It is up to the caller to dispose it: they are the owner now. Of course, this should ideally be documented in the API.
More generally, though, you need to think about exceptions too. What happens if your method errors? For complex scenarios, you may need something like:
SomeType foo = null;
try {
// initialize and populate foo - this could error half-way through
return foo;
} catch {
if(foo != null) foo.Dispose();
throw;
}
to ensure that the object is disposed correctly in the failure case.
Use the using statement in the calling method, not the method returning the object.
public void Caller()
{
using(DataSet ds = GetDataSet())
{
// code here
}
}
public DataSet GetDataSet()
{
// don't use a using statement here
return ds;
}
The using statement is basically the same as doing this:
DataSet ds = null;
try
{
// code here
}
finally
{
if(ds != null)
{
ds.Dispose();
ds = null;
}
}
So, if you used a using statement in a method that is supposed to return the object in the using statement, it would return a Disposed object (i.e. closed stream, closed dataset, etc...)which means some of the internal objects could be null, or closed. In other words, all of the internal resources would be cleaned up, which is the purpose of implementing IDisposable in the first place. If your application relied upon some of these internal resources to be available, for example when using a Stream object, it would throw an exception.
Also keep in mind that not all finally blocks are written the same. Remember, IDispoable was implemented to clean up any INTERNAL resources and unmanaged objects. Those internal resources may not be needed outside the using statement, so sometimes using the using statement as you have may appear to work properly but it is not recommended, and definately won't work with all objects. If Microsoft decided to change the DataSet object in a future release, disposing of something vital to your application, then your working code would suddenly stop working.
I'm not sure what exactly your question is.
Once the method ends by retunring something, ds.Dispose() will automatically be called.
This means that the DataSet your method returns will already be disposed when your calling method receives it.
as Mert comment, note that you're disposing the object you're return. but basically, the using is actually a try/finally and the dispose will be called the method return. The effect is depends on the IDisposable implementation for each type. usually, you're not suppose to dispose (kill) the entity you're return to caller that probably gonna use it.
