Thoughts - Rumblings - Sharing - Musings

Click Once Deployment

2010-03-01T19:01:00.001-08:00

Deployment term can mean an installation of software program on user’s machines. Microsoft Visual Studio 2008 provides several methods for deploying your application. A familiar technology we all know is Microsoft Installer program which offers more detailed and complex deployment scenarios with multiple configuration steps. We’ll see another alternative light weight mechanism called ClickOnce.

Click Once Deployment features:

A ClickOnce setup can’t perform custom actions (accessing file system,registry, custom installation folder, custom setup wizard) when compared to extensive MSI setups. On the other hand, biggest gaining point is “Automatic update feature.”
ClickOnce applications are installed for a single user. You cannot install an application for all users on a machine. ClickOnce applications are always installed in a system-managed user-specific folder. You cannot change the folder where the application is installed.
ClickOnce setup can’t install shared components in the global assembly cache (GAC). ClickOnce apps are self-contained and isolated from rest of systems and runs no risk of breaking other apps.
By default, ClickOnce applications are self-updating. They can check for an update whenever they’re launched. ClickOnce usually is considered to be the preferred technology for WPF deployment.
ClickOnce technology supports stand alone deployments and deployments to web or file share. Many aspects of its behavior are completely fixed to guarantee a consistent user experience.
Clickonce deployment allows a user to launch a setup program from a browser page.
As you publish newer versions of your application, ClickOnce adds new subdirectories for each new version. The ClickOnce engine, dfsvc.exe, handles updates and downloads.The publishing wizard is a quick way to create a ClickOnce deployment
The key difference is that the publish version is the criteria that are used to determine whether a new update is available. If a user launches version 1.0.0.0 of an application and version 1.0.0.1 is available, the ClickOnce infrastructure will show the update dialog box. The Updates button isn’t available if you’re creating an online-only application. An online-only application always runs from its published location on a website or network share.
ClickOnce is a light weight setup option compared to MSI-based setups. Due to which, Click Once deployment doesn’t allow for much configuration and suitable for apps that don’t have elaborate installation requirements and have minimum security reqs. ClickOnce can deploy apps (WPF,Win Forms, page apps) in Full-Trust as well as partial trust apps(XBAP’s).
ClickOnce supports two flavors of apps. i.e Online/Offline modes. If you choose to create an online-only available application, the user needs to return to the published location to run the application. An old version of the application can’t be used after you roll out an update in online-only apps. This part of the deployment model is similar to a web application.
The publish.htm file is present only if you’re deploying to a web server. If you choose to publish for a CD installation, you don’t have the option of creating an online-only application.
In ClickOnce deployment, the .manifest and .application files store information about required files, update settings, and other details. These files are digitally signed at the time of publication, so these files can’t be modified by hand. If you do make a change, ClickOnce will notice the discrepancy and refuse to install the application.

Using Visual Studio:

You can deploy an application using ClickOnce directly from Visual Studio IDE using Publish tab of the project properties dialog box.

You can publish your app using ClickOnce by setting different publish properties in this page and then clicking “Publish Now” button.

Publish Location:

Specify the publishing location in Publishing Folder Location combo box. This can be a file path, a network file path, IIS path, a FTP address or external http address. Remember, Whatever value you specify, this will finally the go to location to install the app.

Installation folder:

Specify alternate Installation Folder URL if you’re planning to publishing to temporary location (staging) before it’s available for users to download.

Install Mode and Settings:

You can have your app available online which means app is available only when user is online OR you can make it offline. If you choose Online mode, app will be run directly from the publish location ensuring that the user always runs the most recent version. NO client installations!!

You can select “The Application is Available Offline As Well” to make app available both online and off-line. Anyways, local copy of app is available on client computer running offline.

Publish Wizard:

Clicking Publish Wizard makes things easy for you. If you like wizard like interface to configure your ClickOnce deployment, You’re lucky. A wizard will guide your through similar steps what we’re discussing to publish your application.

Options:

Clicking options button on publish dialog box brings up the above window. Obviously, you can set Publisher Name, the Product Name, the Support URL, and the name for the Deployment Web Page that is generated when the app is published.

Updates:

Clicking update button on publish dialog box brings up the above window. This is where magic happens. You can this window to specify whether app can check for updates automatically and time to check for updates.

Check “The application should check for updates” to enable app to check for updates. Either before app starts/after app starts we can check for updates. We can get into more granularity by specifying frequency for update check in terms of days.

You can also specify a minimum required version for the application, and you can also specify a different location for updates if your updates are hosted in a location other than the install location.

Signing the ClickOnce manifests(.manifest/.Application)

Clicking the signing tab opens up the above shown window. You can use this window to associate a certificate/test certificate

with your application. You can use certificates to sign your ClickOnce based apps. You can also create Test certificate right from this window for signing.

Finally, Visual studio creates few criticial files like Application Manifest during ClickOnce deployment that describes the files and dependencies, identity of assemblies and file associations. We cannot configure File associations via Visual Studio user interface. To create a file association, we must edit the manifest file manually.

I missing screen shot of final publish.htm file that pops out when published from visual studio.

WPF Documents

2010-02-24T21:01:00.001-08:00

Windows Presentation Foundation (WPF) provides rich set of features that help work with print ready and authoring documents easily.

WPF supports two types of Document models which provide rich layout support for displaying large amounts of text combined with features like scrolling, pagination and zoom.

Types of Documents:

Fixed Documents are XPS (Open XML Paper Specification) based fixed type set documents which are print ready
Flow Documents are dynamic which can layout the content dynamically based on details such as size of window and resolution.

WPF provides different kinds of Document containers to display these documents.

DocumentViewer allows to show fixed documents (XPS documents) in a window. (readonly) –Shown above
FlowDocumentPageViewer, FlowDocumentReader and FlowDocumentScrollViewer containers are read only which displays flow documents. (XAML documents) – Shown Above

FlowDocumentScrollViewer:

FlowDocumentScrollViewer shows the entire document with a scroll bar to let you move through it if the document exceeds the size of the FlowDocumentScrollViewer. The FlowDocumentScrollViewer doesn’t support pagination or multicolumn displays.

Printing and Zooming is supported.
Toolbar is hidden by default. To make it visible, set IsToolbarVisible to true
To disallow text selection in flowDocumentScrollViewer, use FlowDocumentScrollViewer.IsSelectionEnabled to false.

FlowDocumentPageViewer:

FlowDocumentPageViewer splits a flow document into multiple pages. Each page is as large as the available space and the user can step from one page to the next. The Flow-DocumentPageViewer has more overhead than the FlowDocumentScrollViewer due to pagination feature.

Printing and Zooming is supported.
Toolbar is enabled by default.

FlowDocumentReader:

FlowDocumentReader combines the features of the FlowDocumentScrollViewer and FlowDocumentPageViewer. It lets the user choose whether to read content in a scrollable or paginated display. It also includes searching functionality.

The FlowDocumentReader has the most overhead of any flow document container.

It supports three modes to display document.

