HCanber - Thoughts, Tutorials, Tips and Tricks

Using the Topshelf Shelving Bootstrapper in a Console App

2011-09-23T14:15:00.001+02:00

Note! This was written for Topshelf 2.2.2.0 and things might have changed in newer versions.

Topshelf

Topshelf (http://topshelf-project.com) is a framework for building Windows services. The service can either be standalone or one that is hosted by Topshelf. The latter style is called shelving (and the service you write is called a shelf) and it enables xcopy deploy of your service, instead of stop service, uninstall, copy, install, start.

Debugging a shelf

The problem with using the shelving style for your service is debugging. The documentation explains how to do it (http://topshelf-project.com/debugging-a-topshelf-shelf/), but it’s not that neat as it involves modifying where your build outputs the dlls.

An easier way, at least for me, would be to debug the shelf service by starting it from a console app, i.e. as a standalone service, without any need to modify where the output from the build goes. Ideally the console app would be as simple as possible, just reusing the code from the shelf.

A shelf service is initiated and configured by a bootstrapper (a class that inherits the interface Bootstrapper<T>) but unfortunately, if you compare the configuration for a standalone service with the shelf bootstrapper, they are not configured the same way, so reusing the configuration from the shelf bootstrapper in a standalone service seems not possible, but it’s actually quite easy.

Reuse the bootstrapper

Instead of implementing Bootstrapper<T> derive from this class instead:

public abstract class BootstrapperBase<T> : Bootstrapper<T> where T : class
{
  void Bootstrapper<T>.InitializeHostedService(IServiceConfigurator<T> cfg)
  {
    InitializeHostedService(cfg);
  }

  public abstract void InitializeHostedService(ServiceConfigurator<T> cfg);
}

Instead of implementing
void InitializeHostedService(IServiceConfigurator<T> cfg)
you implement
void InitializeHostedService(ServiceConfigurator<T> cfg)

The bootstrapper in the example at http://topshelf-project.com/documentation/shelving/ becomes (changes are highlighted)

public class AShelvedClockBootstrapper :
      BootstrapperBase<TheClock>
{
  public override void InitializeHostedService(ServiceConfigurator<TheClock> cfg)
  {
    cfg.ConstructUsing(n => new TheClock());
    cfg.WhenStarted(s =>
    {
      XmlConfigurator.Configure(new FileInfo(Path.Combine(
                      AppDomain.CurrentDomain.BaseDirectory,
                      "clock.log4net.config")));
      s.Start();
    });
    cfg.WhenStopped(s => s.Stop());
  }
}

In the console app you start the service like this:

static void Main(string[] args)
{
  XmlConfigurator.ConfigureAndWatch(new FileInfo(".\\log4net.config"));
 
  HostFactory.Run(x =>
  {
    x.Service<TheClock>(
        s => new AShelvedClockBootstrapper().InitializeHostedService(s));
    x.RunAsLocalSystem();   x.SetServiceName("TheClock");
  });
}

“Hello World” with OWIN (on Kayak)

2011-08-31T20:59:00.002+02:00

A link to all code can be found at the end of this post.

When I started implementing an OWIN compatible web framework I couldn’t find any examples on how to get started with OWIN. Jef Claes has an example but this seems to be for an older draft of OWIN. So this post is about how to create a really simple OWIN web application in C#. It’s inspired by Jef Claes code and uses code from Benjamin van der Veen´s example.

Please Note! This post was written when OWIN was Draft 1.0, using Kayak 0.7.2 and Gate 0.1.4. Things might have changed since this post.

Set up the project

Start by creating a C# Console App.

Install the NuGet package Gate.Kayak. This will install the these packages too: Gate & Kayak.

Kayak is is an asynchronous HTTP server written in C#. Gate.Kayak brings OWIN support to Kayak. If you want to host your OWIN app in another environment use another gate like Gate.AspNet or Gate.Wcf.

Create the Kayak Web Server

In order to set up a Kayak web server, we need to tell Kayak three things: What endpoint to listen to; how to handle exceptions and shut downs; and how to handle the incoming requests.

Main() – Configuring and Starting the Server

In this example the Main method of the Console App configures the Kayak server and starts it.

static void Main(string[] args)
{
   //Create the endpoint for incoming requests to Kayak    
   var kayakEndPoint = new IPEndPoint(IPAddress.Any, 5500);
   Console.WriteLine("Listening on " + kayakEndPoint);

   //Start Kayak and call the method Startup.Configuration when starting
    //Let SchedulerDelegate handle exceptions and shut downs
   KayakGate.Start(new SchedulerDelegate(), kayakEndPoint, Startup.Configuration);
}

An endpoint on port 5500 is created. When Kayak is starting it will configure itself by calling the Startup.Configuration method (more on this below), and when stopped, or when an exception is thrown, SchedulerDelegate handles this.

SchedulerDelegate

The methods in SchedulerDelegate class is called when exceptions during Kayak´s event loop occurs and when Kayak is being stopped. We’ll just write messages to the Console.

public class SchedulerDelegate : ISchedulerDelegate
{
   public void OnException(IScheduler scheduler, Exception e)
   {
       // called whenever an exception occurs on Kayak's event loop.
       // this is good place for logging. here's a start:
       Console.WriteLine("Exception on scheduler");
       Console.Out.WriteStackTrace(e);
   }

   public void OnStop(IScheduler scheduler)
   {
       // called when Kayak's run loop is about to exit.
       // this is a good place for doing clean-up or other chores.
       Console.WriteLine("Scheduler is stopping.");
   }
}

Startup.Configuration

Next we need to tell Kayak what to do with incoming requests. The method Startup.Configuration is responsible for that and it will be called when Kayak is starting. In this example, we specified it explicitly in the Main method, but if you were to host the OWIN application on Asp.Net using Gate.AspNet this method will automatically be found and invoked (it’s a convention in Kayak). So creating class with the name Startup with a static method Configuration makes your application more easily portable to other Gate hosts.

public class Startup
{
   // called automatically when Kayak starts up.
   public static void Configuration(IAppBuilder builder)
   {
       // we'll create a very simple pipeline:
       var app = new HelloWorldOwinApp();
       builder.Run(Delegates.ToDelegate(app.ProcessRequest));
   }
}

First our OWIN application is instantiated and then Kayak is told to to let the app´s ProcessRequest method handle all incoming requests.

HelloWorldOwinApp

The primary interface in OWIN is the application delegate. An application delegate takes three parameters: an environment dictionary, a response callback, and an error callback. The HelloWorldOwinApp class exposes the method ProcessRequest that has the same signature as the application delegate specified in OWIN Draft 1.0 and this is where all the fun happens.

If the requested resource, i.e. the path, is the root, “/”, we return a Hello World html page. Otherwise a 404 page is returned.

public class HelloWorldOwinApp
{
   public void ProcessRequest(
        IDictionary<string, object> environment,
       Action<string, IDictionary<string, string>,
               Func<Func<ArraySegment<byte>, Action, bool>,
               Action<Exception>, Action, Action>> responseCallBack,
       Action<Exception> errorCallback)
   {
       var path = environment["owin.RequestPath"] as string;
       var responseHeaders = new Dictionary<string, string>();
       ArraySegment<byte> responseBody;
       string responseStatus;
       if (path == "/")
       {
           responseStatus = "200 OK";
           responseHeaders.Add("Content-Type", "text/html");
           responseBody = new ArraySegment<byte>(Encoding.UTF8.GetBytes((
                   "<!doctype html><html><head><meta charset=\"utf-8\">" +
                       "<title>Hello World</title></head>" +
                   "<body><strong>Hello world</strong></body>" +
                   "</html>")));
       }
       else
       {
           responseStatus = "404 Not Found";
           responseHeaders.Add("Content-Type", "text/html");
           responseBody = new ArraySegment<byte>(Encoding.UTF8.GetBytes((
                   "<!doctype html><html><head><meta charset=\"utf-8\">" +
                       "<title>404 Not Found</title></head>" +
                   "<body>The resource cannot be found.</body>" +
                   "</html>")));
       }
       responseCallBack(
           responseStatus,
           responseHeaders,
           (next, error, complete) =>   // This is the Body Delegate
           {
               next(responseBody, null);
               complete();
               return () => { };
           });
   }
}

The signature is hideous. The people behind OWIN are well aware of this, and considered interfaces in an assembly that all had to implement, but, thankfully, decided to go with using Funcs and Actions instead. This means that there is no OWIN.dll you have to reference, and therefor no versioning conflicts can occur.

Except from the signature, this method is pretty straightforward. We get the relative path from the environment dictionary. If it’s “/” we return a Hello World html page. Otherwise a 404 page is returned.

Returning the resource is a bit special. Instead of just returning some kind of object with headers, status and body content the responseCallBack is invoked. This is necessary for everything to be asynchronous. The callback has as three arguments: the response status; response headers; and a delegate (the next-error-complete-delegate) for retrieving the body content.

The delegate is called the Body Delegate and it is invoked by the host whenever it is ready to receive the body content. The signature of the delegate makes it possible to return chunks of the body. But to keep it simple we will return everything in one chunk, and that is what the next(responseBody, null) call does. responseBody is an ArraySegment (basically a byte array with information about which part of the array the consumer should use).

For simple applications, like this, you don’t have to understand how the Body delegate is intended to be used. Just copy-paste this example, and add the content to responseBody.

Say Hello!

Start the console app. In a browser navigate to http://localhost:5500. You should see a page with “Hello World” in bold. Now go to http://localhost:5500/NotThere and you’ll get a 404 page.

That’s it. Now you have everything you need to create a OWIN web application.

Code

The code can be found on github gist. Show all code.

An extension method for creating a strict mock in FakeItEasy

2011-03-09T15:42:00.001+01:00

The FakeItEasy framework prefers that you don’t create strict mocks, but whenever you need one this extension method might come in handy.

/// <summary>Creates a strict mock of type <typeparamref name="T"/>.</summary>
/// <typeparam name="T">The type of the object to fake.</typeparam>
/// <returns>A FakeItEasy fake configured to behave as a strict mock.</returns>
public static T Mock<T>()
{
  var fake = A.Fake<T>();
  Any.CallTo(fake).Throws(new Exception(string.Format("An unexpected method was called on the fake object {0}.", typeof(T))));
  return fake;
}

To create a strict mock:

var foo = AStrict.Mock<IFoo>();

After you have configured your mock in this fashion you can configure any "allowed" calls as usual, for example:

A.CallTo(() => foo.Bar()).Returns("bar");

Example and code based on: http://code.google.com/p/fakeiteasy/wiki/StrictMocks

Set Custom Tool in the Item Template file

2011-02-13T21:57:00.001+01:00

Documentation for setting the Custom Tool property for a project item created from an item template is not exactly easily found.

There are two things you need in the .vstemplate-file (I’ll assume you know how to create item templates). First you need to include a WizardExtension-node and next you need to specify a CustomTool attribute on the ProjectItem. Both are marked in yellow below.

<VSTemplate Version="3.0.0" xmlns="http://schemas.microsoft.com/developer/vstemplate/2005" Type="Item">
  <TemplateData>
    <DefaultName>MyFile.txt</DefaultName>
    <Name>My File</Name>
    <Description>My File</Description>
    <ProjectType>CSharp</ProjectType>
    <SortOrder>1</SortOrder>
    <Icon>__TemplateIcon.ico</Icon>
  </TemplateData>
  <WizardExtension>
    <Assembly>Microsoft.VSDesigner, Version=10.0.0.0, Culture=Neutral, PublicKeyToken=b03f5f7f11d50a3a</Assembly>
    <FullClassName>Microsoft.VSDesigner.ProjectWizard.ItemPropertyWizard</FullClassName>
  </WizardExtension>
  <TemplateContent>
    <References />
    <ProjectItem SubType="Code" TargetFileName="$fileinputname$.txt" ReplaceParameters="false" CustomTool="MyCustomTool">MyFile.txt</ProjectItem>
  </TemplateContent>
</VSTemplate>

How to register for a WP7Dev account

2010-12-30T15:34:00.001+01:00

Technorati Tags: Windows Phone 7,WP7,#WP7,#WP7Dev

Want to create applications for the Windows Phone 7 (WP7)? You need to register in order to be able to do that, even if you you only want to deploy the application to your own phone and not to the AppHub. Since I haven’t seen any description of the process I wrote down what I had to to. Note that I live in Sweden and the process might vary by countries, but most likely this is what you have to go thru as an individual non-US developer.

1. Register and pay

Make sure:

you enter the correct information since it might be hard to change it later: http://forums.create.msdn.com/forums/t/69335.aspx
you enter the display name you want since it cannot be changed. At all. Ever: http://forums.create.msdn.com/forums/t/68212.aspx

Beware that the fee is said to be $99 USD but in reality this might differ, especially if you´re outside US. In Sweden it will cost you €99. Also beware that the amount you’re accepting, which for me was 919 SEK (€99) is not the amount you’ll be charged. To that a tax of 15% is added, so I was charged 1057 SEK ($150). I’m not sure if it’s legal to ask for acceptance of one amount and then charge another. But, according to Shaun Taulbee, Microsoft:

“Price adjustments are coming, and I'm told refunds will be automatically applied for those who registered since October”
http://forums.create.msdn.com/forums/p/67701/423198.aspx#423198

2. Email: Confirm the email address! /Microsoft

After registering and paying an email will be sent to the email you provided during registration (which might differ from the Live account) in order to confirm the email address. It contains a link that needs to be opened.

3. Email: Approve request! /GeoTrust

Now you should receive an email form GeoTrust. If you haven’t received it within 24 hrs (remember to check your Spam/Junk email folder first) you should contact GeoTrust directly, according to the FAQ: http://create.msdn.com/en-US/home/faq/windows_phone_7#wp7faq10
For me the email came instantly.

Open the link to GeoTrust that was sent to you in the email an approve the order.
”Your order has been successfully approved and your authenticated identity validation status will be reflected on the Windows Phone 7 AppHub within two business days.”

4. Email: Send identification confirmation! /GeoTrust

You just have to wait for the next email from GeoTrust:

“In order for GeoTrust to confirm your information in terms of Microsoft's requirements, GeoTrust must receive a copy of your valid government issued photo identification (for example: a passport or driver's license), attached to the Identification Confirmation Letter below.”

You can fax them the information or send it by email, which is what I did: Print out a copy of the letter. Fill the fields at the bottom (all the info is on your passport). Sign it. Scan the letter with your passport at the designated position. Email GeoTrust with the scanned letter as an attachment.

5. Email: Your email was received. /GeoTrust

After a while you’ll receive an email acknowledging the receipt of your Identification Confirmation email.

“The verification process will be completed within 1-2 business days. If you have any questions, please contact us.”

6. “Welcome to the Windows Phone Marketplace developer program”

The next email should be from Microsoft welcoming you to the program. For me, it took 6 hours to receive this email.

You’re done…. Sort of…. In order to receive payment for your apps you’ll need to do more, but I’ll stop here.

Shortcutting the process

“Wow, that’s many steps and a whole lot of waiting”, you may think. Yeah, it is. But there is a way to speed up the process which worked for me and a friend of mine. Step 1-3 runs smoothly (no human interaction I would guess), but instead of waiting up to 2 days for step 4 and 5 you can contact GeoTrust via their chat: https://www.geotrust.com/support/chat/order-processing.html

Instead of waiting for step 4, ask them for status of your order.
After sending the email in step 4, ask them to check they have received the email, and that it contains the correct information.

For me the steps 1-6 took 2.5 days.

Register the phone

Connect the phone to your computer. Make sure Zune starts. Start the “Windows Phone Developer Registration” program (from the start menu) and enter your Live ID and Password and click Register. Make sure the phone is not locked. For me it took some attempts. I had to restart the phone and then clicking retry a few times.

How to get the Single File Generator sample running

2010-09-02T17:25:00.001+02:00

I’ve started developing a CustomTool for Visual Studio 2010. Microsoft has released a sample with documentation on how to implement a Custom Tool. The code can be found here:
http://code.msdn.microsoft.com/SingleFileGenerator

Visual Studio 2010 SDK must be installed.

The documentation states “Rebuild the class library and start running it”. Didn’t work. Got the error message saying a class library cannot be started. To be able to debug this is what I did:

In Solution Explorer, right click on Generator Sample and select the menu item Properties.
On the Debug tab, click the Start external program radio button.
Browse or enter the path to VS 2010, typically:
C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe
As Command line arguments, enter
/ranu /rootsuffix Exp
As Working directory, specify the folder for VS2010:
C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe
Set a break point in the XmlClassGenerator.GenerateCode method.
Press F5 to start debugging.
A new Visual Studio is started.
Follow the instructions in the documentation (create a new class library, create an xml file, fill with content, set CustomTool for file) and the break point will be hit.

How to remotely connect to ASP.Net Development Server

2009-12-03T21:45:00.001+01:00

The ASP.Net Development Server (webdev.webserver.exe), which is included with Visual Studio, is used when testing web applications locally when IIS isn’t installed. The ASP.Net Development Server will only serve pages to browser requests on the local computer, so a colleague of yours cannot have a look at what you’re doing, since ASP.Net Development Server will not serve pages to another computer.

In order to remotely connect to the ASP.Net Development Server a proxy must be used that accepts remote connections and proxies traffic to and from the ASP.Net Development Server.

I searched the internet for a suitable proxy but I couldn’t find one that is small and easy to use (ok, I admit, I didn’t search that long :-) so I wrote one based on proxy code from http://www.mentalis.org/soft/projects/proxy/. It’s probable not the most elegant piece of code ever written but it will have to do.

To start the proxy just pass the port number to it:

Proxy.exe 62200

Incoming traffic to port 80 (standard http port) is proxied to 62200, so if your computer’s name is YourComputer, your colleague can connect on the url: http://YourComputer/

To listen to another port than 80, specify it as the second argument:

Proxy.exe 62200 15555

Incoming traffic to port 15555 is proxied to 62200, so the url will be: http://YourComputer:15555/

Download

Download executable and source here:
http://cid-1591ce8777facfb4.skydrive.live.com/browse.aspx/Public/Code/Proxy

How to deploy a VS Database Project GDR using vsdbcmd

2008-12-18T17:32:00.001+01:00

With the release of Visual Studio Team System 2008 Database Edition GDR we now have the possibility to use a standalone command for deploying a database project. Unfortunately the documentation for the new vsdbcmd is so full of errors that you cannot use it, see for example “Command-line Reference for VSDBCMD (Deployment and Schema Import)” and “How to: Prepare a Database for Deployment From a Command Prompt by Using VSDBCMD ”. Seems to be written for a previous version.

Properties

The documentation states that you should specify properties using this syntax:

/p:PropertyName:PropertyValue    INCORRECT!

The correct syntax is:

/p:PropertyName=PropertyValue

Verbose and quiet

It also states that there exists a /verbose or /v option. This option do not exist. It has been removed. It’s verbose by default and you can use the undocumented /quiet or /q to turn of verbosity [source].

Invalid property names

The common deployment properties list isn’t right either. For example the TargetDatabaseName is in fact called TargetDatabase. Have a look in the .sqldeployment and .deploymanifest files for proper naming. These files exists in the directory created when building the project, for example MyDbProject/sql/debug/.

Deploy-example

Below is an example of how to deploy a database project that has been built by Visual Studio or Team Server Foundation (TFS).

Start a command prompt and change directory to the directory that was created when the project was built (for example MyDbProject/sql/debug/) and execute the command below (on a single line).

"%ProgramFiles%\Microsoft Visual Studio 9.0\VSTSDB\deploy\vsdbcmd"
  /a:Deploy 
  /ConnectionString:"Data Source=MyServer;Integrated Security=True;" 
  /dsp:SQL 
  /manifest:MyDbProject.deploymanifest 
  /p:TargetDatabase=MyDb 
  /dd

This will create a .sql file and deploy it, i.e. execute it on the server. If you remove the /dd option the .sql will be created but not deployed.

How to include scripts after asp.net ajax framework's

2008-07-27T13:59:00.001+02:00

Swedish version of this entry

When registering script includes using ScriptManager.RegisterClientScriptInclude("myFile.js") the files are always included before the frameworks. This causes errors if your code depends on the ajax framework's. Errors like "Type is not defined" are common since the first line in the included script file often tries to register a namespace: Type.registerNamespace('My.Namespace');

On the other hand, files registered as ScriptReferences on the ScriptManagerProxy will be included AFTER the framework's includes.

<asp:ScriptManagerProxy runat="server" id="ScriptManagerProxy1">
    <Scripts><asp:ScriptReference Path="~/anotherFile.js" /></Scripts>
</asp:ScriptManagerProxy>

Not exactly the expected behavior and certainly not what we want.

When calling ScriptManager.RegisterClientScriptInclude() it delegates to the class ClientScriptManager. This class holds, internally, a list of registered scripts, and new entries ends up at the end. So the call ScriptManager.RegisterClientScriptInclude("myFile.js") will put myFile.js at the end of that list. Like this:

ClientScriptManagerClientScripts = { ..., "~/myFile.js" }

The references in the ScriptManagerProxies are handled a bit differently. The ScriptManager will, on the event PagePreRenderComplete, collect all references from the proxies in a list, and first in that list put the ajax framework's files.

List in ScriptManager = { ajax framework files, "~/anotherFile.js" }

After being collected the files are registered with the ClientScriptManager and are appended at the end of it's list. Since we registered myFile.js before PagePreRenderComplete (which occurs late in the asp.net page's life cycle), myFile.js is before the framework's files:

