C# Edge Blog

ASP.NET performance

2010-05-20T03:23:00.000-07:00

Check out Mads Kristensens ASP.NET performance project.

He tells us, that it's still in alpha, so consider it a preview.

Visit OptimizeASP.NET here: http://optimizeasp.net

Also, check out his open source project WebOptimizer.NET, which aim to provide friction-free performance improvements for new and existing ASP.NET applications.

Visit WebOptimzer.NET on CodePlex

BarCamp Copenhagen 8.2

2008-10-07T13:43:00.000-07:00

Til BarCamp Copenhagen er omdrejningspunktet de folk, der deltager, og det er her vigtigt at understrege, at der menes at deltage aktivt. No tourists!

BarCamp konceptet er bygget op omkring discussions og open space tankegange, og det hører ind under un-conference konceptet, dvs. at programmet sættes sammen, når deltagerne dukker op. Man kan derfor heller ikke sige helt på forhånd, hvad det kommer til at handle om, men man kan kigge på deltagerlisten og google lidt på de folk, der kommer, hvis man vil danne sig et indtryk om det... En ting er sikkert, det er, at deltagerne er:

Folk, der virkelig brænder for det, de gør.
Sociale, åbne og søde mennesker.
Mennesker, der elsker at dele ud af deres viden.
Interesserede, intelligente og intense personer.
- og der kan være tendens til høj GEEK-faktor.

Der er deltagerloft på 50, så man skal være lidt hurtig til at tilmelde sig på wikien, http://barcamp.org/BarCampCopenhagen.

Vi har ikke en location fastlagt endnu, og vi mangler sponsorer, men datoen er under alle omstændigheder den 22. november, fra kl. 10-?

Det gælder om at deltage, både før, under og efter, så blog om det og sig det videre.

- Velkommen til den danske it-undergrund!

OutPost 3.2.001

2008-04-06T08:06:00.000-07:00

The long awaited release!

Download OutPost 3.2.001

Changes since last release, which was 2.2.002:

6/4-2008 - 3.2.001
- First PUBLIC release since version 2.0.003!
- Added support for asynchronous page flakes that loads simultaneously.
- Added better support for external page flakes.
- Improved support for Internet Explorer, Firefox, Opera and Safari browsers.
- Removes linebreaks when comparing for differences to minimize traffic.
- No more supports .net 1.1 (officially).
1/2-2008 - 3.1.001
- Added Suggest.aspx demo.
- Added DocTree.aspx demo.
- Redesigned test suite layout.
- Added support for animations, like YellowFade, BackFade, SlideDown and more.
- Added support for loading indicator.
- Added support for load indicator.
- Added method to Disable Ajax.
- Added support for asynchronous load of Page control after window.onload.
- Redesigned the iGoogle demo to make it more modular and extendable.
- Improved the SignUp demo.
- Added AjaxPage user control.
- Added DataGrid Demo.
- Added ProperReset Demo.
- Added ToDoList Flake for iGoogle demo.
27/11-2007 - 3.0.002
- Modified web.config to make it work with ASP.NET Development Server.
- Edited the howto.txt.
21/04-2007 - 3.0.001
- Added option to hijack links.
- Added support to ajax-enable a page from web.config.
- Redesigned and reimplemented the html compare function by using LCS algorithm.
- Optimized splitting up the HTML into tags by using split in combination with regular expressions.
- Optimized every use of regular expressions by caching the results.
- Huge performance improvements!!
- Added option EnableAjaxRedirect which allows the page to be redirected using ajax.
- Added support for multiple-select drop down lists.
- Improved support for tables.
- Improved support for loading of scripts.
- Added update commands InsertAfter and InsertFirst.
- Improved cursor position store/restore functionality.
- Added scroll position store/restore functionality.
- Added support for external hosts by introducing keyword $ExternalHost$ for the LocalHost property.
- Reimplemented the Page control as a UserControl.
- Added ExternalTest.aspx demo.
- Added FormElementsTest.aspx demo.
15/03-2007 - 2.0.003
- Added support for not sending back inputs with only the value changed.
- Fixed bug with resetting radio buttons.
- Reduced number of unnecessary field updates on the client.
- Added support for ASP.NET 1.1.
- Added support for following parameters: DisableCopyCommand, ShowViewState, ShowEventValidation, ShowLastFocus, SimulateOnload, SimulateOnunload, SimulateOnbeforeunload
- Added ProperReset demo.

Find the full history here

Slides from barCamp Copenhagen 2008

2008-03-22T15:36:00.000-07:00

Here are the slides and the transcript of my presentation at barCamp Copenhagen 2008. The presentation was held in Danish, so I've translated the slides and the transcript into English.

Transcript

Hi, my name is Troels, I work for a company called beaconware.

I primarily work with .net technology and web development.

I would like to tell you about ajax and about how you go from ajax to hijax to indirect ajax.

I'll round this session of with a demo about how indirect ajax works.

There are a lot of definitions of what ajax is. A simple definition would be:

"Ajax is the ability to update a part of the page instead of the whole page."

It may not sound overwhelming.

The strength lies in the ability to call the server asynchronously without reloading the page.

An example could be an explorer in a CMS with folders that you can expand to reveal documents and sub folders.

You could achieve this with ajax by attaching a handler on the click event.

The handler would call a web service asynchronously to get a data representation of the contents of the folder.

Then it would add graphics needed for documents and sub folders to the document structure below the expanded folder.

The great challenge in programming ajax is to make it work in all browsers.

It's difficult and the end user must often download huge scripts to make it work.

Browsers in cell phones has extra difficulties with ajax because they don't have full dynamic html support.

If you make your web application depend on ajax, then you have to realize that there will be end users

who are unable to use it, either because of their browsers or because of other accesibility concerns.

That's why it's so important to make sure that the ajax application degrades gracefully, which means that beneath

all the fancy web 2.0 fireworks there's a fully functional web 1.0 document to fall-back on.

This is where hijax gets into play.

Hijax is a method that reminds you of how you achieve separation of layout from document structure by using css files.

With hijax you achieve separation of ajax from the document structure.

The procedure is to start by developing a fully functional web 1.0 document by using forms and links.

Then you hijack the form's "onsubmit" event and the link's "onclick" event by using unobtrusive Javascript.

That means Javascript that automatically disables itself in a down-level browser.

So, if the browser doesn't live up to the requirements for ajax then the application reverts to web 1.0 behaviour.

When a form's onsubmit event has been hijacked and it gets intercepted then an asynchronous call is made to a web service on the server.

The server returns the requested html fragment and the client updates the DOM.

The technique used here is also called AHAH which stands for Asynchronous Html And Http. You can find it on microformats.org.

Hijax requires that you in your server code is able to separate the output into those html fragments that you want to update separately on the client.

So you need a really flexible server API that can return parts of the page by request.

It can seem as a comprehensive task to make your web application ready for this and it is, especially if you don't do it from the beginning.

You will have to create web services that you can call and a way of telling them which part of which page that you want html returned for.

Not to mention thinking up a way of handling actions and events on the server.

That is why some people gone a step further and invented indirect ajax.

Indirect ajax automates the process of hijaxing a form.

It hijacks all events and communicates with the server through a proxy.

The proxy receives enough information to execute the http request that would have been executed if the event hadn't been intercepted.

The only difference is that the call is executed locally on the server and a lot faster.

The html document that is returned by this call is stored in memory on the server to be compared with the html document returned by the next call.

So, on every request the current document is compared to the previous document.

The comparison results in a difference. This difference consists of a number of html fragments together with information about where they belong in the document structure.

This information is sent back to the client that now updates the document structure.

On the screen it looks like the browser executes a normal post back. It's just quicker, because:

- The traffic to and from the server has been minimized.

- and because the call is executed locally on the server

- and because it doesn't require the whole page to be reloaded.

