How do I load data from an SQL database into a List<T> generic? I was thinking of creating a business object that inherits from List<T> but I can't seem to get it to work. The book is good at explaining the basics of this but I'm still not sure how I would use this kind of a generic in a real-world application. Is this something Microsoft forgot to handle?

List<T> is the generic definition of the list, but you must specify the type you will use for the instance of the list. Decide what business class you want to use and create an instance of the list with your type as the type parameter:

List<MyBusinessClass> myList = new List<MyBusinessClass>();
MyBusinessClass myClassInstance;

myClassInstance = new MyBusinessClass();
//populate the instance members
myList.Add(myClassInstance);
//loop as needed


You can certainly extend List<T> if you wish as well. This is a good method of creating a custom collection. When you extend it, you can define the type of the list you are extending and all the List methods will apply that type parameter. This creates a strongly typed collection from a generic collection.

public class MyBusinessClassList : List<MyBusinessClass>{
   // add your members here
}

Alternatively, if you want to add capabilities to a generic list, but still maintain the generic capability, you can define your own generic type that derives from List<T>:

public class MyBusinessClassList<T> : List<T>{
   // add your members here
}

In this case however, you are still working in the context of a generic type, so you are limited in what you can do. However, if you constrain your definition you can work with some base type or interface.

-Peter

Hi rvincent,

You may want to take a look at my article series about N-Layer design. The series deals with List<T> classes and other design and data access issues. You find part 1 here:

http://Imar.Spaanjaars.Com/QuickDocId.aspx?quickdoc=416

Cheers,

Imar

I guess I need to explain further. Here's what I've created:

using System;
using System.Collections.Generic;
using System.Text;
using System.Data.SqlClient;
using GeoRange;

namespace GeoRange
{
    public class Targets : List<Target>
    {
        public List<Target> Load()
        {
            List<Target> data = new List<Target>();

            string connectionString = @"Server=E17818\SQLEXPRESS;Database=test;Trusted_C onnection=true";

            SqlConnection myConnection = new SqlConnection(connectionString);

            SqlCommand myCommand = new SqlCommand("SELECT Name FROM Targets", myConnection);

            myConnection.Open();

            SqlDataReader reader = myCommand.ExecuteReader();

            while (reader.Read())
            {
                Target Target1 = new Target();

                Target1.Name = reader["Name"] as string;

                //Target.X = reader["X"] as double;

                //Target.Y = reader["Y"] as double;

                data.Add(Target1);
            }

            myConnection.Close();

            myCommand.Dispose();

            return data; // not returning the List

        }
    }
}

//++++++++++++++++++++++++++++++++++++++++++++++++++ +++
//++++++++++++++++++++++++++++++++++++++++++++++++++ +++


using System;
using System.Collections.Generic;
using System.Text;

namespace GeoRange
{
    public class Target
    {
        private string _name;
        private double _X;
        private double _Y;

        public string Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
            }
        }
        public double X
        {
            get
            {
                return _X;
            }
            set
            {
                _X = value;
            }
        }

        public double Y
        {
            get
            {
                return _Y;
            }
            set
            {
                _Y = value;
            }
        }

        public Target()
        {
        }

        public Target(string name, double X, double Y)
        {
            this._name = name;
            this._X = X;
            this._Y = Y;

        }



        }
    }

//++++++++++++++++++++++++++++++++++++++++++++++++++ +++
//++++++++++++++++++++++++++++++++++++++++++++++++++ +++

I then try to use these from a button on a form:

        private void button1_Click(object sender, EventArgs e)
        {

            List<Target> Targets = new List<Target>();

            Targets targetList = new Targets();
            targetList.Load();

            foreach (Target theTarget in targetList)
            {
                comboBox1.Items.Add(theTarget.Name);
            }

            //MessageBox.Show(Target1.Name, "A caption");
        }

This last part is the problem. targetList isn't returning the list. Anyone know why?

That is the most confusing few lines of code I've ever seen.
You create a new class Targets, which derives from List<Target>. You then create an instance of List<Target> also called Targets. You then create an instance of Targets called targetList.
You then do
where you create an instance of Target called theTarget for each Target in targetList.

My head's spinning...

Your method Load returns a List<Target> but you don't actually save the return when you call it.
Why don't you store the data in a private List<Target> instead of returning it?
Have you stepped through the Load method to see if data is being populated?



--

Joe (Microsoft MVP - XML)

Quick Joe! Bite the rope, BITE THE ROPE!! ;)

rvincent,

Joe has a point... Your code is a little confusing. That's the reason I use variable prefixing. I try to avoid naming variables with names that could conflict with class names (if not programmatically, then humanly).

As far as the problem goes... you need to either load the list you are extending or handle the return value of the Load() method as Joe mentioned.

I think what you need is this:
-Peter

Well, I am just learning. Thanks for making me feel like an idiot.

Thanks. That really helps me as I learn this.

That wasn't my intention, I was pointing out how difficult it is to follow the code the way it is written. If you are just beginning you have started with a fairly advanced topic, generics, inheritance and data access.
I would question the value of the derived class at all. You are tying yourself down somewhat especially having a SQL connection inside the class.
I would just use a List<T> to hold the Target instances. I would then have a helper class to perform the data access and return the appropriate DataReader. You can then loop through the reader and create the separate Target instances and add them to List<Target>: Alternatively go with your derived class TargetList deriving from List<Target> but change the Load method to accept a DataReader, this is a more flexible solution. During Load you just add Target instances to the underlying list by using the Add method.
Another option would be to write your own Collection class that just delegates all calls to a private List<Target>.

--

Joe (Microsoft MVP - XML)