ClientScriptManagerClientScripts = { ..., "~/myFile.js", ..., ajax framework files, "~/anotherFile.js"}

These are rendered to the page in this order and it explains why anotherFile.js may use the framework directly and myFile.js not.

Solution 1. Use a proxy

The simplest solution is to put a ScriptManagerProxy on the page (or user control, or MasterPage) and either, as shown above declare a ScriptReference, or add one by code:

ScriptManagerProxy1.Scripts.Add(new ScriptReference("~/myFile.js"));

Solution 2. Register the file after PagePreRenderComplete

If you somehow manage to register myFile.js after PagePreRenderComplete (i.e. after ScriptControl has added all files) it will end up after the framework's files. But you'll need to do it before the rendering takes place. Between PreRender and Render phases is the SaveViewState phase. If we override SaveViewState on a control (Page is also a control) and registers myFile.js there it will be added to the list after the framework's files. This is sort of a hack and it's not guaranteed to work when new versions of the framework are released, but: It works.

protected override object SaveViewState()
{
    ScriptManager.RegisterClientScriptInclude(this,GetType(),"myFile","~/myFile.js");
    return base.SaveViewState();
}

Solution 3. Your own ScriptManager

This is, at least to me, the most elegant solution. Basically: you create the class MyScriptManager, which derives from ScriptManager; you replace the ScriptManager on the page (or user control, or MasterPage) with MyScriptManager; add the method RegisterClientScriptInclude(string url) to MyScriptManager and by some magic inside MyScriptManager makes sure that files registered thru the new method will be rendered after the ajax framework's includes.

