Would you utilise "Using" on a member which is going to be added to a list? I have an interface and a concrete class which I am using in the code below:

    /// &lt;summary&gt;
    /// Converts a DataSet read from the DB to a list of objects of a type
    /// TemplatePart. 
    /// &lt;/summary&gt;
    /// &lt;param name="templatePartDataSet"&gt;DataSet containing the information.
    /// &lt;/param&gt;
    /// &lt;returns&gt;List of unprocessed TemplateParts.&lt;/returns&gt;
    private static List&lt;ITemplatePart&gt; DataSetToTemplatePart(DataSet templatePartDataSet)
    {
        var rawTemplateParts = new List&lt;ITemplatePart&gt;();
        foreach (DataTable table in templatePartDataSet.Tables)
        {
            var tableName = table.ToString();

            foreach (DataRow row in table.Rows)
            {
                if (string.IsNullOrEmpty(
                    row.Field&lt;string&gt;(Strings.TemplateSpreadSheet_Column_PartName)))
                {
                    continue;
                }

                // THE LINE RELATED TO MY QUESTION.
                var rawTemplatePart = TemplatePart.CreateTemplatePart(table, row);
                rawTemplateParts.Add(rawTemplatePart);
            }
        }
        return rawTemplateParts;
    }


TemplatePart is a simple class with 4 properties with the definition of:

{
    public class TemplatePart : ITemplatePart
    {
        #region Creator

        internal static TemplatePart CreateTemplatePart(DataTable table, DataRow row)
        {
            return new TemplatePart
            {
                PartName = row.Field&lt;string&gt;(Strings.TemplateSpreadSheet_Column_PartName),
                BasePart = row.Field&lt;string&gt;(Strings.TemplateSpreadSheet_Column_BasePart)
            };
        }

        #endregion // Creator

        #region Public Properties

        public string PartName { get; set; }
        public string BasePart { get; set; }
        public double? PriceDom { get; set; }
        public double? PriceInt { get; set; }

        #endregion // Public Properties
    }
}


and the ITemplatePart as: 

namespace PriorityPriceGenerator2.Model.TemplatePart
{
    interface ITemplatePart
    {
    }
}


of course the interface hasn't been implemented completely. And also the concrete class doesn't have the IDisposable yet.

Would you prefer (/if it's necessary or even totally wrong) to do such thing in the marked line.

using (var rawTemplatePart = TemplatePart.CreateTemplatePart(table, row))
    rawTemplateParts.Add(rawTemplatePart);


And why? I want to know what happens to a member added to the list which is in the Using. Would it get destroyed and recreated in the List? Would it get destroyed because of using after I am done with the List ?

And please, 
let me know if you see any other issues.
No, you shouldn't use using on the object that you add to the list.

When you add the object to the list, it's just the reference to the object that gets added. There is no copy of the object created for the list.

If you use using on the object, it will be disposed at the end of the code block, which is a single statement in your example. Right after you have added the object to the list it will be disposed.

Although nothing happens automatically when you dispose an object, it's customary that the object should be unusable after the Dispose method has been called. The IDisposable interface is intended for controlling the lifespan of objects, usually to free unmanaged resources when you are done using the object.

After you are done using the objects in the list, you should dispose them.

However, from what I can tell there isn't going to be any unmanaged resources in your object, so there wouldn't be any need for it to implement IDisposable. The (supposedly) database related objects are only used during the creation of the object, and so far there are nothing unmanaged in the class.