Ezequiel Espíndola's Blog : ASP.NET 2.0

ASP.NET 2.0: The "How Do I" Video Series

eespindola — Sun, 26 Feb 2006 17:53:00 GMT

A while ago I posted about ASP.NET 2.0 learning resources. This post about ASP.NET 2.0 Membership, Roles, Forms Authentication and Security Resources pointed me to an excellent series of videos called The “How Do I” Video Series. Be sure to check them.

Pattern to handle QueryString values on ASP.NET 2.0 pages

eespindola — Sun, 26 Feb 2006 15:09:00 GMT

Here you have a good pattern to handle values from the QueryString on your ASP.NET 2.0 pages:

int _id = 0;
string id = Request.QueryString["id"];
if (!String.IsNullOrEmpty(id))
{
int.TryParse(id, out _id);
}

For more information or to discuss about it go to Getting IDs from the QueryString.

Selecting a default item after a DataBound operation in ASP.NET 2.0

eespindola — Tue, 21 Feb 2006 18:18:00 GMT

When using the new DataSource objects you don’t need to write code for data binding. Code like this is not needed anymore:

DropDownList1.DataSource = DataSet1;
DropDownList1.DataBind();
DropDownList1.Items.FindByValue(Request.QueryString[“state”]).Selected = true;

You simply point the DataSourceID property of the DropDownList to a properly setup SqlDataSource or ObjectDataSource and voila! binding occurs behind scenes without need for code.

However, how do you solve what comes after the call to DataBind(), the line that selects a current default value and could previously been in the Page_Load event or DataBind overridden method?

The easy way to do it is to define a handler for the OnDataBound event that gets fired after the control has been databound.

<asp:DropDownList ID="DropDownList1" runat="server" DataSourceID="SqlDataSource1" DataTextField="Name" DataValueField="Id" OnDataBound="DropDownList1_DataBound" />

protected void DropDownList1_DataBound(object sender, EventArgs e)
{
string selectedValue = Request.QueryString["id"];
if (selectedValue != null)
{
    ListItem li = DropDownList1.Items.FindByValue(selectedValue);
    if (li != null)
    {
      li.Selected = true;
    }
}
}

This simple code checks to see if a value has been passed through the QueryString and that it actually exists on the ListItemCollection of the DropDownList. If everything goes fine, the item for the value passed will be selected.

Another related and interesting new feature of the controls derived from ListControl is the property “AppendDataBoundItems”.

In ASP.NET 1.x the DataBind operation always replaced the existing items, so you would have to bind items first and then add any custom values. You couldn’t specify them in a declarative way with an <asp:ListItem> tag on the page markup, but needed to add them programmatically. Now, if you set AppendDataBoundItems=”true” the existing items are kept in the collection.

New ASP.NET Starter Kit: eBay Selling Starter Kit

eespindola — Tue, 21 Feb 2006 11:09:00 GMT

Scott Guthrie have been posting a ton of interesting content lately on his blog. I found thru it that a new ASP.NET 2.0 Starter Kit is on the streets. It's the eBay Selling Starter Kit for VB.NET. I would say too bad if it's only in VB.NET, but I will download it anyway to take a look.

Scott notes that this is different from the ASP.NET 2.0 PayPal-enabled Commerce Starter Kit. I've been playing with the Commerce Starter Kit and can highly recommend it. It's more like the lite version of a product than a Starter Kit and a fun way to learn ASP.NET 2.0.

Connection String Settings In ASP.NET 2.0

eespindola — Sun, 08 Jan 2006 20:43:00 GMT

There is a new configuration section for connection strings on ASP.NET 2.0 called <connectionStrings>. It is something so simple it seems dumb, but it helps to enforce recommended practices from the start. I really like this feature because of that.

In ASP.NET 1.x you could put your connection string anywhere you like it. It was normally on the web.config’s AppSettings section, but there wasn’t any enforcement from the framework on where to put it or how to retrieve it.

In ASP.NET 2.0 you can have all your connection strings on the <connectionStrings> section of the web.config, benefiting from centralized management and also enhanced security by encrypting them if you want.

<configuration>
<connectionStrings>
<add name="Pubs" connectionString="Server=(local);Integrated Security=True;Database=pubs;" providerName="System.Data.SqlClient" />
</connectionStrings>
</configuration>

If you use these features, you can also make use of a new declarative expression that allows you to retrieve the Connection String by name and avoid hard-coding it on the page code.

This tag would retrieve the Connection String setup above by its name, “Pubs”:

<asp:SqlDataSource ID="SqlDataSource1" runat="server"
ConnectionString="<%$ ConnectionStrings:Pubs %>" />

And you can also specify an expression for the ProviderName property of SqlDataSource:

<asp:SqlDataSource ID="SqlDataSource1" runat="server"
ConnectionString="<%$ ConnectionStrings:Pubs %>"
ProviderName="<%$ ConnectionStrings:Pubs.ProviderName %>" />