When the ScriptManager collects all the ScriptReferences from the proxies (as explained above) it also collects ScriptReferences from all controls that have been registered with the ScriptManager as ScriptControls, by calling the method GetScriptReferences, that ScriptControls must implement. These files will be added after the proxies' files.

This is what we'll do: The new RegisterClientScriptInclude method will only add the url to a list, and not register it anywhere else. We let MyScriptManager be a ScriptControl (i.e. implement IScriptControl) and register itself as such. In the method GetScriptReferences we will, when requested, supply the list of registered files, and they will end up after the framework's.

Not much code is needed.

public class MyScriptManager : ScriptManager, IScriptControl
{
    private List<string> _registeredScripts = new List<string>();

    public virtual void RegisterClientScriptInclude(string url)
    {
        _registeredScripts.Add(url);
    }

    protected override void OnPreRender(EventArgs e)
    {
        //Register this instance as a ScriptControl.
        RegisterScriptControl(this);
        base.OnPreRender(e);
    }

    public new static MyScriptManager GetCurrent(Page page)
    {
        return (MyScriptManager) ScriptManager.GetCurrent(page);
    }

    #region IScriptControl Members
    IEnumerable<ScriptDescriptor> IScriptControl.GetScriptDescriptors()
    {
        return null;
    }

    IEnumerable<ScriptReference> IScriptControl.GetScriptReferences()
    {
        //For each element in _registeredScripts create a
        //ScriptReference and return the IEnumerable
        return _registeredScripts.ConvertAll(s => new ScriptReference(s));
    }
    #endregion
}