Now I want to show you a couple of demoes of an indirect ajax framework.

It's an open source project that I have developed for .net and it's called OutPost.

You can try out or download the demo from http://hijax.net/OutPost.

The first demo is inspired by Google Suggest which is a really classic ajax tool.

As you type in words in the search field the suggestions for search terms are shown below based on searches of other users.

I twisted it and made a Farber Suggest application based on the hilarious turns of phrases of David Farber.

Here you type in an English word and then a number of matching farberisms are shown below.

Let's try...

The other demo is a simple explorer that shows folders and documents in a CMS.

You can click on a folder to expand it.

You can also collapse the folder again by clicking on it.

In the background I have a program called Fiddler running. It logs the traffic between client and server.

As you can see the server sends about 8kb back on every request.

Now I enable OutPost.

And run the demo again.

Looking at the source code you can see that some details in the html code has changed to make OutPost able to hijack the events that normally gets the browser to reload the page.

Then we expand the folder... And expand the sub folder...

And then we switch to Fiddler again.

As you can see the amount of traffic is now about 10 times smaller.

This is partly a result of zipping the traffic. So, we use Fiddler to unzip it.

And if we dive deeper in to see the data itself we can see that it's not a full document that's returned to the client.

The client receives commands that the OutPost client framework understands and uses to update the document structure with.

As an example one command means "replace this image with this" and another means "delete this table".

BarCamp Copenhagen 2008

2008-01-25T12:16:00.000-08:00

Cool event, nice people, great atmosphere!!

Here is a link to the demoes, I've just put them online, including at download link to the latest unofficial BETA of OutPost: http://hijax.net/OutPost

My presentation was well received. You can download the power points here (sorry it's only in power point 2007 format right now - AND it's in Danish): AJAX, HIJAX, OUTPOST

OutPost and ASP.NET Development Server

2007-11-27T06:21:00.000-08:00

I just found out, that OutPost has some troubles with the way ASP.NET Development Server handles httphandlers. The section of web.config can be modified to make it work:

Change this:

to this:

And it now works with ASP.NET Development Server

OutPost Demo HowTo for .NET 2.0

2007-11-27T05:03:00.000-08:00

For ASP.NET 2.0 demo

Download and unzip OutPost.zip
Open folder "Demo"
Right-click sub folder "Outpost-2.0-Demo"
Select "Properties"
Select "Web Sharing"
Select "Share this folder", alias should be "Outpost-2.0-Demo"
If .NET 2.0 isn't your default setting you must configure this with Internet Information Services
Now you can open the demo at "http://localhost/Outpost-2.0-Demo/Demo"

BarCampCopenhagen

2007-11-05T14:18:00.000-08:00

I'm making a presentation at BarCampCopenhagen about OutPost. It's in Copenhagen on January 25th, 2008. Hope to see you there! The next release is on its way and includes a lot of improvements.

OutPost Marketing blah

2007-03-15T15:58:00.000-07:00

OutPost hijacks the form post back event and

tells the server to execute the post back locally on the server,
an optimized DHTML-response is sent back to the client,
the page is updated using cross-browser DHTML and
page reloads and flickers are thereby eliminated.

Bandwidth usage is minimized by

diff-comparing two consecutive responses,
keeping state on server,
keeping js framework light,
compressing the response,
sending optimized DHTML and
not using Xml or JSON.

Features

No custom controls needed
No update panels required
No Javascript/DOM skills required
Write ASP.NET like you use to do
Design your page like you use to do
Internal HTTP-compression
Multiple flakes on same page
One line of code enables Ajax
Pages can be included in other pages
Add form using client-scripting
Cross-form posting

Supports

ASP.NET 1.1 & 2.0 controls
Session state
ViewState
Caching
Url redirects
Server events
Most browsers
Form authentication
HTTPS

Options

Simulate onload event on postbacks
Simulate onunload event on postbacks
Simulate onbeforeunload event on postbacks
Keep/reset client-side events on postbacks
Show/hide ViewState
Show/hide EventValidation
Turn compression on/off

OutPost 2.0.002

2007-03-15T02:45:00.000-07:00

New demo added and some bugfixes.

Download OutPost 2.0.002

Changes since last release, which was 2.0.001:

15/03-2007 - 2.0.002
- Fixed bugs in iGoogle demo.
- Fixed properly resetting Page_Validators array on post backs.
- Added Wizard demo.

OutPost 2.0 Released

2007-03-13T16:49:00.000-07:00

New version ready to download!

It is much better at dividing the page up and sending only what's changed. One of the reasons for this is that OutPost no longer restricts itself to looking at html tags that has an ID on them. Any element goes! Also a Delete command and a Copy command is introduced.

Hope you like it and have fun with it! Please, write a comment if you use it for something cool!

Download OutPost 2.0.001

Changes since last release, which was 1.6.002:

14/03-2007 - 2.0.001

Added support for specifying LocalHost dynamically by setting it to $CURRENTHOST$.
Added support for hiding LASTFOCUS field.
Fixed support for storing/restoring selected text.
Added support for client debugging modes.
Added support for simulating (triggering) onload, onunload and onbeforeunload events.
Added support for client side debugging for Ajax javascript.
Added support for adding rows to tables.
Added support for url redirect
Added support for deleting elements by sending a Delete command to the client.
Added WebParts and Cars demoes.
Added support for chunked response.

23/01-2007 - 1.7.001

Added support for adding client side event 'onsuccess' to the form.
Added support for sending modified tags without id or name back to the client.
Added support for copying html from elements that are already present on the client to other elements in stead of sending it again.
Added support for sending table rows (tr) back to client.
Added support for sending only value of input tags back.
Added support for sending only modified script blocks back to the client.
Added cross-browser support for using following DHTML features: outerHTML, replaceNode, parentElement, canHaveChildren.
Added support for adding response headers by specifying appsetting "AddHeaders" (syntax "key1=value1&key2=value2").
Fixed problem with repeatedly submitting a form and not getting the form updated or reset (as pointed out by Jomar Coquia).

23/11-2006 - 1.6.004

Fixed problem with inserting carriage returns into textarea.

15/11-2006 - 1.6.003

Added if there is no difference between two or more post backs the browser is re-updated with the last post back that had a difference. That means if you modify the DOM between the post backs this resets some or all of these modifications (which i closer than before to what is normally expected).

OutPost 1.6

2006-10-11T03:40:00.000-07:00

Download OutPost 1.6.002

11/10-2006 - 1.6.002

Added new Demo in .NET 1.1 project /Brian Ritchie
Fixed a bug where a drop down populates, but resets the position on post back

10/10-2006 - 1.6.001
- Placed version history in separate file
- Utilized HttpHandler instead of Page with code behind. This requires a simple entry in the web.config /Brian Ritchie
- Removed 3rd party code and include binary libraries instead (sharpziplib & blowery) /Brian Ritchie
- Packaged things up into a class library /Brian Ritchie
- Enhanced 1.1 support so it compiles under 1.1 again /Brian Ritchie

See full Version history

Benefits of Hijax

2006-10-06T05:29:00.000-07:00

Did a search on Hijax and found a link to the slides from Jeremy Keith's presentation at XTech 2006. Here's a nice quote from the presentation slides:

Benefits of Hijax

No need to spend time and resources building a non-Ajax version.

No duplication of logic (e.g. form validation).

Keeps your application logic on the server.

Keeps your JavaScript file size down.

Links are spiderable and potentially bookmarkable.

OutPost 1.5 Refresh

2006-10-04T04:29:00.000-07:00

Download OutPost 1.5

10/4-2006 - 1.5.003

Removed bits of Javascript that wasn't used for anything
Added more thorough removal of EventValidation and ViewState input including surrounding DIVs

OutPost version 1.5

2006-09-30T18:34:00.000-07:00

Added gzip and deflate compression internally! Now it really rocks :)

OutPost 1.5

