Кратко съдържание

Работа с бази от данни от ASP.NET

Изтегляне 10.53 Mb.

страница	32/33
Дата	23.07.2016
Размер	10.53 Mb.
	#1889

1 ... 25 26 27 28 29 30 31 32 33

Работа с бази от данни от ASP.NET

В практиката при почти всички уеб приложения се налага работа с данни. Типичният сценарий включва визуализация на таблични данни, идващи от таблици в базата данни, както и добавяне на нови записи и редактиране и изтриване на съществуващи. Такива приложения обикновено се изграждат чрез свързване на ASP.NET уеб форми с ADO.NET.

Преди да изясним по какъв начин можем да изграждаме уеб приложения, използващи релационни бази от данни, нека си припомним основните концепции от ADO.NET. Ще направим само общ обзор на взаимодействието между ASP.NET и ADO.NET. За повече подробности за ADO.NET и работата с бази от данни, разгледайте главата, посветена специално на тази тема.

Обзор на ADO.NET

При създаването на уеб сайтове, които трябва да поддържат хиляди едновременни посещения от хиляди потребители, ще са нужни същия брой отворени връзки към базата от данни. Дори сървърите, отговарящи за поддръжката на базата от данни, да успеят да издържат на това натоварване, скоростта, с която ще работи приложението, ще е нетърпимо бавна. Затова е силно препоръчително при работа с бази от данни с ASP.NET да се използва несвързаният модел.

Обекти за работа с бази от данни

В главата за ADO.NET тези обекти са подробно обяснени, затова тук само ще ги споменем и ще отбележим как се използват в ASP.NET.

Connection – връзка към базата от данни.
Command – команда, служеща за изпълняване на заявки върху базата от данни и за извличане на данни.
DataReader – четец на данни, върнати като резултат от заявка от базата от данни.
DataSet – кеш на част от базата от данни в паметта. Съдържа таблици, релации, ограничения и т.н.
DataAdapter – средство за извличане на данните от базата и обновяването им чрез DataSet обекти.

Визуализиране на данни

Почти всяко уеб приложение, което ползва база от данни, има нужда да представи тези данни на потребителя. Когато се отнася до единични полета (пр. потребителско име или дата) се използват етикети или литерали. Какво обаче да правим, ако искаме да покажем списъка на всички потребители с техните детайли под формата на таблица? Или ако искаме да ги покажем в падащо меню? За да реализираме тези и много други манипулации можем да използваме т.нар. свързани контроли (bound controls). Те играят важна роля в разработката на уеб приложения, защото позволяват бърза и интуитивна работа.

Ще разгледаме два вида свързване на данните – просто и сложно, както и най-важните свързани контроли.

Свързване на данни (data binding)

Свързването на данни е процесът на динамично извличане на данни от зададен източник и визуализирането им чрез подходящи контроли.

За различните контроли източникът на данни се задава чрез различни свойства - Text, DataSource, DataTextField. След малко ще обясним как се използват тези свойства при различните свързани контроли.

Трябва да отбележим, че в някои случаи (например при използването на свойството DataSource), свързване не се извършва, преди да се извика методът DataBind().

Източниците на данни за свързаните контроли могат да са разнородни, не само данни от бази от данни. Източник на данни може да е всеки обект от клас, имплементиращ интерфейса ICollection. Имплементацията на този интерфейс дава всичко необходимо, за да се извърши свързването на данните. Като резултат от това, можем да използваме като източници на данни за свързани контроли всяка една от следните структури:

Класове от .NET Framework, които имплементират ICollection: масиви, списъци (сортирани или свързани), хеш таблици, стекове, опашки, речникови колекции.
Потребителски класове, имплементиращи интерфейса ICollection или някой производен на него (примерно IList).
Класове, свързани с работата с бази данни – DataTable и DataSet. Тъй като обект от тип DataSet може да съдържа много DataTable обекти след като укажем на DataSource свойството DataSet обекта, трябва да зададем на свойството DataMember името на таблицата, която искаме да свържем.
Филтрирани подмножества от редовете на една DataTable таблицата: обекти от тип DataView.