Please note that I've simplified the code in order to show the concept. In production code you'll want to encapsulate the list in a public property that creates the list if needed. And you want two protected virtual versions of GetScriptDescriptors and GetScriptReferences that the existing ones will call.

To register a file to be included after the framework's files you use:

MyScriptManager.GetCurrent(Page).RegisterClientScriptInclude("~/myFile.js");

If you're using AjaxControlToolkit change the inheritance to ToolkitScriptManager.

Note the order the files are included:

ScriptManager.RegisterClientScriptInclude registered files
Ajax framework's files
All ScriptManagerProxy ScriptReferences
MyScriptManager.RegisterClientScriptInclude registered files

If you want your files to be included between 2 and three you're in deep water. It's probably doable but far from trivial, since ScriptManager is pretty closed for extension. It would be nice if Microsoft adhered the Open/Closed-principle a bit more. :)

AutoEventWireup=true

2007-07-27T17:33:00.001+02:00

Swedish version of this entry

If you specify the attribute AutoEventWireup=True on a Web User Control or a Page, methods like Page_Init() och Page_Load() will be automatically routed to the page's Init- and Load-events.

This is good, sometimes. It simplifies for you since you don't have to hook up events to event handlers. But it is something that's done during runtime, and therefore adds to the executiion time and it may cause event handlers to be called many times.

