The title of my RSS 2.0 Feed

Parse and Validate Markup Server Side - Why Not?

Tue, 30 Nov 1999 00:00:00 GMT

I had a fun experience recently at work where I spent the better part of a day trying to figure out what was wrong with an aspx page I was deploying to a SharePoint pages library. My investigation into it has led me to reflect a little on XHTML, and forgiveness/fault-tolerance on the Web.

Can you spot the mistake I made? Here’s a variation of the Page Layout where I made the error:

<%@ Page language=“C#”
         Inherits=“Microsoft.SharePoint.Publishing.PublishingLayoutPage, Microsoft.SharePoint.Publishing, Version=12.0.0.0,Culture=neutral, PublicKeyToken=71e9bce111e9429c” %>
<%@ Register Tagprefix=“RLG” Namespace=“Richard.JP.LeGuen” Assembly=“Richard.LeGuen, Version=8.0.0.0, Culture=neutral, PublicKeyToken=XXX” %>

I was debugging, attached to the IIS worker process, and no matter where I put a breakpoint in my MyCustomControl class, it wasn’t loading. Somehow my custom control’s code was not being executed; not even a constructor.

For anyone who’s found the answer, I’m ashamed to say I needed help to see it and it took the better part of my day.

For anyone who hasn’t found it, I’m missing a runat=‘server’ attribute on my the custom control. Usually you get a compile-time error when you try to write up an aspx and neglect a runat=‘server’, but deploying to SharePoint meant I wasn’t the one doing the compiling.

My first reaction was to wonder “Why? Why is this attribute required for web controls? Why isn’t it ‘sous-entendu’?” which led me to a handful of useful answers on Stack Overflow.

Among the answers are that Microsoft was holding out for the possibility of a runat=“client”, with in-browser (IE-only?) controls. This didn’t come together.

Another answer cited a fellow name Mike Schinkel talking with another fellow named Talbott Crowell about why runat=“server” is needed.

If [runat=client] was required for all client-side tags, the parser would need to parse all tags and strip out the [runat=client] part. Currently, if my guess is correct, the parser simply ignores all text (tags or no tags) unless it is a tag with the [runat=server] attribute or a "<%" prefix or ssi "
The name of this file should be the same the .exe file (including the .exe extension) with an added .config extension. So I’ve named this file FizzBuzz.exe.config.

Step 3: Add an Section to the Application Configuration File

An Application Configuration File is divided into sections. In this first example, I’m using the out of the box so I need to add that section. While I’m at it, I might as well also add my key-value pair:
	
		
	
When I run FizzBuzz.exe I will now be able to programatically access this application setting which I have named “N”.

Step 4: Reading the Entry

I now need to change our FizzBuzz.cs file to read the application settings we’ve added to the config file.

Technically, I’m donig this backwards:I should have started with writing code which can be configured and then written the config file, but this is a learning exercise.
using System;
using System.Configuration;
	
public class FizzBuzz {
	
	public static void Main() {
	
		string configurableNSetting = ConfigurationSettings.AppSettings[“N”];
		int configurableN;
		if(int.TryParse(configurableNSetting, out configurableN)) {
			for(int index=1;index<=100;index++) {
				if(index%configurableN!=0) {
					System.Console.WriteLine(index);
				}
				else {
					System.Console.WriteLine(“FizzBuzz!”);
				}
			}
		}
	
	}
	
}
... it should be noted that in order to read from the in this way you have to use System.Configuration.

Compile and Run!

Since I have the Windows SDK installed, my computer has a command line C# compiler. From a command prompt I just type in the following;
> C:\Windows\Microsoft.NET\Framework\v3.5\csc.exe FizzBuzz.cs
... to compile FizzBuzz.cs file into an executable (.exe) file. I can now run FizzBuzz.exe and I can see that the code uses the value of N in my configuration file. I can change the value in my config file without re-compiling my code.

The More Advanced Way: Custom Config Sections

If using the config section runs the risk of bloating that section and – if the code should be reused – suffering namespace collisions between the key-names of different settings; what if code you written later uses a setting with the key-name ‘N’, and has to be integrated with this code?

The solution I’m trying is to define a custom config section. First, I need to write a new class which extends class System.Configuration.ConfigurationSection:
using System.Configuration;
	
namespace ConfigSectionExample {
	
	public class FizzBuzzConfigSection : ConfigurationSection
	{
		// More to come…
	}
	
}
... I now need to add a element to my app.config, and in it a
:
	
