Search results matching tag 'Code'

How to Add a Locked Header Row to an ASP.NET GridView Control

Anonymous — Wed, 24 Jun 2009 00:22:00 GMT

The GridView control is often used to display tabular data, much like an Excel spreadsheet. However, unlike Excel, the GridView control doesn't have any automatic way of locking the header row so that it doesn't scroll out of view.

Check out this example of a GridView within a DIV with the overflow-Y property set to scroll. Notice that as you scroll the GridView, the header row scrolls out of view. It would be more convenient to have a locked header row so that the header row is always visible regardless of the scoll position of the GridView. It would also be nice to have a header row that dynamically configured itself as per the data source so that if we add a new field to the GridView, a corresponding column automatically gets added to the locked header row.

Here's another example, but this time, the header row stays locked at the top of the GridView so that you can scroll without losing track of column names. There are a few steps required to implement this functionality.

Create a DIV on the page to contain the header row and set the DIV (either statically or dynamically) to the same width as the DIV that contains the GridView.
Insert an ASP.NET Table control into the header DIV.
In Page_Init, dynamically add the necessary cells to the header table and set the appropriate properties so that it matches the appearance of the rest of the GridView.
Check for sortable columns and dynamically add sorting LinkButtons to the header row.
Add code to handle the LinkButton's Click event and sort appropriately.

Let's go through each of these steps. (If you'd prefer to work with a working project, you can download the project at the end of this post.)

Creating the Header DIV and Inserting an ASP.NET Table Control (Steps 1 and 2)

To create a locked header row, we need to disable the header for the GridView control and instead dynamically create our own header.

Select the GridView control and change the ShowHeader property to false.
Create a new DIV above the DIV containing the GridView control using the following code.

<div id="DivHeader" style="vertical-align:top;width:650px;">
    <asp:Table ID="HeaderTable" runat="server"
               CellPadding="4"
               CellSpacing="0"
               Font-Size="11pt"
               BackColor="#274511"
               ForeColor="White">
    </asp:Table>
</div>

Note that the properties for my Table control were derived from the theme applied to my sample page. You can set these properties as you wish or dynamically set them so that they adjust to the GridView's properties automatically.

Notice that this Table control doesn't contain any cells. We'll add the necessary cells in Page_Init in the next step.

Add Code to Page_Init to Dynamically Create Header Cells and LinkButtons (Steps 3 and 4)

To dynamically add the cells for the header table, add the following code to Page_Init.

protected void Page_Init(object sender, EventArgs e)
{
    TableRow headerRow = new TableRow();

    for (int x = 0; x < GridView1.Columns.Count; x++)
    {
        DataControlField col = GridView1.Columns[x];

        TableCell headerCell = new TableCell();
        headerCell.BorderStyle = BorderStyle.Solid;
        headerCell.BorderWidth = 1;
        headerCell.Font.Bold = true;

        // if the column has a SortExpression, we want to allow
        // sorting by that column. Therefore, we create a linkbutton
        // on those columns.
        if (col.SortExpression != "")
        {
            LinkButton lnkHeader = new LinkButton();
            lnkHeader.PostBackUrl = HttpContext.Current.Request.Url.LocalPath;
            lnkHeader.CommandArgument = col.SortExpression;
            lnkHeader.ForeColor = System.Drawing.Color.White;
            lnkHeader.Text = col.HeaderText;
            lnkHeader.Click += new EventHandler(HeaderLink_Click);
            headerCell.Controls.Add(lnkHeader);
        }
        else
        {
            headerCell.Text = col.HeaderText;
        }

        headerCell.Width = col.ItemStyle.Width;
        headerRow.Cells.Add(headerCell);

    }

    HeaderTable.Rows.Add(headerRow);
}

This code adds a new TableCell to the header table and then sets specific properties on that TableCell based on whether or not the GridView's column has a SortExpression specified. If it doesn't, this code just sets the Text property of the cell to the GridView column's HeaderText property. Otherwise, it creates a LinkButton and sets the following properties on it.