Example: Event handler beeing called twice.

protected void Page_Init()
{
    Page.Load += Page_Load;
}
protected void Page_Load(object sender, EventArgs e)
{
    //This code will execute twice
}

Page_Load in the example above will be called twice. Once since you mannually hooked the event to the Page_Load handler. Another time since AutoEventWireup=true and the method has a name causing the event to automatically be hooked to it.

AutoEventWireup works on TemplateControl which both Page och Web User Controls derives from.

K Scott Allen's blog talkes about this. I'll go more into depths.

SupportAutoEvents

What happens when AutoEventWireup=true? A TemplateControl has a property SupportAutoEvents. This is true by default (and will change to false by the parser/control builderif you set the attribute AutoEventWireup=false).

HookUpAutomaticHandlers

TemplateControl.HookUpAutomaticHandlers (which is called during the OnInit) will, if AutoEventWireup=true try to find methods with these names:

If the control is a Page:
- Page_PreInit
- Page_PreLoad
- Page_LoadComplete
- Page_PreRenderComplete
- Page_InitComplete
- Page_SaveStateComplete
For all TemplateControls:
- Page_Init
- Page_Load
- Page_DataBind
- Page_PreRender
- Page_Unload
- Page_Error
- Page_AbortTransaction or if it does not exist; OnTransactionAbort
- Page_CommitTransaction or if it does not exist; OnTransactionCommit