Не можем директно да зададем като източник на данни за свързване XML документ. Трябва да заредим съдържанието на документа в една от споменатите по-горе структури, за да се възползваме от свързването на данни.

Просто свързване

Простото свързване указва връзка между някакви данни и свойство на някоя контрола. Тази връзка се задейства при извикването на метода DataBind() на форма или контрола, когато свързващият израз се оценява и се прилага.

Свързващ израз представлява всеки текст, заграден в таговете <%# и %>. Свързващи изрази можем да поставяме навсякъде в .aspx (.ascx) файла на уеб форма/контрола. Най-често те заместват стойността на някой атрибут на контрола. Ограждат се с единични кавички, за да се отличават от атрибутите, които са с двойни кавички:

Text='<%# "Бай Иван" %>' />

Ако създадем нова уеб форма, поставим в нея гореописания бутон и натиснем [F5], ще забележим, че като текст на бутона не се показва нищо. Това е така, защото не сме извикали метода DataBind(). За да проработи горният пример, трябва да извикаме този метод, примерно при обработчика на събитието Load на формата:

private void Page_Load(object sender, System.EventArgs e)

{

this.DataBind();

}

Горният пример не би се използвал в практиката, защото бихме постигнали същия ефект директно с Text="Бай Иван". Ползите от такъв синтаксис се виждат в случаите, когато за свързващ израз указваме по-сложен израз. В израза могат да се викат методи на езика, на който се компилира страницата, например:

Text='<%# GetData("FirstName") %>' />

Text='<%# GetData("LastName") %>' />

Трябва да направим уточнение, че методите, участващи в израза, трябва да са достъпни във формата. Формата е наследник на code-behind класа и следователно не можем да извикаме от нея частен (private) метод на code-behind класа. Затова щом дефинираме методи, които искаме да извикваме от формата, трябва да им укажем видимост public, или protected. Ето пример:

public string GetData( string fieldName )

