像C＃中的自定义集合一样的数据表

Question

In theory how would I do this.

short winded: store data like a datatable using custom collections, having variable amount of fields and columns...so long as the rows are consistent.

Long winded:

2 or 3 classes: field, row, optionally: table

Normally I would do something like List<Person> myList = new List<Person>; Then that list could be bound to a datagridview and the columns would be based off the properties of the Person class.

Code to look at:

List<row> table = new List<row>;
List<field> row0 = new List<field>;
row0.Add(new field(col1,"value1"));
row0.Add(new field(col2,"value2"));
row0.add(new field(col3,"value3"));
table.Add(row0);


dataGridView1.DataSource = table;

theoretical Output:

|    |col 1 | col 2| col 3|
___________________________
|row0|value1|value2|value3|



public class cField
{
    public string Name { get; set; }
    public string Content { get; set; }
    public cField()
    {
    }

    public cField(string name, string content)
    {
        Name = name;
        Content = content;
    }
}

public class cRow:BindingList<cField>
{
    public cRow()
    {
    }
}
public class tables:BindingList<cRow>
{

    public tables()
    {
        fillTestData();
    }

    private void fillTestData()
    {
        for (Int32 i = 0; i < 10; i++)
        {
            cRow tRow = new cRow();

                for (Int32 x=0; x < 3; x++)
                {
                    cField f1 = new cField("ColumnName" + x.ToString(), "content" + x.ToString());
                    tRow.Add(f1);
                }
                base.Items.Add(tRow);
        }                        
    }
}

//example class which shows the output of what I'd like.
public class eField
{
    public string ColumnName0 { get; set; }
    public string ColumnName1 { get; set; }
    public string ColumnName2 { get; set; }

    public eField(string colName0, string colName1, string colName2)
    {
        ColumnName0 = colName0;
        ColumnName1 = colName1;
        ColumnName2 = colName2;
    }
}

public class eTable : BindingList<eField>
{
    public eTable()
    {
        base.Add (new eField ("content","content", "content"));
        base.Add(new eField("content", "content", "content"));
        base.Add(new eField("content", "content", "content"));
    }
}

Now Here is code for the form.

public partial class Form1 : Form
{

    tables t;

    public Form1()
    {
        InitializeComponent();


    }

    private void Form1_Load(object sender, EventArgs e)
    {
        t = new tables ();

        dataGridView1.DataSource = t;

        dataGridView2.DataSource = t[0];

        eTable table3 = new eTable ();

        dataGridView3.DataSource = table3;

    }
}

If you make that code into a project...you will see the first binding....pulls some built in stuff from the bindinglist into grid1. Grid2 lists my fields vertically when I want them horizontal.

Grid 3 shows exactly how I want my output to be.....yet I can't achieve it with the collection structure I have going to mimic a dataTable....(provided in code)

Disclaimer: I am short on keywords I would need to research this problem. I didn't find much. The closest thing I found was related to linq and pivots. But non of their outputs seemed to be as I described.

I use custom collections all over the place, so I would like to keep my code very similar instead of using a datatable. This is the first time I have needed my collections to behave in this manner.

Answer 1

It sounds like you are looking for a collection of objects to use in memory once you have loaded the data from a database. You can do calculations and the like on the built-in System.Data objects, but it is cumbersome, and it does not perform well with a large amount of data.

We use System.Data objects heavily to present data. We try to do calculations in the database later and present the results as a DataSet, so the client doesn't have to do any data manipulation.

A few of our modules need more sophisticated data processing. In one case, we used an array of objects that represented a large amount of data to be massaged on the fly. The columns were fixed, so they were easy to implement as properties on each object. When the app presented this data, it generated a small summary DataSet to be displayed in a grid.

We have another module in which there are fields that can have values, or they can also have calculations based on other fields. For this model, we opted to use objects that have dependencies on other objects that made a sort of web of calculations. Change one value, and the ValueChanged event notifies any dependent fields that they need to be calculated, which changes those values, etc. (This is a gross simplification.)

If I had to present a variable number of columns, I'd seriously consider sticking with a System.Data.DataSet. If that really doesn't work for you, you might consider a hashtable that maps a column name to a collection of row values for that column. I believe that is how the System.Data.DataTable is implemented; it stores values by column, not by row. Then a row object would know its row index and how to grab the values out of the column collections.