This is carried out in TemplateControl.GetDelegateInformationWithNoAssert().

32 attempts

As K Scott Allen writes two attempts will be made for every name. First it will try to find an EventHandler with the specified name, i.e. a method with the signature:

void EventHandler(object sender, EventArgs e)

Exemple: A method that is an EventHandler

void Page_PreInit(object sender, EventArgs e)

If that fails a VoidMethod is searched for, i.e. a method with the signature:

void VoidMethod()

Exemple: A method that is a VoidMethod

void Page_PreInit()

Although no methods matching the list have been added to the Page, 32 attempts to find a method will be made (K Scott Allen got 28 but he must have forgotten about OnTransactionAbort and OnTransactionCount).

Ok, the result will be cached but the search will be made at least once, at that's for every TemplateControl.

Hook up the event to the handler

For all matching methods on the control TemplateControl.HookUpAutomaticHandlers() will hook up the event to the corresponding event handler, unless the method already has been added to the event since HookUpAutomaticHandlers searches the list of event handlers for the event. If it finds the method, it will not add the method again.

But wait. In the first example Page_Load() was obviously added twice to the event.
Yes, but that's because HookUpAutomaticHandlers already had hooked up the Page.Load event to the Page_Load handler when we in Page_Init did it. Remember that HookUpAutomaticHandlers is called in the Page's OnInit, which is called before our Page_Init method. If we hook up the event to the handler before the page's OnInit we will do it before the HookUpAutomaticHandlers has ben called and therefore Page_Load will only be called once.