1.5.002 - 20061001 0312 twj

Removed selected="selected" when comparing html, it caused dropdown boxes to be refreshed without more often than needed
Removed call to oForm_doReset after each post back because of the change to the dropdowns
Added update of SignUp demo - it now has 3 "linked" controls (two drop-downs and a text field)

1.5.001 - 20061001 0014 twj

Added gzip and deflate compression internally
Changed namespace OutPost.Core to OutPost
Removed constant ContentTypeForNoCompression

1.4.004 - 20060928 1107 twj

Added error message when trying to view OutPost.aspx directly
Added MinimumSizeForCompression and ContentTypeForNoCompression constants

Enjoy!

If you occasionally look at my blog, please drop me a comment once in a while. It keeps me going :) and hopefully keeps me delivering the best performing indirect ajax framework in the world!

OutPost 1.4 Refresh

2006-09-28T02:25:00.000-07:00

I have made som optimizations to version 1.4. Download and update for better performance.

1.4.003 - 20060928 1107 twj

Changed "SessionID" and "session" to "GUID" and "guid"
Optimized client framework size by removing spaces and replacing variable names

1.4.002 - 20060927 1444 twj

Added default setting of PartsNeeded for GET request
Changed "SessionID" and "session" to "GUID" and "guid"

OutPost version 1.4

2006-09-26T16:29:00.000-07:00

Download OutPost 1.4 (with source code)

This release focuses on optimization of traffic between client and server. As a result of moving away from using SOAP I reduced traffic overhead dramatically.

I also made a OutPost 1.4 demo site - try it out!

OutPost version 1.3

2006-09-21T16:38:00.000-07:00

Version 1.3 now available.

OutPost 1.3 (with source code)

A lot of improvements has gone into this release:

New demo with a Sign-Up web form (by request).
Removed Session dependency.
Restores position and selection in IE on postback.
Found problems with unicode characters. As it is your page must include the tag ResponseEncoding="utf-8" in order to work properly with Unicode characters.
Added a cloak (event trap) over the form in IE on postback in order to mimick default web form behaviour.
Added support for WebForm_AutoFocus.
Added support for queueing requests.
Added support for reloading script blocks.
Added setting LocalHost to specify alternative localhost domain.
Added support for HTTP-compression (tested with FlatCompression R1.20.226 from www.flatcompression.org).
A lot of bugs fixed.

Enjoy!

BusinessLogic.web - a .NET business logic wrapper for Javascript

2006-04-14T05:27:00.000-07:00

This is a sample of BusinessLogic.web - A javascript business logic wrapper for ASP.NET.

Download the ASP.NET 2.0 project for the sample.

BusinessLogic.web is Part of dotWeb - A .NET Business Framework for the web under development by beaconware ApS.

The aim of this project is to aid the developer in the proces of writing business logic for the right tier - that is the server - and in a compiled language. Most people can agree on that. This wrapper simplifies the proces of making a business entity available on the client even though it really lives on the server.

BusinessLogic.web concerns itself with BUSINESS ONLY and it's very good at just that.

A very cool thing about this tool is, that you don't have to write web services anymore! Play with it!!

Try online demo

Business Classes

This is the Person class with the business logic layer.

It inherits from dotWeb.Core.Business.Entity, but that is just my own preference, the Entity class is optional, but make sure your business class supports IJsonFormattable, if you don't inherit from the Entity class!

Remember to put [Wrap] attributes on your class and on your public methods to make them available on the client. On the client side public properties will be wrapped like standard javascript properties, but if you want the getter or setter of a property available, like "set_PhoneNumber(value)" then you have to wrap them by specifying the [Wrap] attribute on the "set" symbol.

using System.Data.SqlTypes;
using dotWeb.Core.Scripting;
using dotWeb.Core.Business;

namespace MyCompany.Business.Logic {
  [Wrap]
  public class Person : Entity {
    protected SqlInt32 iId = SqlInt32.Null;
    protected SqlString sName = SqlString.Null;
    protected SqlString sPhoneNumber = SqlString.Null;

    public override SqlInt32 Id {
      get { return iId; }
      set { iId = value; }
    }

    public SqlString Name {
      get { return sName; }
      set { sName = value; }
    }

    public SqlString PhoneNumber {
      get { return sPhoneNumber; }
      [Wrap]
      set { 
        sPhoneNumber = value; 
      }
    }

    [Wrap]
    public void SetProperties(SqlString sName,
      SqlString PhoneNumber) {
      Name = sName;
      PhoneNumber = sPhoneNumber;
    }

    [Wrap]
    public void Save() {
      MyCompany.Data.SavePerson(this);
    }

    public Person(SqlInt32 iId) {
      Id = iId;
      MyCompany.Data.LoadPerson(this);
    }

    public Person() {
    }
  }
}

Data layer

This i the data layer. For simplicity the data layer below uses the web server memory instead of a database. For any real life use, implement the database operations.

using System.Collections.Generic;
using System.Data.SqlTypes;
using System;
using MyCompany.Business.Logic;
using dotWeb.Core.Scripting;

namespace MyCompany {
  [Wrap]
  public class Data {
    protected static Dictionary<Int32, Person> 
      oPersonTable = null;

    [Wrap]
    public static Dictionary<Int32, Person> PersonTable {
      get {
        if (oPersonTable == null) {
          //Implement your database loader here ...
          oPersonTable = new Dictionary<Int32, Person>();

          Person oPerson = new Person();
          oPerson.Id = 1;
          oPerson.Name = "Federico Ferris";
          oPerson.PhoneNumber = "555-6519845";
          oPersonTable[oPerson.Id.Value] = oPerson;

          oPerson = new Person();
          oPerson = new MyCompany.Business.Logic.Person();
          oPerson.Id = 2;
          oPerson.Name = "Kenneth Williamson";
          oPerson.PhoneNumber = "555-9877521";
          oPersonTable[oPerson.Id.Value] = oPerson;

          oPerson = new Person();
          oPerson.Id = 3;
          oPerson.Name = "Jess Nash";
          oPerson.PhoneNumber = "555-7498888";
          oPersonTable[oPerson.Id.Value] = oPerson;
        }
        return oPersonTable;
      }
      [Wrap]
      set {
        oPersonTable = value;
      }
    }

    public static void LoadPerson(
      MyCompany.Business.Logic.Person oPerson) {
      if (oPerson.Id.IsNull) {
        oPerson.Id = SqlInt32.Null;
        oPerson.Name = SqlString.Null;
        oPerson.PhoneNumber = SqlString.Null;
      }
      else {
        if (PersonTable.ContainsKey(oPerson.Id.Value)) {
          oPerson.Name = PersonTable[oPerson.Id.Value].Name;
          oPerson.PhoneNumber = 
            PersonTable[oPerson.Id.Value].PhoneNumber;
        }
      }
    }

    public static void SavePerson(
      MyCompany.Business.Logic.Person oPerson) {
      if (!oPerson.Id.IsNull) {
        //Implement your database updater here ...

        if (PersonTable.ContainsKey(oPerson.Id.Value)) {
          PersonTable[oPerson.Id.Value].Name = oPerson.Name;
          PersonTable[oPerson.Id.Value].PhoneNumber = 
            oPerson.PhoneNumber;
        }
        else {
          PersonTable[oPerson.Id.Value] = new Person();
          PersonTable[oPerson.Id.Value].Id = oPerson.Id;
          PersonTable[oPerson.Id.Value].Name = oPerson.Name;
          PersonTable[oPerson.Id.Value].PhoneNumber = 
            oPerson.PhoneNumber;
        }
      }
    }

    public static void DeletePerson(
      MyCompany.Business.Logic.Person oPerson) {
      if (!oPerson.Id.IsNull) {
        //Implement your database deleter here ...

        if (PersonTable.ContainsKey(oPerson.Id.Value)) {
          PersonTable.Remove(oPerson.Id.Value);
        }
      }
    }
  }
}

