On what objects we should use dispose method ? C# 4.0

Question

Ok here i am going to list objects of my software. Currently memory usage is increasing by the time passes, though it should not increase because i am not keeping any resources. Using only database.

c# 4.0 , visual studio 2010

Lets start with objects. On these objects should i ever call dispose or use "using"

string variable;
int variable;
dataset variable;
HtmlDocument variable;
List<string> variable;
HtmlNode variable;
Uri variable;
DateTime variable;
HtmlWeb variable;
Regex variable;
MatchCollection variable;
bool variable;

piece of code (anything required after File.WriteAllText ? method)

                File.WriteAllText("hatalar/" + UtcTimeNow.Ticks.ToString() + GenerateRandomValue.GenerateRandomValueDefault(10000000) + ".txt", srCrawledUrl + " unknown error page id " + srPageId);

piece of code

                if (irFinishedLast > -1)
            {
                var newTask = Task.Factory.StartNew(() =>
                {
                    fcStartSubPageCrawl(srMainSiteURL, srMainSiteId, irWhichMainTask);
                });
                lock (lockerMainSitesArray)
                {
                    if (MainSitesTaskList[irWhichMainTask, irFinishedLast] != null)
                        MainSitesTaskList[irWhichMainTask, irFinishedLast].Dispose();
                    MainSitesTaskList[irWhichMainTask, irFinishedLast] = newTask;
                }
            }

Alright now classes and functions. Public static function which is being called by many threads at the same time. It is inside public static class.

public static string srInserIntoPagesCommand = "insert into myTable (PageUrl,MainSiteId,CrawlDateInt,CrawlDateChar,CrawlDepth,ExtractedPageId,CrawlStatus) values " +
            "(@PageUrl,@MainSiteId,@CrawlDateInt,@CrawlDateChar,@CrawlDepth,@ExtractedPageId,@CrawlStatus)";

        public static bool InsertIntoPages(string PageUrl, string MainSiteId, string CrawlDateInt, string CrawlDateChar, string CrawlDepth, string ExtractedPageId, string CrawlStatus)
        {
            string srPageUrl = PageUrl;
            string srMainSiteId = MainSiteId;
            string srCrawlDateInt = CrawlDateInt;
            string srCrawlDateChar = CrawlDateChar;
            string srCrawlDepth = CrawlDepth;
            string srExtractedPageId = ExtractedPageId;
            string srCrawlStatus = CrawlStatus;

            if (srCrawlDateInt.Length < 1)
                srCrawlDateInt = "0";
            if (srCrawlDateChar.Length < 1)
                srCrawlDateChar = "null";
            if (srCrawlStatus.Length < 1)
                srCrawlStatus = "0";

            using (SqlConnection connection = new SqlConnection(DbConnection.srConnectionString))
            {
                using (SqlCommand cmd = new SqlCommand(srInserIntoPagesCommand, connection))
                {
                    cmd.CommandType = CommandType.Text;
                    cmd.Parameters.AddWithValue("@PageUrl", srPageUrl);
                    cmd.Parameters.AddWithValue("@MainSiteId", srMainSiteId);
                    cmd.Parameters.AddWithValue("@CrawlDateInt", srCrawlDateInt);
                    cmd.Parameters.AddWithValue("@CrawlDateChar", srCrawlDateChar);
                    cmd.Parameters.AddWithValue("@CrawlDepth", srCrawlDepth);
                    cmd.Parameters.AddWithValue("@ExtractedPageId", srExtractedPageId);
                    cmd.Parameters.AddWithValue("@CrawlStatus", srCrawlStatus);
                    try
                    {
                        connection.Open();
                        cmd.ExecuteNonQuery();
                    }
                    catch (Exception E)
                    {
                        DateTime UtcTimeNow = DateTime.UtcNow;
                        File.WriteAllText("pageshatalar/" + UtcTimeNow.Ticks.ToString() + GenerateRandomValue.GenerateRandomValueDefault(1000000) + ".txt", "InsertIntoPages \r\n\r\n" + E.Message.ToString() + "\r\n\r\n" + srPageUrl);
                        return false;
                    }
                }
                connection.Close();
            }
            return true;
        }

public static database connection for select queries mostly inside public static class

public static string srConnectionString = "server=localhost;database=mydb;uid=sa;pwd=mypw; Max Pool Size=20000; Pooling=True;";

public static DataSet db_Select_Query(string strQuery)
{
    DataSet dSet = new DataSet();
    try
    {
        using (SqlConnection connection = new SqlConnection(srConnectionString))
        {
            connection.Open();
            using (SqlDataAdapter DA = new SqlDataAdapter(strQuery, connection))
            {
                DA.Fill(dSet);
            }
            connection.Close();
        }
        return dSet;
    }
    catch
    {
        DateTime UtcTimeNow = DateTime.UtcNow;
        File.WriteAllText("sqlhatalar/" + UtcTimeNow.Ticks.ToString() + GenerateRandomValue.GenerateRandomValueDefault(1000000) + ".txt", strQuery);
        return null;
    }
}

Answer 1

You don't randomly call dispose on any particular thing. The using statement and the .Dispose method are for objects that implement the interface IDisposable

 public interface IDisposable
 {
       void Dispose();
 }

A cursory inspection of your top variable list indicates that none of these variables implement IDisposable. You cannot invoke Dispose() on these, nor can you wrap them in the using statement.

Further, invoking Dispose() on actual disposable objects is not intended as a form of memory management, it is intended to release unmanaged resources. The garbage collector is not connected to this. If you have a problem with memory management, it might reveal that you are keeping too many objects alive for too long. You need to explore scoping and lifetimes, collection sizes, etc., as those are what will be adding to your garbage.

Your memory problem is not being revealed in your displayed code, except to say that you could be processing and returning large DataSets that your callers could further hold onto longer than necessary. Or it could be something else entirely unrelated to any of the code displayed. If you have a memory problem, run a memory profiler to identify the problem areas. To that end, you can get free trials of profilers from Red Gate or JetBrains.

Answer 2

You can't call Dispose() on most of the objects in your list because they do not expose a Dispose() method. You should call Dispose() on an object of any type that implements the IDisposable interface. That's it.

Answer 3

If for some bizarre reason you don't know at run-time if an object has dispose implemented, you can use this dispose-safe function:

/// ---- IsDisposable --------------------------------
///
/// <summary>
/// returns true if an object is disposable, false if not
/// you can optionally dispose of it immediately
/// </summary>

public static Boolean IsDisposable(Object Item, Boolean DeleteIfDisposable)
{
    if (Item is IDisposable)
    {
        if (DeleteIfDisposable)
        {
            IDisposable DisposableItem;
            DisposableItem = (IDisposable)Item;
            DisposableItem.Dispose();
        }
        return true;
    }
    else
        return false;
}