Программное создание шаблонов серверных элементов управления

Источник: Gotdotnet

Майк Попп (Mike Pope), Никил Котари (Nikhil Kotha)

Аннотация

Демонстрируется, как программно создавать шаблоны для серверных ASP.NET-элементов управления Repeater, DataList и DataGrid; даны примеры на Visual Basic .NET и Visual C# .NET.

Содержание

Статья поделена на разделы, в каждом из которых демонстрируются все более сложные способы создания шаблонов (templates). Например, из первого раздела вы узнаете, как создавать в коде простейшие наблоны. В последующих разделах этот шаблон усложняется, к нему добавляется новая функциональность. К концу статьи вы научитесь создавать полнофункциональный шаблон, способный к связыванию с данными (data binding).

Введение
Базовые сведения о программном создании шаблонов
Добавление шаблонов других типов
Добавление в шаблон поддержки связывания с данными
Программное создание шаблонов в элементе управления DataGrid
Заключение

Требования

Эта статья предполагает, что вы знаете, как создавать страницы на основе Web-форм (Web Forms) и серверных элементов управления ASP.NET. Кроме того, предполагается, что вы хотя бы экспериментировали в Web Forms Designer с созданием шаблонов для ASP.NET-элементов Repeater или DataList. Базовую информацию о шаблонах см. по ссылке Web Server Controls Templates.

Наконец, предполагается, что вы умеете связывать элементы управления на страницах - Web-формах с данными. Базовую информацию о связывании с данными см. в документации Microsoft® Visual Studio® .NET (Web Forms Data Binding).

Введение

Серверные элементы управления ASP.NET Repeater, DataList и DataGrid рассчитаны на связывание с данными (data binding). Они генерируют один элемент (item) (например, строку) для каждого элемента (element) в связанном с ними источнике данных. Разметка данных определяется шаблонами. Шаблон - это контейнер для других элементов управления, не имеющий собственного пользовательского интерфейса (UI). Чтобы выводить информацию, к шаблону нужно добавить элементы управления и настроить их свойства, определяющие внешний вид (display properties) (обычно через связывание с данными). Во время своей работы элемент управления перебирает элементы в источнике данных и для каждого из них создает свой элемент, соединяющий элементы управления в шаблоне с информацией в элементе данных.

Элементы управления Repeater и DataList позволяют выводить результат в более свободной форме: элементами могут быть строки таблицы, пункты маркированного списка, элементы списка, разделенные запятыми, или что угодно еще. Элемент управления DataGrid использует предопределенный формат - сетку (grid). Каждый элемент данных соответствует строке в сетке. При отображении элемента управления каждый элемент показывается как строка таблицы.

Определение шаблонов

Если вы работаете с элементами управления Repeater, DataList или DataGrid на странице Web Forms, создать шаблон на этапе разработки несложно. DataList поддерживает окно редактирования в стиле WYSIWYG. Что касается Repeater, его шаблоны создаются в окне просмотра HTML (HTML view) в виде специальных элементов, вложенных в элемент управления. Для создания нового шаблонного столбца в элементе управления DataGrid воспользуйтесь окном Properties.

Но это предполагает, что шаблоны создаются на этапе разработки. По разным причинам иногда на этом этапе не известно, какие шаблоны понадобятся или какой в них нужен текст и элементы управления. В этом случае надо создавать шаблоны "на лету". А для этого следует понять основные принципы создания классов и связывания с данными в Web Forms. В этом вам и поможет данная статья.

Примечание. Кроме того, можно создавать шаблоны в виде пользовательских элементов управления Web Forms и динамически связывать их с элементами управления на странице. Более подробную информацию см. в Creating a Templated User Control в документации .NET Framework SDK.

Базовые сведения о программном создании шаблонов

Для начала рассмотрим, как создать простейший шаблон в коде. Для этого нужно выполнить следующие выражения:


' Visual Basic
Repeater1.ItemTemplate = New MyTemplate()
// C#
Repeater1.ItemTemplate = new MyTemplate();

Как видите, здесь создается экземпляр класса MyTemplate. Откуда берется этот класс шаблона? Вы сами его и создаете.

Примечание. Шаблоны для DataGrid создаются в коде чуть иначе, так как в этом случае вы создаете столбец. Дополнительные сведения вы найдете в конце статьи. Однако большинство сведений о элементах управления DataList и Repeater относятся и к DataGrid.

Базовый класс шаблона