PostBackUrl - Set to the local URL of the current request.
CommandArgument - Set to the SortExpression of the GridView's column so that we can apply it when the LinkButton is clicked.
ForeColor - Set to White in my example, but you can set this dynamically if you wish to make the example more generic.
Text - Set to the GridView column's HeaderText property.

I also add a new event handler for the Click event of the LinkButton control. Let's look at the code for that event.

Code for the LinkButton's Click Event

The code in the LinkButton's Click event applies the necessary SortExpression based on which LinkButton was clicked. The code for the Click event appears below.

protected void HeaderLink_Click(object sender, System.EventArgs e)
{
    LinkButton lnkHeader = (LinkButton)sender;
    SortDirection direction = SortDirection.Ascending;

    // the CommandArgument of each linkbutton contains the sortexpression
    // for the column that was clicked.
    if (GridView1.SortExpression == lnkHeader.CommandArgument)
    {
        if (GridView1.SortDirection == SortDirection.Ascending)
        {
            direction = SortDirection.Descending;
        }
    }

    GridView1.Sort(lnkHeader.CommandArgument, direction);
}

This code checks the CommandArgument for the LinkButton that was clicked (retrieved from the EventArgs) and applies the ascending or descending SortDirection based upon the result. It then calls the Sort method on the GridView.

AJAX-Enabling the Sample

If you are using ASP.NET AJAX, the code as-is will not do a partial postback. In order to have the LinkButtons sort using an AJAX async postback, you need to replace the line of code that sets the PostBackUrl property of the LinkButton with the following code.

lnkHeader.ID = "Sort" + col.HeaderText;

Doing this will allow ASP.NET Viewstate to track the LinkButton so that ASP.NET AJAX will work with the LinkButton.

Using this example, you can easily apply a locked header row to your GridView controls. If you'd like the completed sample project, you can download it below.

Sample Project

Size: 12KB
Download Now

Note: This download is hosted on my personal site, JimcoBooks.com.

Improving Time-Critical Code written in C

Anonymous — Tue, 02 Sep 2008 10:00:33 GMT

Writing web pages is very similar to writing any other type of code. You have to understand how it is going to be used and where you need to really make things run as quickly as possible.

There are a number of tips on this blog already that deal with managed code and ways to optimize it. But one of the things that we don't look at as often are other areas of code that we are dependant on. For example, if you P/Invoke a native function, whatever it is doing, is something that you need to be aware of. Because there is a lot of native functionality that is still available to us, I wanted to remind everyone of some of the tips you can use when dealing with C/C++ code.

A great place to start is with: Tips for Improving Time-Critical Code. While most of these things don't apply to .NET based code, they are all very important when working with native code. Another useful thing to be aware of is what the compiler can do for you. For example, take a look at Optimizing Your Code with Visual C++.

Feel free to add your own tips or pointers here. I'd like to get a good collection going and then I can share that out as well.

Debugging .NET Framework Source Code

Anonymous — Tue, 13 May 2008 12:45:10 GMT

I am not sure how many people are familiar with the .NET Reference Source project, but if you do a lot of debugging of .NET code, chances are that you have had a situation where you wanted to be able to step into the .NET Source from within Visual Studio.

Well, thanks to this project. This is now something that you can accomplish. It just takes a few steps and you will be off and running.

I don’t want to go into the specific steps to get this setup as Shawn did a fantastic job explaining them on his blog here. This is also mentioned on ScottGu’s blog with another example.

This is a big win for everyone. If you have any problems with this and Shawn’s blog doesn’t have your issue documented, feel free to post it here or on the MSDN Forum.

Keep in mind that you view this through a read-only reference license so feel free to look at the code.

Visual Studio Designer not Respecting Assembly Binding Redirection

Anonymous — Thu, 24 Apr 2008 19:16:33 GMT

So we recently came across an issue where Visual Studio 2005 and 2008 Designers were not respecting assembly binding redirection.

Scenario

We have a file which is now version 2 and stored in the GAC. So the assembly version is 2.0.0.0. We have some existing customers using version 1 so we want to be able to use Assembly Binding Redirection to point them to the new version of the assembly.