{

switch (fieldName)

{

case "FirstName":

{

return "Иван";

}

break;

case "LastName":

{

return "Иванов";

}

break;

default:

{

return "Unknown";

}

break;

}

Сложно свързване

Много често ни се налага да визуализираме голямо количество данни, извлечени от база от данни. Сложното свързване представлява свързване на множество редове/свойства с една контрола. Използва се предимно в списъчните и итериращите контроли, които ще разгледаме по-долу.

Контроли за показване на данни

Можем условно да разделим контролите за показване на данни в две групи - списъчни и итериращи.

Списъчни контроли

Списъчните контроли са DropDownList, CheckBoxList, RadioButtonList и ListBox. Фигурирането на думата List (списък) в името им, показва че служат за представяне на данните под формата на списък. Нека разгледаме какви са общите неща между тях.

Базовият клас ListControl

Класовете на списъчните контроли произлизат от един и същ абстрактен базов клас – ListControl. Той осигурява голяма част от функционалността на списъчните контроли.

Всяка списъчна контрола съдържа колекция Items. Тази колекция отговаря за елементите на списъка. Всеки елемент на списъка е от тип ListItem и има три свойства, които го характеризират – Text, Value и Selected. Полето Text съдържа текста, който да се покаже. Полето Value съдържа стойността на съответния елемент. Примерно можем да покажем списък с имената на държавите България, Германия, Русия, САЩ, и да използваме за ключова стойност техните държавни кодове – BGR, DEU, RUS, USA. Полето Selected съдържа булева стойност, показваща дали съответният елемент на списъка е избран.

Основната функционалност, която предоставят списъчните контроли, е възможност за избор от елементите на списъка.

Текущ избран елемент в списъчни контроли

За работа с избраните елементи се използват свойствата SelectedIndex, SelectedItem и SelectedValue:

SelectedIndex връща индекса на първия избран елемент от списъка. Ако няма такъв, връща -1. Стойността на това поле може да се задава програмно.
SelectedItem връща първия избран елемент от списъка. Ако няма такъв, връща null.
SelectedValue връща стойността на първия избран елемент от списъка. Ако няма такъв, връща null. Може да използваме това поле, когато искаме да зададем програмно на някоя списъчна контрола избран елемент, но не знаем на коя позиция се намира в списъка. Например, ако имаме списък с всички държави и искаме България да е избрана, но не знаем на коя позиция се намира. Тогава задаваме като стойност на полето SelectedValue – "BGR".

Всички списъчни контроли имат събитие SelectedIndexChanged. То се предизвиква при промяна на индекса на първия избран елемент.

Елементите на списъчните контроли могат да се дефинират основно по три начина: декларативно (директно в .aspx/.ascx файла), динамично (като се добавят един по един в изпълним код), и чрез свързване (като съответната списъчна контрола се свърже с някой източник на данни). Ще демонстрираме всеки един от трите метода.

Списъчни контроли и свързване с данните

Всички списъчни контроли имат едни и същи свойства, отговарящи за свързването с източници на данни - DataSource, DataTextField, DataValueField, DataTextFormatString и DataMember:

DataSource определя източника на данни.
DataTextField определя стойностите на кое поле от източника на данни да се използват за стойности на полето Text за елементите на списъка.
DataValueField определя стойностите на кое поле от източника на данни да се използват за стойности на полето Value за елементите на списъка.
DataTextFormatString определя какъв форматиращ низ да се използва за визуализиране на текста. В случай, че източникът на данни е от тип DataSet, съдържащ повече от един DataTable обект, се използва полето DataMember, което задава коя точно таблица да се използва.

Контролата DropDownList

Контролата DropDownList показва данните под формата на падащ списък, от който може да се избира само един елемент:

Всеки един от елементите на списъка е обект от тип ListItem. Нека покажем как става тяхното дефиниране за DropDownList контролата в горния пример. Има три основни начина: декларативно (статично), динамично и чрез свързване на данни (data binding).

Декларативно (статично) задаване на елементите в списъчни контроли

Декларативното (известно още като статично) задаване на елементите в списъчни контроли е най-простият вариант да заредим данни в списъчна контрола. То става чрез дефинираме елементите директно в .aspx (.ascx) файла:

Мечо Пух

Тигър

Прасчо

Йори

Динамично задаване на елементите в списъчни контроли

При динамичното задаване на елементите в списъчни контроли се използва свойството Items.

Ето един пример. Дефинираме контролата в .aspx (.ascx) файла:

След това динамично добавяме елементите в кода:

ddlList.Items.Add(new ListItem("Мечо Пух", "1"));

ddlList.Items.Add(new ListItem("Тигър", "2"));

ddlList.Items.Add(new ListItem("Прасчо", "3"));

ddlList.Items.Add(new ListItem("Йори", "4"));

Задаване на елементите в списъчни контроли чрез свързване на данни

Свързването на данни със списъчна контрола се използва най-често, когато данните идват от базата данни. То се реализира малко по-сложно в сравнение със статичното и динамичното задаване на елементите.

Започваме с указване на източника на данни, като ще използваме два различни типа. Първият ще бъде масив от потребителски обекти, а вторият DataSet, съдържащ DataTable.

Потребителският клас, от който ще се състои масивът, изглежда така:

public class Character

{
private string name;

private long id;

public string Name

{
get { return name; }

set { name = value; }

}
public long ID

{

get { return id; }

set { id = value; }

}
public Character(string name, long id)

{

this.name = name;

this.id = id;

}
}

Дефинираме контролата в .aspx или.ascx файл:

DataTextField="Name" DataValueField="ID">

Изкуствено ще създадем масив от елементи Character (на практика този масив може е извлечен от база от данни):

Character[] bookCharacters = new Character[]
{
new Character("Мечо Пух", 1),

new Character("Тигър", 2),

new Character("Прасчо", 3),

new Character("Йори", 4)

};
ddlList.DataSource = bookCharacters;

ddlList.DataBind();

В последните два реда от примера, масивът bookCharacters се задава като източник на данни за DropDownList контролата и се извиква методът DataBind(), за да се свържат данните с нея.

За да демонстрираме свързване с DataSet обект, ще се наложи и него да създадем изкуствено. Нека дефинираме отделен метод, който връща обект от тип DataSet:

public DataSet GetDataSource()

{

DataSet dataSource = new DataSet();

DataTable charactersTable = new DataTable("Characters");
Characters.Columns.Add("ID", typeof(long));

Characters.Columns.Add("Name", typeof(string));

DataRow row1 = charactersTable.NewRow();

DataRow row2 = charactersTable.NewRow();

DataRow row3 = charactersTable.NewRow();

DataRow row4 = charactersTable.NewRow();

row1["Name"] = "Мечо Пух";

row1["ID"] = 1;

row2["Name"] = "Тигър";

row2["ID"] = 2;

row3["Name"] = "Прасчо";

row3["ID"] = 3;

row4["Name"] = "Йори";

row4["ID"] = 4;

charactersTable.Rows.Add(row1);

charactersTable.Rows.Add(row2);

charactersTable.Rows.Add(row3);

charactersTable.Rows.Add(row4);

dataSource.Tables.Add(charactersTable);

return dataSource;

}

Дефинираме контролата в .aspx или.ascx файла:

DataSource='<%# GetDataSource() %>' DataTextField="Name"

DataValueField="ID" DataMember="Characters">

В примера по-горе като стойност на свойството DataSource сме задали свързващ израз, който извиква функцията GetDataSource(). Свързващ израз може да се задава само за това поле на списъчна контрола. Указали сме също и стойността на свойството DataMember да е "Characters" – името на таблицата от DataSet обекта, която служи за източник на данни. В случая DataSet обектът има само една таблица и полето DataMember може да бъде пропуснато, но сме го дали за пълнота.

Контролата CheckBoxList

Тази контрола показва данните под формата на списък от CheckBox контроли, от който могат да се избират произволен брой елементи. Ето как изглежда тя:

Начините, по които могат да се зададат елементите на списъка, са аналогични на тези за DropDownList контролата. Допълнителните характеристики за CheckBoxList се определят чрез полетата RepeatColumns, RepeatDirection и RepeatLayout:

Чрез свойството RepeatColumns се задава в колко колони да се покаже списъкът (по подразбиране в една).
Свойството RepeatDirection определя в каква посока да се подреждат елементите на списъка - Vertical (по подразбиране) или Horizontal.

Нека дефинираме контролата така:

RepeatColumns="2" RepeatDirection="Vertical">

Мечо Пух

Тигър

Прасчо

Йори

В този случай резултатът ще бъде следният:

Ако свойството RepeatDirection има стойност Horizontal, вместо Vertical, то резултатът ще е следният:

Свойството RepeatLayout отговаря за начина, по който се представят елементите на списъка. То може да приема само две стойности – Flow и Table. Стойността му по подразбиране е Table. Ако стойността е Flow[,], за да се представят елементите на различни редове (един под друг), след последния елемент на всеки ред се поставя

, за да се премине на следващия. Ако стойността е Table, елементите се представят в таблична структура.

Контролата RadioButtonList

Разликите между CheckBoxList и RadioButtonList са в начина на представяне на данните и в броя на елементите, които могат да се избират едновременно.

При RadioButtonList елементите на списъка се представят така:

Само един елемент от списъка може да бъде избран.

Начините за дефиниране на елементите на списъка и свойствата на контролата са същите, както при CheckBoxList.

Контролата ListBox

Тази контрола показва данните под формата на списък, поставен в кутия.

Има две свойства, които характеризират тази контрола: Rows и SelectionMode:

Стойността на полето Rows определя от колко реда се състои кутията. Ако елементите на списъка са повече от тази стойност, отдясно на кутията се появява плъзгаща се лента (ScrollBar).
Свойството SelectionMode може да приема само две стойности – Single и Multiple. Ако стойността му е Single, то от списъка може да се избира само един елемент. В противен случай може да се извършва множествена селекция.

Итериращи контроли

Списъчните контроли предоставят базовата функционалност, необходима на едно уеб приложението да комуникира успешно с потребителя. Чрез тях данните се показват на потребителя и той може да направи избор от тях.

В много случаи е удачно тези данни да се представят в табличен вид. Например, ако работим с база от данни и искаме нашето приложение да визуализира всички данни от дадена таблица.

Старият начин за итерация

Нуждата от визуализиране на данни в таблична форма не е нещо ново. В класическото ASP (преди появата на ASP.NET) се ползваше следния начин на реализация:

int dataItemsCount = Data.Tables[0].Rows.Count;

int dataColumnsCount = Data.Tables[0].Columns.Count;
for(int i=0; i < dataColumnsCount; i++)

{

<% }%>

<%

for(int i = 0; i< dataItemsCount; i++)

{

for(int j = 0; j< dataColumnsCount; j++)

{

<% }%>

<% }%>

style="background-color: #00AAFF; padding: 5px;">

<%= Data.Tables[0].Columns[i].ColumnName %>

<%= Data.Tables[0].Rows[i][j].ToString()%>

В примера по-горе сме използвали обекта Data, който е от тип DataSet. Тъй като и за напред ще ни се наложи да го използваме в различни примери, нека зададем следната дефиниция за Data:

private DataSet dsData;
public DataSet Data

{

get

{

return dsData;

}

}
private void Page_Load(object sender, System.EventArgs e)

{

GenerateDataSet();

}
private void GenerateDataSet()

{

dsData = new DataSet();

DataTable dtData = new DataTable("Characters");

dtData.Columns.Add("Character First Name");

dtData.Columns.Add("Character Last Name");

dtData.Columns.Add("Character Birth Date", typeof(DateTime));

dtData.Columns.Add("Character Age", typeof(Int32));
DataRow drData = dtData.NewRow();
drData["Character First Name"] = "Мечо";

drData["Character Last Name"] = "Пух";

drData["Character Birth Date"] = new DateTime(1971,4,1);

drData["Character Age"] = 35;

dtData.Rows.Add(drData);

drData = dtData.NewRow();

drData["Character First Name"] = "Прасчо";

drData["Character Last Name"] = "Свински";

drData["Character Birth Date"] = new DateTime(1978,5,11);

drData["Character Age"] = 28;

dtData.Rows.Add(drData);
drData = dtData.NewRow();
drData["Character First Name"] = "Тигър";

drData["Character Last Name"] = "Бенгалски";

drData["Character Birth Date"] = new DateTime(1984,8,12);

drData["Character Age"] = 21;

dtData.Rows.Add(drData);
drData = dtData.NewRow();
drData["Character First Name"] = "Йори";

drData["Character Last Name"] = "Магарисченко";

drData["Character Birth Date"] = new DateTime(1955,4,30);

drData["Character Age"] = 51;

dtData.Rows.Add(drData);
dsData.Tables.Add(dtData);

}

Дефинираме обекта Data като свойство на страницата, което връща член-променливата dsData. По време на зареждане на страницата (Page_Load) извикваме метода GenerateDataSet(). Той инициализира dsData с примерни данни. За простота тук данните не се вземат от база от данни, но това е без значение за целите на демонстрацията.

Как работи примерът?

Да се върнем обратно към примера. Ако сте разработвали приложения с ASP, този пример сигурно ви се струва донякъде познат. За тези, които тепърва започват да се запознават с разработка на уеб приложения с ASP.NET, кодът сигурно изглежда изключително объркващ. Няма да се задълбочаваме в детайли, а ще обясним само ключовите части на примера.

Както сте забелязали, тук по особен начин се смесват сървърни тагове (<% %>) и обикновен HTML. Нека разгледаме следния отрязък код:

Character List

<% for(int i = 0 ; i < 10; i++)

{

<% if((i % 2)> 0) { %> <% }%>

Character <%= (i+1)%>

<% if((i % 2)> 0) { %> <% }%>
<% } %>

Total : 10

В резултат на интерпретирането на този код, в уеб браузъра на клиента ще пристигне следният HTML:

Character List

Character 1

Character 2

Character 3

Character 4

Character 5

Character 6

Character 7

Character 8

Character 9

Character 10

Total : 10

В крайна сметка браузърът ще покаже следния списък:

Примерният код се интерпретира така: за всяка стойност на i от 0 до 9 се изпълнява тялото на цикъла. В него всичко, което не е заградено в сървърни тагове (<% %>) остава непроменено, а всичко заградено в сървърни тагове се интерпретира.

Този опростен пример демонстрира как може да се реализира повторение на HTML елементи. В първоначалния пример вместо фиксирана стойност 10 използваме dataColumnsCount и dataItemsCount.

Този начин на реализация на представяне на данни в табличен вид е твърде непрактичен, но преди ASP.NET не е имало друга алтернатива. Основните му недостатъци идват от необходимостта от смесването на процедурен код и HTML, което води до нечетливост на написаното и затруднения в поддръжката.

Нуждата от начин за представяне на данните в табличен вид е довела до създаването на контролите DataGrid, DataList и Repeater.

Сходства между итериращите контроли

Всички итериращи контроли съдържат списък с елементи, отговорни за генерирането на изходния HTML.

DataGrid показва записите в HTML таблица (чрез тага ), където всеки елемент се представя в отделен ред. Класът DataGridItem е предназначен да визуализира табличен запис и затова е наследник на класа TableRow.
Аналогично DataList е съставен от елементи от тип DataListItems. Класът Repeater, от друга страна, позволява пълна настройка на изходния HTML. Затова класът за елементите му RepeaterItem не е наследник на TableRow.
При извикване на метода DataBind() се преминава през всички записи на свойството DataSource. За всеки запис се създава нова инстанция от тип DataWebControlNameItem и записът се свързва със свойството й DataItem.
Събития на итериращите контроли за свързване с данните

Итериращите контроли поддържат няколко общи събития, касаещи процеса на свързването на данните:

Събитието ItemCreated се активира за всеки нов DataWebControlNameItem добавен към контролата, преди още да е инициализирано свойството DataItem. Събитието ItemDataBound се случва веднага след инициализацията на свойството DataItem. А ItemCommand събитието се активира при всяка команда от Button or LinkButton в итериращата контрола.

Друга важна обща характеристика на итериращи контроли е, че всички позволяват използването на шаблони. Контролите DataList и Repeater задължително изискват шаблони, докато при DataGrid използването им е незадължително.

DataGrid и DataList са наследници на класа WebControl, докато Repeater е наследник на класа Control. Класът WebControl има множество свойства свързани с визуализацията: BackColor, ForeColor, CssClass, BorderStyle и др. Repeater контрола не поддържа директно тези свойства, но аналогични форматиращи настройки могат да бъдат указвани чрез шаблоните му.
Контролата DataGrid

От гледна точка на вградени възможности, DataGrid е най-мощната от итериращите контроли. За сметка на това, тя не е гъвкава по отношение на генерирания HTML код. Той винаги генерира HTML таблици, като за всяка свързана колона се създава ред чрез тага и за всяко поле от записа, се създава колона чрез тага

.

Сред вградените възможности на DataGrid контролата са сортиране, страниране и редакция на данните директно в таблицата. Примерно чрез указване на свойството AllowSorting = true и малко допълнителен код, лесно може да се предостави на потребителя средство за сортиране.

С DataGrid можем много бързо да реализираме показване на данни в ASP.NET уеб страница. Само трябва да поставим контрола в страницата, да укажем DataSource и да извикваме DataBind(). DataGrid има свойство AutoGenerateColumns, с което може да укажем дали колоните се генерират автоматично, или дали само ще задаваме кои от тях да се покажат и по какъв начин.

Всяка колона в DataGrid е инстанция на клас, наследник на DataGridColumn. Вградените типове колони са:

BoundColumn – колона, свързана с поле от източника на данни. Показва данните под формата на обикновен текст.

ButtonColumn – колона, показваща бутон.

EditColumn – колона за редакция на данни.

HyperLinkColumn – колона, показваща хипервръзка, като текста и URL-то могат да бъдат от отделни полета на източника на данни.

TemplateColumn – колона шаблон, чрез която може да се генерира произволен изходен HTML. Има шаблони за различните части на таблицата: ItemTemplate, HeaderTemplate, FooterTemplate и EditItemTemplate.

Производителността на DataGrid понякога може да е проблем, тъй като при голям обем данни размерът ViewState на контролата става значителен. Ако ViewState бъде изключен, то това ще е за сметка на възможностите за сортиране, страниране и редактиране.
Контролата DataList

Необходимостта от DataList възниква, когато представянето на данни в HTML таблица с по един запис на ред е неудачно. Понякога може да искаме да покажем повече от един запис на ред или да решим да използваме <span> вместо <table> тагове.
При DataList концепцията за "колони" не присъства. Всички настройки се задават чрез шаблони, в които разработчикът може да укаже комбинация от HTML и код за свързване с данните. Примерно следният ItemTemplate ще покаже полето Name от източника на данни:

<%# DataBinder.Eval(Container.DataItem, "Name") %>

Можем лесно да разширим горния шаблон, за да покажем Name полето удебелено и под него да добавим поле ID:

<%# DataBinder.Eval(Container.DataItem, "Name") %>
<%# DataBinder.Eval(Container.DataItem, "ID") %>

За всеки запис в източника на данни на DataList, се рендира изходен HTML след като се оцени свързването, указано в ItemTemplate. Поддържат се следните типове шаблони:

ItemTemplate – шаблон за елемента

AlternatingItemTemplate – ако е указан, всеки следващ елемент от източника на данни, използва този шаблон вместо ItemTemplate.

EditItemTemplate – шаблон на елемента в режим на редакция.

HeaderTemplate – шаблон за заглавния елемент. Показва се само ако свойството ShowHeader е true.

FooterTemplate - шаблон за заключителния елемент. Показва се само ако свойството ShowFooter е true.

SelectedItemTemplate – шаблон за избран елемент

SeparatorTemplate – шаблон, прилаган след всяко добавяне на DataListItem.

По подразбиране, DataList показва всеки елемент като ред в HTML таблица. Чрез свойството RepeatColumns можем да укажем колко елементи искаме да се съдържат на всеки ред. Можем чрез свойството RepeatLayout, което приема стойности Table или Flow, да зададем да се ползват <span> тагове вместо <table>, Тези допълнителни възможности правят DataList контролата по-гъвкава от DataGrid.
С шаблона EditItemIndex и събитията EditCommand, UpdateCommand и CancelCommand, контролата DataList също поддържа редактиране на място, но реализацията изисква повече програмиране от страна на разработчика. Още по-трудоемко е имплементирането на възможности за сортиране и страниране в DataList контрола.

Контролата Repeater

Контролата Repeater предлага максимална гъвкавост в рендирането на HTML. Тя е удачно решение, когато не искаме да използваме нито HTML <table>, нито серия от <span> тагове.

Repeater предлага следните пет шаблона, чиято функция вече ни е добре позната:

AlternatingItemTemplate

FooterTemplate

HeaderTemplate

ItemTemplate

SeparatorTemplate

HeaderTemplate и FooterTemplate указват HTML, който да се покаже съответно преди и след данните, свързани с контролата. AlternatingItemTemplate и ItemTemplate указват HTML кода и свързващия синтаксис за рендиране на елементите от източника на данни.
Нека свързваме данни за героите от книгата "Мечо Пух" с Repeater контрола и едно от полетата е Name. Ако искаме да покажем списък с имената им в несортиран списък можем да използваме следния синтаксис:

<%# DataBinder.Eval(Container.DataItem, "Name") %>

Тъй като Repeater не е наследник на WebControl и не предлага свойства за указване на стила на форматиране, то ако искаме да покажем имената на героите с удебелен шрифт, трябва в ItemTemplate да добавим HTML тага :

<%# DataBinder.Eval(Container.DataItem, "Name")
%>

Тази особеност на Repeater контролата води понякога до по-тежки, а следователно и по-трудно четими шаблони. Също така ако се наложи да реализираме сортиране и страничен преглед, трябва да го реализираме от нулата.
Предимствата на Repeater са в нейната гъвкавост и добра производителност.

Каталог: dotnetbook
dotnetbook -> Кратко съдържание
dotnetbook -> Кратко съдържание

Изтегляне 10.53 Mb.

Сподели с приятели:

1 ... 25 26 27 28 29 30 31 32 33