Implementation of Generic SQL Data Reader I am using below virtual method to read the data from SQL Data Reader like:

public IList&lt;District&gt; GetList()
{
    IList&lt;District&gt; _list = new List&lt;District&gt;();

    SqlConnection con = new SqlConnection(ConStr);
    try
    {
        string StoreProcedure = ConfigurationManager.AppSettings["SP"].ToString();

        SqlCommand cmd = new SqlCommand(StoreProcedure, con);
        cmd.CommandType = CommandType.StoredProcedure;
        con.Open();
        SqlDataReader rdr = cmd.ExecuteReader();
        _list = new GenericReader&lt;District&gt;().CreateList(rdr);
        rdr.Close();
        con.Close();
    }
    finally
    {
        IsConnectionOpenThenClose(con);
    }
    return _list;
}


District Class:

public class District
{
    public int id { get; set; }
    public string name { get; set; }
}


And GenericReader Class as:

public class GenericReader&lt;T&gt;
{
    public virtual List&lt;T&gt; CreateList(SqlDataReader reader)
    {
        var results = new List&lt;T&gt;();

        while (reader.Read())
        {
            var item = Activator.CreateInstance&lt;T&gt;();
            foreach (var property in typeof(T).GetProperties())
            {
                if (!reader.IsDBNull(reader.GetOrdinal(property.Name)))
                {
                    Type convertTo = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
                    property.SetValue(item, Convert.ChangeType(reader[property.Name], convertTo), null);
                }
            }
            results.Add(item);
        }
        return results;
    }
}


Is this approach is better or still, we can refactor?
GetList()  


SqlConnection, SqlCommand and SqlDataReader are all implementing the IDisposable interface hence you should either call Dispose()  on that objects or enclosing them in a using block.  
You should use var instead of the concrete type if the right-hand-side of an assignment makes the concrete type obvious.
E.g the line SqlConnection con = new SqlConnection(ConStr); we can see at first glance that the concrete type   is SqlConnection and therfor we should use var con = new SqlConnection(ConStr); instead.
Using abbreviations for naming things shouldn't be done because it makes reading and maintaining the code so much harder.  
Underscore-prefixed variablenames are usually used for class-level variables. Method-scoped variables should be named using camelCase casing hence list would be better than _list because Sam the maintainer wouldn't wonder about it.  
You return an IList&lt;&gt; which is good because coding against interfaces is the way to go.