ScrollBarMode
TwoPageMode
PageMode

Printing and Zooming is supported.
Toolbar is enabled by default.
Document search functionality is supported.

Preserving space in WPF documents:

You need to use the xml:space attribute with the value preserve, which is an XML convention that tells an XML parser to keep all the whitespace characters in the content

Fixed Document snippets:

Code Snippet
 using System.Windows;
using System.Windows.Documents;
using System.Windows.Markup;
using System.Windows.Xps.Packaging;
using System.Xml;
 

Creating a simple Fixed document Programmatically:

Code Snippet
  var fixedDocument = new FixedDocument();
            PageContent pageContent = new PageContent();
            fixedDocument.Pages.Add(pageContent);
            FixedPage fixedPage = new FixedPage();
            TextBlock textBlock = new TextBlock
                                      {
                                          Margin = new Thickness(10, 10, 0, 0),
                                          Text = "TestPage",
                                          FontSize = 20
                                      };
            fixedPage.Children.Add(textBlock);
            ((IAddChild)pageContent).AddChild(fixedPage);
            dvDocumentViewer.Document = fixedDocument;
 

Saving a simple Fixed document Programmatically:

Code Snippet
 var xpsDocument = new XpsDocument(@"C:\test.xps", FileAccess.ReadWrite, CompressionOption.NotCompressed);
         XpsDocumentWriter xdw = XpsDocument.CreateXpsDocumentWriter(xpsDocument);
         xdw.Write(document);
         xpsDocument.Close();
 

Programmatically opening a Fixed document(XPS doc):

Code Snippet
 XpsDocument document = new XpsDocument(@"C:\Test.xps", FileAccess.Read);
          IDocumentPaginatorSource documentPaginatorSource = document.GetFixedDocumentSequence();
          dvDocumentViewer.Document = documentPaginatorSource;
 

Flow Documents snippets:

Code Snippet
 using System;
using System.IO;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Markup;
using System.Windows.Media;
using System.Windows.Shapes;
using System.Xml;
 

Programmatically creating a Flow document(XAML):

Code Snippet
 var flowDocument = new FlowDocument();
            //creating a new paragraph
            var paragraph = new Paragraph();
            paragraph.Inlines.Add("This is a simple para.");
            paragraph.Inlines.Add("created in a flow document.");
            paragraph.Inlines.Add("This is a para3");
            paragraph.Inlines.Add("This is a para4");
            paragraph.Inlines.Add("This is a para5");
            paragraph.Inlines.Add("This is a para6");
            paragraph.Inlines.Add("This is a para7");
            //Adding para to blocks collection of flow document.
            flowDocument.Blocks.Add(paragraph);
            //Creating new floater object.
            Floater floater = new Floater();
            paragraph = new Paragraph();
            Rectangle rect = new Rectangle();
            rect.Width = 50;
            rect.Height = 50;
            rect.Fill = Brushes.Blue;
            rect.StrokeThickness = 2;
            rect.Stroke = Brushes.Black;
            paragraph.Inlines.Add(rect);
            floater.Blocks.Add(paragraph);
            //Adding floater object to blocks collection of flow document.
            flowDocument.Blocks.Add(new Paragraph(floater));
            fdrViewer.Document = flowDocument;
 

Saving a simple Flow document Programmatically(XAML):

Code Snippet
  XmlTextWriter xmlWriter = null;
            TextWriter writer = null;
            Stream file = null;
 
            try
            {
                file = File.Create(fileName);
                writer = new StreamWriter(file);
                xmlWriter = new XmlTextWriter(writer);
                //The main function of the XamlDesignerSerializationManager is to get and set the serialization mode for a given expression type.
                var xamlDesignerSerializationManager = new XamlDesignerSerializationManager(xmlWriter);
                XamlWriter.Save(documentPaginatorSource.DocumentPaginator.Source, xamlDesignerSerializationManager);
            }
 

Programmatically opening a Flow document(XAML):

Code Snippet
 Stream file = null;
         TextReader reader = null;
         XmlTextReader xmlTextReader = null;
         try
         {
             file = File.OpenRead(@"c:\test.xaml");
             reader = new StreamReader(file);
             xmlTextReader = new XmlTextReader(reader);
 
              FlowDocument flowDocument = XamlReader.Load(xmlTextReader) as FlowDocument;
              fdv.Document = flowDocument;
         }
 

WCF errors: No set method for property on Type 'xx'

2010-01-19T20:06:00.000-08:00

I was surprised when i first saw this error. This usually happens when you try to publish DataContract on WCF service containing Read only properties. I don't know why exactly this error occurs? As many people are concerned, workaround for this problem looks very obvious.

Add Setter to the property in question. But, this move will defeat your original purpose of Read only property.

Huh.., Ok, here's solution. just add Private keyword to your setter method. WCF allows this provision. So, client can never see the set method on your property acting much like a read only property.

WCF errors: WCF service has zero application (non-infrastructure) endpoints.This might be because no configuration file was found on your application, or because no service element matching the service name is found in the configuration file, or because no endpoints were defined in the service element.

2010-01-19T19:57:00.000-08:00

This WCF error always pops on my computer when ever i'm creating brand new WCF service. Bluntly, we can understand from error that we haven't configured the service properly. Of course, there can be multiple causes. Handy tool which can help during this crisis :-) is "WCF Service Configuration Editor". You can open WCF Service Configuration Editor (SvcConfigEditor.exe) by right clicking on configuration file in your WCF service library project or accessing it under Tools menu in the Visual Studio IDE.

On left pane in editor, you'll see various service elements already defined. Click on your Service Endpoint node. 90% of time root cause of this error will be hanging around this Service Endpoint definition.

Remember, all the WCF service configuration definition is found under element

Here's the checklist that should help resolve this error.

Confirm your Contract attribute of Endpoint element is pointing to appropriate Service contract instead of "IService1" unless you are still using "IService1" as service contract.
Confirm your Name attribute of Service Element is set appropriately to Service class implementation instead of "Service1" unless you're still using "Service1" as service implementation.
Also, Examine ServiceHost directive declaration in service1.svc markup. Clean up any scrap you see and provide fully qualified namespace for the service class for service attribute.

I strongly recommend you use Service Configuration Editor for any kind of poking around web.config/app.config related to WCF service. This way, you'll keep service configuration neat and clean. especially with complex configuration files, this tool will come handy in organizing the service elements easily.

WCF errors: Type 'xxx' is an invalid collection type since it has DataContractAttribute attribute.

2010-01-19T19:04:00.000-08:00

If you have ever happen to get "Type xxx is an invalid collection type since it has DataContract Attribute attribute" error at any time when ever publishing WCF service, Make sure you annotate your custom collections with CollectionDataContract attribute instead of DataContract attribute. This attribute will appropriate serialize and deserialize collection.

CollectionDataContract attribute is typically utilized in scenarios involving non-WCF providers/clients to extract exact shape of data. But, you loose one important benefit with "CollectionDataContract" is "Cross Collection Interchangeability". For instance, in case of homogeneous environment of WCF client and service though WCF service exposes List collections as response, client expecting different native collection type like ArrayList/Collection can still consume the collection.