Класс шаблона относительно прост. Как минимум, в нем нужно:

объявить, что ваш класс реализует интерфейс ITemplate из пространства имен System.Web.UI;
реализовать метод InstantiateIn (единственный член этого интерфейса). С помощью этого метода экземпляры элементов управления и текст помещаются в указанный контейнер.
Примечание. Базовую информацию о создании классов в Microsoft Visual Basic® .NET см. в разделе Understanding Classes документации Visual Studio .NET. Аналогичные сведения по Microsoft Visual C#™ .NET см. в class.

Конечно, смысл шаблона - в выводе текста и элементов управления для каждого элемента в источнике данных. Это делается в методе класса InstantiateIn, именно там создается UI шаблона.

Обычно сценарий работы с этим методом таков: вы создаете новый элемент управления, настраиваете необходимые свойства, а затем добавляете его в набор (cillection) Controls родительского элемента. Статический текст напрямую добавить в этот набор нельзя, но вы можете создать элементы управления Literal или LiteralControl, настроить их свойства Text и добавить их к родительскому набору. Метод InstantiateIn передает ссылку на родительский элемент управления (элемент управления Repeater, DataList или DataGrid), что упрощает последний шаг.

Ниже приведен полный класс шаблона, выводящего статический текст ("Item number:") и счетчик. Счетчик хранится в разделяемой или статической (в зависимости от языка программирования) переменной класса itemcount и увеличивается на 1 при каждом создании нового элемента.


' Visual Basic
Public Class MyTemplate
   Implements ITemplate
   Shared itemcount As Integer = 0
   Sub InstantiateIn(ByVal container As Control) _
         Implements ITemplate.InstantiateIn
      Dim lc As New Literal()
      lc.Text = "Item number: " & itemcount.ToString & "<BR>"
      itemcount += 1
      container.Controls.Add(lc)
   End Sub
End Class
// C#
private class MyTemplate : ITemplate
{
   static int itemcount;
   public void InstantiateIn(System.Web.UI.Control container)
   {
      Literal lc = new Literal();
      lc.Text = "Item number: " + itemcount.ToString() + "<BR>";
      itemcount += 1;
      container.Controls.Add(lc);
   }
}

Тестирование класса шаблона

Чтобы посмотреть, как работает наш класс, протестируйте его с элементом управления Repeater. Начните с создания новой страницы на основе Web Forms и выполните следующие действия.

Добавьте элемент управления Repeater.
Добавьте объект соединения с данными и адаптер данных. Для этого теста тип данных не важен.
Создайте набор данных (dataset), схема которого совпадает с SQL-запросом в созданном адаптере данных. Там хранятся данные, выводимые в элементе управления.
Совет. Если вы пользуетесь Visual Studio, перетащите адаптер данных на страницу и создайте соединение с помощью мастера. Затем вызовите команду Generate Dataset из меню Data и создайте типизированный набор данных.
Присвойте свойству DataSource элемента управления Repeater созданный набор данных и запишите в свойство DataMember имя таблицы в наборе данных.

Теперь вы готовы к созданию класса шаблона. Выполните следующие действия.

Скопируйте последний пример, приведенный выше, и вставьте его в код страницы.

Страница со вставленным классом выглядит примерно так (вставленный код выделен):


' Visual Basic
Public Class WebForm1
   Inherits System.Web.UI.Page
   ' прочие операторы наследования
   Private Class MyTemplate
      Implements ITemplate
      Dim itemcount As Integer = 0
      Sub InstantiateIn(ByVal container As Control) _
            Implements ITemplate.InstantiateIn
         Dim lc As New Literal()
         lc.Text = "Item number: " & itemcount.ToString & "<BR>"
         itemcount += 1
         container.Controls.Add(lc)
      End Sub
   End Class