Javascript

Download the ASP.NET 2.0 project for the sample.

Calling a static property setter on MyCompany.Data

    
<script language=Jscript>

  MyCompany.Data.set_PersonTable(null);
  alert("Person table is now reset.");

</script>

Reading Person properties.

   
<script language=Jscript>

  var oPerson = new MyCompany.Business.Logic.Person(1);
  alert("Person with Id 1 has the following name: "
   + oPerson.Name);

  var oPerson = new MyCompany.Business.Logic.Person(2);
  alert("Person with Id 2 has the following phone number: " 
    + oPerson.PhoneNumber);

  var oPerson = new MyCompany.Business.Logic.Person(3);
  alert("Person with Id 3 has the following name: "
    + oPerson.Name);

</script>

Updating a Persons properties.

      
<script language=Jscript>

  var oPerson = new MyCompany.Business.Logic.Person(1);
  alert("Person with Id 1 has the following name: " 
    + oPerson.Name + " and phone number: " 
    + oPerson.PhoneNumber);
  
  oPerson.Name = "Brandon Carpenter";
  oPerson.PhoneNumber = "555-9872112";

  alert("Invoking method Person.Save()");
  oPerson.Save();
  
  var oPerson = new MyCompany.Business.Logic.Person(1);
  alert("Person with Id 1 now has the following name: " 
    + oPerson.Name + " and phone number: " 
    + oPerson.PhoneNumber);

</script>

Invoking Person methods.

<script language=Jscript>

  var oPerson = new MyCompany.Business.Logic.Person(2);

  alert("Person with Id 2 now has the following name: " 
    + oPerson.Name
    + " and phone number: " + oPerson.PhoneNumber);

  alert("Now invoking method " 
    + "Person.SetProperties('Russel Yeager', '555-987445')");
  oPerson.SetProperties('Russel Yeager', '555-987445');

  alert("Person with Id 2 now has the following name: "
    + oPerson.Name + " and phone number: " 
    + oPerson.PhoneNumber);
</script>

reboot8 "renaissance?"

2006-03-28T03:15:00.000-08:00

It's time for reboot8, which this year will take place in Copenhagen on June 1- 2 (Thursday and Friday). Same venue; better food; dinner, lounge and entertainment the first evening. More conversation; More Europeans doing interesting things; and still as informal and open an atmosphere as always, hopefully...

THE CHALLENGE

The theme for reboot8 is "renaissance?" - as in renaissance-question-mark. As in renaissance = rediscovery and revitalization. Question mark because it's a big word and a question to explore whether it's real, but renaissance because it seems as a healthier and more challenging perspective than the current bubble easy-reality buzzwords currently flowing around. So reboot8 is like reboot7 a journey into the interconnectedness of creation, participation, values, openness, decentralization, collaboration, complexity, technology, p2p, humanities, connectedness and many more areas. Applied towards us as individuals, citizens, teachers, culture workers, entrepreneurs, creators and change makers.

It feels like we more should think a lot about the emerging new models and how we can help shape them, instead of focusing on how the new models are superior to the current models.

Explore renaissance question mark at http://reboot.dk/wiki/Renaissance

THE PLATFORM

Unlike previous years there isn't a final speakers list or a black box creation model. reboot is a platform for bringing the European community together, a platform for conversations and relationships, a platform for sharing visions and meeting the people you didn't think you'd meet.

So the platform is all yours, and this is an invitation to participate and help co-create reboot..:

- an invitation to submit topics you would like on the agenda for reboot - an invitation to submit pointers to interesting people you know in your country that has something to contribute, and help us recruit them to come - an invitation for your proposal to host or present if you've been doing some interesting thinking the last year or have created something that's worth sharing. - an invitation for you to help make sure that we have the people that have open minds and are ready to make a difference at reboot. to connect europe, to widen the community, to add perspective.

Help co-create reboot8 at http://reboot.dk/wiki/Participate

Ajax for Business Logic

2006-02-19T05:39:00.000-08:00

I created a JavaScript Wrapper for my C# Business Logic classes. You specify which dll to "wrap" and the wrapper spits out javascript.

The result is that you can write near-C# language in JavaScript! I have all the public classes, constructors, public constants, public methods and public properties available client side in javascript.

The methods and constructors are just "empty" functions that check if the correct number of parameters are specified and then perform a synchronous web service call. The web service then invokes the constructor or method and returns the resulting value.

This means that you don't need to write hundreds of web services and web service methods when you need to interact with the business entities and business logic.

In respect to security the wrapper only wraps public classes and namespaces. And furthermore it checks that a [Wrap] attribute is present.

For even more security WSE provides a mechanism to digitally sign SOAP messages.

Examples:

Creating an instance of Business.Logic.ContractSale using the constructor that takes an id as parameter, invoking Validate() and Accept(DateTime oDateAccepted) on the instance.

  var oContractSale = 
    new Business.Logic.ContractSale(iCSal_Id);

  if (oContractSale.Validate()) {
    oContractSale.Accept(new Date());
  }
  else {
    alert("Sales contract is not valid!");
  }

Creating a new instance of Business.Logic.InvoiceSale setting properties and invoking method Save() on the instance.

  var oInvoiceSale = 
    new Business.Logic.InvoiceSale();

  oInvoiceSale.DateInvoice = new Date();
  oInvoiceSale.Amount = 150;
  oInvoiceSale.Currency = Business.Logic.Currency.USD;
  oInvoiceSale.Save();

Hijax.NET?

2006-02-14T12:41:00.000-08:00

I am considering a new name for OutPost, what do you think about Hijax.NET?

OutPost 1.2

2006-02-13T10:48:00.000-08:00

Version 1.2 now available.

OutPost 1.2 (with source code)

Screenshot of "The iGoogle Demo" in the demo project

Support for client event validation.
Support for server event validation.
Support for form validation.
Support for inputs with type=image.
Support for object databinding.
Full cross-browser support without need for ATLAS scripts.
Added Session support on first post back.
Added Response.Filter to take advantage of differences on first post back.
Support for Netscape.
Support for Opera.
Support for Opera.
Support for Visual Studio 2005
Support for both ASP.NET 1.1 and ASP.NET 2.0
Support for HTTPS/SSL

Please give feedback!

Executing multi-valued web service calls from javascript

2005-10-31T13:18:00.000-08:00

I'm currently working hard on a web based business system for a theatre agency here in Denmark. Client-side business logic communicates through web service calls with server-side business logic.

I'm using the web service proxies that Matthias Hertels AJAX Engine generates, but I was unable to use ajax.Start to execute multi-valued calls.

Maybe I overlooked something? :) Anyway, I came up with a fix for it...

This an example of a multi-valued call:

  ...
  var Add = {
    delay: 200,
    prepare: function() { return [34, 23]; },
    call: proxies.AddService.Add,
    finish: function (p) {
      alert("Sum: " + p);
    },
    onException: proxies.alertException
  };

  ajax.Start(Add);
  ...

I changed some lines in Ajax.js. After this:

      ...      
      // start the call
      ca.call.func = ajax.Finsh;
      ca.call.onException = ajax.Exception;

I added this:

      // multi-valued call (new)
      if ((typeof(data)=="object") && (data!=null) && data.length) {
        ca.args = new Object();
        var aArg = new Array();
        for (var i = 0; i<data.length; i++) {
          ca.args["a" + i] = data[i];
          aArg[aArg.length] = "a" + i;
        }
        with (ca.args) {
          eval("ca.call(" + aArg.join(",") + ")");
        }
      }
      // single-valued call
      else { 
        ca.call(data);
      }      
      ...

And it worked. I hope you can use this.

OutPost: Near future roadmap

2005-10-19T14:37:00.000-07:00

