Hisham Elbreky : ASP.Net

Web developers will need for some top up there web dev experience with new frameworks and technologies that will be required by new web development Trend, Web Developer should know about:

1- Javascript frameworks (Jquery,Dojo ….)

2- Service Oriented Architecting (SOA), Web Services will play the first role in new trend

3- REST Architecture

4- Cloud Computing

5- Model Driven Architecture

6- Rich internet Applications (RIA) and User Experience (UX)

7- Web 3.0 (ie. Google gears)

The following is my view about Web based applications Trend

Software applications moves toward Web due to web user experience and other Web based applications benefits at least user do zero effort to move from one version to another (Easy Deployment) and the big benefit is that web app is a client-server model by default and other advantage of web based applications.

Number of users that use world wide web is in increasing due to technological progress and social changes, and then web applications should be ready for the upcoming users that will hit Web App Server, Web based Application should have architecture that will fit new changes and requirements.

There will be two trends in web app UI architecting :

1- Server Pages, Rendering all UI in server side by using Server pages and server web controls.

2- Native html and JavaScript frameworks, we can say bye bye server pages or server UI rendering (don’t worry about dynamic content the architecture pattern will explain how to do that).

I’m with second trend “Native html and JavaScript frameworks” where is the right and nature path, most server performance is consumed by UI rendering and also bugs of development comes mostly from UI and developers founding themselves doing client side scripting, with “Native html and JavaScript frameworks” there will be a thin layer on server side dealing with client side UI throw Web service.

JQuery Tips

Hisham El-bereky — Thu, 04 Jun 2009 13:52:00 GMT