' и т. д.
// C#
using System;
using System.Collections;
// прочие пространства имен
namespace myproject
{
   public class WebForm1 : System.Web.UI.Page
   {
   protected System.Data.SqlClient.SqlDataAdapter sqlDataAdapter1;
   // прочие объявления
   public class MyTemplate : ITemplate
   {
      int itemcount;
      public void InstantiateIn(System.Web.UI.Control container)
      {
      Literal lc = new Literal();
      lc.Text = "Item number: " + itemcount.ToString() + "<BR>";
      itemcount += 1;
      container.Controls.Add(lc);
      }
   }
// и т. д.

Добавьте к обработчику Page_Load код, создающий экземпляр класса шаблона, и присвойте его свойству ItemTemplate элемента управления Repeater.

Наконец, в обработчике Page_Load заполните набор данных и вызовите метод DataBind элемента управления Repeater.

После этого обработчик Page_Load будет выглядеть примерно так (код, добавленный на этапах 2 и 3, выделен):


' Visual Basic
Private Sub Page_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
   Repeater1.ItemTemplate = New MyTemplate()
   SqlDataAdapter1.Fill(DataSet11)
   Repeater1.DataBind()
End Sub
// C#
private void Page_Load(object sender, System.EventArgs e)
{
   Repeater1.ItemTemplate = new MyTemplate();
   sqlDataAdapter1.Fill(dataSet11);
   Repeater1.DataBind();
}

Запустите страницу.
Вы увидите список, каждой строке которого соответствует один элемент из источника данных.

Добавление шаблонов других типов

Вышеприведенные примеры демонстрируют работу с единственным шаблоном, а именно: с шаблоном элемента (item template). Из этого раздела вы узнаете, как создавать более сложную версию класса шаблона, позволяющую указывать шаблон заголовка (header template), шаблон нижнего колонтитула (footer template), шаблон переменного элемента (alternating item template) (для Repeater и DataList) и т. д.

Во-первых, можно создать отдельный класс шаблона для каждого типа шаблона или базовый класс шаблона и производные от него классы для различных типов шаблонов. Это может оказаться практичным, если шаблоны очень сложны или сильно отличаются друг от друга.

С другой стороны, можно воспользоваться одним классом для всех элементов и указывать, каков тип создаваемого шаблона. Для этого классу следует передать соответствующее значение. На самом деле, подойдут значения из перечисления ListItemType, уже определенного для типов шаблонов в элементах управления Repeater, DataList и DataGrid.

Приведенный ниже пример - усовершенствованная версия предыдущего кода. Теперь класс содержит явный конструктор, который принимает строку, определяющую тип шаблона. Для выяснения типа создаваемого шаблона в методе InstantiateIn применяется оператор Select Case или switch в зависимости от языка программирования. Чтобы показать преимущества создания шаблонов различного типа, в примере создается таблица с разным цветом фона для шаблона переменного элемента (alternating item template).


' Visual Basic
Private Class MyTemplate
   Implements ITemplate
   Shared itemcount As Integer = 0
    Dim TemplateType As ListItemType
    Sub New(ByVal type As ListItemType)
        TemplateType = type
    End Sub
   Sub InstantiateIn(ByVal container As Control) _
         Implements ITemplate.InstantiateIn
      Dim lc As New Literal()
      Select Case TemplateType
         Case ListItemType.Header
                lc.Text = "<TABLE class=borderall><TR><TH>Items</TH></TR>"
         Case ListItemType.Item
            lc.Text = "<TR><TD>Item number: " & itemcount.ToString _
               & "</TD></TR>"
         Case ListItemType.AlternatingItem
            lc.Text = "<TR><TD bgcolor=lightblue>Item number: " _
               & itemcount.ToString & "</TD></TR>"
         Case ListItemType.Footer
            lc.Text = "</TABLE>"
      End Select
      container.Controls.Add(lc)
      itemcount += 1
   End Sub
End Class
// C#
public class MyTemplate : ITemplate
{
   static int itemcount = 0;
   ListItemType templateType;
   public MyTemplate(ListItemType type)
   {
      templateType = type;
   }
   public void InstantiateIn(System.Web.UI.Control container)
   {
      Literal lc = new Literal();
      switch( templateType )
      {
         case ListItemType.Header:
            lc.Text = "<TABLE class=borderall><TR><TH>Items</TH></TR>";
            break;
         case ListItemType.Item:
            lc.Text = "<TR><TD>Item number: " + itemcount.ToString() +
               "</TD></TR>";
            break;
         case ListItemType.AlternatingItem:
            lc.Text = "<TR><TD bgcolor=lightblue>Item number: " +
               itemcount.ToString() + "</TD></TR>";
            break;
         case ListItemType.Footer:
            lc.Text = "</TABLE>";
            break;
      }
      container.Controls.Add(lc);
      itemcount += 1;
   }
}

Для создания разных шаблонов используется примерно такой код:


' Visual Basic
Private Sub Page_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
   Repeater1.HeaderTemplate = New MyTemplate(ListItemType.Header)
   Repeater1.ItemTemplate = New MyTemplate(ListItemType.Item)
   Repeater1.AlternatingItemTemplate = _
      New MyTemplate(ListItemType.AlternatingItem)
   Repeater1.FooterTemplate = New MyTemplate(ListItemType.Footer)
   SqlDataAdapter1.Fill(DataSet11)
   Repeater1.DataBind()
End Sub
// C#
private void Page_Load(object sender, System.EventArgs e)
{
   Repeater1.HeaderTemplate = new MyTemplate(ListItemType.Header);
   Repeater1.ItemTemplate = new MyTemplate(ListItemType.Item);
   Repeater1.AlternatingItemTemplate =
      new MyTemplate(ListItemType.AlternatingItem);
   Repeater1.FooterTemplate = new MyTemplate(ListItemType.Footer);
   sqlDataAdapter1.Fill(dataSet11);
   Repeater1.DataBind();
}

Добавление в шаблон поддержки связывания с данными

Сейчас наш класс шаблона способен выводить только статические данные. В этом разделе мы дополним его поддержкой включения данных из источника.

Обращаться к данным из класса шаблона можно по-разному, в зависимости от способа создания класса. По-хорошему архитектура страницы сама должна реализовать связывание с данными. Добавляя элементы управления к шаблону, вы добавляете и обработчик события DataBinding. Оно вызывается после того, как шаблон создаст все свои элементы управления.

Примечание. Возможно, вы полагаете, что выражение связывания с данными можно встроить просто в виде строки при создании элементов управления в шаблоне - точно так же, как и при определении шаблонов на этапе разработки. Но ничего не выйдет: оказывается, выражения связывания с данными превращаются в код при обработке страницы, т. е. до создания шаблона.

В обработчике события DataBinding вы можете управлять содержимым элемента управления. Обычно (но не обязательно) данные откуда-то загружаются и записываются в свойство Text элемента управления.

Примечание. Базовую информацию о связывании данных на страницах Web Forms см. в документации Visual Studio .NET по ссылке Web Forms Data Binding.

Связывание обработчика событий с элементами управления

Начните со связывания обработчика событий с создаваемыми в шаблоне элементами управления. В приведенном ниже фрагменте элемент управления в шаблоне связывается с обработчиком TemplateControl_DataBinding. (Код самого обработчика вы добавите позже.)


' Visual Basic
      Case ListItemType.Item
         lc.Text = "<TR><TD>"
         AddHandler lc.DataBinding, AddressOf TemplateControl_DataBinding
// C#
      case ListItemType.Item:
         lc.Text = "<TR><TD>";
         lc.DataBinding += new EventHandler(TemplateControl_DataBinding);
         break;

Примечание. Дополнительную информацию о динамическом добавлении обработчиков событий см. AddHandler and RemoveHandler (для Visual Basic) и Events Tutorial (для Visual C#) в документации Visual Studio .NET.

Обратите внимание, что в этом примере текст, добавляемый к строковому свойству Text элемента управления, отличается от текста в предыдущем. Он содержит только начало строки таблицы и ячейки для шаблона элемента. Ячейку и строку мы закончим в обработчике события связывания с данными.

Создание обработчика события

Теперь нам нужен обработчик, вызываемый при связывании элемента управления с данными. Обработчик является частью класса шаблона и ничем не отличается от других методов класса (вроде InstantiateIn).

Сигнатура обработчика показана в следующем примере. Имя обработчика должно совпадать с именем, указанном при связывании с обработчиком.


' Visual Basic
Private Sub TemplateControl_DataBinding(ByVal sender As Object, _
ByVal e As System.EventArgs)
// C#
private void TemplateControl_DataBinding(object sender,
System.EventArgs e)

При вызове метода вы передаете в аргументе sender ссылку на элемент управления, поэтому можете настраивать его свойства. Так как этот аргумент имеет тип object, его надо привести к элементу управления правильного типа (в нашем примере - к Literal).

Как получить доступ к данным? Для каждого элемента в источнике данных Repeater, DataList или DataGrid создает один элемент, содержимое которого основывается на шаблоне. Каждый такой элемент содержит свойство DataItem, обеспечивающее доступ к данным для этого элемента (т. е. к соответствующей строке данных).

Однако при вызове обработчика события связывания с данными вы имеете дело с конкретным элементом управления, а не с шаблонным элементом. Поэтому вам придется пройти по иерархическому дереву вверх от элемента управления к элементу шаблона. Лучше всего для этого подходит свойство элемента управления NamingContainer, возвращающее ссылку на элемент шаблона, в котором создан этот элемент управления. (Кроме того, ссылку на контейнер хранит свойство Parent. Однако, если элемент управления вложен в другой - например, в Panel или Table, - это свойство не вернет ссылку на элемент шаблона.)

Таким образом, чтобы связать элемент управления в шаблоне с конкретными данными, необходимо предпринять следующие действия.

Получите ссылку на элемент шаблона. Создайте переменную и запишите в нее значение свойства NamingContainer.
Используя эту ссылку, получите свойство DataItem именующего контейнера (naming container), т. е. шаблонного элемента.
Извлеките индивидуальный элемент данных (например, столбец) из объекта DataItem и настройте свойство связываемого элемента управления в соответствии с данными в нем.

Следующий код демонстрирует один из способов выполнения требуемых действий (за основу взяты ранее приведенные примеры). Это полный обработчик события связывания с данными для элементов управления Literal, созданных для шаблонов.

Код создает переменную container типа RepeaterItem (так как мы работаем с элементом управления Repeater) и присваивает ее свойству NamingContainer связываемого элемента управления. Теперь по этой ссылке можно обратиться к DataItem контейнера-объекта. Это легко сделать, вызвав метод Eval объекта DataBinder (этот же метод часто применяется в выражениях связывания с данными) и передав ему ссылку на объект DataItem контейнера и имя требуемого поля.

Если в ваших шаблонах содержатся элементы управления множества типов, создайте обработчик события связывания с данными для каждого типа элемента управления.


' Visual Basic
Private Sub TemplateControl_DataBinding(ByVal sender As Object, _
ByVal e As System.EventArgs)
   Dim lc As Literal
   lc = CType(sender, Literal)
   Dim container As RepeaterItem
   container = CType(lc.NamingContainer, RepeaterItem)
   lc.Text &= DataBinder.Eval(container.DataItem, "CategoryName")
   lc.Text &= "</TD></TR>"
End Sub
// C#
private void TemplateControl_DataBinding(object sender,
System.EventArgs e)
{
   Literal lc;
   lc = (Literal) sender;
   RepeaterItem container = (RepeaterItem) lc.NamingContainer;
   lc.Text += DataBinder.Eval(container.DataItem, "CategoryName");
   lc.Text += "</TD></TR>";
}

Программное создание шаблонов в элементе управления DataGrid

Вышеописанная процедура работает для элементов управления Repeater и DataList. Кроме того, можно программно создавать шаблоны для элемента управления DataGrid. Процесс создания собственно шаблона ничем не отличается. Но есть различия в его использовании:

шаблон создается не для сетки, а для столбца сетки;
шаблоны для столбцов DataGrid отличаются от шаблонов для элементов Repeater или DataList. Столбец DataGrid не содержит переменного элемента (alternating item) или шаблона разделителя. Однако, как и элемент управления DataList, он содержит шаблон EditItem.

Коротко: в элементе управления DataGrid разрешены следующие типы столбцов:

связанные столбцы - созданные из конкретных элементов в источнике данных;
столбцы-кнопки - столбцы с предопределенными кнопками (Edit, Update, Cancel, Delete или Select);
столбцы-ссылки - столбцы, каждый элемент которых является ссылкой на URL, заданный на этапе разработки;
шаблонные столбцы - столбцы на основе шаблонов.

Наверное, вы уже догадались, что именно для столбцов последнего типа программно создаются шаблоны. Другими словами, если вы хотите изменять элементы управления в столбце DataGrid на этапе выполнения, вам следует использовать шаблонные столбцы и создавать шаблоны "на лету".

В следующем примере показано, как создать два шаблона для элемента управления DataGrid и назначить их столбцам. Вначале создаются шаблоны, практически так же, как и в предыдущих примерах. Однако есть два небольших отличия. Во-первых, конструктор класса шаблона принимает два параметра; во втором параметре передается имя создаваемого столбца. Во-вторых, в этот пример включен код, создающий шаблон EditItem, который создает элемент управления Textbox.


' Visual Basic
Private Class DataGridTemplate
   Implements ITemplate
   Dim templateType As ListItemType
   Dim columnName As String
   Sub New(ByVal type As ListItemType, ByVal ColName As String)
      templateType = type
      columnName = ColName
   End Sub
   Sub InstantiateIn(ByVal container As Control) _
        Implements ITemplate.InstantiateIn
      Dim lc As New Literal()
      Select Case templateType
         Case ListItemType.Header
            lc.Text = "<B>" & columnName & "</B>"
            container.Controls.Add(lc)
         Case ListItemType.Item
            lc.Text = "Item " & columnName
            container.Controls.Add(lc)
         Case ListItemType.EditItem
            Dim tb As New TextBox()
            tb.Text = ""
            container.Controls.Add(tb)
         Case ListItemType.Footer
            lc.Text = "<I>Footer</I>"
            container.Controls.Add(lc)
      End Select
   End Sub
End Class
// C#
public class DataGridTemplate : ITemplate
   {
      ListItemType templateType;
      string columnName;
      public DataGridTemplate(ListItemType type, string colname)
      {
         templateType = type;
         columnName = colname;
      }
      public void InstantiateIn(System.Web.UI.Control container)
      {
         Literal lc = new Literal();
         switch(templateType)
         {
            case ListItemType.Header:
               lc.Text = "<B>" + columnName + "</B>";
               container.Controls.Add(lc);
               break;
            case ListItemType.Item:
               lc.Text = "Item " + columnName;
               container.Controls.Add(lc);
               break;
            case ListItemType.EditItem:
               TextBox tb = new TextBox();
               tb.Text = "";
               container.Controls.Add(tb);
               break;
            case ListItemType.Footer:
               lc.Text = "<I>" + columnName + "</I>";
               container.Controls.Add(lc);
               break;
         }
      }
   }

В следующем примере демонстрируется создание шаблонов столбцов и назначение их столбцам.


' Visual Basic
Private Sub Page_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
   Dim tc1 As New TemplateColumn()
   tc1.HeaderTemplate = New _
      DataGridTemplate(ListItemType.Header, "Column1")
   tc1.ItemTemplate = New DataGridTemplate(ListItemType.Item, "Column1")
   tc1.EditItemTemplate = New _
      DataGridTemplate(ListItemType.EditItem, "Column1")
   tc1.FooterTemplate = New _
      DataGridTemplate(ListItemType.Footer, "Column1")
   DataGrid1.Columns.Add(tc1)
  
   Dim tc2 As New TemplateColumn()
   tc2.HeaderTemplate = New _
      DataGridTemplate(ListItemType.Header, "Column2")
   tc2.ItemTemplate = New DataGridTemplate(ListItemType.Item, "Column2")
   tc2.EditItemTemplate = New _
      DataGridTemplate(ListItemType.EditItem, "Column2")
   tc2.FooterTemplate = New _
      DataGridTemplate(ListItemType.Footer, "Column2")
   DataGrid1.Columns.Add(tc2)
   SqlDataAdapter1.Fill(DsCategories1)
   DataGrid1.DataBind()
End Sub
// C#
private void Page_Load(object sender, System.EventArgs e)
{
   TemplateColumn tc1 = new TemplateColumn();
   tc1.HeaderTemplate = new
      DataGridTemplate(ListItemType.Header, "Column1");
   tc1.ItemTemplate = new DataGridTemplate(ListItemType.Item, "Column1");
   tc1.EditItemTemplate = new
      DataGridTemplate(ListItemType.EditItem, "Column1");
   tc1.FooterTemplate = new
      DataGridTemplate(ListItemType.Footer, "Column1");
   DataGrid1.Columns.Add(tc1);
   TemplateColumn tc2 = new TemplateColumn();
   tc2.ItemTemplate = new DataGridTemplate(ListItemType.Item, "Column2");
   tc2.HeaderTemplate = new
      DataGridTemplate(ListItemType.Header, "Column2");
   tc2.EditItemTemplate = new
      DataGridTemplate(ListItemType.EditItem, "Column2");
   tc2.FooterTemplate = new
      DataGridTemplate(ListItemType.Footer, "Column2");
   DataGrid1.Columns.Add(tc2);
   sqlDataAdapter1.Fill(dataSet11);
   DataGrid1.DataBind();
}

Заключение

Хотя примеры в этой статье достаточно просты, они демонстрируют все основные принципы создания шаблонов в коде. Конечно, шаблоны, которые вы создадите в своих приложениях, скорее всего окажутся гораздо более сложными - все шаблоны в этой статье легко можно создать на этапе разработки. Но теперь вы знаете достаточно, чтобы создавать шаблоны "на лету".

Программное создание шаблонов серверных элементов управления (исходники)