As soon as I have a version of OutPost that is ASP.NET version independent (I'm working on that now) I'll optimize more on the amount of data sent back to the client.

I have just added support for Netscape 8 and Opera 8.5 in my development version, and I'll post a new beta version of that soon. I also got OutPost working nicely with the Personal Web Starter Kit for ASP.NET 2.0 RC.

OutPost 1.1 beta (ASP.NET 2.0 only)

2005-10-15T14:07:00.000-07:00

Great news for beta testers: You can download the 1.1 beta ASP.NET 2.0 version of OutPost now.

OutPost 1.1 beta (ASP.NET 2.0 only)

It doesn't work in FireFox yet, because I haven't been able to make the tags behave like they should.

Here are some of the new features / bug fixes:

1.1.000 - 20051014 1700 twj
Support for HTTPS/SSL.
Support for Visual Studio 2005 Release Candidate.

1.0.002 - 20051007 1125 twj
Bug fixed in javascript Serializer: Unicode characters were not escaped properly.
Optimization of the JavaScript property by using StringBuilder.
Default values are stored before PostBack and restored afer PostBack.

1.0.001 - 20051004 1825 twj
Bug fixed in constructor: PartsNeeded is only initialized as a StringArray if the "PartsNeeded" header is set.
Bug fixed in window_onload function: Script error if no forms present on page.
Added version comment to client-framework javascript.

1.0.000 - 20051003 0149 twj
Initial article release.

OutPost: Performance Tuning and Optimization

2005-10-12T14:24:00.000-07:00

The same principles for Performance Tuning and Optimization apply when developing with OutPost. You optimize by taking advantage of the view-state, page level caching, page fragment caching, application caching, session caching and the web server Cache.

With OutPost you can actually get further performance improvements:
- Splitting up your page and having more web forms on the same page, like in "The iGoogle Demo", is a great idea.
- Finding the balance of when to use the view-state and when not to is also important and would often require you to test your application and analyze the load times to find the right settings.
- Setting the IDs of the HTML elements that frequently get updated is a good idea, because OutPost compares the innerHTML of elements with IDs.

I'll grant you that AJAX is much nicer to the server. But I would say that OutPost is much nicer to the developer

I like the simple structure of ASP.NET Web Forms and the way that you can develop ASP.NET controls for different browsers (with or without DHTML, depending on the capabilities of the browser).

The improvements to ASP.NET in upcoming versions (e.g. the view-state) will also have impact on the performance in OutPost web applications.

The improvements that you mention in ASP.NET 2.0 that you can write asynchronous pages will also work in combination with OutPost.

ATLAS will also work in combination with OutPost to provide extra RIA features to up-level browsers.

OutPost: Future Improvements

2005-10-11T14:24:00.000-07:00

I am working on an easy way to make web service calls from JavaScript and I will include that in OutPost, so that you don't have create an invisible web form with text boxes and buttons if you want to call the server. I think it will be inspired heavily by ATLAS. I would really like to include more ATLAS features in OutPost.

OutPost: How I got the Idea

2005-10-10T14:20:00.000-07:00

It is a novel solution. I got the idea, while I was developing the framework for a web site editor called UpFront in 2002, where the user designs his pages by inserting text, images, data lists, web forms and navigation menus on the pages.

The language was ASP (JavaScript) on the server-side and JavaScript on the client. I had two parallel frameworks to create data lists, web forms and navigation menus (one on the client-side and one on the server-side). The client-side framework was used when dynamically creating or updating the properties of a data list, web form or navigation menu in the editor (with heavy use of DHTML and XmlHttp calls to retrieve dataset in JSON - developed on top of JSRS). The server-side framework was used when rendering HTML on the first page load.

I found out that I could trash the client-side framework by calling an ASP page that returned the HTML and JavaScript needed over XmlHttp. This was a huge improvement i productivity, because I had one framework less to maintain and I could develop new "controls" faster.

This solution also gave me the advantage that I could gradually convert to C#-compiled code and I did so by calling a .NET web service over XmlHttp for the data list and navigation menus to start of with, and I still used a page (now an ASP.NET page) to render data lists and navigation menus. Now I could take advantage of the ASP.NET DataGrid for my lists, but in order to make it work properly I had to support the view-state and the server-events, so I examined the headers and the body of post backs to ASP.NET pages (using Fiddler and other HTTP debugging tools) and I was able to simulate it. So now I had my data lists and navigation menus rendered like stand-alone .NET pages with support for State Management, Server Events, Page-Level Caching, Page Fragment Caching, Session, Application and Data Cache. The HTML that the page generated contained the view-state, but I didn't have to return that to the client, since it's not used for anything on the client, so I stored it in Application together with the HTML. In that way I could compare HTML from request to request and didn't have to send more than necessary to the client. The view-state was combined with the form data from the client to make the request to the ASPX page.

So that's how I got the idea. As you can see I started out with Remote Scripting and DHTML (AJAX!). I moved away from that primarily to get productivity gains. OutPost is cross-browser compatible because it relies on ASP.NET controls that are cross-browser compatible. That also means that when you use OutPost on an up-level browser JavaScript will be transmitted on the first page load to take advantage of the capabilities in the client browser, and less HTML will be transmitted on post backs or no post backs will be necessary at all. So it will not be a screen scraping on up-level browsers. If the client browser is a downlevel-browser more HTML will be transmitted. In the examples in the demo project I have set the Page attribute clienttarget="downlevel" to force it to make a post back, but you can remove that attribute and no post backs will be made.

OutPost: Creating Interactive Web Applications

2005-10-09T14:26:00.000-07:00

When you are creating interactive web applications with AJAX (any AJAX framework), you need a solid understanding of the DOM and CSS in different browsers. DHTML can be a challenge for any developer - you have to test your application rigorously in different browsers. And browsers do change. You have to write the DHTML for your controls and you have to make it cross-browser compatible yourself. ATLAS lends the developer a hand by introducing its layers of DOM compatibility. The DOM is extended by adding methods to the document and window element (as I describe it in the article). And that is great if you need to write DHTML! But with OutPost you don't! You just have to use stardard ASP.NET controls that are able to output HTML for downlevel browsers. If the browser is up-level it outputs HTML+JavaScript, and if the browser is down-level is outputs HTML. If you installed the demo project, you can try this out by removing the clienttarget="downlevel" attribute in the Page directive of Validator7.aspx or Validator8.aspx. You'll then notice that with up-level browsers fewer XmlHttp-calls are now made, because the validation is done with JavaScript.

OutPost: Post Back Over XmlHttp

2005-10-05T03:01:00.000-07:00

Perform real Post Backs of ASP.NET Web Forms without reloading the entire page.
Keywords: AJAX, XmlHttp, WebForms, Post Back, DHTML, Web Service, OutPost.

Screenshot of "The iGoogle Demo" in the demo project

Introduction

This article assumes that you are familiar with ASP.NET WebForms. You might also want to know the basics about AJAX. This is a quote from Wikipedia on AJAX:

Ajax applications look almost as if they reside on the user's machine, rather than across the Internet on a server. The reason: pages get updated, not entirely refreshed.
“Every user action that normally would generate an HTTP request takes the form of a JavaScript call to the Ajax engine instead”, wrote Jesse James Garrett, in the essay that first defined the term. “Any response to a user action that doesn’t require a trip back to the server — such as simple data validation, editing data in memory, and even some navigation — the engine handles on its own. If the engine needs something from the server in order to respond — if it’s submitting data for processing, loading additional interface code, or retrieving new data — the engine makes those requests asynchronously, usually using XML, without stalling a user’s interaction with the application.”
Traditional web applications essentially submit forms, completed by a user, to a web server. The web server responds back by sending a new web page. Because the server must submit a new page each time, applications run more slowly and awkwardly than their native counterparts.
Ajax applications, on the other hand, can send requests to the web server to retrieve only the data that is needed, usually using SOAP or some other XML-based web services dialect. On the client, JavaScript processes the web server response. The result is a more responsive interface, since the amount of data interchanged between the web browser and web server is vastly reduced. Web server processing time is also saved, since much of it is done on the client.

AJAX is a maintenance nightmare

Today you have to create web applications that work in both IE and Firefox, and that is definitely doable but also pretty time consuming and a maintenance nightmare.

AJAX has become very popular, because it answers a need for speed and responsiveness in web applications and there has also been the "Google" effect:

- "We create interactive web applications like Google does and they use AJAX too",

yeah, but it is not so cool, if you use 95% of the time on testing in different browsers.

AJAX falls short on two major points: It has no support of the state management in ASP.NET Web Forms and it has no support for cross-browser web applications. The goal of this article is to solve these two issues.

Example

Lets say you have a tree-structure displayed to the user (like in Windows Explorer) and you only want to retrieve and display the sub-folders when the user expands a folder in the tree.

With AJAX you would call a web service to retrieve an array containing the subfolder names, links and icons and create the tree nodes using DHTML. You would have to create the web service methods, write cross-browser javascript to make it work and have hidden fields in your ASP.NET WebForm containing the state of the control.

What OutPost does is to perform a real Post Back through a Web Service that also manages the view-state (and keeps it on the web server). The InnerHtml of the modified elements are sent back to the client and displayed in the browser. In that way the whole process is generalized and you don't need to create Web Service methods, DHTML javascripts or add hidden fields for your ASP.NET Controls.

So obviously you get considerable productivity gains by using OutPost to AJAX-enable your web applications.

What makes OutPost unique?

OutPost is a new angle on AJAX. Other AJAX frameworks use specifically tailored Web Services, that you have to write yourself to return the data you need. And none of the frameworks fully support the benefits of the ASP.NET Framework. With AJAX you have to re-think and re-write your code.

Unique advantages of OutPost

A single .js include file is enough for OutPost.
OutPost converts any ASP.NET WebForm into an AJAXed WebForm without any modifications to the code.
It has cross-browser support built-in.
The Post Backs are 100% real and server-side events are triggered, as you'd expect them to trigger.
Multiple server-side WebForms (.aspx-pages) are supported side by side on the same page.
Excess traffic between client and server is eliminated (the view-state stays on the server and only modified HTML is sent back to the client).
A lightweight javascript client-framework makes it possible to add, remove and Post Back WebForms by script.

Other OutPost features

Output caching is supported on WebForm-level.
Unicode characters are supported.
A WebForm has its own Session.
No custom controls are needed.
Main pages and WebForms can be designed in VS.NET.

OutPost-enabling a single WebForm

The decision to add "AJAX" to your pages is not a question of "do we have the time and skill to implement it". Instead it becomes a design question.

To add OutPost and AJAX-enable a WebForm, all you need is to write the following in the beginning of your .aspx file:

  <script src="/OutPost/OutPost.js.aspx" type="text/javascript"></script>

But let us just zoom out for a second:

Background

When developing interactive applications for the web, you have different models to use, and two of them are shown below. They can be combined in many ways, but if they are not combined the following is a non-pre-emptive comparison of their advantages and disadvantages:

ASP.NET WebForms

+	FAST AND SAFE: Compiled code, type safe code model.
+	OPEN OOP MODEL: Object oriented programming model, open extendable classes, reusable code.
+	FRAMEWORK: Has an extensible framework with a fair amount of rapid development tools and web controls ready to use.
+	STATE MANAGED: It manages the state for you using viewstate post backs.
+	SERVER-EVENTS: An event model takes care of the communication between client and server.
+	CROSS-BROWSER: The HTML and javascript it produces automatically match the capabilities of the target browser.
+	CACHED OUPUT: Pages, controls and datasets can be cached in a variety of ways.
+	FAST STARTUP: Only the HTML needed for displaying the current page is transmitted to the client.
-	HEAVY TRAFFIC: When posting back, the whole web form including the viewstate is uploaded to the server and the whole page is then sent back to the client.
-	RELOADS: When posting back the whole page is refreshed and especially on slow connections and or slow cpu's this makes the page flicker.

AJAX

+	LIGHT TRAFFIC: State is not transmitted back to the server, only the needed data is transmitted
+	NO RELOADS: The page is updated by using DHTML (manipulating the DOM with javascript).
-	NO SERVER-EVENTS: Communication with the server is done by directly calling different web service methods.
-	SLOW AND UNSAFE: Jscript is not a compiled language and testing is pretty difficult on some devices.
-	SLOW STARTUP: Huge amounts of javascript is usually needed for client controls and these files are sent to the client on startup.
-	NOT CROSS BROWSER: Making sure the DHTML is cross browser is completely in the hands of the developer.
-	NO FRAMEWORK: You have to put together your own client-control framework to manipulate the DOM.

OutPost - The best of both worlds

In OutPost the advantages of ASP.NET WebForms and AJAX are combined. OutPost takes care of the following:

Need for cross-browser DHTML is eliminated.
A real Post Back is executed and server-side events are fired.
Excess traffic is eliminated.
Page reloads are eliminated.

That easy, right? Yes, let's take it step by step.

Step by step

The steps below describe the life of a Post Back when using OutPost:

Need for cross-browser DHTML is eliminated
- A main page loads the Web Form Page and in that process (on the server) the HTML and ViewState are stored for later use (it is used again on the server when posting back the WebForm). Also the needed link(s) to javascript file(s) are inserted in the HEAD section of the HTML (extra cross-browser compatibility layer scripts are added if necessary).
  
  When loading a WebForm, you can decide whether you want all the HTML or only the outerHTML of the form. If you want several forms loaded onto the same main page, you would only need the outerHTML of each form and add that, where you'd like on the page (as long as it is not inside the page's own web form).
  
  If you load a single WebForm you could go for the HTML of the whole page and simply let that be the contents of the main page. The main page does not necessarily need to have its own web form.