For more information on configuring this, check out Configuring Assembly Binding Redirection.

The web page has code like:

<tc:TestContacts ID="QuickContacts1" runat="server">
    <tc:AContact Name="Test Tester" 
        Email="test@test.com" 
        Phone="(999) 555-1212" />
    <tc:AContact Email="no@spam.thx" 
        Name="Mr. A. Nonymous" 
        Phone="(999) 555-1234" />
</tc:TestContacts>

We also have a Register Assembly line at the top that points to the 1.0.0.0 version of the file. And we have an entry in our web.config that looks like this:

<runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
        <dependentAssembly>
            <assemblyIdentity name="Tester1" publicKeyToken="6ace53ab3256c766"/>
            <bindingRedirect oldVersion="1.0.0.0-1.1.0.0"
                             newVersion="2.0.0.0"/>
        </dependentAssembly>
    </assemblyBinding>
</runtime>

We could have done this in a policy file and got the same results. So now we open this file in Design view inside Visual Studio and change a property of the TestContacts control. For instance, adding an AccessKey. Switching back to the Source view, we will now see:

<tc:TestContacts ID="QuickContacts1" runat="server">
    <samples.aspnet.cs.controls.acontact Name="Test Tester" 
        Email="test@test.com" 
        Phone="(999) 555-1212" />
    <samples.aspnet.cs.controls.acontact Email="no@spam.thx" 
        Name="Mr. A. Nonymous" 
        Phone="(999) 555-1234" />
</tc:TestContacts>

This breaks the site and it no longer works.

Note: Assembly Binding Redirection works find in other scenarios, it just doesn’t work right inside the Designer.

Resolutions

There are two ways to resolve this issue.

Don’t use Assembly Binding Redirection at all and just leave the 1.0.0.0 version of the file in the GAC. You will see a lot of .NET files do this, there are versions for .NET 1.0, 1.1, 2.0, etc all inside the GAC at the same time.
Change the existing files so that the Register Assembly line at the top of the web page points to the 2.0.0.0 version of the file.

Keep in mind that this is only a problem if you are actively changing the older files already, if you don’t touch the file it will be fine since this issue is only with the Designer. So since you are already updating the file, it is trivial to update this line also.

We are looking into this issue also, so there may be another resolution posted in the future.

Making an Asynchronous Call using the Impersonation Identity

Anonymous — Wed, 23 Apr 2008 02:20:09 GMT

If you try to make an asynchronous call, you will notice that the thread that executes the call doesn't run under the same account as the thread that called it, assuming you are using impersonation.

There are a number of ways to change this if you would like to have it use the same identity.

Method 1

The Thread used by BeginInvoke doesn't copy the windowsIdentity from the calling thread. You have to impersonate the new thread manually:
Before calling BeginInvoke save the current identity into a variable:

Dim identity as WindowsIdentity
identity = System.Security.Principal.WindowsIdentity.GetCurrent()

Inside the asynchronously called method use this variable and execute:

identity.Impersonate

From that point on the asynchronous call uses the same privileges than the calling thread and it should not be a problem to execute the callback.

Method 2

If the thread making the asynchronous call creates the thread being used, and you are using .NET 2.0 or later, you can set the following in the config file. For ASP.NET, use the aspnet.config file:

<configuration>
 <runtime>
   <alwaysFlowImpersonationPolicy enabled="true"/>
   <legacyImpersonationPolicy enabled="false"/>
 </runtime>
</configuration>

Method 3

Another way to handle this is if you have an account that you want the asynchronous call to run under, you can impersonate that account, run what you need to, and then undo the impersonation. The following code will do that:

using System.Security.Principal;
...
WindowsIdentity wi = new WindowsIdentity(userName@fullyqualifieddomainName);
WindowsImpersonationContext ctx = null;
try
{
  ctx = wi.Impersonate();
  // Thread is now impersonating
}
catch
{
  // Prevent exceptions propagating.
}
finally
{
  // Ensure impersonation is reverted
  ctx.Undo();
}

Additional Information

For more information, you can check out these links