You loose this benefit if you use CollectionDataContract attribute with Collection Types.

WCF also imposes additional requirements when using collections. Keep in mind of following items when exposing custom collections via WCF service or else custom collections are not serialized/deserialized.

Collection should support Add method.
Collection should have default constructor.

Unity Framework v1.2 - IoC Dependency Injection

2010-01-05T20:40:00.001-08:00

Following is the power point presentation related to IoC and Dependency Injection (DI) pattern. This presentation specifically focuses on Unity Framework v1.2 based IoC container. Integration WCF service with IoC container provides finer control over WCF instance management.

Unity Framework v1.2 - IoC Dependency Injection

View more presentations from guest003bf.

WCF Service Trace Viewer (SvcTraceViewer.exe) tool

2009-12-18T22:10:00.000-08:00

If you're familiar with WCF application development, some times, you might across this kind of exception thrown back to client after unsuccessful service operation. Above exception in the screen shot doesn't provide any detailed information regarding the source of exception or any stack trace.

Windows Communication Foundation (WCF) Service Trace Viewer is a useful utility to help analyze WCF messages that are exchanged between service and client. Any inner exception buried deep in the stack trace can be traced, analyzed and diagnosed. Some times, due to security concerns, WCF services doesn't emit complete exception details back to the client. Lot of times, cryptic, brief and vague exceptions thrown by WCF service leaves no clue about the error. For example, lot of times you find "Connection closed abruptly/MessageSecurity exception/ Security token" exception being thrown back to WCF client.

Even if you turn on IncludeExceptionDetailInFaults service behavior element to True, Some times, you don't get the complete picture you expect. In such scenarios, Service Trace viewer tool is really helpful increasing productivity and saving time and takes us to the right spot of error occurence. We can utilize Service Trace Viewer Tool (SvcTraceViewer.exe) for WCF service level tracing and instrumentation.

We can configure tracing using either app.config file or web.config file. We can easily enable tracing/message logging using Service configuration Editor tool which can be accessed from Visual Studio IDE (Tools section of MainMenu).

Service Trace Viewer tool generates tracing file (.svcLog). This tool also supports two other file types