ASP.NET 2.0 Compilation Model

eespindola — Fri, 09 Dec 2005 22:06:00 GMT

I'm still trying to discover all about the new ASP.NET 2.0 project model. The fact that you don't need IIS, not even a Web Project makes development so much faster and easier. There is no web project actually, any folder can be a Web Site. This doesn't mean you should grab your whole application and throw it inside the App_Code folder. Application layers should still be on their own class library projects and assemblies as necessary.

I've found some interesting posts on the matter from Scott Allen where he explains that contrary to be worse than in ASP.NET 1.x, the new compilation model is actually better. This relates to my post about the ASP.NET 2.0 simplified code-behind model and my question about why do you need an Inherits attribute on the @Page declaration. As a matter of fact, you probably don't need it, it should be named something else, like PartialClassName. As Scott explains, the compilation model now takes both parts, aspx page and code-behind and merge them into one assembly under the same Class name. There is no inheritance going on there at least as I can see.

In another post he mades a point related to the ASP.NET Web Site Precompilation about how in some cases you would need to specify a @Reference directive to make things work. Take note.

So far, I'm enjoying this stuff.

App_Code & Bin Folders, Making Code Accessible from your Web Pages

eespindola — Wed, 07 Dec 2005 19:34:00 GMT

The App_Code Folder

There are a number of new App_NNN folders in ASP.NET 2.0 with special meaning. One of them is App_Code.

You might want to have some functionality accessible from many pages in your application and think of using the Global.asax file or something similar. Well, there is no Global.asax file by default anymore. You can add it to your project if you want, but now it uses the <script> syntax instead of a code-behind file. Besides, when you used it you had to include an Import directive on every page of your application referencing the namespace that contain the Global class.

There is another option to have global access to functionality and data in ASP.NET 2.0, the App_Code folder. This is a productive way of sharing code between pages of your web application. You can place source code files (.cs, .vb) in the App_Code folder and they will be dynamically compiled into an assembly at run time. Any class you put in the App_Code folder will be made directly accessible from anywhere in the web application without the need of special references on the code that uses it.

In VS.NET 2005 if you add a new class from the Add New Item... dialog, you get a screen asking to put the class into the App_Data folder and if you answer yes and the folder is not there yet, it gets created.

You can organize the code inside the App_Code folder anyway you like it but no folder can contain class files of different languages. You don't need to specify which language you are using, ASP.NET 2.0 will infer it from the files itself. But, if you want to use more than one language you have to use different subfolders. You'll need to specify this on the web.config:

<configuration>
<system.web>
    <compilation>
      <codeSubDirectories>
        <add directoryName="Subfolder1"/>
        <add directoryName="Subfolder2"/>
      </codeSubDirectories>
    </compilation>
</system.web>
</configuration>

This is necessary so ASP.NET treats the different folders as different compilable units and puts them on different assemblies. Note that there is no need to actually specify the language. It will still be inferred from the files.

You can also add other files that would generate a class like .wsdl, .xsd, etc. and they will also be compiled into assemblies. If the folder contains files that don't pertain to any programming language in particular, i.e. all .xsd files, it will use the default compiler for web applications established in the <compilation> configuration element.

The Bin Folder

The Bin directory is still there for compiled assemblies, but now it doesn't get included in the web projects by default anymore. There is no References special folder either and the web application is not compiled into a DLL on the Bin folder at least while developing.

The Bin folder is used to throw compiled assemblies and use them without the need to register them. They are automatically loaded and accessible. You still need to put some Import directives on pages or using statements on code-behind classes though, or you'll get some nasty errors.

ASP.NET 2.0 Simplified Code Behind Model

eespindola — Tue, 06 Dec 2005 18:45:00 GMT

I knew about the existence of partial classes although I haven't read much about them. It seems I will be using them a lot because ASP.NET 2.0 has the code-behind model simplified by its use.

The advantage is that you don't need to declare in the code-behind class the variables for the server controls lying on the page markup. Remember all those protected variable declarations for the 100th server controls you have on your page filling up the entire screen on the code-behind class? No need for them anymore. =)

Now you can access the server controls directly from the code-behind class just by using the CodeFile and Inherits attributes in the <%@ Page %> directive:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="MyPage.aspx.cs" Inherits="MyPage" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>My Page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:Label ID="MyLabel" runat="server"></asp:Label></div>
    </form>
</body>
</html>

And having your code-behind class declared as a partial class:

public partial class MyPage : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        MyLabel.Text = "Hello ASP.NET 2.0!";
    }
}

You even get Intellisense everywhere while using VS.NET 2005. You'll get all the methods and properties for the MyLabel control on the code-behind class without even declaring that this is the partial class for the page file that has the actual Label markup. It's kind of magic! Well, actually it's the other way around (the page file declaring which class file has the code-behind) and VS.NET 2005 must know it. But, anyway...

I don't know why is the Inherits attribute needed if this is the same class sliced in pieces. I have to read more about partial classes.