- The above is optional and you can insert the javascript link in your code yourself and use the server-controls to add the cross-browser compatibility layers if needed.
  The compatibility layers are added by the files AtlasCompat.js and AtlasCompat2.js from Atlas (the Microsoft ASP.NET 2.0 AJAX platform) and they ensure that the OutPost runtime works the same in all browsers. For example on the window and the document elements the attachEvent and detachEvent functions are added, so the DHTML in the OutPost runtime can be the same.
  If you don't use a main page, the HTML structure and the ViewState of the first call will not be stored on the server and the first post back will have to send the ViewState to the server and the inner HTML of the whole web form will also be sent back to the client on the first Post Back.
A real Post Back is executed and server-side events are fired

The PostBack of the form is replaced by out-of-band calls to a .NET Web Service. The calls are made from javascript without reloading the page. This is done by posting a SOAP-envelope to the Web Service using XmlHttp. The SOAP-envelope contains the Uri of the WebForm Page (the action attribute of the form element) and the contents of the input fields in the WebForm (but not the ViewState).

The Web Service then executes the real Post Back using HttpWebRequest and HttpWebResponse. Headers containing user agent, language and session cookie are sent on to the WebForm Page.
Excess traffic is eliminated

The HTML read from the HttpWebResponse is parsed and the tags/elements that have an ID gets picked out and put into a tree structure. This step only works if the HTML structure is correct. If the structure is not correct the inner HTML of the whole web form is sent back to the client (not the ViewState though).

The HTML tree structure of the new post back is compared to the HTML tree structure of the last post back. This is done in a bottom-up way, so first the contents of the form without any inner HTML of sub nodes are compared. If no differences found, the inner HTML of the next sub nodes (with the same id and id-index) from each tree are compared without the inner HTML of their sub nodes. And so forth.
Page reloads are eliminated

The inner HTML of the elements found to be different in the previous step are returned to the client. The DOM is updated, element by element, using cross browser DHTML.
It might seem as a bit of a crude way to just send the modified innerHTML fragments back to the client, but it really makes sense when developing cross-browser web applications.