(Event Tracing file(.etl) and Crimson Tracing file

WCF service generates .svcLog files.

After enabling tracing/message logging in config files using WCF service configuration editor, exchange couple of messages between WCF service and client for recording trace. You can enable tracing/logging both at the client and service side in their respective config files.

To open a trace file, navigate to your WCF installation location (C:\Program Files\Microsoft SDKs\Windows\v6.0\Bin), then you can find SvcTraceViewer.exe in bin folder or you can also access it from start menu as shown below.

After you open the service trace viewer tool, Now try to open your .svcLog file from the location you specified in the config file.

Service Trace Viewer supports four different views of trace data.

Activity view
Project view
Message view
Graph view.

Below screenshot display default activity view from trace viewer. In Activity view, all the related traces are grouped into activities. The activity view displays activity names, number of traces and duration.

To view a trace detail, select a trace in the trace pane. The details are displayed in the Detail pane.

Detail pane which is located in bottom left provides three tabs to view trace details. Formatted view displays the information in a more organized way. You can see formatted view in the screenshot. XML View displays XML related to the trace. The Message view displays the message part of the XML in message log traces. It is invisible when you select a non-message trace.

Filling cascading dropdown example using jQuery and AJAX.Net library

2009-11-24T11:12:00.000-08:00

Previous post related to filling cascading dropdown asynchronously offers more simple and traditional approach for beginner programmers who're more familiar with readymade asp.net update panel control. That post demonstrated dynamic approach which utilizes update panel to enable partial postbacks from a web page. You can read previous post from here.

As mentioned in previous post, we'll look into more advanced ways of solving same problem space. This time, I used combination of JQuery/AJAX.Net library to achieve responsive and far more superior user experience. I almost fell in love with jQuery. If you don't know jQuery library, I recommend you to read about it.

jQuery is a free open source lightweight javascript library which is compatible with Microsoft ASP.NET Ajax and Visual studio. jQuery provides powerful functions like DOM element manipulation, function Chaining and extensibility. jQuery usually exists as a single JavaScript file. It can be included within a web page using the following markup.

This demo demonstrates technique of calling server side method using jQuery script and Ajax.Net library. This offers more clean and faster way to update DOM elements with results from the server. This is more light weight and no page life cycle being kicked off. This is true power of jQuery.

Pre-Requisites:

Please register the Ajax HTTP handler in the web.config file in <httpHandlers> section to allow ajax call interception

<!--following ajax handler is needed for asynchronous communication with server side code-->
<add path="ajax/*.ashx" verb="POST,GET" type="Ajax.PageHandlerFactory, Ajax"/>

Please add reference to approriate version of Ajax.Net assembly.

Please add reference to approriate version of jQuery script to your web page. I’ve utilized 1.3.2 version of jQuery “jQuery-1.3.2.min.js” for this demo.

<script type="text/javascript" src="JQuery/jquery-1.3.2.min.js"></script>
<script src="JQuery/JQueryScripts.js" type="text/javascript"></script>

.ASPX page(Default.aspx)

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="JQueryAsynchronousCallBackDemo._Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title></title>
<!--following references include jQuery file and a script file which includes custom functions -->
<script type="text/javascript" src="JQuery/jquery-1.3.2.min.js"></script>
<script src="JQuery/JQueryScripts.js" type="text/javascript"></script>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Literal ID="Literal1" runat="server">States:&nbsp;</asp:Literal>
<asp:DropDownList ID="ddStatesList" runat="server">
<asp:ListItem Selected ="True" Text = "please select state" Value = "0"></asp:ListItem>
<asp:ListItem Text="USA" Value ="1"></asp:ListItem>
<asp:ListItem Text ="Europe" Value = "2"></asp:ListItem>
<asp:ListItem Text ="Asia" Value = "3"></asp:ListItem>
</asp:DropDownList>
<br />
<hr />
<asp:Literal ID="Literal2" runat="server">Cities:&nbsp;</asp:Literal>
<asp:DropDownList ID="ddCitiesList" runat="server">
</asp:DropDownList>
</div>
</form>
</body>
</html>

Default.aspx.cs:

1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Web;
5: using System.Web.UI;
6: using System.Web.UI.WebControls;
8: 
9: namespace JQueryAsynchronousCallBackDemo
10: {
11:     //THIS SAMPLE DEMONSTRATES USAGE OF AJAX.NET LIBRARY FOR DESIRED CLIENT SIDE PROGRAMMING.
12:     public partial class _Default : System.Web.UI.Page
13:     {
14:         protected void Page_Load(object sender, EventArgs e)
15:         {
16:             Ajax.Utility.RegisterTypeForAjax(typeof(AjaxUtilities)); 
17:             this.ddStatesList.Attributes.Add("OnChange", string.Format("AdjustCitiesDropDown(this, '{0}')", this.ddCitiesList.ClientID));
18:         }
19:     }
20: }
21: 
jQuery script file:: //******************************************************************************************//3: //This is jquery based script. JQuery offers more concise and light weight javascript code.//This script is called on "Onchange" event and asynchronously calls server side method to retrieve cities5: //corresponding to given state. 6: function AdjustCitiesDropDown(ddlState, ddlCity) {7:     if (ddlState && ddlCity) {8:         var stateId = $(ddlState).val();9:             var res = AjaxUtilities.GetCities(stateId);12:             if (res.value != null && res.value.length > 0) {13:                 var options_cityTypes = '';14:                 $.each(res.value, function(i, d) {15:                 options_cityTypes += '<option value="' + d+ '">' + d + '<\/option>';16:                 });17:                 $('#' + ddlCity).html(options_cityTypes);18:            }19:     }20: }AjaxUtilities Class file

1: using System.Collections.Generic;
2: 
3: namespace JQueryAsynchronousCallBackDemo
4: {
5:     public class AjaxUtilities
6:     {
7:         public AjaxUtilities()
8:         {
9:         }
10:         //The method which is invoked from client side javascript/jquery must be marked with following
11:         //attribute
12:         [Ajax.AjaxMethod()]
13:         public List<string> GetCities(string stateId)
14:         {
15:             if (stateId == "1")
16:             {
17:                 return new List<string>() { "Chicago", "NewYork", "LA" };
18:             }
19:             else if (stateId == "2")
20:             {
21:                 return new List<string>() { "London", "Paris", "Madrid" };
22:             }
23:             else if (stateId == "3")
24:             {
25:                 return new List<string>() { "Mumbai", "Shanghai", "Tokyo" };
26:             }
27:             else
28:             {
29:                 return new List<string>() { "GothamCity" };
30:             }
31:         }
32:     }
33: }

Programmatic way of adding update panel control to asp.net web page

2009-11-23T17:09:00.000-08:00

Due to issue with some legacy third party controls on a regular asp.net web page, I was not able to declaratively add UPDATE PANEL controls to the page. My aim was to generate asynchronous behavior or partial postback for the new controls which i was supposed to add to legacy page. Finally, I came up with this following basic idea which involves using placeholder container controls and dynamically adding controls to the place holder controls. There are few other options like using JQuery techniques. Ofcourse, I finally ended up using JQuery technique to achieve the same effect.

But, I thought some people might feel comfortable using the traditional asp.net code-behind model and more aligned towards microsoft ajax controls and techniques.

Following sample code is almost self-explanatory. You can copy it and run it as is. Please feel free to post your questions in comments








html code:




DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">

    <title>title>
head>

<body>
    <form id="form1" runat="server">
    <div>
    <asp:Literal ID="literal1" runat="server">Countryasp:Literal>
    <asp:PlaceHolder  ID= "placeHolder1" Visible="true" runat="server">
    asp:PlaceHolder>
     <asp:Literal ID="literal2" runat="server">Citiesasp:Literal>

     <asp:PlaceHolder  ID= "placeHolder2" Visible="true" runat="server">asp:     PlaceHolder>
    div>
    form>
<body>
<html>











Code behind code:




using System;
using System.Collections.Generic;

using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;


namespace WebApplication1
{

    public partial class _Default : System.Web.UI.Page
    {
       private static System.Collections.Generic.List<Int32> 
     


        protected void Page_Load(object sender, EventArgs e)

        {
           ScriptManager manager = new ScriptManager();
           CheckBoxList checkboxList = new CheckBoxList();
           checkboxList.ID = "Cities";
           checkboxList.AutoPostBack = true;
           DropDownList dropdwnlist = new DropDownList();
           dropdwnlist.ID = "ddCountry";
           dropdwnlist.SelectedIndexChanged += 
           new EventHandler(dropdwnlist_SelectedIndexChanged);
           dropdwnlist.AutoPostBack = true;



           dropdwnlist.Items.Add(new ListItem("please select","0"));

           dropdwnlist.Items.Add(new ListItem("India","1"));
           dropdwnlist.Items.Add(new ListItem("USA","2"));
           placeHolder1.Controls.Add(dropdwnlist);
           placeHolder2.Controls.Add(checkboxList);
         
           UpdatePanel panel = new UpdatePanel();
           panel.ContentTemplateContainer.Controls.Add(placeHolder1);
           panel.ContentTemplateContainer.Controls.Add(placeHolder2);
           Page.Form.Controls.Add(manager);
           Page.Form.Controls.Add(panel);
   

          }


         protected void dropdwnlist_SelectedIndexChanged(object sender,EventArgs e)
        {

           var checkboxlist = placeHolder2.FindControl("Cities") as CheckBoxList;
           var dropdwonlist = placeHolder1.FindControl("ddCountry") as DropDownList;
           if (dropdwonlist.SelectedValue == "1")
           {
               checkboxlist.Items.Add(new ListItem("Hyderabad","1"));
               checkboxlist.Items.Add(new ListItem("Mumbai","2"));
               checkboxlist.Items.Add(new ListItem("NewDelhi","3"));
               checkboxlist.Items.Add(new ListItem("Chennai","4"));
           }
           else if (dropdwonlist.SelectedValue == "2")
           {
               checkboxlist.Items.Add(new ListItem("NewYork","1"));
               checkboxlist.Items.Add(new ListItem("Chicago","2"));
               checkboxlist.Items.Add(new ListItem("LosAngeles","3"));
           }
        }
  }
}

C# Object oriented programming concepts

2009-10-26T02:35:00.000-07:00

Object oriented programming is a successful paradigm shift from procedural world. Representing a real world entity through an object and encapsulating data and behavior together in an object are some of basics of OOPS world. Object oriented has showered us with many benefits esp. code re usability through inheritance and abstraction. At the same time, we are pushed into complex world filled with classes, contracts, objects and relationships between them. Polymorphism, encapsulation, messaging, abstraction are OOPS concepts.

There are three kinds of relationships between objects

Association: Simple relationship which relates two objects. Customer object is related to sales object.

Aggregation: It is containment or composition model. Example: page class encompasses controls on the page.

Inheritance: Defining specialized derived classes from preexisting generalized classes. It shows more of a parent-child relationship like vehicle -> car

Abstract classes and Interfaces:

A class can implement more than one interface but can only inherit from one abstract class. Since C# doesn't support multiple inheritance, interfaces are used to implement multiple inheritances. All elements in interfaces are public by default.

An abstract class can contain non-abstract methods. i.e methods with code in it.
An interface cannot contain non-abstract methods. Abstract classes SHOULD have atleast one method abstract and interfaces have all abstract methods.

Interfaces are used to define the peripheral abilities of a class. In other words both Human and Vehicle can inherit from a IMovable interface.

An abstract class defines the core identity of a class and there it is used for objects of the same type.

An abstract class can contain non-static member variables.
An interface cannot contain non-static member variables.

A derived class uses the keyword "Extends" for an abstract class.
A subclass uses the keyword "Implements" for an interface.

If the subclass extends an abstract class, it cannot extend any other class.
If the subclass implements an interface, it can implement any number of other interfaces.

If the various implementations only share method signatures then it is better to use interfaces ( Multiple behaviors for different conditions)

Abstract classes provide a simple and easy way to version our components. By updating the base class, all the inheriting classes are automatically updated with the change. In an interface, creation of additional functions will have an effect on its child classes due to the necessary implementations of interface methods in classes. Abstract classes should be used primarily for objects that are closely related, whereas interfaces are best suited for providing common functionality to unrelated classes.

Say there are two classes, bird and airplane, and both of them have methods called fly. It would be ridiculous for an airplane to inherit from the bird class just because it has fly() method. Rather, the fly() method should be defined as an interface and both bird and airplanes should implement that interface. If we want to provide common, implemented functionality among all implementations of component.

In VB.Net language, abstract classes are created using "MustInherit" keyword. In C#, we have "Abstract" keyword. Abstract class is designed to act as a base class. You cannot create a object of abstract class.

Shadowing:

When two elements in a program have same name, one of them can hide and shadow the other one. So in such cases the element which shadowed the main element is referenced.

Differences between overriding and shadowing:

Overriding redefines only the implementation while shadowing redefines the whole element.

Sealed classes:

The sealed modifier is used to prevent derivation from a class. An error occurs if a sealed class is specified as the base class of another class. A sealed class cannot also be an abstract class. In .Net Framework, string is a sealed class.

Virtual keyword: (Overridable)
They signify that method and property can be overridden.

Static/Shared:

If you want an object to be shared between multiple instances you will use a static/shared class.
Static classes cannot be instantiated. By default, an object is created on the first method call to that object.
Static classes cannot be inherited.
Static classes can have only static members.
Static classes can have only static constructor

Structures and classes:

Structures are value types and classes are reference types. So structures use stack and classes use heap.
Structure members cannot be declared as protected, but class member can be.
You cannot define inheritance in structures.
Structures do not require constructors while classes require.
Objects created from classes are terminated using garbage collector while structures are not destroyed GC

ASP.Net Instrumentation - Tracing

2009-10-22T22:20:00.001-07:00

Tracing in ASP.NET 3.5:

Tracing is a way to monitor the execution of your ASP.NET application. You can record exception details and program flow in a way that doesn’t affect the program’s output. In ASP.NET 3.5, there is rich support for tracing. The destination for trace output can be configured with TraceListeners like the EventLogTraceListener.

ASP.NET 3.5 Improvements for Tracing:

ASP.NET Tracing has increased precision from 6 digits to 18 digits for highly accurate profiling.

Trace forwarding between the ASP.NET page-specific Trace class and standard Base Class Library’s (BCL) System.Diagnostics.Trace used by non-Web developers.

First, we will explore ASP. Net’s tracing facilities first, and then learn how to bridge the gap and see some new features in 3.5 that make debugging even easier.

Page level Tracing:

ASP.NET tracing can be enabled on a page-by-page basis by adding “Trace=true” to the Page directive in any ASP.NET page:

<%@ Page Language="C#" Trace="true" TraceMode = "SortByCategory" Inherits = "System.Web.UI.Page" CodeFile="Default.aspx.cs" %>

Additionally, you can add the TraceMode attribute that sets SortByCategory or the default, SortByTime. You can use SortByTime to see the methods that take up the most CPU time for your application. You can enable tracing programmatically using the Trace.IsEnabled property.

Application Tracing:

You can enable tracing for the entire application by adding tracing settings in web.config. In below example, pageOutput=”false” and requestLimit=”20” are used, so trace information is stored for 20 requests, but not displayed on the page because pageOutput attribute is set to false.

<system.web>

</system.web>

</configuration>

The page-level settings take precedence over settings in Web.config, so if enabled=”false” is set in Web.config but trace=”true” is set on the page, tracing occurs.

Viewing Trace Data:

Tracing can be viewed for multiple page requests at the application level by requesting a special page called trace.axd. When ASP.NET detects an HTTP request for trace.axd, that request is handled by the TraceHandler rather than by a page.

Create a website and a page, and in the Page_Load event, call Trace.Write(). Enable tracing in Web.config as shown below

<system.web>

</system.web>

protected void Page_Load(object sender, EventArgs e)

{

System.Diagnostics.Trace.Write("This is Page_Load method!");

}

When you run the page, you can see a great deal of trace information in the browser because we have set PageOutput=true as shown below

Trace Information

The message from Trace.write appears after Begin Load and before End Load. Eleven different sections in Trace provide a great deal of information.

Request Details: This section includes the ASP.NET Session ID, the character encoding of the request and response, and the HTTP conversation’s returned status code.

TraceInformation: This section includes all the Trace.write methods called during the lifetime of the HTTP request and a great deal of information about timing. The timing information located here is valuable when profiling and searching for methods in your application that take too long to execute.

Trace Information

Control Tree: Control tree presents an HTML representation of the ASP.NET Control Tree. Shows each control’s ID, run time type, the number of bytes it took to be rendered, and the bytes it requires in View State and Control State.

Session State: Lists all the keys for a particular user’s session, their types and their values.

Application State: Lists all the keys in the current application’s Application object and their type and values.

Request Cookies: Lists all the cookies passed in during the page is requested

Response Cookies: Lists all the cookies that were passed back during the page’s response.

Headers Collection: Shows all the headers that might be passed in during the request from the browser, including Accept-Encoding, indicating whether the browser supports the compressed HTTP responses and Accept languages.

Form Collection: Displays a complete dump of the Form Collection and all its keys and values.

QueryString Collection: Displays a dump of the Querystring collection and all its contained keys and values

Server Variables: A complete dump of name-value pairs of everything that the web server knows about the application

Trace.axd:

Page output of tracing shows only the data collected for the current page request. However, if you want to collect detailed information for all the requests then we need to use Trace.axd. We can invoke Trace.axd tool for the application using the following URL http://localhost/application-name/trace.axd. Simply replace page name in URL with Trace.axd. That is, in our case. We should use following URL (Address bar) for our application as shown below.

Application Trace

Trace.axd displays all the tracing information for all requests up to a present limit. Above figure shows that three requests have been made to this application and the right side of the header indicates “Remaining:7” That means that there is seven more requests remaining before tracing stops for this application. After that final request, tracing data is not saved until an application recycle or until you click “Clear Current Trace” from the Trace.axd page. The request limit can be raised in Web.config by setting requestLimit to a higher value as shown below

Trace forwarding:

ASP.NET 3.5 introduced new attribute to Web.config <trace> element that allows you to route messages emitted by ASP.NET tracing to System.Diagnostics.Trace:writeToDiagnosticsTrace.

When you set writeToDiagnosticsTrace to true, all calls to System.Web.UI.Page.Trace.Write(the ASP.NET TraceContent) also go to System.Diagnostics.Trace.Write, enabling you to use all the standard TraceListeners. The simple writeToDiagnosticsTrace setting connects the ASP.NET tracing functionality with the rest of the base class library.

New Trace Listeners in ASP.NET 3.5:

The new ASP.NET 3.5 WebPageTraceListener derives from System.Diagnostics.TraceListener and automatically forwards tracing information from any component calls to System.Diagnostics.Trace.Write. This enables you to write your components using the most generic trace provider and to see its tracing output in the context of your ASP.NET application

The WebPageTraceListener is added to the web.config as shown below

<system.diagnostics>

<add name="webListeners"

type="System.Web.WebPageTraceListener, System.Web" />

</listeners>

</trace>

</system.diagnostics>

XmlWriterTraceListener:

XmlWriterTraceListener derives from TextWriterTraceListener and writes out a strongly typed XML file. The XML created is not well formed. Specifically, it doesn’t have root node. It’s just collection of peer nodes.

DelimitedListTraceListener:

DelimitedListTraceListener derives from TextWriterTraceListener. It writes out comma-separated values (CSV) files.

Membership provider and Login controls explained in ASP.NET 3.5

2009-10-22T22:16:00.001-07:00

New Security Features in ASP.NET 3.5

Security is an important attribute of any ASP.NET application. The authentication and authorization of users and resistance against the malicious attacks are important tasks in web applications. In ASP.NET 1.x introduced new authentication service called Forms-based authentication which involves authenticating users and redirecting unauthenticated users again to Login page. It also performs necessary cookie management. This kind of authentication was fine in many ways, but it required developers to build every element including Login page User Interface and create necessary tables to manage user accounts.

ASP.NET 3.5 introduced a new membership and role management service that provides both authentication and authorization services and management of users who access your application with out building any tables or writing any code. To achieve this Microsoft implements extensible provider based security model in ASP.NET 3.5

Security Model:

ASP.NET 3.5 provides two providers in new security model

Membership Provider
Role Provider

The extensible Membership provider framework can register and authenticate new users. Membership provider uses Microsoft SQL Server as the back-end data store. Role providers are used to manage user roles like creating new roles for users. This Provider based framework also includes new API that allows for programmatic access to both membership and role management services.

Membership Provider:

The provider model in ASP.NET 3.5 provides pluggable architecture for developers to plug their own implementations for creating custom membership providers. The provider model begins with the abstract class ProviderBase. Inheriting from ProviderBase are the MembershipProvider and RoleProvider abstract classes. These classes add additional properties and methods to define the interface for their custom needs. Below listings should give you a concrete idea.

MembershipProvider abstract class Listing

RoleProvider abstract class Listing

ASP.NET 3.5 ships with two membership providers: the SqlMembership provider and the AccessMembership provider. As name implies, Sqlmembership provider stores membership information in a SQL Server database. Similarly, AccessMembership provider stores membership information in Access database. You can also create custom membership provider using any OLEDB DataSource or XML data source. But you need to implement all the methods and properties of the abstract MembershipProvider class.

SqlMembership Provider:

Unlike the Microsoft Access Provider, before you can use the SQL Provider you must create the necessary database tables and stored procedures. You can automatically create all of the required SQL Server database objects by executing the aspnet_regsql tool from the command line. This tool, by default, creates a new database named aspnetdb on your local instance of SQL Server. Let’s see how to configure aspnetdb using aspnet_regsql tool in below series of listings.

When we run aspnet_regsql from command prompt the following wizard opens up to configure aspnetdb database

Click Next

Choose Configure SQL Server for application services to create new database to membership information and click next

Specify the server name and authentication mode for membership database and click next

Summary of settings which you have specified and once you are done, click next

Database has been created and you can now configure the provider for membership. Click finish to end the wizard.

After you create the new database, you'll want to make sure the database can be accessed by your ASP.NET application. You can find default membership provider settings for the server by looking at the machine.config file

<add name="AspNetSqlMembershipProvider" type="System.Web.Security.SqlMembershipProvider, System.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" connectionStringName="LocalSqlServer"

enablePasswordRetrieval="false"

enablePasswordReset="true"

requiresQuestionAndAnswer="true"

applicationName="/"

requiresUniqueEmail="false"

passwordFormat="Hashed"

maxInvalidPasswordAttempts="5"

minRequiredPasswordLength="7"

minRequiredNonalphanumericCharacters="1"

passwordAttemptWindow="10"

passwordStrengthRegularExpression="" />

</providers>

</membership>

Machine.config filesettings for sqlmembership provider

Configuring Membership Provider Properties:

The SqlMembershipProvider support several provider specific attributes:

ApplicationName: If you need to host multiple applications on the same Web server, you can use this property to isolate the users who are associated with the different applications.
ConnectionStringName: The name of a database connection string defined in the connectionStrings section of the Web configuration file.
Description: A description of the provider definition.
EnablePasswordReset: When true, users can reset their password to a randomly generated password.
EnablePasswordRetrieval: When true, user passwords can be retrieved from the Membership provider.
PasswordFormat: This property has three possible values: Clear, Encrypted, and Hashed. When passwords are hashed, the original passwords cannot be retrieved from the Membership Provider.
RequiresQuestionAndAnswer: When true, the user must answer a password retrieval question before the user password can be reset or retrieved.
RequiresUniqueEmail: When true, a unique e-mail address must be associated with each user.

You can use these Membership Provider attributes to control how membership information is stored and retrieved from the database. The values of these attributes can be changed in your application's Web configuration file. For example:

By default, the machine.config file configures membership and roles to work with a SQL Server Express database file in the App_Data directory. Looking back at the configuration listing above, we see the connectionStringName property is “LocalSqlServer”. If you locate the connectionStrings section of machine.config you’ll find the following:

</connectionStrings>

ConnectionStrings section of machine.config file

One you’ve configured a database for the provider to use, you can modify the web.config file for your application to redefine the LocalSqlServer connection string to point to the new database.

<add name="LocalSqlServer"

connectionString="server=.;database=aspnetdb;integrated security=sspi;"/>

</connectionStrings>

Testing the Settings Using Web Site Administration Tool:

You can also test above created settings with the ASP.NET Configuration tool. You can open the Web Site Administration Tool by selecting ASP.NET Configuration from under the Website menu. You can also navigate directly to the Web Site Administration Tool by requesting the special page WebAdmin.axd. For example, if your application is located in a virtual directory named MyWebApp on your local machine, you can open the Website Administration Tool for your application by entering the following URL in your Web browser.

http://localhost/MyWebApp/WebAdmin.axd

Web site Administration Tool is opened when you run the above URL in IE as shown below

Click different provider for each feature link. We are referring sqlmembershipProvider as AspNetSqlProvider becoz it is named in machine.config. refer to machine.config listing above

Click Test link if you want to test AspNetSqlMembershipProvider and once test is successful click back to return from web site administration tool.

Login Controls:

ASP.NET 3.5 contains a new set of security-related controls, known collectively as the Login controls. By taking advantage of the Login controls, you can create standard registration, login, and password recovery pages without writing any code. By default, login controls integrate with ASP.NET membership and forms authentication to help automate user authentication for your Web site. The Login control, for example, will ultimately call the ValidateUser method of the current membership provider when a user enters their username and password and clicks the Login button. There is no need to write any code if the built-in controls provide all the functionality you need. All of the controls allow customization various levels of customization through styles and templates. You can find the controls in the Visual Studio toolbox under the “Login” category.

Behind the scenes, the Login controls take full advantage of the Provider Model. If the SqlMembershipProvider is enabled, the configured SQL Server database is used by the controls.

Before using any of the Login controls, you should enable Forms Authentication for your application. You can enable Forms Authentication by modifying your application's Web configuration file, or by using the Web Site Administration Tool.

Different Login and Password server Controls:

CreateUserWizard server control
Login server Control
LoginStatus Server Control
LoginName Server Control
ChangePassword Server Control
PasswordRecovery Server Control
LoginView Server Control

CreateUserWizard server control enables you to plug registered users into your data store for later retrieval. LoginStatus Server control enables users to click a link to log in or log out of a site. LoginName server control enables you to display the username of the authenticated user. PasswordRecovery control enables to retrieve password for the user. ChangePassword as the name implies allows changing the password for the user. Login server control provides Login mechanism for application.

Login Server Control:

The Login server Control display standard login interface for user authentication. The Login control can be used as a standalone control on a main or home page, or you can use it on a dedicated login page.

If you use the Login control with ASP.NET membership, you do not need to write code to perform authentication. However, if you want to create your own authentication logic, you can handle the Login control's Authenticate event and add custom authentication code.

Create an ASP.NET Web application that uses ASP.NET membership. Create an ASP.NET Web page in your application named Login.aspx. By default, ASP.NET forms authentication is configured to work with a page named Login.aspx. You can change the default login page name in the Web.config file for your application using the LoginUrl property.

Following example shows the markup for a Login control:

<asp:Login ID="Login1" runat="server" DestinationPageUrl="~/MembersHome.aspx"> </asp:Login>

Login Control on Default page listing

When you submit your username and password by using the Login control, your credentials are automatically validated by the configured Membership Provider.

Login Control properties:

FailureText: used to control the content and appearance of the text that is displayed when a login attempt fails.
CreateUserUrl: used to create links to registration page to create user
PasswordRecoveryUrl: used to create links to password recovery page
VisibleWhenLoggedIn: This property enables you to automatically hide the Login control when the user is already authenticated
DestinationPageUrl: This property sets the name of the page that the user will be redirected to after logging in. If you do not specify a value for the DestinationPageUrl property, the user will be redirected to the originally requested URL after being authenticated.

CreateUserWizard Control:

The CreateUserWizard control enables you to create a standard user registration page. You can use the CreateUserWizard control to allow users to create a new user entry in the membership system. The exact appearance of the interface generated by the CreateUserWizard depends on the settings of your application's Membership Provider. For example, the text boxes for a password question and answer appear only when the default Membership Provider's requiresQuestionAndAnswer attribute has the value true.

CreateUserWizard Output listing

Create or edit an ASP.NET Web page.
Place a CreateUserWizard control on the page using the following syntax:

<asp:CreateUserWizard ID="CreateUserWizard1" Runat="server"> </asp:CreateUserWizard>

Set the ContinueDestinationPageUrl to the URL of the page that users will visit after completing registration, such as your home page

One of the interesting things that you can do with the CreateUserWizard control is to automatically send a registration e-mail message after the user has completed all of the registration steps.

ChangePassword Control:

The ChangePassword control enables users to change their passwords. The control displays text boxes for entering the original password and entering a new password

ChangePassword control Output listing

Like the CreateUserWizard and PasswordRecovery controls, the ChangePassword control includes a MailDefinition property. When values are assigned to the MailDefinition property, the ChangePassword control automatically sends an e-mail message to the user when a password is successfully changed.

LoginName and LoginStatus Controls:

The LoginName and LoginStatus controls enable you to display information about the current authentication status of a user. After a user has logged onto your application, the LoginName control displays the user's registered username. If a user has not been authenticated with Forms Authentication, the LoginName control displays absolutely nothing.

<asp:LoginName ID="LoginName1" Runat="server" />

The LoginStatus, on the other hand, enables a user to log in or log off your Web application. The control displays one of two links. If the user is not authenticated, a link to the Login.aspx page is displayed. If the user has already been authenticated, a link that enables the user to log off is displayed. Here's how you declare the LoginStatus control.

<asp:LoginStatus ID="LoginStatus1" Runat="server" />

LoginView Control:

The LoginView control enables you to display different content depending on the role of the current user. For example, many Web sites display different information on their home page, depending on whether the user is a new user or a registered user. New users might get an overview of the purpose of the Web site, while registered users can view information that is customized for them.

The ASP.NET 3.5 framework includes significant new security features which make the life of developer a lot easier. The new Web Site Administration Tool enables you to create and manage users entirely through a Web form interface. The new Login controls enable you to build standard Web site security pages without writing a single line of code. Finally, the Membership API provides you with a powerful set of methods for manipulating membership information through code.

Site Navigation explained in ASP.Net

2009-10-22T21:59:00.001-07:00

Site Navigation in ASP.NET 3.5

Web applications that you develop will have multiple pages interconnected with each other in some fashion. You need to have a navigation system in place which can help the end user to successfully work through your application. There is no standard mechanism which offers well-defined navigation system for the web application in ASP.NET 1.x. Only known method for building navigation within web application is to fill the pages with hyperlinks. Problem arises when you move pages around or change page names. Hyperlinks don’t work phew!! As site grows and new pages are added, it will be a nightmare for the developer to manage all the links in the application.

ASP.NET 3.5 eliminates this problems with a built in site navigation feature which provides a consistent way for the user to navigate your website. The new site navigation system allows defining all the links at a central location file usually an XML file and display those links in lists or navigation menus in each required page using navigation-based server controls

Different ways to implement Site Navigation in ASP.NET 3.5

Site maps: Site maps are XML files which describes the logical structure of your web application. We can use it to define the layout of all pages in application and how they relate to one another. You can add or remove links/pages to your site map there by managing navigation of website effectively. Site maps are defined with .sitemap extension. You can interact with site maps in variety of ways. You can use sitemap class for programmatic access to site map file. You can also use new SiteMapDataSource control to help bind the information in the site map file to new navigation server controls provided by ASP.NET 3.5

<?xml version="1.0" encoding="utf-8" ?>

</siteMapNode>

</siteMapNode>

</siteMapNode>

</siteMapNode >

</siteMap>

Sitemap file listing

The root node of sitemap is <sitemap> element. Only one <sitemap> element can exist in the file.

Within the <sitemap> element, there is a <siteMapNode> element. This is generally the start page of the application. In above listing the root <siteMapNode> points to the Default.aspx page the start page

Title: attribute provides a textual description of the link

Description: this is used for ToolTip attribute on the link

URL: this gives the location of the physical file

You can place as many additional <siteMapNode> elements as you want. Additional link-levels can be created by adding child <SiteMapNode> elements for any parent <SiteMapNode> in the structure.

Above listing defines following logical structure

Home

News

U.S News
UK News
Asia News

Finance

NASDAQ
NY
HONGKONG

Weather

NYC
Chicago

SiteMapPath Server Control:

ASP.NET 3.5 provides new SiteMapPath Server control which works exclusively with .sitemap files. You can find this new control in the Navigation section of Visual Studio 2005 IDE.

The SiteMapPath control creates navigation mechanism which is generally referred to as breadcrumb navigation. This is a linear path defining where the user is currently located in navigation structure.

It usually helps end user to know his location in relation to the rest of the site

Breadcrumb navigation in msn website. Surrounded by Black box

Let’s create an example to demonstrate capabilities of SiteMapPath Server Control

We have already seen the structure of sitemap file. We will use the same sitemap for our example.

The SiteMapPath server control is so easy to use that you can simply drag and drop the server control onto any page and it shows breadcrumb navigation for that page.

%@ Page Language="C#" AutoEventWireup="true" CodeFile="AsiaNews.aspx.cs" Inherits="AsiaNews" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<title>Untitled Page</title>

</head>

<body>

<div>

<asp:SiteMapPath ID="SiteMapPath1" runat="server">

</asp:SiteMapPath>

</div>

</form>

</body>

</html>

SiteMapPath Server control listing

In the above sample, I have added SiteMapPath control to AsiaNews.aspx and you can see in output when you open AsiaNews.aspx, you will observe that this page belongs to News section of the site which is turn belongs to Home section of website.

The SiteMapPath control creates breadcrumb navigation with very little effort on your part.

Output Listing of AsiaNews page displaying breadcrumb navigation

Properties of SiteMapPath Control:

PathSeparator Property:

PathSeparator property defines the element to separate the link elements. By default, (>) greater than symbol is used to separate link elements as shown in above listing

PathDirection Property:

This property changes the direction of the links generated in the output. Possible settings for this property are RootToCurrent and CurrentToRoot. In the above example, I have used default RootToCurrent setting. If we change the setting to CurrentToRoot you will the output as shown below. I think you got the difference.

Output listing with PathDirection set to CurrentToRoot

Few more properties in nut shell:

NodeStyle property: Applies styles to all links in the sitemap uniformly
RootNodeStyle property : Applies styles to the root link in the SiteMapPath navigation
CurrentNodeStyle property: Gets the style used for the display text for the current node.

Menu Server Control:

Another important navigation control in ASP.NET 3.5 which allows the end user to navigate through a large collection of options(links) with very less effort. This is used to display menu in a web page and used in combination with SiteMapDataSource control for navigating a web site. You can customize the appearance of menu control through styles, user-defined templates and themes.

Menu control displays two types of menus: a Static menu and Dynamic menu. The static menu is always displayed in menu control. By default, only menu items at the root levels are displayed. You can also display additional menu levels by setting StaticDisplayLevels property.

Menu items with a higher level than the value specified by StaticDisplayLevels property are displayed in dynamic menu. A Dynamic menu appears only when the user positions the mouse pointer over the parent menu item that contains a Dynamic submenu.

Menu control exposes events such as MenuItemClick, Load,UnLoad,Prerender,DataBound and certain other events. MenuItemClick event enables you to take some action when end user clicks one of the available menu items.

When the user clicks a menu item, the Menu control can either navigate to a linked Web page or simply post back to the server. If the NavigateUrl of a menu item is set, the Menu control navigates to the linked page; otherwise, it posts the page back to the server for processing. By default, a linked page is displayed in the same window as menu control.

We will again use same sitemap for menu server control too.

Drag and drop the menu server control from Navigation Section of Toolbox and similarly drag and drop the SiteMapDataSource control from Data Section of Toolbox and connect the two by using Menu control’s DataSourceId property. From this example, you can see that I’m using a SiteMapDataSource control that automatically works with the application’s web.sitemap file. DataSourceID property will connect the menu control with SiteMapDataSource control

Menu Control Properties dialog box

You can change the appearance and style of menu control by using predefined styles and define your own custom styles. Appearance and style are always left you to decide. I have chosen Professional predefined style in SmartTag for the menu control. There are plenty of properties available for you to configure the style of mouse pointer, display text style and styles for dynamic menus and static menus. Play around with the various properties and see the change for yourself.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="News.aspx.cs" Inherits="News" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<title>Untitled Page</title>

</head>

<body>

<div>

<asp:Menu ID="Menu1" runat="server" BackColor="#B5C7DE" DataSourceID="SiteMapDataSource1"

DynamicHorizontalOffset="2" Font-Names="Verdana" Font-Size="0.8em" ForeColor="#284E98"

StaticSubMenuIndent="10px">

</asp:Menu>

</div>

<asp:SiteMapDataSource ID="SiteMapDataSource1" runat="server" />

</form>

</body>

</html>

HTML listing of Menu Control

Output listing for Menu Control using SiteMapDataSource control using sitemap xml file

ASP.NET 3.5 provides powerful navigation mechanisms. The core of the new navigation model is the ability to represent the navigation structure in an xml file which can then used by navigation controls such as SiteMapPath controls. You can design navigation structure for your application with out writing single piece of code.

ASP.Net Caching vs Caching Application block (CAB)

2009-10-21T22:45:00.000-07:00

Why do we need caching?

Faster performance
Throughput and faster response time
To avoid expensive roundtrips
Data must always be available, even when the source, such as server is not available.

What influences caching?

The amount of data you cache and amount of time you cache.

What kind of data should be cached?

Frequently used general purpose data used in the lifetime of application should be cached

What kind of data should NOT be cached?

Data which is not frequently used or which is based on request or session

Which caching mechanism to use?

Caching application block or ASP.Net Caching mechanism

Caching application block:

We see value of caching application block when using durable storage like database or isolated storage for caching.The Caching Application Block integrates seamlessly with the Data Access Application Block for backing store functionality

Drawbacks:

Overhead of configuration files to manage cache policies.
Overhead of creating and managing backing stores
By default, cache manager writes to in-memory cache

However, the nonvolatile, persisted storage of data comes with a cost. While it is good to have data that will not disappear when a computer is shut off, the actual task of storing data can hinder performance. The most expensive performance costs typically involve the reading and writing of data to disk,

ASP.NET Cache

The .NET Framework includes the ASP.NET cache in the System.Web namespace. ASP.NET application developers access this cache through the System.Web.HTTPContext.Cache object. The ASP.NET cache was developed and tuned for ASP.NET applications. However, this cache can also be used outside of an ASP.NET application by accessing the System.Web.HTTPRuntime.Cache object. The ASP.NET cache requires the System.Web assembly.

We can cache user controls, page output caching, selective caching caching portion of page and post cache substitution.

Problems with caching:

Static data/memory overrun/
Performance hits/Database Invalidation
File invalidation & Data refresh problems

Caching scheme only works with in current appdomain but not suitable for webfarm/webgarden