Exemple: Page_Load is only called once.

public partial class _Default : System.Web.UI.Page
{
    public _Default()
    {
        Page.Load += Page_Load;
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        //This code will execute once
    }
}

Conclusion: AutoEventWireup=false

Consider setting AutoEventWireup=false and manually hook up the events to the handlers. You gain control over when things are called and you don't have to pay for the overhead TemplateControl.HookUpAutomaticHandlers causes.

Microsoft recommends setting it to false if performance is a key consideration.

More on AutoEventWireup on MSDN

http://msdn2.microsoft.com/en-us/library/system.web.configuration.pagessection.autoeventwireup.aspx
http://support.microsoft.com/default.aspx/kb/324151

Insert Do-nothing comments

2007-05-21T15:09:00.000+02:00

Swedish version of this entry

Always insert a //Do nothing comment in places where the intention is that nothing should be done. Let Me show you why by an example. Assume you have a constructor for a Control that inherits WebControl and all you want to do is changing the default tag (which is Span).

public MyControl()
   :base(HtmlTextWriterTag.Div)
{
}

When someone else reads this code (or you in a month or so when you've forgotten all about it) they might wonder if this code has been finished or if there is something missing in the constructor. By adding a comment, you show for anyone reading the code that there shouldn't really be any code inside the constructor.

public MyControl()
   :base(HtmlTextWriterTag.Div)
{
   //Do nothing
}

I have a code snippet for this so I just need to type don and hit tab twice and //Do nothing is inserted.

Passing values to behavior properties

2007-05-18T10:23:00.000+02:00

Swedish version of this entry

Typically a property in a AjaxControlToolkit Extender looks like this:

[ExtenderControlProperty]
[DefaultValue("")]
public string MyProperty
{
  get { ... }
  set { ... }
}

Which will match a property in the behavior:

get_MyProperty : function() { ... },
set_MyProperty : function(value) { ... }

Values for MyProperty on the server side will end up in the behavior. Sometimes you want to pass values to the behavior without creating a property in the Extender control. To do this, simply override RenderScriptAttributes() and add the properties using AddProperty().

protected override void RenderScriptAttributes(ScriptBehaviorDescriptor descriptor)
{
  base.RenderScriptAttributes(descriptor);
  string horizontalAlignment=GetHorizontalAlignment();
  descriptor.AddProperty("HorizontalAlignment", horizontalAlignment);
}

And voilà, the HorizontalAlignment property in the beahvior will be set.

Property names & Extenders

2007-05-18T09:39:00.000+02:00

Swedish version of this entry

Properties for extenders inheriting ExtenderControlBase typically looks like this:

[ExtenderControlProperty]
[DefaultValue("")]
public string MyProperty
{
  get
  {
    return GetPropertyValue("MyProperty", "");
  }
  set
  {
    SetPropertyValue("MyProperty", value);
  }
}

You must have a property with the same name in the behavior on the client side:

get_MyProperty : function() {
  return this._myProperty;
},
set_MyProperty : function(value) {
  this._myProperty = value;
}

But what if you want it to have different name on the client side? Easy. Add the ClientPropertyName attribute to the server side property. If we want MyProperty to be called myProp instead this is how it's done:

[ExtenderControlProperty]
[DefaultValue("")]
[ClientPropertyName("myProp")]
public string MyProperty
{
  get
  {
    return GetPropertyValue("MyProperty", "");
  }
  set
  {
    SetPropertyValue("MyProperty", value);
  }
}

On the client side we get:

get_myProp : function() {
  return this._myProperty;
},
set_myProp : function(value) {
  this._myProperty = value;
}

More on attributes: http://ajax.asp.net/ajaxtoolkit/Walkthrough/ExtenderClasses.aspx

OOP in Javascript

2007-05-10T12:28:00.000+02:00

Swedish version of this entry

MSDN Magazine May 2007 edition has an interesting article on how to use object oriented techniques in Javascript. A must-read if you are using Microsoft AJAX since the entire client script library is written using these techniques. http://msdn.microsoft.com/msdnmag/issues/07/05/JavaScript/default.aspx

Validators not working with UpdatePanel??

2007-03-22T16:16:00.000+01:00

Swedish version of this entry

The validators don't work very well sometimes when put in an UpdatePanel. But they used to... The reason is that in the 1.0 release of Ajax asp.net the validators that were used in place of the the ordinary asp.net validators have been removed. There was supposed to be an update available for the System.Web namespace to overcome this problem but it will take some time before we have the update. In the meantime there is a fix available. Have a look here: http://blogs.msdn.com/mattgi/archive/2007/01/23/asp-net-ajax-validators.aspx

Shortcuts and Cheat Sheets

2007-02-16T10:49:00.000+01:00

Keyboard shortcuts for VS 20005: http://blogs.msdn.com/robcaron/archive/2007/01/29/1552795.aspx Regular Expressions cheat sheet: http://www.ilovejackdaniels.com/cheat-sheets/regular-expressions-cheat-sheet/ CSS cheat sheet http://www.ilovejackdaniels.com/cheat-sheets/css-cheat-sheet/ JavaScript cheat sheet http://www.ilovejackdaniels.com/cheat-sheets/javascript-cheat-sheet/ Asp.net Lifecycle: http://john-sheehan.com/blog/index.php/net-cheat-sheets/ AJAX asp.net http://aspnetresources.com/blog/ms_ajax_cheat_sheets_batch2.aspx

Don't access the property ClientId to early

2007-02-08T14:45:00.000+01:00

Swedish version of this entry

The ClientId property on a Control is correct only after the control has been added to a Parent, i.e. added to a Controls collection. The parent must also be connected to a parent, and it's parent, and so on up al the way to the Page control. If you try to get ClientId to early, not only will you get something unusable, it will be cached so all subsequent calls will get the same. It will also prevent postback events from working. Big No-no:

public class MyControl : CompositeControl
{
 protected override void CreateChildControls()
 {
  Button myButton = new Button();
  myButton.Text = "Unclicked";
  myButton.Click += new EventHandler(myButton_Click);
  Controls.Add(myButton);
  
  //MyControl has no parent yet. The following code will prevent
  //the myButton_Click from beeing called when the button is clicked.
  //Remove the line and it will be called.
  string id = myButton.ClientID; 
 }
 
 void myButton_Click(object sender, EventArgs e)
 {
  Button button = (Button)sender;
  button.Text = "clicked";
 }
}

Another example: http://aspadvice.com/blogs/joteke/archive/2007/01/28/Accessing-ClientID-or-UniqueID-too-early-can-cause-issues.aspx

Find a control in javascript (Ajax ASP.Net)

2007-01-31T18:08:00.000+01:00

Swedish version of this entry

To find a control with id "MyControl" us the function $get. Example:

alert($get("MyControl").id);

Show and Hide a ModalPopupExtender from javascript

2007-01-31T16:44:00.000+01:00

Swedish version of this entry

To show a modal popup handled by a ModalPopupExtender from javascript you need to set the BehaviorID property:

<ajaxToolkit:ModalPopupExtender...
BehaviorID="MyModalPopupExtender"
... />

The script for showing and hiding the popup:

<script language="javascript">
   function hidePopup()
   {
       $find('MyModalPopupExtender').show();
   }
   function hidePopup()
   {
       $find('MyModalPopupExtender').hide();
   }
</script>

Asp.Net ViewState

2007-01-30T21:39:00.000+01:00

Swedish version of this entry

A good article explaining ViewState in Asp.Net. http://weblogs.asp.net/infinitiesloop/archive/2006/08/03/Truly-Understanding-Viewstate.aspx Some of the interesting titbits:

When a control is tracking ViewState, items changed in the ViewState will be marked dirty. Only dirty items in the ViewState StateBag will be serialized to the hidden __VIEWSTATE field.
Controls starts to track ViewState after the it's OnInit.
The page's OnInit is called after all controls' so at this stage all controls are tracking viewstate.
Data bound during the page's OnInit and OnLoad will go into ViewState since the control is tracking view state. This means, don't set properties on controls in a page's OnInit and OnLoad if you don't want it to go into viewstate.
Properties set on a control during the page's OnPreInit, before controls are tracking view state, will not go into ViewState. This can be used to fill controls with data that's easy and cheap to get on every postback.
When dynamically creating controls (for example in CreateChildControls in a custom control) set all properties before adding the control to the control collection, or else you are at risk of that the control is already tracking ViewState.