Using the code

A single WebForm

To add OutPost and AJAX-enable a WebForm, all you need is to write the following in the beginning of your .aspx file:

  <script src="/OutPost/OutPost.js.aspx" type="text/javascript"></script>

Using a main page to load the WebForm

To load a page from a main page and OutPost-enable it you write the following in your Page_Load method:

    private void Page_Load(object sender, System.EventArgs e) {
      Page.Controls.Add(OutPost.Core.OutPost.GetLiteralControl(ResolveUrl("Validator7.aspx")));
    }

This (when placed in the top) adds cross-browser scripts on demand, based on the client User-Agent:

  <%@ Register TagPrefix="outpost" Namespace="OutPost.Controls" Assembly="OutPost" %>
  <outpost:script Runat="server" Path="~/ScriptLibrary/AtlasCompat.js" Browsers="Netscape,Mozilla,Firefox,Apple,Safari,Mac" />
  <outpost:script Runat="server" Path="~/ScriptLibrary/AtlasCompat2.js" Browsers="Apple,Safari,Mac" />

Having two forms on the same page that depend on each other

Using javascript it is possible to let two forms depend on each other:

  <script type="text/javascript">
    //OutPost7.aspx

    function document_onkeyup() {
      if (event.srcElement==Forms[0].TextBox1) {
        Forms[1].TextBox1.value = event.srcElement.value;
      }
    }

    function document_onclick() {
      if (event.srcElement==Forms[0].Button1) {
        Forms[1].Button1.bClicked = true;
        Forms[1].doPostBack('','');
      }
    }
    
    document.attachEvent("onclick",document_onclick);
    document.attachEvent("onkeyup",document_onkeyup);
  </script>

Using the Client Framework

The following example shows how you can dynamically add, remove and Post Back different forms on a page (See "The iGoogle Demo" in the demo project and the screen shot from the demo in the beginning of this article).

  //RssFeed.js - "The iGoogle Demo"

  function DeleteBox() {
    var oNodeForm = null;
    if (oEventNode) {
      oNodeForm = misc_getForm(oEventNode);
      oEventNode = null;
    }
    if (oNodeForm!=null) {
      oNodeForm.parentNode.parentNode.removeChild(oNodeForm.parentNode);
      Forms[oNodeForm.iIndex] = null;
    }
    var sAction = unescape(oNodeForm.action);
    FormMain.bAddBox = false;
    FormMain.doPostBack("oButtonDelete",sAction);
  }
  
  function AddBox() {
    var sUri = "/OutPost/Demo/RssFeed.aspx?rss="+escape(document.getElementById('FormMain').oTextBoxAddRssUri.value);
    
    for (var i in Forms) {
      if ((Forms[i]!=null) && (unescape(Forms[i].action)==unescape(sUri))) {
        alert("The feed has already been added");
        return;
      }
    }
  
    var oNodePanel = document.createElement("DIV");
    oNodePanel.className = "cPage";
    
    var oNodeColumn = document.getElementById("oTableCell2");
    if (document.getElementById("oTableCell1").childNodes.length<oNodeColumn.childNodes.length) {
      oNodeColumn = document.getElementById("oTableCell1");
    }
    if (document.getElementById("oTableCell3").childNodes.length<oNodeColumn.childNodes.length) {
      oNodeColumn = document.getElementById("oTableCell3");
    }
    
    oNodeColumn.appendChild(oNodePanel);
    
    var oNodeForm = createForm("Form1", sUri, AddBox_onerror);
    oNodePanel.appendChild(oNodeForm);
    document.getElementById('FormMain').oTextBoxAddRssUri.value = "";
  }
  
  function AddBox_onerror() {
    alert("Error adding RSS feed");
  }
  
  function FormMain_onsuccess() {
    this.base_onsuccess();
    if (this.bAddBox!=false) {
      AddBox();
    }
    this.bAddBox = true;
  }
  
  function window_onload() {
    FormMain.onsuccess = FormMain_onsuccess;
  }
  
  window.attachEvent("onload", window_onload);

The Future of OutPost

Making it possible to send back changes on a smaller scale (like only setting the value of an input or only changing one option in a dropdown list).
I would like to incorporate simple AJAX behaviour, so that you can interact with business logic on the web server.
Solving the Bookmark issue. It is not possible to bookmark a WebForm page and I'm trying to find a solution to that.
Solving the Back-button issue. It is not possible to use Back-Button and I'm trying to find a solution to that also.

History

Sep 2005 - OutPost version 1.0 - Added cross-browser support, lightweight client-framework,
May 2005 - OutPost version 0.5 - Single web form supported, IE only.
Nov 2004 - First initial testing performed.

OutPost: I'm writing an article about the project

2005-09-14T23:24:00.000-07:00

I am working on an article about OutPost, a very simple way to achieve "AJAX"-style behaviour in your ASP.NET applications

The basics

The viewstate is properly updated
Session works
Unicode characters are supported
Server-side events work

In order to make it easy to use, you would also need the following

No custom controls are needed
Pages can be designed as normal

To make it really fun and powerful to use, what about

Multiple forms on same page
Multiple aspx pages on the same page

All the above is already working now, so what about the future?

Automatic dotfuscating of javascript and html
Minimizing transfer by only transmitting difference between posts

Writing typesafe SQL-WHERE clauses

2005-06-14T01:54:00.000-07:00

I have written a code generator, that generates C# classes based on the tables and views in a database. It had for some time irritated me that even though everything was now neatly packaged in a data layer and an entity relation layer I still needed the occasional SQL-WHERE clause here and there. And as you know they never result in compile time errors, but instead in runtime errors, which is worse... So I wanted the compiler to catch me if I wrote a syntax incorrect SQL-WHERE clause, instead of getting a runtime error, when a user reached the specific page and state of things.

Also when I modified the database, I wanted the compiler to check the SQL-WHERE clauses for me, which can be a tideous chore to do manually. So I came up with this solution, that works best in combination with a code generator, because then you'll have complete syncronisation with the columns and datatypes to use.

Features

Support for != and == operators
Support for && and || binary operators
Support for int datatype
Support for string datatype

Examples

Note: The examples show how to create Filter instances. I use my code generator to do this for me. It creates a filter instance for each column. If I refer to a column that has been deleted or renamed in the database the compiler will catch this.

Filter.IntFilter iEmpl_Id = new Filter.IntFilter("Empl_Id"); string sSQLWhere = (iEmpl_Id=="A text").ToString(); Results in a compile time error.
Filter.IntFilter iEmpl_Id = new Filter.IntFilter("Empl_Id"); string sSQLWhere = (iEmpl_Id==13).ToString();
Results in the string "Empl_Id=13".
Filter.StringFilter sEmpl_NameFirst = new Filter.StringFilter("Empl_Name"); Filter.IntFilter iEmpl_Id = new Filter.IntFilter("Empl_Id"); string sSQLWhere = (iEmpl_Id==13 || iEmpl_Id!=10&&sEmpl_NameFirst=="D'angelo").ToString();
Results in the string "Empl_Id=13 OR (NOT (Empl_Id=10) AND Empl_Name='D''angelo')".

Todo

Support for < and > operators
Support for IN clause
Support for Datetime datatype
Support for Guid datatype
Support for SqlTypes datatypes

using System;

namespace NatMus.Data.Core {
  public class Filter {
    protected string sOperandName = "";
    protected string sSqlOperator = "";
    protected string sSqlPrefix = "";
    protected string sSqlPostfix = "";
    protected string sValue = "";
    protected bool bNegated = false;
    protected Filter oFilterLeft = null;
    protected Filter oFilterRight = null;

    public Filter() {
    }

    public Filter(string sOperandName) {
      this.sOperandName = sOperandName;
    }