This
element means I can now add a element to my app.config file, and settings defined in that element are associated with my class ConfigSectionExample.FizzBuzzConfigSection which will be in an assembly named FizzBuzzConfigSection.dll.

While there are a few ways I could proceed, the main two options for defining custom config sections would be to either provide my configurable ‘N’ as an XML attribute (or what Microsoft would call a Configuration Property) of this section, or as XML elements nested within my section.

XML Attributes for a Custom Section

What if I want to use XML Attributes to define my configurable value of ‘N’? I’ll start by adding an XML attribute on this config section, so all together my app.config file now looks like this:
	
		
	
	
In order to read and utilize this “N” XML attribute I need to make some code changes to the custom config section class:
using System.Configuration;
	
namespace ConfigSectionExample {
	
	public class FizzBuzzConfigSection : ConfigurationSection
	{
		[ConfigurationProperty( “N” )]
		public string N {
			get {
				// Note the ConfigurationProperty( “N” ) attribute,
				// and how the “N” there matches the “N” index here…
				return this[“N”].ToString();
			}
		}
	}
	
}
What I’ve had to do is add a property ‘N’ to my FizzBuzzConfigSection class. I have applied the ConfigurationProperty attribute to this new property, associating it with the ‘N’ XML attribute in my app.config file. Doing this allows me to access this XML attribute using an indexer:
this[“N”]
... without the ConfigurationProperty attribute, this would generate a runtime exception.

Accessing this custom config section as opposed to the also requires a change in the main program.
using System;
using System.Configuration;
	
public class FizzBuzz {
	
	public static void Main() {
	
		FizzBuzzConfigSection section = (FizzBuzzConfigSection)ConfigurationManager.GetSection( “richard” );
		string configurableNSetting = section.N;
		int configurableN;
		if(int.TryParse(configurableNSetting, out configurableN)) {
			for(int index=1;index<=100;index++) {
				if(index%configurableN!=0) {
					System.Console.WriteLine(index);
				}
				else {
					System.Console.WriteLine(“FizzBuzz!”);
				}
			}
		}
	
	}
	
}
Compiling the Custom Confi Section

Lastly, I need to compile the two .cs files. To compile FizzBuzzConfigSection.cs into a DLL (since it has no main it can’t be a .exe. file) I can use the /t:library switch on the command prompt:
> csc /t:library FizzBuzzConfigSection.cs
I can then reference the newly creaetd FizzBuzzConfigSection.dll when I compile FizzBuzz.cs into a .exe file, using the /r: switch.
> csc /r:FizzBuzzConfigSection.cs FizzBuzz.cs
Custom Configuration Elements

You may have noticed that the original app.config – when I was using – was using an element instead of an XML attribute on the config section. I’m not going to document my attempts to do this here; maybe in a future news entry. I will, however, link to the tutorial I’m reading to figure it out: http://devlicio.us/blogs/derik_whittaker/archive/2006/11/13/app-config-and-custom-configuration-sections.aspx

Don't Look Directly Into Its Eyes

Tue, 30 Nov 1999 00:00:00 GMT

Asp.NET Development With Nothin' But a Pair of Sticks

Tue, 30 Nov 1999 00:00:00 GMT

Given my status as a Microsoft Certified Technical Specialist, I figured I should start playing with .NET and – since I fancy myself a bit of a web-developer – Asp.NET in particular. When it comes to Asp.NET though I don’t really have a good environment in which to do anything cool like take chances, get messy or make mistakes and since my work environment provides me with all the conveniences of Asp.NET development, I thought maybe I’d like to contrast that a little at home by learning this the way Boy Scouts stereotypically learn to make fire.

Setup

With a little bit of what some might call researching, I figured out that I am running “Windows Vista Home Premium” (Start>Computer>Help>‘About Windows’) which means that IIS and Asp.NET are waiting for me to turn them on. All I have to do is activate those Windows features from the Control Panel.

If you’re following along and running Vista, while you’re in there you might want to consider poking around and choosing if you want to remove some features which may just be slowing your machine down. Most notably – since this excercise involces a lot of ‘Run as Administrator’ – you might want to turf off UAC.

Activating the features took “several minutes to complete”, but once I was done I had IIS and Asp.NET up and running.

I was surprised to discover that the setup was that easy. Seriously, try it; once you do the above, just type up an ASPX file… (I did it in notepad and cleverly named the file “hello.aspx”)

<%@ Page language=“C#” %>
PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>

 
	
	Hello World AspX
 
 
  
	
		Did it work?

