A migrant

Read and Write Binary Large Object with ADO.NET

2010-10-22T02:31:00.000-07:00

There are situations where you need to read a large object, such as a large image or text stored in database or you need to write such an object. You can do so by using ADO.NET connected classes. Here I use a SQL Server 2005 database and ASP.NET 3.5. I created a database named TestTable with 3 columns, TestID which is of type bigint, TestTitle which is of type nvarchar(50) and TestData which is of type Image. The latter is supposed to store the actual data.
To read data, I used SqlDataReader which normally reads data one row at a time. The columns are buffered if available. Then you can access them by using the columns index. To access large object, we need to change this default behavior of DataReader to a sequential stream. This way you need to go through the bytes in the stream until the end of the stream is reached. Here is the code:

string constr = ConfigurationManager.ConnectionStrings["TestDBConnectionString"].ConnectionString;

int bufferSize = 1024;

byte[] buffer = new byte[bufferSize];

long currentIndex = 0;

int byteCount;

using (SqlConnection conn = new SqlConnection(constr))

{

conn.Open();

using (SqlCommand comm = conn.CreateCommand())

{

comm.CommandText = "select TestID, TestTitle, TestData from TestTable where TestID=1000";

SqlDataReader reader = comm.ExecuteReader(CommandBehavior.SequentialAccess);

while (reader.Read())

{

string id = reader.GetInt64(0).ToString();

string title = reader.GetString(1);

using (FileStream fs = new FileStream(title + ".jpg",FileMode.Create,FileAccess.Write))

{

byteCount = (int)reader.GetBytes(2, currentIndex, buffer, 0, bufferSize);

while (byteCount!=0)

{

fs.Write(buffer, 0, byteCount);

currentIndex += byteCount;

byteCount = (int)reader.GetBytes(2, currentIndex, buffer, 0, bufferSize);

}

This code selects a row and retrieves the columns and cycles through the bytes of the third column (TestData) and writes it into a buffer of bytes and eventually writes the content of the buffer into a FileStream Object. The result is an image file in the file system.

To write the BLOB object, you need a pointer to the column that actually stores the data. So you first get the pointer by TEXTPTR T-SQL command. The returned scalar value is used to update the column with the stream of the actual data. There is a loop in the code below that does the main job. It reads an image file on the hard disk and buffers its content and writes the buffer into the column on each iteration of the loop until the end of the file has been reached. Note that you have to provide a few paramters for the T-SQL that updates the column. A parameter holds the current index of data written into the column (offsetParam), one is the pointer that indicates the column to be updated (pointerParam) and is retreieved at the beginning of the code. The last one is the parameter that keep the actual data (dataParam).

string constr = ConfigurationManager.ConnectionStrings["TestDBConnectionString"].ConnectionString;

int bufferSize = 100;

byte[] buffer = new byte[bufferSize];

long currentIndex = 0;

byte[] dataPtr;

using (SqlConnection conn = new SqlConnection(constr))

{

conn.Open();

using (SqlCommand comm = conn.CreateCommand())

{

comm.CommandText = "select textptr(TestData) from TestTable where TestID=1000";

dataPtr = (byte[])comm.ExecuteScalar();

}

using (SqlCommand comm2 = conn.CreateCommand())

{

comm2.CommandText = "updatetext TestTable.TestData @pointer @offset null @data";

SqlParameter pointerParam = comm2.Parameters.Add("@pointer", SqlDbType.Binary, 16);

pointerParam.Value = dataPtr;

SqlParameter dataParam = comm2.Parameters.Add("@data", SqlDbType.Image);

SqlParameter offsetParam = comm2.Parameters.Add("@offset", SqlDbType.Int);

offsetParam.Value = 0;

using (FileStream fs = new FileStream("C:\\image.jpg", FileMode.Open, FileAccess.Read))

{

int count = fs.Read(buffer, 0, bufferSize);

while (count != 0)

{

dataParam.Value = buffer;

dataParam.Size = count;

comm2.ExecuteNonQuery();

currentIndex += count;

offsetParam.Value = currentIndex;

count = fs.Read(buffer, 0, bufferSize);

}

How to use a user control within a GridView control

2010-10-11T09:00:00.000-07:00

Recently, I have been working on a web application where I have to display a list of users to the administrator. I took advantage of LinqDataSource and GridView control. The database record contained a DateTime field. Dealing with this field made me think of a simple application. I thought it would be a good sample on how to use Linq to SQL, how to truncate DateTime field and show only the date part by adding properties to the Linq generated class and how to use your own web user controls within a GridView. Needless to mention that the code I used is not optimized and these things may be done in more efficient ways. I just want to share what I experienced.

I used ASP.NET 3.5 and SQL Server 2005 for this sample code. First I create a database called TestDB containing a single table called tbMember. The table contains three columns, MemberID which is of type bigint with autoincrememnt, MemberName of type nvarchar(50) and MemberBirthday of type DateTime.

In my sample application, I add a new item of type LINQ to SQL classes and I name it MemberDataClasses. Then I use Server Explorer to browse the database I just created and drag the table over to the designer surface of the LINQ to SQL class. This will generate the code automatically and now on I can simply use LinqDataSource to display the data in any data-bound control. It couldn't be any easier!

In my sample page, I add a GridView control and in 'Choose Data Source', I select 'New data source'. A wizard pops up and I choose Linq data source type. The next wizard shows which lets me configure the data source. If 'Show only DataContext objects' checkbox is checked, the classes within the application that implements DataContext will be displayed in the drop-down list. The class that I created using LINQ to SQL is shown and I choose it. Then I can select the columns I want to display. If I select *, Advanced option will be enabled where I can enable the data source to perform automatic deletes, inserts and updates. If these options are selected on the data source, I can enable editing and deleting on the GridView control by using the smart tag and checking the appropriate checkbox.

At this moment, you can easily edit the records without even writing a single line of code. Suppose that you want to display only the date part of the DateTime field (which is a property in the Linq generated class). Simply you can add a string property to the Linq generated class which returns a short version of the DateTime column. You could use ToShortDateString method. I set the allow null on the DateTime column so that the generated property would be Nullable. Here is the property I added to return a short date.

public string ShortMemberBirthday

{

get

{

if (MemberBirthday.HasValue)

{

return MemberBirthday.Value.ToShortDateString();

}

else

{

return string.Empty;

}

set

{

if (value == null || value == string.Empty)

{

MemberBirthday = (DateTime?)null;

}

else

{

MemberBirthday = Convert.ToDateTime(value);

}

I did some checks to handle null values. Now you can edit the BoundField column of the GridView control that displays the DateTime property. Instead of the original property, you can set its DataField attribute to the new property to show the short date. So far, your GridView and data source should look something like this:

<asp:GridView ID="MemberGridView" runat="server"

DataSourceID="MemberDataSource" AllowSorting="True"

AutoGenerateColumns="False" DataKeyNames="MemberID">

<asp:CommandField ShowDeleteButton="True" ShowEditButton="True" />

<asp:BoundField DataField="MemberID" HeaderText="ID"

InsertVisible="False" ReadOnly="True" SortExpression="MemberID" />

<asp:BoundField DataField="MemberName" HeaderText="Name"

SortExpression="MemberName" />

<asp:BoundField DataField="ShortMemberBirthday" HeaderText="Birthday"

SortExpression="MemberBirthday" />

</Columns>

There are no records to display!

</EmptyDataTemplate>

</asp:GridView>

<asp:LinqDataSource ID="MemberDataSource" runat="server"

ContextTypeName="MemberDataClassesDataContext" EnableDelete="True"

EnableInsert="True" EnableUpdate="True" TableName="tbMembers">

</asp:LinqDataSource>

The DataField of the BoundField was originally set to MemberBirthday and I changed it to ShortMemberBirthday.

Now I'm going to point out another issue you may come across dealing with DateTime. When using the default behavior of GridView, you will notice that a Label control is used to display fields in normal mode and a TextBox control to display fields in edit mode. Since the web server and the database servers we use might be geographically in different place, this will be potentially troublesome. Each server uses its own culture settings which means when you enter a DateTime value in the TextBox in edit mode, it could be interpreted in different ways depending on the CultureInfo defined on the server. If the CultureInfo object is set to "en-GB", the date-time format will be DD/MM/YYYY, while if it is set to "en-US", the format is expected to be MM/DD/YYYY. Sometimes it's difficult to handle every single situation where a DateTime value entry is expected. To avoid the headache, I thought of a web user control that simply contains three DropDownList controls for displaying day, month and year regardless of the CultureInfo information. Instead of the default TextBox that is displayed in the edit mode of the GridView control, we could use this user control. Here is my control:

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="DateControl.ascx.cs" Inherits="uc_DateControl" %>

<tr>

<td>

<asp:DropDownList EnableViewState="false" ID="DayList" runat="server" Font-Size="11px"

Width="36px">

<asp:ListItem Selected="True"></asp:ListItem>

<asp:ListItem Value="1">1</asp:ListItem>

<asp:ListItem Value="2">2</asp:ListItem>

<asp:ListItem Value="3">3</asp:ListItem>

<asp:ListItem Value="4">4</asp:ListItem>

<asp:ListItem Value="5">5</asp:ListItem>

<asp:ListItem Value="6">6</asp:ListItem>

<asp:ListItem Value="7">7</asp:ListItem>

<asp:ListItem Value="8">8</asp:ListItem>

<asp:ListItem Value="9">9</asp:ListItem>

<asp:ListItem Value="10">10</asp:ListItem>

<asp:ListItem Value="11">11</asp:ListItem>

<asp:ListItem Value="12">12</asp:ListItem>

<asp:ListItem Value="13">13</asp:ListItem>

<asp:ListItem Value="14">14</asp:ListItem>

<asp:ListItem Value="15">15</asp:ListItem>

<asp:ListItem Value="16">16</asp:ListItem>

<asp:ListItem Value="17">17</asp:ListItem>

<asp:ListItem Value="18">18</asp:ListItem>

<asp:ListItem Value="19">19</asp:ListItem>

<asp:ListItem Value="20">20</asp:ListItem>

<asp:ListItem Value="21">21</asp:ListItem>

<asp:ListItem Value="22">22</asp:ListItem>

<asp:ListItem Value="23">23</asp:ListItem>

<asp:ListItem Value="24">24</asp:ListItem>

<asp:ListItem Value="25">25</asp:ListItem>

<asp:ListItem Value="26">26</asp:ListItem>

<asp:ListItem Value="27">27</asp:ListItem>

<asp:ListItem Value="28">28</asp:ListItem>

<asp:ListItem Value="29">29</asp:ListItem>

<asp:ListItem Value="30">30</asp:ListItem>

<asp:ListItem Value="31">31</asp:ListItem>

</asp:DropDownList>

</td>

<td>

</td>

<td>

<asp:DropDownList EnableViewState="false" ID="MonthList" runat="server" Font-Size="11px"

Width="42px">

<asp:ListItem Selected="True"></asp:ListItem>

<asp:ListItem Value="1">Jan</asp:ListItem>

<asp:ListItem Value="2">Feb</asp:ListItem>

<asp:ListItem Value="3">Mar</asp:ListItem>

<asp:ListItem Value="4">Apr</asp:ListItem>

<asp:ListItem Value="5">May</asp:ListItem>

<asp:ListItem Value="6">Jun</asp:ListItem>

<asp:ListItem Value="7">Jul</asp:ListItem>

<asp:ListItem Value="8">Aug</asp:ListItem>

<asp:ListItem Value="9">Sep</asp:ListItem>

<asp:ListItem Value="10">Oct</asp:ListItem>

<asp:ListItem Value="11">Nov</asp:ListItem>

<asp:ListItem Value="12">Dec</asp:ListItem>

</asp:DropDownList>

</td>

<td>

</td>

<td>

<asp:DropDownList EnableViewState="false" ID="YearList" runat="server" Font-Size="11px"

Height="16px" Width="50px">

</asp:DropDownList>

<asp:ListItem Selected="True"></asp:ListItem>

<asp:ListItem Value="1967">1967</asp:ListItem>

<asp:ListItem Value="1968">1968</asp:ListItem>

<asp:ListItem Value="1969">1969</asp:ListItem>

<asp:ListItem Value="1970">1970</asp:ListItem>

<asp:ListItem Value="1971">1971</asp:ListItem>

<asp:ListItem Value="1972">1972</asp:ListItem>

<asp:ListItem Value="1973">1973</asp:ListItem>

<asp:ListItem Value="1974">1974</asp:ListItem>

<asp:ListItem Value="1975">1975</asp:ListItem>

<asp:ListItem Value="1976">1976</asp:ListItem>

<asp:ListItem Value="1977">1977</asp:ListItem>

</td>

</tr>

</table>

Notice that I could add the days to the list in Load event of the control, but I prefered to do it declaratively. This will save me from having to set EnableViewState to true. As I explained in my post about ViewState, every programmatic change to controls needs to be persisted in view state.

In the code behind of your control class, you need a property that gets and sets the date that the control displays. I called it SelectedDate and I let it be Nullable because it will let us be more flexible with the database fields. Here is the property code:

public DateTime? SelectedDate

{

get

{

if (YearList.SelectedIndex == 0 || MonthList.SelectedIndex == 0 || DayList.SelectedIndex == 0)

{

return (DateTime?)null;

}

int year = Convert.ToInt32(YearList.SelectedValue);

int month = Convert.ToInt32(MonthList.SelectedValue);

int day = Convert.ToInt32(DayList.SelectedValue);

try

{

DateTime test = new DateTime(year, month, day);

}

catch (Exception exc)

{

if (exc is ArgumentOutOfRangeException)

{

return GetValidDate(year, month, day - 1);

}

return new DateTime(year, month, day);

}

set

{

if (!value.HasValue)

{

return;

}

int year = value.Value.Year;

int month = value.Value.Month;

int day = value.Value.Day;

YearList.SelectedValue = year.ToString();

MonthList.SelectedValue = month.ToString();

DayList.SelectedValue = day.ToString();

}

DateTime GetValidDate(int year, int month, int day)

{

try

{

DateTime test = new DateTime(year, month, day);

}

catch (Exception exc)

{

if (exc is ArgumentOutOfRangeException)

{

return GetDateValid(year, month, day - 1);

}

return new DateTime(year, month, day);

}

Here I also did a little check if the selected date is valid by using GetValidDate method. At this level, I select the DateTime column and use 'Convert this field into a TemplateField'. In the design mode, I replace the TextBox control with my user control. There is a problem if you want to use the new property in edit mode in the GridView control. Since this property is of type string, there will be a casting exception. For example, if your template field is like this in the GridView:

<asp:TemplateField HeaderText="Birthday" SortExpression="MemberBirthday">

<uc1:DateControl ID="DateControl1" runat="server" SelectedDate='<%# Bind("ShortMemberBirthday")%>' />

</EditItemTemplate>

<asp:Label ID="Label1" runat="server" Text='<%# Bind("ShortMemberBirthday") %>'></asp:Label>

</ItemTemplate>

</asp:TemplateField>

you are going to get an error message saying 'Specified cast is not valid'. This means SelectedDate property is expecting a DateTime value, while I passed in a string value. So in normal mode, you can use that string to set the Label control's Text property. But in edit mode, you will need to use the first property which is MemberBirthday. So the template field should be like this:

<asp:TemplateField HeaderText="Birthday" SortExpression="MemberBirthday">

<uc1:DateControl ID="DateControl1" runat="server" SelectedDate='<%# Bind("MemberBirthday")%>' />

</EditItemTemplate>

<asp:Label ID="Label1" runat="server" Text='<%# Bind("ShortMemberBirthday") %>'></asp:Label>

</ItemTemplate>

</asp:TemplateField>

Now if you run the page, in normal mode, you will see the short DateTime values in MemberBirthday column and in edit mode, you will see the three DropDownList controls with the appropriate values selected.

My GridView control looks like this in normal mode:

and this is what it looks like in edit mode:

Which DataBound Control to use?

2010-10-04T03:59:00.000-07:00

ASP.NET offers a rich set of data-bound controls. This variety of controls lets you choose the control that best suits your needs. At the same time, it might be confusing which control fits the job. Deciding which control to use depends on the functionalities the developer is going to offer the user. For example, if the user is supposed to have editing ability, certainly you cannot use the Repeater control.

Here is the list of the data-bound controls in ASP.NET:

GridView
DataList
DetailsView
FormView
ListView
Repeater

GridView is one of the commonly used data-bound controls developers mostly use. It provides a number of default functionalities that make common operations easy to implement with much less code than ever (if any!). You can edit a row or delete it, page through the records or sort rows based on a columns. GridView is the successor to DataGrid control. If you want to see a comparison between GridView and DataGrid controls, see http://msdn.microsoft.com/en-us/library/05yye6k9.aspx.

DataList is another data-bound control for displaying data as a table. It's a template-driven control and provides different templates to display data in normal, alternate, edit or select mode. You can also have templates for header and footer.
You can edit or delete rows in DataList, but the big disadvantage that makes me avoid using DataList is that it does not utilize the capabilities of data source controls for editing or deleting data. If you opt to use this control, you should consider that you have to write codes to handle data modification. I think generally the capabilities offered by the other data-bound controls saves you from using such a cumbersome control. I even wonder why they bothered to create it and add it to the list of data-bound controls!

DetailsView is a control usually used along with GridView control in master/detail scenarios. In this case, the selected row in the GridView control will be displayed in the DetailsView control.
DetailsView shows a single row at a time and provides paging, inserting new records, updating and deleting rows. It uses a table-based layout.

FormView is very similar to DetailsView, except that it's a template-driven control and doesn't provide a pre-defined layout. It contains several templates that allows developers to design the layout used for displaying the data.

ListView is a template-driven data-bound control. Like other template-driven controls, it uses several templates you can use to customize the layout of the data that is to be displayed. Unlike DataList control, it utilizes capabilities of the data source controls for common operations such as editing, inserting and deleting and also functionalities like sorting and paging.
Because it's the only control that implements IPageableItemContainer interface, it's the only one that can use DataPager control.

Repeater is used to create a read-only list of data rows. It's a template-driven control and allows you to customize the design of the displayed records by using templates. It has no default layout.

To wrap it up, whenever you reach the point where you have to choose the best control that suits your need best, you should consider what you exactly need the control to do, what kind of functionalities you want it to offer and whether you want to give it a customized look at design time or not.

View state in ASP.NET

2010-09-18T00:46:00.000-07:00

In my last post, I explained the life cycle of a page in ASP.NET. My main purpose was to explain how view state relates to page's life cycle. What is view state supposed to do? View state is responsible for persisiting state of an ASP.NET page and its controls across postbacks. Some developers might think they need to store every state data related to a control in view state. This is not true. For example, the properties that have been declared in the HTML source of the page, do not need to be persisted across postbacks. If your recall from my last post, in page's life cycle, the first stage is instantiation which builds up the control hierarchy. It's where the properties that are defined declaratively, will be assigned to the control in the control hierarchy. Thus, developers do not need to persist such properties. What needs to be persisted in view state is the state that changes programmatically. For instance, if the state of a control is changed in a Button control's click event, it will need to be persisted in view state. Otherwise, the change will be lost through the life cycle of the page.

As an example, suppose you have a page containing a Label control and two Button controls. The Label's BackColor property is declaratively set to Beige. The first Button changes the BackColor property of the Label control to Red. The second Button control only posts the page back. Now, let's walk through the page's life cycle when the page first loads, when the first Button is clicked and when the second one is clicked.

When the page loads, the instantiation occurs and the Label control's BackColor property is set to Beige. Since it is not a postbacl, load view state and save view state stages will not execute. The page will be rendered and the output is a Label with a beige background color.

Now you click the first Button control. The instantiation sets the Label's background color to Beige. Load view state makes no changes, because no save view state happened in the previous page load. After the load event, raise postback event happens which changes the Label's background color to Red. The next stage is save view state. It's when the BackColor property of the Label control will be persisted, because it's a programmatic change. At the end, the result is rendered and sent back to the client's browser.

Now you click the second Button control which posts the page back. The instantiation stage loads the BackColor property of the Label control and sets it to Beige. In load view state stage, the state that was saved in the previous stage, is loaded which means the Label control's BackColor property is set to Red. Then save view state happens exactly as the previous page load. The page is rendered and is transmitted to the browser.

Suppose the BackColor property of the Label control was not persisted. This means the change made by clicking the first Button control wouldn't be loaded after clicking the second Button control and it would be lost. You can try this out by setting the EnableViewState property of the Label control to false. You will notice that after clicking the second Button control, the change is lost and the background color of the Label control is set back to Beige.

There is something I need to point out here. There are certain controls that persist their state even when EnableViewState is set to false. MSDN explains it this way. This behaviour occurs because ViewState of a control is only one of the methods that are used to persist a control's attributes across requests. In TextBox, CheckBox and RadioButton controls, attributes that are not normally posted to the server through the GET and POST methods are handled by ViewState. Attributes that are normally posted to the server are handled by the IPostBackDataHandler interface.

ASP.NET page's life cycle

2010-09-15T03:11:00.000-07:00

Today I decided to discuss one of the most misconcepted features in ASP.NET; ViewState. I started to write about it, then I realized I’d better create a separate post about ASP.NET page’s life cycle. Because understanding view state depends on how accurately you know page’s life cycle. So not to mix up things, I decided to explain page’s life cycle first. Later I will refer to view state. Well, before I go on, let me explain some terms you may hear when you study in this area. One of the terms that may often be heard is IIS pipeline. According to MSDN, IIS pipeline is a state machine consisiting of the states below:

BEGIN_REQUEST
AUTHENTICATE_REQUEST
AUTHORIZE_REQUEST
RESOLVE_REQUEST_CACHE
MAP_REQUEST_HANDLER
ACQUIRE_REQUEST_STATE
PRE_EXECUTE_REQUEST_HANDLER
EXECUTE_REQUEST_HANDLER
RELEASE_REQUEST_STATE
UPDATE_REQUEST_CACHE
LOG_REQUEST
END_REQUEST

When a request is received by IIS, it goes through the state machine until it completes. In IIS 7.0, developers can register their own codes to be executed in any of these steps. This introduces another term. The codes that can be plugged into IIS pipeline to be executed, are called HTTP Modules. It means you can manipulate what happens during the execution of these steps programmatically by creating HTTP modules. At the end of the pipeline, there is another unit called HTTP Handler whose duty is to handle and retrieve the resource that has been requested in the URL by the browser. Every resource known to IIS is mapped and handled by a handler in configuration. For example, when you install ASP.NET on a machine running IIS, it will configure IIS to hand over aspx file requests to ISAPI assembly. You can create your own custom HTTP handler and configure IIS to allow your handler to handle the requests regarding a specific file type. This way you can configure your server to handle any file requests with specific extensions, even those that do not physically exist on the server, such as http://www.myserver.com/myfile.dummy.

I think I need to mention a difference between processing stages in IIS 6.0 and IIS 7.0. If a request is made in IIS 7.0 integrated mode, it goes through the same stages as in IIS 6.0. However these stages include some additional application events, such as MapRequestHandler and PostLogRequest. In fact the main difference is how ASP.NET is integrated with IIS server. In version 6.0 of IIS, there are two request processing pipelines; one for native code ISAPI filters and the other is for managed code components. In version 7.0 of IIS, ASP.NET is integrated with IIS server. This means there is one unified request processing pipeline for all requests. This is an advatnages for ASP.NET developers because, for example, they can handle requests for HTML or ASP pages and make them pass through the same authentication process as ordinary ASPX pages would.

Ok, after defining those tems, it's time to talk about the big deal. I have found dozens of web pages explaining page’s life cycle in ASP.NET on the internet. I think the one that beautifully explains what actually happens, is an image I found in MSDN:

You can see the name and the order of the methods and events that occur during the life cycle of a page. The order of occuring is top down, and from left to right. The list above is a detailed list of the events and methods. I'm going to only discuss those that are more related to view state.

1-Instantiation

Regarding page’s life cycle, the first stage is Instantiation. As you may remember, the last unit in the request processing pipeline is a HTTP handler. Every HTTP handler object has a ProcessRequest method. The life cycle of the page starts by invoking this method in the HTTP handler. It generates the page’s control hierarchy. It’s a control tree which is created by an autogenerated class that is created by ASP.NET runtime when a page is first visited after being created or being modified and saved. If you use a code behind programming model, this autogenerated class will inherit from your page’s associated class which in turn, derives from Page class. If you use inline programming model and use <script> tages directly in your page’s source, this autogenerated class will inherit from Page class. Then the class will be compiled and both the class and its compiled assembly will be saved in temporary ASP.NET folder. This will prevent redundant compilation upon each page request.
This class generates the page’s control hierarchy by parsing the page’s source, converting HTML markup of the page to Literal controls, and translating ASP.NET server controls to appropriate codes.

Let me give you an example to make it clear. Suppose you have a page with the source shown below:

<html>

<body>

<asp:Label ID="NameLabel" runat="server" Text="Name:"></asp:Label>

<asp:TextBox runat="server" ID="NameTextBox"></asp:TextBox>

<asp:Button ID="SendButton" runat="server" Text="Send" />

</form>

</body>

</html>

The autogenerated class for this page could be something like this:

LiteralControl lc1 = new LiteralControl(@"<html>\r\n<body>\r\n<p>Here is some text</p>\r\n");

LiteralControl lc2 = new LiteralControl(@"\r\n<\body>\r\n<\html>");

HtmlForm form1 = new HtmlForm();

form1.ID = "form1";

form1.Method = "post";

Label l1 = new Label();

l1.ID = "NameLabel";

l1.Text = "Name:";

TextBox tb1 = new TextBox();

tb1.ID = "NameTextBox";

Button bt1 = new Button();

bt1.ID = "SendButton";

bt1.Text = "Send";

form1.Controls.Add(l1);

form1.Controls.Add(tb1);

form1.Controls.Add(bt1);

Page.Controls.Add(lc1);

Page.Controls.Add(form1);

Page.Controls.Add(lc2);

As you can see, the properties that have been set declaratively in the page’s source, have been assigned in code too.

2-Initialization

The next stage is initialization. After the control hierarchy is built, init method occurs recursively on the controls. This method is called in bottom-up order. This means, init method of child controls happens befor init method of the container control. This makes the Page control the last one to invoke init method.
Well, so far, the control hierarchy has been created and the controls’ properties that are set declaratively, have been assigned.

3-Load View State

The next stage is Load View State. This stage occurs only when the page is posted back. At this stage, the state data that was saved in previous page visits will be loaded. Also, view state is validated at this stage.

4-Load Postback Data

The next stage is Load Postback Data. Like the previous stage, this stage occurs when the page is posted back. Load postback data happens for controls that implement IPostBackDataHandler interface. The page checks the data in form fields that have been posted back in HTTP header and finds the data related to the controls that implements IPostBackDataHandler interface and invoked the controls’ LoadPostData method. This will populate the control’s state with the posted back data.

The best example for this is the TextBox control. When you enter a string into the TextBox and post the page back, what happens is the browser requests the same page, passing the form field values (including the TextBox's new value) in HTTP headers. If you want to see the process in action, you can enable tracing on your web page with a TextBox and a Button control and enter something into the TextBox and post the page back by clicking the Button control. If you check the tracing information, in Form Collection section, you will see the new value entered into the TextBox control.

As you can see, this stage has nothing to do with view state. One of the most common misconceptions about controls and postback values is that some developers believe view state is somehow responsible for controls remembering their postback values while, in fact, these value are retrieved from form fields and are handed over to those controls that implements IPostBackDataHandler interface.

Something else worth mentioning is the two types of postback events. Controls like Button that cause postback automatically, implement IPostBackEventHandler interface. This is raised event. On the other hand, there are controls like TextBox whose value may change by the user, while they don’t raise any events after the change. These controls implements IPostBackDataHandler interface. This is changed event.

5-Load

The next stage is Load. At this stage, view state has been loaded and controls are in a consistent state.

6-Raise Postback Events

The next stage is Raise Postback Events. As I explained before, some controls implements IPostBackDataHandler interface. Their events regarding any changes in them will be invoked at this time. For example, a TextBox’s TextChanged event or a DropDownList’s SelectedIndexChanged event. Also, for those controls like Button that implement IPostBackEventHandler interface, corresponding event will fire at this stage.

7- Save View State

The next stage is Save View State. At this time of page’s life cycle, view state is constructed. It consists of the state data that must be persisted across postbacks. This is done by calling SaveViewState method of the controls in the control hierarchy. The result is serialized into base-64 encoded string. It is in the next stage where this value is persisted in a hidden form field called __VIEWSTATE.

8-Render

The next stage is Render. At this time, the actuall HTML that must be sent to the client’s browser is generated by using the control hierarchy and posted back data. This is accomplished by calling each control’s RenderControl method.

These stages are not the only stages in page’s life cycle. But regarding view state, they take a higher priority to be explained. Now that I have discussed page’s life cycle, I can explain view state in my next post. Until then, happy coding!

Execute a synchronous method asynchronously

2010-09-11T08:44:00.000-07:00

Delegates are abstraction of one or more functions. They can be used as general function pointers, callbacks, events and threads. One of the areas where delegates can be useful is when you need to call a synchronous method asynchronously to boost the performance. In order to do so, you will need to define a delegate with the same signature as that of the method you want to execute. By defining that delegate, you will have access to two additional method called BeginInvoke and EndInvoke which can be used in asynchronous programming. For example, say we have a method that takes in two parameters and calculates their product. In real life, the execution of such a method wouldn’t take so long. Thus, to simulate a situation where you execute a long-running method, I called Sleep method of Thread class which makes the current thread suspend for a specified amount of time. Here is the code:

public int CalculateProduct(int number1, int number2)
{
Thread.Sleep(10000);
return number1 * number2;
}

This method will roughly take 10 seconds to finish. So if you execute it synchronously, the application will stop responding until the job is done. But if you execute it using a delegate’s BeginInvoke method, you could still do some more tasks in the meantime. The delegate could be something like this:

public delegate int CalculateDelegate(int number1, int number2);

I suppose you want to use this approach in a Windows Forms application. On the form, there is a button control and a label control. You run the method asynchronouly and set the value of the label control to the result of the method execution. you can add the code below to the click event handler of the button control.

int val1= 5;
int val2 = 3;
int result;
CalculateDelegate myDel = new CalculateDelegate(CalculateProduct);
IAsyncResult res = myDel.BeginInvoke(val1, val2, null, null);

//You can do some more things here

result = myDel.EndInvoke(res);

When you run BeginInvoke, a new thread is created and the job is handed over to it. This method has the same paramters of the method you assigned to the delegate plus two additional parameters. The first one is a AsyncCallback delegate which is a reference to a method you would want to be executed whenever the asynchronous execution is completed. The second parameter is a custom object that is used to pass data to the callback method. If you run BeginInvoke, you will notice that execution is not blocked upon running it. It returns immediately. The method returns an IAsyncResult which is used to check the completion of the task. In fact, there are several ways to check if the task has completed or not:

• Using EndInvoke method
• Polling
• Using AsyncWaitHandle object
• Using callback method

You can use EndInvoke method to block execution until the asynchronous method completes. Right after you run this method, the execution halts and waits for the asynchronous method to return. So you can be sure that the code you put after EndInvoke runs while the asynchronous method has returned.

You can also use polling. The BeginInvoke method returns an IAsyncResult object. You can check it constantly (for example in a while loop) to see if the asynchronous execution has completed. The IAsyncResult has a property of type Boolean called IsComplete. When the asynchronous call completes, it is set to true.

IAsyncResult has a property of type WaitHandle called AsyncWaitHandle. You can use its WaitOne method to block execution until the WaitHandle object is signaled. Then you can use EndInvoke method to finish the task.

The last approach is to use a callback method. BeginInvoke method takes in a parameter of type AsyncCallback. It’s a delegate that references a method which can be called upon completion of the asynchronous method. You can also send custom data to it using the next parameter which is of type Object.

When the execution completes, you can access the result of the method execution by running EndInvoke method. Its only parameter is the return object of the BeginInvoke method which is of type IAsyncResult and its return type is the same as that of the actual method you ran asynchronously.

Control caching based on custom information

2010-09-06T18:42:00.000-07:00

In order to use VaryByCustom attribute of OutputCache directive, you must override a method in Global.asax file. Here is a sample code:

public override string GetVaryByCustomString(HttpContext context, string custom)
{
      if (custom == "UserBased" && User.Identity.IsAuthenticated)
      {
            return User.Identity.Name;
      }
      return base.GetVaryByCustomString(context, custom);
}

Then you can set VaryByCustom attribute to “UserBased”. In this example, an instance of the cache will be created for the page based on the user’s identity and username.

Export data to a CSV file

2010-09-06T07:32:00.000-07:00

If you have your data in a DataTable object and want to export it in CSV format, you could use this sample code. I suppose that you already have a method called GetData that returns the DataTable.

DataTable dt = GetData();
HttpContext context = HttpContext.Current;
context.Response.Clear();
context.Response.ContentType = "text/csv";
context.Response.AddHeader("Content-Disposition", "attachment; filename=csvfile.csv");
context.Response.ContentEncoding = Encoding.UTF8;
for (int i = 0; i < dt.Columns.Count; i++)
{
      if(i > 0)
            context.Response.Write(",");
      context.Response.Write(dt.Columns[i].ColumnName);
}
context.Response.Write(Environment.NewLine);
foreach(DataRow row in dt.Rows)
{
      for(int i = 0; i < dt.Columns.Count; i++)
      {
            if(i > 0)
                  context.Response.Write(",");
            context.Response.Write(row[i].ToString());
      }
      context.Response.Write(Environment.NewLine);
}
context.Response.End();

Using FtpWebRequest object to upload files to a Ftp Server

2010-09-06T02:39:00.000-07:00

There are two main classes you can use to gain access to a remote Ftp Server in your ASP.NET web application, FtpWebResponse and FtpWebRequest. Here is a sample code that uses a FileUpload control to upload a file to the remote server:

FtpWebRequest wReq = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://myftpsrver.com/" + FileUpload1.FileName));
wReq.UseBinary = true;
wReq.Method = WebRequestMethods.Ftp.UploadFile;
wReq.Credentials = new NetworkCredential("admin", "mypass");
FileInfo fi = new FileInfo(FileUpload1.PostedFile.FileName);
byte[] bytes = new byte[fi.Length];
FileStream fs = fi.OpenRead();
fs.Read(bytes, 0,(int) fi.Length);
fs.Close();
Stream rs = wReq.GetRequestStream();
rs.Write(bytes, 0, bytes.Length);
rs.Close();
FtpWebResponse wResp = (FtpWebResponse)wReq.GetResponse();
Label1.Text = "Code: " + wResp.StatusCode.ToString() + ", Description: " + wResp.StatusDescription;

How to make use of Filter property of Response object

2010-09-05T05:01:00.000-07:00

Response object has a property called Filter. Not surprisingly, you can use it to filter the response data and manipulate it. First, you need to define a class that derives from Stream class. You then need to implement the required methods and properties. In this case, you will need Read, Write and Flush methods to be implemented. If you use ‘Implement abstract class’ feature, all the abstract properties and methods will be placed in the code with a throw statement. You will need to remove the default throw statement from Flush method. Otherwise you will get an error message at run time. Here is a sample class:

public class ResponseFilter: Stream
{
      Stream baseStream;
      public ResponseFilter(Stream responseStream)
      {
            if (responseStream == null)
            {
                  throw new ArgumentNullException("ResponseStream");
            }
            baseStream = responseStream;
      }
      public override void Write(byte[] buffer, int offset, int count)
      {
            string text = Encoding.UTF8.GetString(buffer, offset, count);
            text = text.Replace("old_text", "new_text");
            buffer = Encoding.UTF8.GetBytes(text);
            baseStream.Write(buffer, 0, buffer.Length);
      }
      public override int Read(byte[] buffer, int offset, int count)
      {
            return baseStream.Read(buffer, offset, count);
      }
}

In the handler method of the Page’s Load event, Filter property needs to be set to an instance of the newly created class by passing in the Filter property to the constructor:

protected void Page_Load(object sender, EventArgs e)
{
      Response.Filter = new ResponseFilter(Response.Filter);
}

In this example, all occurances of the string "old_text" will be replaced with "new_text". It's not a very sophisticated example, but it shows how you can filter the response and modify the stream.

Create and use a custom configuration section in web.config

2010-09-05T01:06:00.000-07:00

If you want to have a custom configuration section like the one defined below, you will have to define a class to handle it. The class needs to derive from ConfigurationSection.

<mySettings myval1="customvalue1" myval2="customvalue2" myval3="customvalue3"/>

Also you will have to define its structure in the configSections of the web.config:

<configuration>
      <configSections>
            <section name="mySettings" type="myNameSpace.mySettings"/>
      </configSections>
...
</configuration>

Note that the configSections, if defined, has to be the first child element of configuration element in the web.config file. The class can be defined this way:

public class mySettings: System.Configuration.ConfigurationSection
{
      [ConfigurationProperty("myval1", IsRequired=true)]
      public string myval1
      {
            get{return this["myval1"].ToString();}
            set{this["myval1"] = value;}
      }

      [ConfigurationProperty("myval2", IsRequired = true)]
      public string myval2
      {
            get{return this["myval2"].ToString();}
            set{this["myval2"] = value;}
      }

      [ConfigurationProperty("myval3", IsRequired = true)]
      public string myval3
      {
            get{return this["myval3"].ToString();}
            set{this["myval3"] = value;}
      }
}

Object Oriented Programming

2010-09-04T04:44:00.000-07:00

C# is an Object Oriented language. Even if it is not pure Object Oriented like Eiffel or SmallTalk, it was designed mainly for Objected Oriented programming. Ok, what is Object Oriented programming?
In Object Oriented Programming or OOP, we map identities in real world to objects and model the actions as methods. What takes priority in OOP is the object, as opposed to the actions related to it.
In OOP, there are a couple of concepts that we might ignore as programmers most of the time, while having a solid grasp of what these concepts are, is imporatning to create robust OOP application.

Level of abstraction:
In real life, we try to reduce the number or the complexity of things we deal with. It means we work at a specific level of details. In OOP terminology, this is called the level of abstraction. If you want to turn on the TV and watch a program, you are not going to have to open the TV set or reprogram the electronic chips in it, even if your expertise is assmebling television sets. This means you abstract away the details you don't want to get involved in.

Classification:
We classify almost everything to reduce the number of things we have to remember. If you are asked to use a brand new mobile phone, in spite of being unfamiliar with that particular phone, you will still be able to perform the basic operations on it, because at the end of the day, it's a mobile phone and you are likely to have already operated one. The new type of mobile phone shares most of the properties of other mobile phones. So we can say the phone inherits the common properties and actions from a general phone.
In C#, classification has been implemented by Inheritance. A class can derives from another one. This way, it inherits the properties and methods of the base class. The first class is a child of the second class (the parents class). The parent class can have several child classes, while each class can only have one parent class.
You may wonder how we benefit from Inheritance. In terms of OOP in C#, Inheritance introduces these benefits:

It reduces the amount of typing. If you have several classes that have some properties in common, you can create a base class defining the common properties and behaviors, then derive the other classes from the base class.
It facilitates reusability. Well, you shouldn't reinvent the wheel. Starting a software from the scratch is a pain in the neck, while you could use already existing components. By using Inheritance, you can adapt existing classes to your program while leaving the internals of the classes intact.
Updates will be integrated with much less hassle. If you change a base class, the change will be reflected in all child classes as well.

Polymorphism:
Late binding or polymorphism is the ability to decide the type at run time. This concept is so important that if a language supports Objects but not polymorphism is called Object Base (such as Ada).
Suppose you have a base class and a sub class that inherits from it.

public class baseClass
{
      int prop1;
      int prop2;
      public int Prop1{get{return prop1;}set{prop1 = value;}}
      public int Prop2{get{return prop2;}set{prop2 = value;}}
      public virtual int Operation()
      {
            return Prop1 * Prop2;
      }
}

public class subClass : baseClass
{
      public override int Operation()
      {
            return Prop1 * Prop2 / 2;
      }
}

...

public void Test()
{
      baseClass b;
      b = new subClass();
      b.Prop1 = 4;
      b.Prop2 = 3;
      int result = b.Operation();
}

In method Test, object b is a reference to baseClass while it actually contains an object of type subClass. So, to the compiler, it is a baseClass, while at run time, polymorphism will let you take the appropriate type. The method Operation is a virtual method, which means it can be overriden in the sub classes.
If you run this code, the result will be 6, not 12. That's polymorphism! At run time, the most appropriate type was chosen, which was baseClass and its method was executed. Of course, if you don't override the method and hide the method by using the keyword 'new', the result will be different. This happens because you break the chain of hierarchy by using 'new'. You can check it out by debugging and stepping into the method.

Covariance and Contravariance

2010-09-04T00:52:00.000-07:00

In C#, there are two terms defined regarding delegates; Covariance and Contravariance. These two concepts exapand the set of methods that you can assign to a delegate. They still maintain type-safeness. I’d better clarify it using an example. Suppose that you have these classes:

public class P1
{
…
}
public class C1 : P1
{
…
}

public class P2
{
…
}

public class C2 : P2
{
…
}

And you have a delegate defined this way:

public delegate P1 myDelegate(C2 c2);

If you intend to use this delegate, you will have to assign a method with a same signature. For example:

public P1 myMethod(C2 c2)
{
…
}

But not only can you use any method with a return type of P1, but any child class of P1 (in this case C1) in the chain of hierarchy. This is called Covariance.
On the other hand, you can use any method with a paramater of type C2 or any super type of C2 (in this case P2). This is called Contravariance.

Access the control that has invoked a method in JavaScript

2010-09-03T23:12:00.000-07:00

Suppose that you have a function in Javascript that can be invoked by several controls. In order to access the actual control that has invoked the method, you can use the code shown here:

<input id="Button1" type="button" value="button" onclick="myfunc();"/>

function myfunc()
{
window.event.srcElement.style.color = 'red';
}

In this example, if you click the button (or any other buttons with their onclick set to 'myfunc'), its forecolor will change to red.

Access a control in a web user control from within JavaScript

2010-09-03T23:04:00.000-07:00

Suppose that you have a page that contains a web user control that, in turn, includes a Button control. If you want to access the button properties or methods, you can expose a property in the user control that returns the property or the method result. To use it in JavaScript, use the syntax shown below:

<script language="javascript" type="text/javascript">
function myFunction()
{
      var btnid = '<%= WebUserControl1.ButtonClientID %>';
      document.getElementById(btnid).style.color= 'green';
}
</script>

The code assumes that there is a property named ButtonClientID defined in the web user control.

public string ButtonClientID
{
      get
      {
            return Button1.ClientID;
      }
}

User selectable Themes

2010-09-03T22:55:00.000-07:00

In order to let user select a theme, for example defined as values in a DropDowList control, you need to first override PreInit method of the page and then access the control using Request.Form syntax.

protected override void OnPreInit(EventArgs e)
{
this.Master = Request.Form[this.Master.FindControl("DropDownList1").UniqueID];
}

It's important to note that you cannot access the DropDownList control at this stage of the page life cycle. That is why you need to resort to Form collection and FindControl method.

Handle events in Master and Content pages

2010-09-03T22:50:00.000-07:00

If you have a web control on a master page and intend to access it on a content page, you can do so by exposing the control as a public property. This way you can register a handler for the control which is actually a property, in the content page.
Another way is to define your custom delegate and use it to define your custom event in the master page. Then in your content page, you can register a handler for the master page event as the code below shows:

protected void Page_Load(object sender, EventArgs e)
{
this.Master.selectionChangeEvent += Content_Changed;
}

public void Content_Changed(object sender, TypeSelectionEventArgs args)
{
Label1.Text = "Content changed to " + args.SelectedType.ToString();
}

You will need to define @MasterType directive in your content page. Also, you will more likely have your own custom data that needs to be transferred through this procedure. You can define your own Enums and Classes and pass it to your delegate to accomplish the job.

Multiple File Uploads

2010-09-01T01:26:00.000-07:00

If you want to add multiple File Upload controls on demand, you will need a Javascript code to add the controls. The form could look like this:

<form id="form1" runat="server" enctype="multipart/form-data">

Here is a sample Javascript code that accomplishes the job:

<script type="text/javascript">
function addFileUploadBox()
{
      if(! document.getElementById || !document.createElement)
      {
            return false;
      }
      var uploadArea = document.getElementById("upload-area");
      if(!uploadArea)
      {
            return;
      }
      var newLine = document.createElement("br");
      uploadArea.appendChild(newLine);
      var newLine = document.createElement("br");
      uploadArea.appendChild(newLine);
      var newUploadBox = document.createElement("input");
      newUploadBox.type = "file";
      newUploadBox.size = "60";
      if(!addFileUploadBox.lastAssignedId)
            addFileUploadBox.lastAssignedId = 100;
      newUploadBox.setAttribute("id","FileField" +    addFileUploadBox.lastAssignedId);
      newUploadBox.setAttribute("name","FileField" + addFileUploadBox.lastAssignedId);
      uploadArea.appendChild(newUploadBox);
      addFileUploadBox.lastAssignedId++;
}
</script>

In code behind, you need to iterate through the Files property of the Request object. It is an HttpFileCollection:

HttpFileCollection uploads = HttpContext.Current.Request.Files;
for (int i = 0; i < uploads.Count; i++)
{
      if (uploads[i].ContentLength > 0)
      {
            string c = Path.GetFileName(uploads[i].FileName);
            try
            {
                  string path = MapPath("uploads/") + c;
                  FileField.PostedFile.SaveAs(path);
            }
            catch{}
      }
}

Http Modules

2010-08-31T00:56:00.000-07:00

What is an Http Module?
An Http Module is an assembly that implements IHttpModule interface and serves as a component that can be plugged into ASP.NET request processing pipeline. This is performed by registering for a set of events.

To implement IHttpModule, you need to implement its two methods; Init and Dispose. Here is a couple of events the module can register for. You hook up to those events in Init method.

AcquireRequestState
AuthenticateRequest
AuthorizeRequest
BeginRequest
Disposed
EndRequest
Error

Before I dive into the details, I should mention something I experienced in IIS 7. When implementing HttpModule, the website must use an application pool with managed pipeline mode of Classic. If integrated mode is chosen, the code in the module will not be hit.

To implement an HttpModule, use IHttpModule interface and implement Dispose and Init methods in your module class (in the example, Module1). In Init method which takes in an HttpApplication object, you can register handlers for several events.

public class Module1 : IHttpModule
{
      public void Init(HttpApplication context)
      {
            context.BeginRequest += new EventHandler(context_BeginRequest);
            context.EndRequest += new EventHandler(context_EndRequest);
      }

      void context_BeginRequest(object sender, EventArgs e)
      {
            HttpApplication app = (HttpApplication)sender;
            app.Context.Response.Output.Write("This is the beginning.<br/>");
      }
}

Then in the web.config file, you need to add the code below to register the module:

A good example of an HttpModule could be Url Rewriting:

void context_BeginRequest(object sender, EventArgs e)
{
      HttpApplication app = (HttpApplication)sender;
      string url = app.Request.Url.ToString();
      if (url.Contains("product1.aspx"))
      {
            app.Context.RewritePath("det.aspx?name=product1");
      }
      else if(url.Contains("product2.aspx"))
      {
            app.Context.RewritePath("det.aspx?name=product2");
      }
}

Here arises a small problem. In this example, if you have a button in det.aspx page, by clicking it, a postback occurs which changes the Url to the rewritten path. To avoid this, you will need to create a class library and implement a class that derives from System.Web.UI.HtmlControls.HtmlForm:

namespace ActionlessForm

{
      public class Form :System.Web.UI.HtmlControls.HtmlForm
      {
            protected override void RenderAttributes(System.Web.UI.HtmlTextWriter writer)
            {
                  writer.WriteAttribute("name", this.Name);
                  base.Attributes.Remove("name");
                  writer.WriteAttribute("method", this.Name);
                  base.Attributes.Remove("method");
                  this.Attributes.Render(writer);
                  base.Attributes.Remove("action");
                  if (base.ID != null)
                  {
                        writer.WriteAttribute("id", base.ClientID);
                  }
          }
      }
}

You need to add a reference to the new class library in the website and add a Register directive to det.aspx page:

<%@ Register TagPrefix="mnf" Namespace="ActionlessForm" Assembly="ActionlessForm" %>

Then you will need to set a prefix for the page’s form control as follows:

<mnf:form id="form1" runat="server">
…
</mnf:form>

Manage the content of navigation controls based on the roles defined in ASP.NET

2010-08-30T13:35:00.000-07:00

This one is really cool! I suppose you have already set up role and membership in your ASP.NET application. If you have a TreeView or a Menu control that uses SiteMapDataSource and in the Web.sitemap file, you have elements pointing to files in the folders the access rule of which you have set, it makes sense if you want to show and hide the menu or treeview items (nodes) according to the user’s roles. This can be accomplished by a setting added to the web.config file:

<siteMap defaultProvider="default">
      <providers>
            <clear/>
            <add name="default" type="System.Web.XmlSiteMapProvider"
securityTrimmingEnabled="true" siteMapFile="Web.sitemap" />
      </providers>
</siteMap>

As you can see, the magic is done by an attribute called securityTrimmingEnabled.

Reset the state of a page containing web parts

2010-08-30T13:24:00.000-07:00

In a page containing web parts, you can tweak the location and appearance of the web parts. Then you may want to clean the mess and reset the state of the web parts to the original one. You can do so by running this code:

PersonalizationAdministration.ResetAllState(PersonalizationScope.User);

Cache API

2010-08-30T03:20:00.000-07:00

Imagine a situation where you want to load data from an XML file and you want to avoid redundant IO operation by caching the data and invalidate cache if the file changes. To do the job, you can use a CacheDependency object and pass in the path to the file to the constructor. Here is the complete code:

DataSet ds = null;
ds = (DataSet)Cache["_records"];
if (ds == null)
{
      string path = Server.MapPath("records.xml");
      ds = new DataSet();
      ds.ReadXml(path);
      CacheDependency cd = new CacheDependency(path);
      Cache.Insert("_records", ds, cd);
}
GridView1.DataSource = ds;
GridView1.DataBind();

The codes checks if the cache already contains the data. If not, it refers to the file and loads the data and inserts it into the cache. Then it is displayed in a GridView control.

In order to remove the cache programmatically, you can use this code:

Cache.Remove("_records");

Execute a code regardless of caching using Substitution control

2010-08-30T03:08:00.000-07:00

When you want an arbitrary code to be executed irrespective of caching settings in a page, you can use a Substitution control. Its main property is MethodName which points to the static method that is to be executed. Its signature needs to look like this:
static string Method1(HttpContext context)
{
…
}

Caching in ASP.NET pages

2010-08-30T01:30:00.000-07:00

The simplest situation in caching is when you need to cache a page for a specific number of seconds regardless of the page parameters. The code below does the magic for 5 seconds:

<%@ OutputCache Duration="5" VaryByParam="*" %>

If you show data from a database, for example SQL Server, this method will not display the last version of the data. If a new row is added to the database within the amount of time specified as Duration, it will not be shown until the specified time elapses. To make the page display the latest version of data, you need a SqlCacheDependency object. There are two methods to perform this job. The first one is polling and is supported by both SQL Server 2000 and SQL Server 2005. The second one is using broker service which is supported in SQL Server 2005.

To enable the first method on a SQL Server database, you need to run aspnet_regsql command with a few switches indicating the target database and tables for caching.

C:\>aspnet_regsql –S myServer –U myUsername –P myPassword –d myDatabase –ed –et –t myTable

This command adds a table named ‘AspNet_SqlCacheTablesForChangeNotification’ and a trigger named ‘myTable_AspNet_SqlCacheNotification_Trigger’ to the database. The table is going to be polled by ASP.NET to see if there is any change.
Also, you need to add the code below in the web.config file:

<caching>
      <sqlCacheDependency enabled="true" pollTime="2000">
            <databases>
                  <add connectionStringName="myDBCS" name="myDBCS"/>
            </databases>
      </sqlCacheDependency>
</caching>

Here I assume that we have a connection string defined as myDBCS. Also the OutputCache directive will need an additional attribute:

<%@ OutputCache Duration="5" VaryByParam="*" SqlDependency="myDBCS:myTable"%>

To enable the second method, you should change the code above to this:

<%@ OutputCache Duration="5" VaryByParam="*" SqlDependency="CommandNotification"%>

Also, you need to add a Global.asax file to the application and add the code snippet below to start SQL dependency:

System.Data.SqlClient.SqlDependency.Start(ConfigurationManager.ConnectionStrings["myDBCS"].ConnectionString);

Note: It is very important to know that you must include the database schema in the select query supplied in the SqlDataSource object you use to let the broker service work properly.

<asp:SqlDataSource ID="SqlDataSource1" runat="server"
ConnectionString="<%$ ConnectionStrings: myDBCS %>"
SelectCommand="SELECT column1, column2 from dbo.table1">
</asp:SqlDataSource>

URL mapping to map obscure URLs to more human-readable URLs

2010-08-30T01:06:00.000-07:00

There might be situations where you have long ugly file names on your website and you have links to them. You would not want to have a link to something like 7bd137a5-8a61-2a21-eb82-3352af7ec87d.html in your web application. There is an easy way to map such ugly Urls to more readable Urls. You need to enable Url mapping in web.config and then add elements to urlMappings tag. The code below is self descriptive enough.

<urlMappings enabled="true">
<add url="~/page.html" mappedUrl="~/7bd137a5-8a61-2a21-eb82-3352af7ec87d.html"/>
</urlMappings>

Protect web.config sections

2010-08-28T23:38:00.000-07:00

There are always sections in web.config files that contain confidential information, like the database credentials in connection string. So you may want to encrypt it so that the bad guys who gain access to the web.config cannot steal your secret information. This is not the only possible scenario. Suppose that your shared hosting system offers you a service to edit your files online. If someone sniffs the network, they can easily check your sent and received data and if the connection is not secure and your data is transmitted in plain text, your confidential data will be disclosed.

Here is a common way to encrypt a section in web.config:

void EncryptConfig(bool encrypt)
{
      string path = Request.ApplicationPath;
      Configuration config = WebConfigurationManager.OpenWebConfiguration(path);
      ConfigurationSection sec = config.GetSection("connectionStrings");
      if (encrypt)
      {
            sec.SectionInformation.ProtectSection("RSAProtectedConfigurationProvider");
      }
      else
      {
            sec.SectionInformation.UnprotectSection();
      }
      config.Save();
}

There is an alternative to the parameter that the protectSection takes in. Instead of RSAProtectedConfigurationProvider, you can use DataProtectionConfigurationProvider.

The second way to achieve the same goal is to use aspnet_regiis with a couple of switches to encrypt a section in the web.config file. Run Visual Studio command prompt and execute aspnet_regiis command followed by /pef switch, then the section you want to protect, and lastly the application path.

C:\>aspnet_regiis /pef "connectionStrings" "C:\...\MyWebApp"
Encrypting Configuration section...
Succeeded!

In the sample above, the connectionStrings section of the web.config file in MyWebApp application is encrypted and protected (You need to specify the full path to the application). To unprotect a section, replace the switch /pef with /pdf.

C# history

2010-08-28T06:09:00.000-07:00

Since the C# language was introduced, it has been evolving. The other day, I was thinking how different it has become, so to make it more accurate, I downloaded the specification files from microsoft website and other resources. Here is a short list of the changes after C# 2.0 was introduced:

New features added to C# 2.0	Generics Anonymous methods Iterators Partial types Nullable types
New features added to C# 3.0	Implicitly typed local variables Lambda expressions Object and collection initializers Anonymous types Implicitly typed arrays Query expressions Expression trees
New features added to C# 4.0	Dynamic binding Named and optional arguments COM interoperability Covariance and Contravariance

I don't think the list is complete. So if you think there is something wrong or you could add an item to it, let me know.

Plan

2010-08-28T05:40:00.000-07:00

I have recently been watching some videos I downloaded from http://www.asp.net/ a while ago. I've found some of them really helpful. I thought I could put the codes here so that I can refer to them later and who knows, maybe it will resolve the problems of someone in trouble!