Selectors:
Getting text box value
$(“#TextBoxId”).val();
Chang or set label text
$(“#LabelId”).text(“Your Text”);
Set control CSS “i.e td border width”
$(“#td_id”).css('border-width', '1px');

Animation:
Display DIV element with animation
$("#div-id").show("slow");
$("#div-id").hide("slow");

Swap Items between two lists
$(“#list1-id :selected”).remove().appendTo(“#list2-id”);

Ajax:
Passing parameters to asp.net web services
var prm1=”value”;
var prm2=2;
$.ajax({
        type: "POST",
        url: "/AjaxWebMethods.aspx/WebMethod ",
        data: '{"parameter1":"' + prm1+ '”,"parameter1":"' + prm2+ '"}',
        contentType: "application/json; charset=utf-8",
        dataType: "json",
        success: function(msg) {
            /*your code*/
        },
        error: function(err) { /*your code*/}
    });
Look for data line

An entry to JQuery

Hisham El-bereky — Thu, 04 Jun 2009 13:26:00 GMT

JQuery is a JavaScript library simplify using JavaScript in client side, with JQuery you can handle document objects where you can select and change style or behavior in easy way, I think JQuery as a successful JavaScript Library will play a big role in the next days of web development and that is makes Microsoft embedding JQuery in ASP.NET AJAX.

JQuery Site :

http://docs.jquery.com/Main_Page

http://docs.jquery.com/How_jQuery_Works

http://docs.jquery.com/Core

http://docs.jquery.com/Selectors

http://docs.jquery.com/Events

http://docs.jquery.com/Effects

http://docs.jquery.com/Ajax

http://docs.jquery.com/UI

Blogs :

http://encosia.com/category/jquery/ -Dave Ward

Article:

http://www.west-wind.com/presentations/jQuery/default.aspx - An introduction to jQuery By Rick Strahl

Books:

Manning.jQuery.in.Action – By John Resig

Eye On .NET (2)

Hisham El-bereky — Tue, 27 May 2008 19:27:00 GMT

Blogs

Scott Hanselman

The Weekly Source Code : OpenID Edition, LINQ to Regular Expressions and Processing in Javascript

TypeConverters: There's not enough TypeDescripter.GetConverter in the world

11 Top Tips for a Successful Technical Presentation

Joshua Flanagan

Readable Regular Expressions

Joe Sagner

Tutorials at - Defaultdotaspx.com - Mustafa Basgun

Intellisense for jQuery

Charlie Calvert

Where are the Visual Studio 2008 Keybinding Posters?

ADO.NET Team Blog

What's New in the SP1 Beta for LINQ to SQL?

Recent ADO.NET Entity Framework provider news - Demos and downloads

Articles

The Difference between GET and POST

Writing to the Event Log

Entity Framework and Lazy Loading

Save and Retrieve Images from the Database using ASP.NET 2.0 and ASP.NET 3.5

Building a File Service

SQL Server Indexes : http://www.sqlteam.com/article/sql-server-indexes-the-basics, http://www.odetocode.com/Articles/70.aspx

Client Application Services : Part 1, Paert 2

Fast, Scalable, Streaming AJAX Proxy - continuously deliver data from across domains

Designing Application Using Test Driven Development

HTTP Handlers and HTTP Modules in ASP.NET

Managing Configuration Data Programmatically in ASP.NET 2.0

Announcement

Visual Studio 2008 and .NET Framework 3.5 Service Pack 1 Beta

.NET 3.5 Enhancements Training Kit

Visual Studio extensions for SharePoint

Recent ADO.NET Entity Framework provider news Demos and downloads

Eye On .NET

Hisham El-bereky — Sat, 03 May 2008 09:15:22 GMT

Eye On .NET is periodical listing series for .NET(Blogs, Articles, Media, Events and Announcing) I hope that my simple view to .NET development be helpfully at least reflect the best.

And this is my first List that will be focus on Blogs Community :)

Scott Guthrie

links: April 28th, April 11th

ASP.NET MVC: (Part 0): What is it? , (Part 1): Building an MVC Application , (Part 2): URL Routing , (Part 3): Passing ViewData from Controllers to Views , (Part 4): Handling Form Edit and Post Scenarios

Slides from my ASP.NET Connections Orlando Talks

ASP.NET 3.5 Extensions CTP Preview Released

ASP.NET 2.0 Tips, Tricks, Recipes and Gotchasa

Charlie Calvert

Community Convergence: XLIII, XLII, XLI

Future Focus II: Call Hierarchy

Link to Everything: A List of LINQ Providers

Expression Tree Basics

Scott Hanselman

Scott Hanselman's Greatest Hits

The Weekly Source Code 25 - OpenID Edition

Dave Ward

Why you should not place your whole site in an UpdatePanel

Why do ASP.NET AJAX page methods have to be static?

Using jQuery to Consume ASP.NET JSON Web Services

Boost ASP.NET performance with deferred content loading

4 ASP.NET AJAX JavaScript UI methods you should learn

Joe Stagner

Microsoft patterns & practices Web Client Software Factory 2.0

ASPConnections Orlando - Dynamic Data & Listview Talks

Rob Conery

MVC Storefront

Subsonic

Robert Shelton

Free Download: Approval Workflow Starter Kit, for Windows Workflow Foundation

Video: See Microsoft's new Live Mesh Technology

How to video: SharePoint and Silverlight 2

ASP.NET AJAX Overview And Technical Tips

Hisham El-bereky — Sat, 19 Apr 2008 18:48:00 GMT

Latest days I was interested with the best use for ASP.NET Ajax also covering its helpfully features, after many reads for books and websites (blogs, articles) hope to introduce something that help developers.(download PDF document version)

Contents:

About AJAX
History of the XMLHttpRequest Object
How XMLHttpRequest object works?
About JSON
Installing ASP.NET AJAX in VS 2005
Dealing with ASP.NET AJAX Main Items

ScriptManager

the brains of an Ajax page
Understanding the ScriptManager
Dynamically Assigning ASP.NET AJAX Script References

ASP.Net AJAX Toolkit

Installing the Control Toolkit for VS 2005
AJAX with UpdatePanels And Web Services

Invoking web service methods from JavaScript
Invoke ASPX Page Methods
Working with the DOM Using AJAX Client library

References and Links

About AJAX

The main concept behind Ajax is to enable web pages to make HTTP requests in the background, or asynchronously, without reloading an entire page (or, in ASP.NET terms, without a round trip, or a postback). Ajax also allows more responsive UIs to be constructed by drawing on the power of commonly supported browser functions such as, JavaScript, Document Object Model (DOM), and Cascading Style Sheets (CSS).

Creating Ajax-enabled web pages by programming the browser requires knowledge of JavaScript, DOM, and the XMLHttpRequest object, which handles the requests from the client to the server.

The name of the XMLHttpRequest object is somewhat misleading because data can be transferred in the form of XML or other text-based formats. The ASP.NET AJAX framework relies heavily on a format called JavaScript Object Notation (JSON) to deliver data to and from the server.

History of the XMLHttpRequest Object

The first implementation of XMLHttpRequest can be found in the 1999 release of Internet Explorer 5. That release included an ActiveX object called XMLHttpRequest that did just what the name suggests; make an HTTP request and get a message back. (The format of the returned message could be an XML message, but that was not a requirement.)
Originally, Internet Explorer engineers needed this functionality for the web frontend to Outlook (Outlook Web Access [OWA]), so they could makeOWAbehave more like a desktop application. As useful as it was, for some time the addition of the XMLHttpRequest object to Internet Explorer went unnoticed by web programmers. However, competing browser developers later incorporated a compatible version in their own applications. Because only Internet Explorer supports ActiveX controls,other browsers implemented the XMLHttpRequest object natively in their browser.

After Internet Explorer, the first browser to support XMLHttpRequest was the Mozilla 1.0 browser (not to be confused with the code name for early Netscape browsers). Subsequent versions of Mozilla as well as derivatives, such as the Camino browser for Mac OS X and Firefox, implement XMLHttpRequest. Apple then added appropriate support
in the 1.2 version of their Safari browser. Safari is based on the KHTML renderer that is part of Konqueror, the web browser of the KDE desktop environment for Linux. Apple engineers later back-ported support for the XMLHttpRequest object to Konqueroras as well.
Opera 8.0 and later also included XMLHttpRequest support in their browser, as did the rather exotic system, Open Laszlo, from IBM.

How XMLHttpRequest object works?

look for the following simple example:

The fact that there are different implementations of the object based on browsers and their versions requires you to write browser-sensitive code when instantiating it from script. Listing 1.1 uses a technique called object detection to determine which XMLHttpRequest object is available.

var xmlHttp = null;

if (window.XMLHttpRequest) { // IE7, Mozilla, Safari, Opera, etc.

xmlHttp = new XMLHttpRequest();

} else if (window.ActiveXObject) {

try{

xmlHttp = new ActiveXObject("Microsoft.XMLHTTP"); //IE 5.x, 6

}

catch(e) {}

}

Now that the object has been instantiated, you can use it to make an asynchronous request to a server resource. To keeps things simple, you can make a request to another page called Welcome.htm (listing 1.2).

<head>

<title>Welcome</title>

</head>ting 1.2 Welcome.htm

<body>

<div>Welcome to ASP.NET AJAX!</div>

</body>

</html>

Welcome.htm is pretty minimal and contains some static text welcoming you to the book. You make the asynchronous request with a few more lines of code that you wrap in a function called sendRequest ( listing 1.3).

function sendRequest(url) {

if (xmlHttp) {

xmlHttp.open("GET", url, true); // true = async

xmlHttp.onreadystatechange = onCallback;

xmlHttp.setRequestHeader('Content-type',

'application/x-www-form-urlencoded');

xmlHttp.send(null);

}

The sendRequest method takes as a parameter the URL to which you’ll be making an HTTP request. Next, it opens a connection with the asynchronous flag set to true. After the connection is initialized, it assigns the onreadystatechange property of the XMLHttpRequest object to a local function called onCallback. Remember, this will be an asynchronous call, which means you don’t know when it will return. A callback function is given so you can be notified when the request is complete or its status has been updated. After specifying the content type in the request header, you call the send method to transmit the HTTP request to the server.

When the status of the request changes and the callback function is invoked, the final step is to check the status and update the user interface with the contentsreturned from Welcome.htm ( listing 1.4).

function onCallback() {

if (xmlHttp.readyState == 4) {

if (xmlHttp.status == 200){

var r = document.getElementById('results');

r.innerHTML = xmlHttp.responseText;

}

else {

alert('Error: ' + xmlHttp.status);

}

The status of the request is returned in the readyState property of the XMLHttpRequest object. The value 4 indicates that the request has completed. Next, the response from the server must be checked to confirm that everything was successful. Status code 200 is designated in the HTTP protocol to indicate that a request has succeeded. Finally, the innerHTML of a span element is updated to reflect the contents in the response

About JSON

In addition to the XMLHttpRequest object and XML, a third major technology often used for Ajax applications is JavaScript Object Notation (JSON, http://www.json.org/). With JSON, JavaScript objects or data can be persisted (serialized) in a short and easily understandable way, without requiring a lot of JavaScript code to either write or read the data (also true for XML). JSON makes use of a previously oftenoverlooked feature of JavaScript, or more accurately, of the ECMAScript language

specification, also known as ECMA-262. JSON is used internally by current versions of ASP.NET AJAX and generally can be used to exchange complex data with a server. This allows JavaScript to understand

it, and it helps avoid the sometimes cumbersome parsing process of XML. The following code uses JSON to define a book object:

{"book": {

"title": "Programming ASP.NET AJAX",

"author": "Christian Wenz",

"chapters": {

"chapter": [

{"number": "1", "title": "Introduction"},

{"number": "2", "title": "JavaScript"},

{"number": "3", "title": "Ajax"}

]

}

}}

The object with the book property contains title, author, and chapters properties.

The chapters property contains several chapter subelements, each with a number and

a title property. This can be best visualized when looking at it as XML data.

</chapters>

</book>

Simple example for Using JSON

<head>

</head>

<body>

var json = '{"book": { "title": "Programming ASP.NET AJAX", "author": "Christian

Wenz","chapters": {"chapter": [ {"number": "1", "title": "Introduction"}, {"number": "2",

"title": "JavaScript"}, {"number": "3", "title": "Ajax"} ]} }}';

var obj = eval("(" + json + ")");

for (var i=0; i < obj.book.chapters.chapter.length; i++) {

document.write(

"<p>" +

obj.book.chapters.chapter[i].number +

": " +

obj.book.chapters.chapter[i].title +

"</p>"

);

}

</script>

</body>

</html>

Installing ASP.NET AJAX in VS 2005

AJAX enabled web application is a new feature added with visual studio 2008 but with VS 2005 you will need to setup ASP.NET AJAX that is integrated directly into the IDE. On the ASP.NET AJAX home page (http://ajax.asp.net), you can finda link to ASP.NET AJAX itself in the form of an MSI installer package named ASPAJAXExtSetup.msi. Look for the Microsoft ASP.NET 2.0 AJAX Extensions 1.0.

Dealing with ASP.NET AJAX Main Items

ScriptManager

the brains of an Ajax page

The ScriptManager control is considered the brains of an Ajax-enabled page and is by far the most important control in the framework. As we move along in this chapter and throughout the book, we’ll demonstrate how to leverage the ScriptManager and reveal its intricacies. The important thing to understand at thispoint is that, as the name suggests, this control is responsible for many of the operations that take place during an Ajax application.

Because you want this control to be present on all the pages of the site, you place it in the master page of the web application rather than in the home page (or content page):

<asp:ScriptManager ID="ScriptManager1" runat="server" />

You place it in the master page so that any content pages that inherit from it receive the same functionality. This is generally a good practice for similar controls that are used across multiple content pages. Furthermore, this invisible control must be declared before all other Ajax-enabled server controls in the page hierarchy to

ensure that they’re loaded and initialized accordingly.

Even though the ScriptManager control isn’t declared in the content page, you can easily retrieve an instance of it by calling its static method GetCurrentand passing in the current Page instance:

ScriptManager scriptManager = ScriptManager.GetCurrent(this.Page);

With this instance, you can manage and configure the way the errors, scripts, and other settings on the page behave. We’ll explore some of this in a moment; first, let’s see what adding the ScriptManager to the page does to the application.

Understanding the ScriptManager

The primary responsibility of the ScriptManager is to deliver scripts to the browser. The scripts it deploys can originate from the ASP.NET AJAX library—embedded resources in the System.Web.Extensions.dll, local files on the server, or embedded resources in other assemblies. By default, adding the control to the page, declaratively or programmatically, delivers the required scripts you need for Ajax functionality on the page. To see the evidence, right-click the home page from the browser, and select the View Source option (or select View > Source in IE, or View > Page-Source in Firefox). In the viewed source window, search for an occurrence of ScriptResource.axd

iw9S-TvBA24ugyHeZ8NSIfT6_bRe7yPttgsOhCr1ud1jBUWNQa9KSAugqepLY7DN4cuXzH5ybztCger

rk1&t=633141075498906250"

type="text/javascript">

</script>

Let’s decode what this tag means; this is at the core of how scripts are delivered to

the client.

In ASP.NET 2.0, resources embedded in an assembly are accessed through the WebResource.axd HTTP handler. In the ASP.NET AJAX framework, a new HTTP handler called ScriptResource.axd replaces it with some additional functionality for localization and browser compression. Previous script shows a reference to a script assigned by the ScriptManager that is eventually downloaded by the new handler.

What about the cryptic text? How does the browser decipher it, and what does it mean? A closer look exposes two parameters: d and t. They assist the browser in identifying and caching the resource. The first is the encoded resource key, assigned to the d parameter. The second is the timestamp, t, that signifies the last

modification made to the assembly (for example, t=632962425253593750). When the page is loaded a second time, the browser recognizes the parameters and spares the user the download by using what’s in its cache to retrieve the resources.

NOTE Embedding resources in an assembly is a common technique for controls

and libraries that require resources like images and scripts. This

approach simplifies how controls are packaged and deployed.

Dynamically Assigning ASP.NET AJAX Script References

In most scenarios, the easiest way to add a script file to an ASP.NET page is in markup, as in the following example:

<asp:ScriptManager ID="SMgr" runat="server">
  <Scripts>
    <asp:ScriptReference Path="./Script.js" />
  </Scripts>
</asp:ScriptManager>

However, it is also possible to add script references dynamically.

1 -

ScriptManager Smgr = ScriptManager.GetCurrent(Page);

if (Smgr == null) throw new Exception("ScriptManager not found.");

ScriptReference SRef = new ScriptReference();

2 -

// If you know that Smgr.ScriptPath is correct...

SRef.Name = "Script.js";

// Or, to specify an app-relative path...

SRef.Path = "~/Scripts/Script.js";

3 -

If the script is part of an assembly, set the Name and Assembly properties of the ScriptReference instance.

SRef.Name = "Script.js";
SRef.Assembly = "ScriptAssembly";

4 -

Specify whether to run debug or release versions of the script. To set this mode for all scripts on the page, set the ScriptMode property of the ScriptManager control. To set debug mode for an individual script, set the ScriptMode property of the ScriptReference object.

// To set ScriptMode for all scripts on the page...
Smgr.ScriptMode = ScriptMode.Release;

//Or, to set the ScriptMode just for the one script...
SRef.ScriptMode = ScriptMode.Debug;

//If they conflict, the setting on the ScriptReference wins.

5 -

Smgr.Scripts.Add(SRef);

ASP.Net AJAX Toolkit

The Ajax Control Toolkit is an open source project that Microsoft started in the early days of ASP.NET AJAX. It’s a collection of extenders, script controls, and client components written with the Microsoft Ajax Library.

Installing the Control Toolkit for VS 2005

Before you can use ASP.NET AJAX controls, you need to add the Toolkit controls to your development environment. You can download it from the ASP.NET AJAX home page at http://ajax.asp.net/toolkit/default.aspx?tabid=47. Up-to-date documentation can be found at http://ajax.asp.net/ajaxtoolkit. The toolkit is hosted on CodePlex web site (http://www.codeplex.com/AtlasControlToolkit/) and is provided in the form of a ZIP archive. Actually, two archives: one contains the toolkit plus source code; the other, smaller archive, does not come with the sources.

AJAX with UpdatePanels And Web Services

The UpdatePanel is an Ajax-enabled server control that works closely with the ScriptManager to apply partial-page updates to a page. also it the most obviously control in toolkit and as I think that it most used one by developers, where UpdatePanle still consume server resources then we must use UpdatePanle carefully and in special cases like refreshing GridView or other data controls, but if you plan to to get small data from server then calling web service by AJAX is better

Invoking web service methods from JavaScript

The first step in Ajax-enabling a page is to add the ScriptManager control. Remember, the ScriptManager is the brains of an Ajax page because its responsibilities primarily include managing and deploying scripts to the browser. In this case, you want to leverage the ScriptManager so the page can use the web service

proxy you just generated.

<asp:ScriptManager ID="ScriptManager1" runat="server">

<asp:ServiceReference Path="~/StarbucksService.asmx"

InlineScript="true" />

</Services>

</asp:ScriptManager>

<div>

<input id="GetNumLocations" type="button" value="Get Count"

onclick="getLocations()" />

</div>

function getLocations(){

var zip = $get("Location").value;

AspNetAjaxInAction.StarbucksService.GetLocationCount(zip,

onGetLocationSuccess,

onGetLocationFailure,

"<%= DateTime.Now %>");

}

Invoke ASPX Page Methods

An interesting feature in ASP.NET AJAX is the ability to call, from JavaScript, methods that are declared in the ASP.NET page itself. Because these methods are declared on a page, not from a Web Service, they’re appropriately called page methods. To demonstrate how this works, let’s add a simple static method called HelloEmployee to the page. This method takes as a parameter an instance of the Employee class you created earlier. The method returns to the caller a formatted greeting:
[WebMethod]
public static string HelloEmployee(AspNetAjaxInAction.Employee emp)
{
return string.Format("Hello {0} {1}.", emp.First, emp.Last);
}
Notice how the method is decorated with the WebMethod attribute (defined in the System.Web.Services namespace), similar to public methods in a Web Service.
This required attribute must be adorned on any methods you want to expose as a page method. In the .aspx page, you enable support for these types of methods by setting the EnablePageMethods property of the ScriptManager to True. By default, this setting isn’t enabled, and any static web methods on the page are omitted from the
web service proxy:
<asp:ScriptManager ID="ScriptManager1" runat="server"
EnablePageMethods="True">
<Services>
<asp:ServiceReference Path="StarbucksService.asmx"
InlineScript="true" />
</Services>
</asp:ScriptManager>
To complete this example, you need to call the method from JavaScript and process
the response

Working with the DOM Using AJAX Client library

The Microsoft Ajax Library lets you access the DOM in a manner independent from the browser that renders the page. The abstraction API consists of the methods exposed by two client classes: Sys.UI.DomElement and Sys.UI.DomEvent. The first one abstracts a DOM element, and the second represents the event data

object that DOM event handlers receive as an argument.

The following is Shortcut Methods used for accessing AJAX library

$get, Sys.UI.DomElement.getElementById Returns a reference to aDOM element

$addHandler, Sys.UI.DomElement.addHandler Adds an event handler toan event exposed by a DOM

element

$removeHandler, Sys.UI.DomElement.removeHandler Removes an event handler added with $addHandler

$addHandlers, Sys.UI.DomElement.addHandlers Adds multiple event handlers to events exposed byDOM elements and wraps the handlers with delegates

$removeHandlers, Sys.UI.DomElement.removeHandlers Removes all the handlers added with $addHandler

and $addHandlers

References and Links

Books:

ASP.NET AJAX IN ACTION

Programming.ASP.NET.AJAX (OReilly)

URLs:

http://www.asp.net/AJAX/Documentation/Live/default.aspx

http://encosia.com/

Messaging Using Remoting Service (Samples)

Hisham El-bereky — Fri, 21 Mar 2008 22:22:16 GMT

latest days I was interested with .net remoting service and events delegation between client and server sides, then I decided to write application that cover event delegation between clients and server and vis versa using .net remoting service, we can use this technique in chatting applications or any other business applications that depend on messaging between client and server.

the first application is simple broadcasting message application, Download Link.

the second application is more complex where you can specify which client you need to send message to it, also all calls are performed concurrently. If connection to the specific client is slow (or is broken), sending to other clients will not be delayed until that specific client replies (or server recognizes clients unavailability via time-out), Download Link.

this tow applications written by me using Remoting Service technique.

To understanding samples you must be aware about remoting service and event delegate

References And Links

Books:

MCAD/MCSD Self-Paced Training Kit: Developing XML Web Services and Server Components

Advanced .NET Remoting, by Ingo Rammer

Links:

.NET Remoting Overview

.NET Remoting - Events

Powering ASP.Net By CSS

Hisham El-bereky — Tue, 19 Feb 2008 06:42:00 GMT

When developing a web site one can choose between creating a CSS-based or TABLE-based web site. Both types of layouts have advantages and disadvantages and perform quite differently.

TABLE-based layouts web sites have the flowing facts:

- They're easy to use and implement (compared to CSS-layouts).

- WYSIWYG (What You See Is What You Get) editors like FrontPage and Dreamweaver make it very easy for developers to include them.

- Tables "break" on various browsers (newer and older versions) thus producing layout dysfunctions.

- Increase almost unnecessarily the HTML/text ratio. This means that other options could be used to create layouts that produce smaller page files by employing less HTML tags.

And

CSS-based layouts web sites have the flowing facts:

- Widely supported by modern browsers but not by older browsers

- Allows extreme flexibility in positioning

- Increases usability by encouraging liquid design

- Keeps the HTML/text ratio at a low level thus decreasing load time

- Allows the display of main content first while the graphics load afterwards

You can think now that CSS layout is more powerful than table based layout and Tables should only be used in extreme cases where there is no other viable alternative.

So if you need to improve your ASP.net Web Site performance and layout then you need to add CSS functionality to your site by using elements other than table if it possible like DIV, UI, LI … with CSS

But what I can do with ASP.Net server controls? You can use ASP.NET CSS Friendly Control Adapters 1.0 that provided more flexibility for customizing the rendered HTML. For example, the Menu control makes it simple to add a menu to a web site, but it would be better if it didn't create <table> tags and was easier to style using CSS. Happily, it's easy to customize and adapt the Menu control to generate better HTML. Indeed, you can modify any ASP.NET control so it produces exactly the HTML you want.

For more details:

ASP.NET 2.0 CSS Friendly Control Adapters 1.0

CSS Layouts Vs. Table Layouts - Alternate Browsers and Accessibility Issues

ASP.Net MVC

Hisham El-bereky — Sun, 17 Feb 2008 06:22:45 GMT

I like the New ASP.Net Model View controller (MVC) too much, it's a good pattern for developing ASP.Net Applications also it's easy in use more than Web Client Software Factory, the first MVC preview was released December 2007 and the next release is announced by Scott Guthrie that it will be after few weeks, the best one that introduce ASP.Net MVC is Scott Guthrie, you can flow this link to cover Asp.net MVC ASP.NET MVC Framework Road-Map Update.