... and drop it in the C:\inetpub\wwwroot folder, no different than you’d toss a PHP script in an htdocs folder on a LAMPP system. Open up a web browser and visit http://localhost/hello.aspx and you should see the fruits of your labors!

Again, if you’re following along and this is your first aspx file, you should take note of the characteristics that distinguish ASP.NET Web pages from static HTML pages:

A file name extension of .aspx instead of .htm, .html, or other file name extensions. The .aspx file name extension causes the page to be processed by ASP.NET.
An optional Page directive. In the future, you might use other directives, such as Control, Import, Implements, Register, Assembly, OutputCache and Reference.
A
element which includes a runat=‘server’ attribute.
Web server controls, such as the . (note that it also has a runat=‘server’ attribute) These are special tags which are processed server-side and are changed into (sometimes complicated and inaccessible) HTML-CSS-JavaScript.
Server code, though this is not in the example.

Adding Code Behind

As exciting as accomplishing this much was, the really useful part of Asp.NET development (contrasted with classic Asp) is the code behind. (this is also where JSP disappoints a little…¹)

If you’re not familiar with what I mean by code behind, support.miscrosoft.com describes it very effectively as follows:

Code-behind refers to code for your ASP.NET page that is contained within a separate class file. This allows a clean separation of your HTML from your presentation logic.

I wanted to write up a code behind, still using no spiffy development environments. This meant three things:

Writing the code behind
compiling the code behind to a DLL
deploying the compiled DLL to my web application

Writing a C# Code Behind

Writing a C# code behind the old fashioned way using just notepad and the command line wasn’t that tough in the end. All I had to do was install the Windows SDK, open up notepad and write out a class (in C#) which extends System.Web.UI.Page:

using System;
	
public class HelloWorld : System.Web.UI.Page {
	
	protected System.Web.UI.WebControls.Label message;
	
	public void Page_Load() {
		message.Text = DateTime.UtcNow.ToString();
	}
	
}

This code will change the Text of a ‘message’ Label to the current date-time. I’m doing this by overriding the Page_Load method of class System.Web.UI.Page and manipulating my server controls in that method. Overloading this method actually seems to be a shorthand for using the Load event:

using System;
	
public class HelloWorld : System.Web.UI.Page {
	
	protected System.Web.UI.WebControls.Label message;
	protected System.Web.UI.WebControls.Button button;
	
	public HelloWorld() {
		this.Load += LoadHelloWorld;	// I like this better than using Page_Load
						// but if you’re new to .NET Page_Load might be easier to grasp…
	}
	
	public void LoadHelloWorld(Object sender, EventArgs e) {
		message.Text = DateTime.UtcNow.ToString();
	}
	
}

... whichever way, the end result is the same.

Next came the interesting part; I saved the file as ‘HelloWorld.cs’ and compiled it into a DLL.

Compiling a .cs File On The Command Line (Look Mom! No IDE!)

To use this HelloWorld class in an Asp.NET page, it had to be compiled into a DLL. Again, though, the point of this exercise has been to learn how to develop .NET from the ground up using nothing but my wits and a couple of twigs, so I installed the Windows SDK on my computer, which includes the C# compiler csc.exe. The compiler itself ends up in the C:\Windows\Microsoft.NET\Framework\v3.5 folder, so from the command prompt I used the following command to compile ‘HelloWorld.cs’ into a DLL:

> C:\Windows\Microsoft.NET\Framework\v3.5\csc.exe /t:library HelloWorld.cs

The /t:library option specifies that the ouput file should be a DLL.

Since I suspsect I’ll be using csc.exe pretty often in my Asp.NET adventures, I think I’ll modify the PATH environment variable on my system to include the C:\Windows\Microsoft.NET\Framework\v3.5\ directory, so I don’t have to type out the full path to csc.exe every time I use it…

> csc /t:library HelloWorld.cs

Deploying the Code Behind

I copy-pasted the resulting ‘HelloWorld.dll’ file into the ‘bin’ directory of my web application’s virtual directory, C:\inetpub\wwwroot\bin and added an ‘inherits’ attribute to my Page directive:

<%@ Page language=“C#” inherits=“HelloWorld” %>
PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>

 
	
	Hello World AspX
 
 
  
	
		Did it work?

Since this was my first little adventure with Asp.NET on this machine, the bin folder did not exist for my web application, so I had to create it myself.

Alternately, I figure I could have deployed to the GAC.

¹ Why am I disappointed? JSP Page directives provide the ‘extends’ attribute but no one seems to have ever used it! The only information I’ve ever found about it is that “Sun recommends ‘to use this attribute cautiously’”.