Generic Asp.Net Table UserControl - asp.net

Question

I want to design a table user control and dynamically add the properties of custom objects. I want to populate this table with a collection object with a generic type. How can I do that ? I can not send the properties of the class to PopulateTable with its custom headers.
What I have so far (in a usercontrol) is..
<table class="datatable">
<thead>
<asp:Literal id="ltrlHeaders" runat="server" />
</thead>
<tbody>
<asp:Literal runat="server" ID="ltrlContent" />
</tbody>
</table>
public void PopulateTable(? myCollection)
{
List<string> headers = new List<string>();
FieldInfo[] fields = type.GetFields();
foreach (FieldInfo f in fields)
{
headers.Add(f.Name);
}
// headers
StringBuilder headerString = new StringBuilder();
headerString.Append("<thead>");
headers.ForEach(delegate(string h)
{
headerString.Append(String.Format("<th>{0}</th>", h));
});
headerString.Append("</thead>");
ltrlHeaders.Text = headerString.ToString();
StringBuilder contentString = new StringBuilder();
foreach (var item in list)
{
contentString.Append("<tr>");
foreach (string fieldInfo in headers)
{
contentString.Append(String.Format("<td>{0}</td>", type.GetField(fieldInfo).GetValue(item) as string));
}
contentString.Append("</tr>");
}
ltrlContent.Text = contentString.ToString();
}

Answer 1

public void PopulateTable<T>(T myCollection)
Assuming that T objects can be cast to string. Or you might want:
public void PopulateTable<T>(IEnumerable<T> myCollection)
if you wanted to be able to pass a collection and know something about its interface.

Answer 2

A very simple method to do what you want might look like this. I've updated it with a List of Person as defined in my code. Note that I've also included a class derived from Person so you can see other properties.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Reflection;
public partial class _Default : System.Web.UI.Page
{
public class Person
{
public string Name { get; set; }
public string Title { get; set; }
}
public class WorkingPerson : Person
{
public string Job { get; set; }
}
protected void Page_Load(object sender, EventArgs e)
{
List<Person> people = new List<Person>();
people.Add(new Person() {Name = "T", Title = "Mr" }) ;
people.Add(new WorkingPerson() {Name="Face", Title="Mr", Job ="Film Star" } );
TextBox textBox = new TextBox();
Controls.Add(CreateTableFromObject<Person>(people));
}
public PlaceHolder CreateTableFromObject<T>(IEnumerable<T> objectList) where T : Person
{
PlaceHolder holder = new PlaceHolder();
foreach (T thing in objectList)
{
Table table = new Table();
PropertyInfo[] properties = thing.GetType().GetProperties();
TableRow propertiesSpan = new TableRow();
propertiesSpan.Cells.Add(new TableCell() { ColumnSpan = properties.Length, Text = String.Format("Properties of {0}", thing.GetType().FullName) });
table.Rows.Add(propertiesSpan);
TableRow tableRow = new TableRow();
foreach (PropertyInfo propertyInfo in properties)
{
TableCell tc = new TableCell();
tc.Text = propertyInfo.Name;
tableRow.Cells.Add(tc);
}
table.Rows.Add(tableRow);
holder.Controls.Add(table);
}
return holder;
}
}
This effectively takes an object, uses reflection to discover its properties, and then writes them out to table cells. You can change the signature to accept your custom collection, and modify the internals to render your table.