    public Filter(Filter oFilter) {
      this.sOperandName = oFilter.sOperandName;
      this.sSqlOperator = oFilter.sSqlOperator;
      this.sValue = oFilter.sValue;
      this.bNegated = oFilter.bNegated;
      this.sSqlPrefix = oFilter.sSqlPrefix;
      this.sSqlPostfix = oFilter.sSqlPostfix;
    }

    public static Filter operator & (Filter oFilterLeft, Filter oFilterRight) {
      Filter oFilterResult = new Filter();
      oFilterResult.sSqlPrefix = "(";
      oFilterResult.sSqlOperator = " AND ";
      oFilterResult.sSqlPostfix = ")";
      oFilterResult.oFilterLeft = oFilterLeft;
      oFilterResult.oFilterRight = oFilterRight;
      return oFilterResult;
    }

    public static Filter operator | (Filter oFilterLeft, Filter oFilterRight) {
      Filter oFilterResult = new Filter();
      oFilterResult.sSqlOperator = " OR ";
      oFilterResult.oFilterLeft = oFilterLeft;
      oFilterResult.oFilterRight = oFilterRight;
      return oFilterResult;
    }

    public static bool operator true(Filter v) {
      return false;
    }

    public static bool operator false(Filter v) {
      return false;
    }

    public override string ToString() {
      System.Text.StringBuilder oStringBuilder = new System.Text.StringBuilder();
      oStringBuilder.Append(sSqlPrefix);
      if ((object)oFilterLeft!=null) {
        oStringBuilder.Append(oFilterLeft.ToString());
      }
      oStringBuilder.Append(sOperandName + sSqlOperator + sValue);
      if ((object)oFilterRight!=null) {
        oStringBuilder.Append(oFilterRight.ToString());
      }
      oStringBuilder.Append(sSqlPostfix);
      return oStringBuilder.ToString();
    }

    public class StringFilter : Filter {
      public StringFilter(string sOperandName) : base(sOperandName) {
      }

      public StringFilter(Filter v) : base(v) {
      }

      public static StringFilter operator == (StringFilter v, string sValue) {
        StringFilter oFilter = new StringFilter(v);
        oFilter.sSqlOperator = "=";
        oFilter.sValue = "'" + sValue.ToString().Replace("'", "''") + "'";
        return oFilter;
      }

      public static StringFilter operator != (StringFilter v, string sValue) {
        return !(v==sValue);
      }

      public static StringFilter operator ! (StringFilter v) {
        StringFilter oFilter = new StringFilter(v);
        oFilter.bNegated = !oFilter.bNegated;
        if (oFilter.bNegated) {
          oFilter.sSqlPrefix = "NOT (" + oFilter.sSqlPrefix;
          oFilter.sSqlPostfix += ")";
        }
        return oFilter;
      }

      public override bool Equals(object o) {
        if (o==null) return false;
        return this==(StringFilter)o;
      }

      public override int GetHashCode() {
        return sOperandName.GetHashCode();
      }
    }

    public class IntFilter : Filter {
      public IntFilter(string sOperandName) : base(sOperandName) {
      }

      public IntFilter(Filter v) : base(v) {
      }

      public static IntFilter operator == (IntFilter v, int iValue) {
        IntFilter oFilter = new IntFilter(v);
        oFilter.sSqlOperator = "=";
        oFilter.sValue = iValue.ToString();
        return oFilter;
      }

      public static IntFilter operator != (IntFilter v, int iValue) {
        return !(v==iValue);
      }

      public static IntFilter operator ! (IntFilter v) {
        IntFilter oFilter = new IntFilter(v);
        oFilter.bNegated = !oFilter.bNegated;
        if (oFilter.bNegated) {
          oFilter.sSqlPrefix = "NOT (" + oFilter.sSqlPrefix;
          oFilter.sSqlPostfix += ")";
        }
        return oFilter;
      }

      public override bool Equals(object o) {
        if (o==null) return false;
        return this==(IntFilter)o;
      }

      public override int GetHashCode() {
        return sOperandName.GetHashCode();
      }
    }
  }
}

Checking If Form Data Is Stale Before Saving

2005-06-13T02:59:00.000-07:00

With multiple users working on the same database using ASP.NET webforms, you have to make a design decision how to prevent stale data from being saved. By definition in a web application the data you see in a form is a snapshot in time, so when you post your changes back to the server, the save method must check to see if the data you worked on is stale, meaning it has been changed by another user in the meantime.

public void Form_OnSave() {
  if (DataIsStale()) {
    if (!WarnContinue("The data is stale, mate!"))
      return;
    }
  SaveData()
}

DataIsStale():
MEANING: The currently shown data has a RevisionNumber that is older than the data currently in database

RevisionNumber:

MEANING: The RevisionNumber is the id of the last HistoryItem of an "updated"-class type (created, changed, deleted, deactivated)
HistoryItem:
MEANING: A record in a table called History with columns: history item id, date, user id, guid of element, historytype (created, viewed, changed, deactivated, deleted, etc), session id (only in Method B)

Method A

When saving an element the RevisionNumbers are compared
UPSIDE: Simple and easy solution
DOWNSIDE: You need to store the revision number in the form

Method B

The current SessionID is saved alongside the HistoryItem, so the date of the last HistoryItem of the viewed type and for the current SessionID is compared to the date of the last HistoryItem of an "updated"-class type for all other session ids.
UPSIDE: Doesn't require any extra fields added to the form
DOWNSIDE: The session id is the same when a user has more windows open so it will not alarm a user that edits the same element in two browser windows and saves them both.

Method C

All the original data is compared to the current data in database, if different the the two objects must be different revisions, hence data is stale.
UPSIDE: You don't need HistoryItems and RevisionNumbers and SessionIDs
DOWNSIDE: All the orignal values must also be stored in the form

C# Edge Blog

ASP.NET performance

BarCamp Copenhagen 8.2

OutPost 3.2.001

Slides from barCamp Copenhagen 2008

Transcript

BarCamp Copenhagen 2008

OutPost and ASP.NET Development Server

OutPost Demo HowTo for .NET 2.0

BarCampCopenhagen

OutPost Marketing blah

OutPost 2.0.002

OutPost 2.0 Released

OutPost 1.6

Benefits of Hijax

Benefits of Hijax

OutPost 1.5 Refresh

OutPost version 1.5

OutPost 1.4 Refresh

OutPost version 1.4

OutPost version 1.3

BusinessLogic.web - a .NET business logic wrapper for Javascript

Business Classes

Data layer

Javascript

Calling a static property setter on MyCompany.Data

Reading Person properties.

Updating a Persons properties.

Invoking Person methods.

reboot8 "renaissance?"

THE CHALLENGE

THE PLATFORM

Ajax for Business Logic

Examples:

Hijax.NET?

OutPost 1.2

Executing multi-valued web service calls from javascript

OutPost: Near future roadmap

OutPost 1.1 beta (ASP.NET 2.0 only)

OutPost: Performance Tuning and Optimization

OutPost: Future Improvements

OutPost: How I got the Idea

OutPost: Creating Interactive Web Applications

OutPost: Post Back Over XmlHttp

Introduction

AJAX is a maintenance nightmare

Example

What makes OutPost unique?

Unique advantages of OutPost

Other OutPost features

OutPost-enabling a single WebForm

Background

ASP.NET WebForms

AJAX

OutPost - The best of both worlds

Step by step

Need for cross-browser DHTML is eliminated

A real Post Back is executed and server-side events are fired

Excess traffic is eliminated

Page reloads are eliminated

Using the code

A single WebForm

Using a main page to load the WebForm

Having two forms on the same page that depend on each other

Using the Client Framework

The Future of OutPost

History

OutPost: I'm writing an article about the project

Writing typesafe SQL-WHERE clauses

Features

Examples

Todo

Checking If Form Data Is Stale Before Saving