Asp.net and c#

URL Rewriting in ASP.NET using global.asax and web.config

2011-09-07T11:46:00.000-07:00

URL rewriting is very important for search engines like google, yahoo, etc. as we know website getting most of the traffic from search engines.

Here I am explaining 2 way to rewrite URL in asp.net.
URL rewrining using web.config and URL rewriting using global.asax

URL rewrining using web.config:
URL rewriting in web.config is only use for small number of pages. Here you have to rewrite every page manually in web.config. I am writing sample code for 4 urls.
xml version="1.0"?>
<configuration>
<urlMappings enabled="true">
<add url="~/About-company.aspx"
   mappedUrl="~/index.aspx?id=1" />
<add url="~/About-products.aspx"
   mappedUrl="~/index.aspx?id=2" />
<add url="~/Contact-us.aspx"
   mappedUrl="~/index.aspx?id=3" />
<add url="~/our-team.aspx"
   mappedUrl="~/index.aspx?id=4" />
urlMappings>
. . .
configuration>

URL rewriting using global.aspx:

This very simple way and very use full. In this way we can rewrite N number of pages and there is no need extra server configuration. Only you have to use Application_BeginRequest event. Inside this event use Context.RewritePath method to set which URL will execute internally in code behind. Here is the code:

void Application_BeginRequest(object sender, EventArgs e)
{
// Get the current path
string CurrentURL_Path = Request.Path.ToLower();

if (CurrentURL_Path.StartsWith("/news/"))
{

   CurrentURL_Path = CurrentURL_Path.Trim("/");
   string NewsID = CurrentPath.Substring(CurrentPath.IndexOf("/"));
   HttpContext MyContext = HttpContext.Current;
   MyContext.RewritePath("/news-show.aspx?News=" + NewsID);
}
}

In next article i will write about URL rewriting using HttpModule.

Url Routing MVC TUTORIAL

2011-07-27T05:46:00.000-07:00

This tutorial covers an introduction to the MVC pattern using Visual Basic. It also includes a brief overview of the URL routing assumptions that are a foundation to the implementation of the pattern. A sample application is created to demonstrate the fundamentals of this new web-application model. Implementing business rules and testing is also covered. Finally, the use of two alternative view engines, Silverlight and XML Literals, is coverd.

What is ASP.NET MVC? 80 minute technical video for developers, building NerdDinner

2011-07-27T05:32:00.000-07:00

Overview of ASP.NET MVC Routing

2011-06-21T02:06:00.000-07:00

In this tutorial, we introduce an important feature of all ASP.NET applications ASP.NET MVC Routing call. The ASP.NET routing module is responsible for assigning incoming requests particular browser MVC controller actions. At the end of this tutorial, you will understand how the standard routing table maps requests to controller actions.

Using the default route table

When you create a new ASP.NET MVC, the application is configured to use ASP.NET Routing. ASP.NET routing is configured in two places.

First, ASP.NET routing is enabled on the file from the Web application configuration (Web.config file). There are four sections in the configuration file that are relevant for routing: the system.web section. httpModules, section system.web.httpHandlers, system.webserver.modules section and section system.webserver.handlers. Be careful not to delete these sections, because without these sections routing no longer work.

Second, and most importantly, a routing table is created in the application's Global.asax file. The Global.asax file is a special file that contains event handlers for the events of the life cycle of the ASP.NET application. The routing table is created during the application start event.

The file in Listing 1 contains the default Global.asax file for an ASP.NET MVC application.

Listing 1 - Global.asax.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace MvcApplication1
{
// Note: For instructions on enabling IIS6 or IIS7 classic mode,
// visit http://go.microsoft.com/?LinkId=9394801

public class MvcApplication : System.Web.HttpApplication
{
public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

routes.MapRoute(
"Default", // Route name
"{controller}/{action}/{id}", // URL with parameters
new { controller = "Home", action = "Index", id = "" } // Parameter defaults
);

}

protected void Application_Start()
{
RegisterRoutes(RouteTable.Routes);
}
}
}

When an MVC application first starts, the method Application_Start () is called. This method in turn calls the RegisterRoutes () method. The RegisterRoutes () creates the routing table.

The routing table contains a single default route (default name). The default route maps the first part of a URL for a driver name, the second segment of the URL of a controller action, and the third segment with a parameter named id.

Imagine you enter the following URL into the address bar of your browser:

/ Home/Index/3

Maps of the default route this URL for the following parameters:

controller = Home

action = index

id = 3

When you request the URL / Home/Index/3, the code runs as follows:

HomeController.Index (3)

The default route includes defaults for all three parameters. Failure to provide a driver, then the default parameters of the controller to the brokerage. Failure to provide an action, the default parameters of action for the value index. Finally, failure to provide an identifier, the id parameter defaults to an empty string.

Here are some examples of how the default route maps URLs to controller actions. Imagine you enter the following URL into the address bar of your browser:

/ Home

Because the default the default path, entering this URL will cause the index () class in Schedule 2 HomeController called.

Listing 2 - HomeController.cs

using System.Web.Mvc;

namespace MvcApplication1.Controllers
{
[HandleError]
public class HomeController : Controller
{
public ActionResult Index(string id)
{
return View();
}
}
}

In Listing 2, the class includes a method called HomeController Index () that accepts one parameter named ID. The URL / Home causes the index () to call an empty string as the parameter id.

Due to the way the MVC framework invokes the actions of the driver, the URL / Home also matches the index () HomeController class in Listing 3.

Listing 3 - HomeController.cs (Index action with no parameter)

using System.Web.Mvc;

namespace MvcApplication1.Controllers
{
[HandleError]
public class HomeController : Controller
{
public ActionResult Index()
{
return View();
}
}
}

The index () method in Listing 3 does not accept any parameters. The URL / Home will make the index () to be called. The URL / Home/Index/3 also invokes this method (the ID is ignored).

The URL / Home also matches the index () HomeController class in Listing 4.

Listing 4 - HomeController.cs (Index action with nullable parameter)

using System.Web.Mvc;

namespace MvcApplication1.Controllers
{
[HandleError]
public class HomeController : Controller
{
public ActionResult Index(int? id)
{
return View();
}
}
}

In Listing 4, the method index () has an integer parameter. Because the parameter is nullable (can be set to zero), the index () can be called without causing an error.

Finally, invoking the index () method in Listing 5 to the URL / Home causes an exception as the parameter identification is not a parameter accepts null values. If you try to invoke the method index () then the error is show.

The URL / Home/Index/3 other hand, works very well with the controller action index List 5. Application / Home/Index/3 makes the method index () is called with a parameter ID that has the value 3.

Summary

The aim of this tutorial is to provide a brief introduction to ASP.NET Routing. We examined the routing table by default you get with a new ASP.NET MVC. He has learned default route maps URLs to controller actions.

Seven Tips and Tricks Programming WPF

2011-05-26T23:24:00.000-07:00

The Internet has much to offer in any topic and there is much to learn, but where to start? I realized many years ago, when I got intrigued by the Windows Presentation Foundation (WPF), short write-ups that help you acquire additional knowledge, which when combined can provide solutions to the bigger picture. This article provides a list of tips I learned a year ago, while scanning for simple solutions to big problems. javascript:void(0)

Use the list Visibility.Collapsed vs Visibility.Hidden
The collapsed value ensures that the element is not involved in the design and gives you a zero height and width. The latter causes the element to continue to participate in the design.

Reduce CPU consumption for animations to WPF
As you know, WPF animations are based on 60 frames per second. You can reduce this to a lower optimal rate, resulting in less CPU usage. Use the timeline. DesiredFrameRateProperty to change the default, set to a lower value as 15, and then changes according to the smoothness you want.

Timeline.DesiredFrameRateProperty.OverrideMetadata(
typeof(Timeline),
new FrameworkPropertyMetadata { DefaultValue = 15 }

);

Default of Culture of the application for the Culture of the client machine

WPF elements expose a property of language that can be used to map language as any culture. When this property is applied to a window, applies to all items it contains. See the sample code that applies the language of contemporary culture. The start function in the application class is an ideal place to implement this change through the application.

protected override void OnStartup(StartupEventArgs e)
{
FrameworkElement.LanguageProperty.OverrideMetadata(typeof(FrameworkElement), new FrameworkPropertyMetadata(XmlLanguage.GetLanguage(System.Globalization.CultureInfo.CurrentCulture.IetfLanguageTag)));

base.OnStartup(e);
}

Use StaticResource StaticResource vs DynamicResource are evaluated only once and only for the purpose. Dynamic resources assessment because each time they are requested by the control, and hence make the request to perform slower. Although this is a deferred execution time search makes sense if the action will not change

The use of WPF Performance Suite to the profile of WPF applications
WPF Performance Suite is available in the Windows SDK and is composed of a few important profiling tools that allow you to analyze the requests and provide information on the optimizations that can be applied. You can download from the Microsoft website.

The driller and tools of Visual Profiler profiles give much information and also indicate potential bottlenecks in implementation. This suite is part of the Microsoft Windows SDK for Windows 7 and Vista. NET Framework 3. 5 SP1.

Avoid design errors with the help of DesignerProperties. Method GetIsInDesignMode
Most designers often break the "Could not create an instance" error. Although this is due to some unhandled exception occurs in the constructor's control, may not require the code execution at design time.

public SampleControlConstructor()
{
InitializeComponent();
if (!System.ComponentModel.DesignerProperties.GetIsInDesignMode(this))
{
//place your code here.
}
}

Use IsMouseDirectlyOver event to determine the exact mouse movement.
The event IsMouseOver respond to mouse movement within a control or their children.

IsMouseDirectlyOver use the event to determine if the mouse movement on the control and not their containers. This is useful for building the triggers specific change in mouse movement.

Bind jQuery event handlers for this object CoffeeScript

2011-05-24T22:13:00.001-07:00

Bind jQuery event handlers for this object CoffeeScript

Friends have told me that the rich domain objects rarely does so using jQuery to improve performance in web pages. I myself have always loved dynamic JavaScript as a language rich first and something for the second DOM. So most of my client-side JavaScript is an object-oriented robust approach similar to Ruby. This is the main reason they have used Prototype.js for so long.

Since both jQuery and Rails CoffeeScript announced as the default in version 3.1, I decided it was time to start learning them. I had always known that jQuery linked keyword is in the event handlers to the DOM object. Something you are totally confused and unacceptable for someone working on their own objects to encapsulate behavior. Today I found two ways to deal with my problem, one way and one way CoffeeScript jQuery. First a code example.

class MyObject

  constructor: ->
    @myDomElement = $('#myDomElement')
    @._initBehavior

  handler: (event) ->
    console.log(this)
    false

_initBehavior: ->
$(window).resize @handler

jQuery ->
window.myObject = new MyObject();

Here is a simple class using methods CoffeeScript. Is initialized with a static property this.myDomElement a DOM element on the page with the id "myDomElement." Then, you assign an event handler to the event of resizing the window and records this on the road. Simple things, the only problem is that the registered object will not be an instance of MyObject, but the raw DOM element, in this case the window object. One way to fix this is to use jQuery function as a proxy for

_initBehavior: ->
$(window).resize jQuery.proxy(@handler,this)

This works but seems a little tedious for me and can clog up your initialization code of the event. The other way is to use the arrow operator CoffeeScript fat. An extract from the project page explains it well.

The fat arrow => can be used both to define a function, and linked to the current value of this, on the spot. This is useful when using callback libraries based on how Prototype or jQuery, to create a repeater function to pass each, or the event handler functions for use with link. Created with the arrow functions of fat are able to access the properties where they are defined.
So all we have to do is change - of> = for any of our callbacks or event handlers, and now this is our own object and not the DOM element. Hot Damn!

class MyObject

  constructor: ->
    @myDomElement = $('#myDomElement')
    @._initBehavior

  handler: (event) =>
    console.log(this)
    false

_initBehavior: ->
$(window).resize @handler

jQuery ->
window.myObject = new MyObject();

Adding a Controller

2011-05-23T04:42:00.000-07:00

Adding a Controller

MVC stands for model-view-controller. MVC is a pattern for developing applications that are well architected and easy to maintain. MVC-based applications contain:

Controllers: Classes that handle incoming requests to the application, retrieve model data, and then specify view templates that return a response to the client.
Models: Classes that represent the data of the application and that use validation logic to enforce business rules for that data.
Views: Template files that your application uses to dynamically generate HTML responses.

We'll be covering all these concepts in this tutorial series and show you how to use them to build an application.

Let's begin by creating a controller class. In Solution Explorer, right-click the Controllers folder and then select Add Controller.

Name your new controller "HelloWorldController". Leave the default template as Empty controller and clickAdd.

Notice in Solution Explorer that a new file has been created named HelloWorldController.cs. The file is open in the IDE.

Inside the public class HelloWorldController block, create two methods that look like the following code. The controller will return a string of HTML as an example.

using System.Web;
using System.Web.Mvc; 
 namespace MvcMovie.Controllers { 
    public class HelloWorldController : Controller 
    { 
        // 
        // GET: /HelloWorld/ 
 
        public string Index() 
        { 
            return "This is my default action..."; 
        } 
 
        // 
        // GET: /HelloWorld/Welcome/ 
 
        public string Welcome() 
        { 
            return "This is the Welcome action method..."; 
        } 
    } }

Your controller is named HelloWorldController and the first method above is named Index. Let’s invoke it from a browser. Run the application (press F5 or Ctrl+F5). In the browser, append "HelloWorld" to the path in the address bar. (For example, in the illustration below, it's http://localhost:43246/HelloWorld.) The page in the browser will look like the following screenshot. In the method above, the code returned a string directly. You told the system to just return some HTML, and it did!

ASP.NET MVC invokes different controller classes (and different action methods within them) depending on the incoming URL. The default mapping logic used by ASP.NET MVC uses a format like this to determine what code to invoke:

/[Controller]/[ActionName]/[Parameters]

The first part of the URL determines the controller class to execute. So /HelloWorld maps to theHelloWorldController class. The second part of the URL determines the action method on the class to execute. So /HelloWorld/Index would cause the Index method of the HelloWorldController class to execute. Notice that we only had to browse to /HelloWorld and the Index method was used by default. This is because a method named Index is the default method that will be called on a controller if one is not explicitly specified.

Browse to http://localhost:xxxx/HelloWorld/Welcome. The Welcome method runs and returns the string "This is the Welcome action method...". The default MVC mapping is /[Controller]/[ActionName]/[Parameters]. For this URL, the controller is HelloWorld and Welcome is the action method. You haven't used the[Parameters] part of the URL yet.

Let's modify the example slightly so that you can pass some parameter information from the URL to the controller (for example, /HelloWorld/Welcome?name=Scott&numtimes=4). Change your Welcome method to include two parameters as shown below. Note that the code uses the C# optional-parameter feature to indicate that the numTimes parameter should default to 1 if no value is passed for that parameter.

public string Welcome(string name, int numTimes = 1) {
     return HttpUtility.HtmlEncode("Hello " + name + ", NumTimes is: " + numTimes);
}

Run your application and browse to the example URL (http://localhost:xxxx/HelloWorld/Welcome?name=Scott&numtimes=4). You can try different values for name and numtimes in the URL. The system automatically maps the named parameters from the query string in the address bar to parameters in your method.

In both these examples the controller has been doing the "VC" portion of MVC — that is, the view and controller work. The controller is returning HTML directly. Ordinarily you don't want controllers returning HTML directly, since that becomes very cumbersome to code. Instead we'll typically use a separate view template file to help generate the HTML response. Let's look next at how we can do this.

Related link

Passing Data in an ASP.NET MVC Application
ASP.NET MVC Overview
Basic concept and fundamentals of ASP.NET MVC (Model View Controller) Architecture
ASP.NET MVC 3 Introduction

ASP.NET MVC 3 Introduction

2011-05-17T13:58:00.000-07:00

This article will explain you the basics of ASP.NET MVC 3 Web application by using Microsoft Visual Web Developer 2010 Express Service Pack 1, which is a free version of Microsoft Visual Studio 2010. Make sure you've installed the prerequisites listed below before you start.

You can install all prerequisites by clicking this link: Web Platform Installer. OR, you can individually install the prerequisites by the following links:

Visual Studio Web Developer Express SP1 prerequisites
ASP.NET MVC 3 Tools Update
SQL Server Compact 4.0 (runtime + tools support)

If you're using Visual Studio 2010 instead of Visual Web Developer 2010, install the prerequisites by clicking the following link: Visual Studio 2010 prerequisites.

A Visual Web Developer project with C# source code is available to accompany this topic. Download the C# version. If you prefer Visual Basic, switch to the Visual Basic version of this tutorial.

What You'll Build

You'll implement a simple movie-listing application that supports creating, editing, and listing movies from a database. Below are two screenshots of the application you’ll build. It includes a page that displays a list of movies from a database:

The application also lets you add, edit, and delete movies, as well as see details about individual ones. All data-entry scenarios include validation to ensure that the data stored in the database is correct.

Skills You'll Learn

Here's what you'll learn:

How to create a new ASP.NET MVC project.
How to create ASP.NET MVC controllers and views.
How to create a new database using the Entity Framework Code First paradigm.
How to retrieve and display data.
How to edit data and enable data validation.

Getting Started

Start by running Visual Web Developer 2010 Express ("Visual Web Developer" for short) and select New Project from the Start page.

Visual Web Developer is an IDE, or integrated development environment. Just like you use Microsoft Word to write documents, you'll use an IDE to create applications. In Visual Web Developer there's a toolbar along the top showing various options available to you. There's also a menu that provides another way to perform tasks in the IDE. (For example, instead of selecting New Project from the Start page, you can use the menu and selectFile > New Project.)

Creating Your First Application

You can create applications using either Visual Basic or Visual C# as the programming language. Select Visual C# on the left and then select ASP.NET MVC 3 Web Application. Name your project "MvcMovie" and then click OK. (If you prefer Visual Basic, switch to the Visual Basic version of this tutorial.)

In the New ASP.NET MVC 3 Project dialog box, select Internet Application. Check Use HTML5 markupand leave Razor as the default view engine.

Click OK. Visual Web Developer used a default template for the ASP.NET MVC project you just created, so you have a working application right now without doing anything! This is a simple "Hello World!" project, and it's a good place to start your application.

From the Debug menu, select Start Debugging.

Notice that the keyboard shortcut to start debugging is F5.

F5 causes Visual Web Developer to start a development web server and run your web application. Visual Web Developer then launches a browser and opens the application's home page. Notice that the address bar of the browser says localhost and not something like example.com. That's because localhost always points to your own local computer, which in this case is running the application you just built. When Visual Web Developer runs a web project, a random port is used for the web server. In the image below, the random port number is 43246. When you run the application, you'll probably see a different port number.

Right out of the box this default template gives you two pages to visit and a basic login page. The next step is to change how this application works and learn a little bit about ASP.NET MVC in the process. Close your browser and let's change some code.

Related links:

Introducing MVC Development w/the Razor View Engine for Visual Studio Developers

2011-05-16T00:25:00.000-07:00

The Razor View Engine is a precise, useful, light language that enables you to create views for MVC projects in ASP.NET still while keeping a separation of concerns, ability to test, and pattern based development. ASP.NET MVC developers looking for a more concise syntax now have another option that's built-in (of course, there are many 3rd party view engines out there) with the language being a familiar light version of C#.

The Razor View engine is used to create WebMatrix sites or Visual Studio MVC applications. When using ASP.NET MVC with either engine, you'll stick to a style of development called "convention over configuration", meaning that you'll use certain naming conventions to name files, models, views, controllers, and other key application elements rather than storing lots of metadata about these same elements in a configuration file. When using MVC in Visual Studio 2010, it's is setup so that you'll be guided to use convention over configuration, which becomes evident when exploring an ASP.NET MVC project.

Getting Started

Before you start, go and download these two things (as of this post; things are subject to change - these could end up in VS at some point):

ASP.NET MVC 3
Razor Syntax Highlighter Extension (not mandatory, but a huge help)

You can also find the Razor Syntax Highlighter by choosing Extensions Manager from the Visual Studio Tools menu. Once installed, MVC 3 project templates are available from Visual Studio. The MVC 3 Web Application template allows you to use either the Web Forms View Engine or the Razor View Engine, while MVC 2 Applications contain only the WF View Engine.

When creating a new MVC 3 project a new dialog box appears asking which application type, view engine, and testing framework you'd like to use. You can andshould add a test project so you can test your code, then actually write some tests in it. The image below demonstrates selecting the internet application project template using Razor as the view engine, as well as the test framework. The internet application MVC template adds in ASP.NET membership & security features to the project by creating the necessary model, view and controller for logging on and registering as a site user.

Verify that the project is created with three folders, one each for Models, Views, and Controllers which is the same folder structure as a MVC 2 site. The project also contains auxiliary folders and files needed for the application such as the Content & App_Data folders. Since this is an MVC application using the Razor View Engine, you will see a different file extension - .cshtml. The .cshtml files are Razor View Pages written using the Razor View Engine. If you're not familiar with Razor syntax, I've blogged about it here, and the online documentation has more information as well.

The application template sets up some models, views and controllers to start with, and is now ready for new models, views, and controllers. I've found the easiest way to work with MVC in VS is to start with the model, move to the controller, then create the view, so we'll look at models first.

Models

A model is a representation of an underlying data store. Models can be almost anything from any data source; EF or Linq2Sql Models, or a simple class. The code the builds the model below consists of two classes, a ProductModel class and a Product class. The ProductModel class returns a List of Product objects in a property aptly named Products that represents one or more products in the data store . Product objects contain ProductNumber, Name and Price properties and represent an individual product in the data store. The model code representing these product objects is below:

using System.Collections.Generic;
namespace AdventureWorks.Models
{
    public class ProductModel
    {
        public List<Product> Products { get; set; }
        public ProductModel()
        {
            Products = new List<Product>();
            this.Products.Add(new Product("AB-00-J1" ,"Super Fast Bike" ,1000M));
            this.Products.Add(new Product("EE-9-OL"  ,"Durable Helmet"  ,123.45M));
            this.Products.Add(new Product("MMM99-54" ,"Soft Bike Seat"  ,34.99M));
        }
    }
 
    public class Product
    {
        public Product(string productNumber, string name, decimal price)
        {
            Name = name;
            Price = price;        
            ProductNumber=productNumber;
        }
        public string ProductNumber { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
        
    }
}

Models are handed over to views by controllers so the views can render the data from the model. The model will extend business logic (of course, this is a simple example, business logic will likely be spread out into other applications & tiers). Models also provide validation information to the view via metadata & code. You can add the model to the \Models folder or you can reference an external data model library. In this case, the model's been added to the \Models folder.

See full details: http://rachelappel.com/razor/introducing-mvc-development-w-the-razor-view-engine-for-visual-studio-developers/

Related link

LINQ to SQL

2011-05-15T10:46:00.000-07:00

LINQ to SQL allows .NET developers to write “queries” in their .NET language of choice to retrieve and manipulate data from a SQL Server database. In a general sense, LINQ to SQL allows us to create SQL queries in our preferred .NET language syntax and work with a strongly types collection of objects as a return result. We can make changes to these objects then save changes back to the database.

To get an idea of the syntax for LINQ to SQL, we will be using the following SQL database schema. It is a simple software registration and helpdesk. It is populated with sample data and has foreign-key relationships defined where appropriate.

SQL Database Schema used for LINQ to SQL examples.

For the moment I ask you to ignore the fact that we will be coding against a type HookedOnLINQ, I’ll get to how that was created in a few pages time, for now just understand it is an object structure that mimics this database schema.

HookedOnLINQ db = new HookedOnLINQ("Data Source=(local);Initial Catalog=HookedOnLINQ"); var q = from c in db.Contact where c.DateOfBirth.AddYears(35) > DateTime.Now orderby c.DateOfBirth descending select c; foreach(var c in q) Console.WriteLine("{0} {1} b.{2}", c.FirstName.Trim(), c.LastName.Trim(),c.DateOfBirth.ToString("dd-MMM-yyyy")); Output: Mack Kamph b.17-Sep-1977 Armando Valdes b.09-Dec-1973

See full details: http://www.hookedonlinq.com/LINQtoSQL5MinuteOverview.ashx

Passing Data in an ASP.NET MVC Application

2011-05-15T10:31:00.000-07:00

The ASP.NET MVC framework provides page-level containers that can pass data between controllers and views. This topic

explains how to pass both weakly typed and strongly typed data in an MVC application. It also explains how to pass

temporary state data between action methods

Passing Data Between a Controller and a View
To render a view, you call the View method of the controller. To pass data to the view, you use the ViewData property of

the ViewPage class. This property returns aViewDataDictionary object that has case-insensitive string keys. To pass data to

the view, you can assign values to the dictionary, as shown in the following example:

List<string> petList = new List<string>();
petList.Add("Dog");
petList.Add("Cat");
petList.Add("Hamster");
petList.Add("Parrot");
petList.Add("Gold fish");
petList.Add("Mountain lion");
petList.Add("Elephant");

ViewData["Pets"] = new SelectList(petList);

If you call the View method without parameters (as shown in the previous example), the controller object's ViewData

property is passed to the view that has the same name as the action method.

In the view page, you can access the ViewData property to obtain data that was passed to the view. The ViewData property is

a dictionary that supports an indexer that accepts dictionary keys.

The following example shows the markup for a view that displays the data in an HTML form and enables the user to modify

values and make selections.

<h2><%= Html.Encode(ViewData["Message"]) %></h2>
<br /><br />
<% using(Html.BeginForm("HandleForm", "Home")) %>
<% { %>
    Enter your name: <%= Html.TextBox("name") %>
    <br /><br />
    Select your favorite color:<br />
    <%= Html.RadioButton("favColor", "Blue", true) %> Blue <br />
    <%= Html.RadioButton("favColor", "Purple", false)%> Purple <br />
    <%= Html.RadioButton("favColor", "Red", false)%> Red <br />
    <%= Html.RadioButton("favColor", "Orange", false)%> Orange <br />
    <%= Html.RadioButton("favColor", "Yellow", false)%> Yellow <br />
    <%= Html.RadioButton("favColor", "Brown", false)%> Brown <br />
    <%= Html.RadioButton("favColor", "Green", false)%> Green
    <br /><br />
    <%= Html.CheckBox("bookType") %> I read more fiction than non-fiction.<br />
    <br /><br />
    My favorite pet: <%= Html.DropDownList("pets") %>
    <br /><br />
    <input type="submit" value="Submit" />
<% } %>

Passing Strongly-Typed Data Between a Controller and a View

When you pass data between a view and a controller by using the ViewData property of the ViewPage class, the data is not

strongly typed. If you want to pass strongly typed data, change the @ Page declaration of the view so that the view

inherits from ViewPage instead of from ViewPage, as shown in the following example

<%@ Page Inherits="ViewPage<Product>" %>

ViewPage<TModel> is the strongly-typed version of ViewPage. The ViewData property of ViewPage returns a

ViewDataDictionary object, which contains strongly typed data for the view based on a model. The model is a class

that contains properties for each data item that you want to pass. (A simpler approach to creating a strongly typed view

page is to use the Add View dialog box.)

The following example shows the definition of a typical data model class named Person.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;

namespace MvcDataViews.Models
{
    public class Person
    {
        [Required(ErrorMessage = "The ID is required.")]
        public int Id { get; set; }

[Required(ErrorMessage = "The name is required.")]
public string Name { get; set; }

[Range(1, 200, ErrorMessage = "A number between 1 and 200.")]
public int Age { get; set; }

        [RegularExpression(@"(($\d{3}$ ?)|(\d{3}-))?\d{3}-\d{4}",
            ErrorMessage = "Invalid phone number.")]
        public string Phone { get; set; }

        [RegularExpression(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$",
            ErrorMessage = "Invalid email address.")]
        public string Email { get; set; }
    }
}

The following example shows a view that enables the user to modify the values of a Person object and to submit the changes

for update.

The following example shows the action method that receives a Person object from the Edit view, checks its validity against

the model, updates a list of Person objects, and then redirects to the Index action.

Action methods might have to pass data to another action, such as if an error occurs when a form is being posted, or if the

method must redirect to additional methods, as might occur when the user is directed to a login view and then back to the

original action method.

Passing State Between Action Methods

An action method can store data in the controller's TempDataDictionary object before it calls the controller's

RedirectToAction method to invoke the next action. The TempData property value is stored in session state. Any action

method that is called after the TempDataDictionary value is set can get values from the object and then process or display

them. The value of TempData persists until it is read or until the session times out. Persisting TempData in this way

enables scenarios such as redirection, because the values in TempData are available beyond a single request.

Note: This behavior is new in ASP.NET MVC 2. In earlier versions of ASP.NET MVC, the values in TempData was available only

until the next request.

The following example shows a data class that is used to trap an error and to transfer data between actions.

public class InsertError
{
    public string ErrorMessage { get; set; }
    public string OriginalFirstName { get; set; }
    public string OriginalLastName { get; set; }
}

// CustomersController

public ActionResult InsertCustomer(string firstName, string lastName)
{
    // Check for input errors.
    if (String.IsNullOrEmpty(firstName) ||
            String.IsNullOrEmpty(lastName))
    {
        InsertError error = new InsertError();
        error.ErrorMessage = "Both names are required.";
        error.OriginalFirstName = firstName;
        error.OriginalLastName = lastName;
        TempData["error"] = error;
        return RedirectToAction("NewCustomer");
    }
    // No errors
    // ...
    return View();
}

public ActionResult NewCustomer()
{
    InsertError err = TempData["error"] as InsertError;
    if (err != null)
    {
        // If there is error data from the previous action, display it.
        ViewData["FirstName"] = err.OriginalFirstName;
        ViewData["LastName"] = err.OriginalLastName;
        ViewData["ErrorMessage"] = err.ErrorMessage;
    }
    // ...
    return View();
}

The following example shows the markup for a view that accepts user input and displays an error message if an error occurs.

<form action="/Home/InsertCustomer">
  <% if (ViewData["ErrorMessage"] != null) { %>
    The following error occurred while inserting the customer data:
    <br />
    <%= ViewData["ErrorMessage"] %>
    <br />
  <% } %>

  First name:
  <input type="text" name="firstName" value="<%= ViewData["FirstName"] %>" />
  <br />
  Last name:
  <input type="text" name="lastName" value="<%= ViewData["LastName"] %>" />
  <br />
  <input type="submit" value="Insert" />
</form>

ASP.NET MVC Overview

2011-05-10T06:09:00.000-07:00

Introduction

ASP.NET MVC is one of the methods of developing ASP.NET applications. In this article, we will go through the overview of ASP.NET MVC by creating a simple application.

ASP.NET MVC Framework is Microsoft’s Web Application development framework, the other one being traditional webforms framework.

MVC or Model View Controller is a design pattern that addresses the separation of concerns(Soc) which is the process of identifying and separating the application into distinct parts like UI, Logic and Data Access.

Soc has proven to be useful in the design of web applications. Keeping the view separate from the other parts of the application means that we can easily change the view without affecting the rest of the application.

Similarly, if we want to change the main application logic, we just need to change the controller.

ASP.NET MVC is an implementation of the MVC design pattern. The framework helps Test Driven Development which is a method of development in which Unit Test Cases are written before the rest of the application.

The above diagram shows the relationship between the MVC Framework and the .NET Framework. Observe that the Web Forms and MVC are both built on top of ASP.NET Framework.

While building web applications, developers can either choose the web forms model or the MVC model depending on the requirements of the application.

An MVC application consists of Model, View and Controller at its core:

Model: Consists of the data access logic and the classes that represent the objects in the application domain (Business Objects)
View: A view contains HTML markup
Controller: Consists of the main application flow logic

Let’s start with creating simple MVC application to understand the basics of the MVC application. We will start by creating a blank ASP.NET MVC application.

Once the web application is created, we will add the functionality to make it work.

Adding the Controller

For adding the controller, we will right click the controllers folder and select Add -> Controller. We will type the name NamesController in controller name dialog.

Note that the Controller name must end with Suffix Controller. Doing so creates a controller with the default code. We have renamed the action as in the following code.

See full details: http://www.codeproject.com/KB/aspnet/ASPNETMVCOverview.aspx

Implement a Cancel button while using Bindings, and send only an object's changes to a WCF service

2011-05-10T06:03:00.000-07:00

Take the following scenario: A user of your application opens a customer for editing. They put in a new address. Now they realize they're in the wrong customer entirely and want to cancel their changes.

What does your application do? If you're like me, then you are on a mission to keep code behind to an absolute minimum. You have two way bindings setup for everything. You're proud of all the C#/VB code that you haven't written in your application. So, your model is already updated. Do you not have a cancel button? Blame the user for the bad experience and tell them not to do that? Or did you add a reload method to your cancel button instead, forcing the application to grab data from a web service or a database?

Another possible option might have been to follow MVVM completely and to separate the Model from the ViewModel even on the most basic classes. The ViewModel could then store copies of this data and include methods to move back to the object and to reload data from the object. The downside here is that you need to add properties twice, and always remember to include them in your methods. This is a lot of code duplication.

Here's another predicament: You use a web service for your data source. You'd like to keep the data sent across the Internet to a minimum. But your class has 100+ properties. Sure, only one might have changed, but how do you know which ones have changed? Do you serialize the entire class to send it? Do you create 100 variables called OrgAddress, OrgName, etc?

I'd like to share a solution to both of these that has worked for me: A special base class.

Using the code

Let's introduce our class:

See full details: http://www.codeproject.com/KB/WCF/cancelbutton_changelist.aspx

Related links

WCF Chat Sample
Implement a Cancel button while using Bindings, and send only an object's changes to a WCF service
Send Cookies When Making WCF Service Calls
Hosting WCF in SharePoint 2010
WCF Architecture Overview
Getting Started Tutorial
WCF programming for Beginners
Returning Large Volume of Records from SOAP based WCF Service
Windows Communication Foundation
Windows Communication Foundation Architecture Overview
How to: Implement an Asynchronous Service Operation
Windows Communication Foundation Architecture Overview
A truely simple example to get started with WCF
What's New for WCF in Visual Studio 2008

Send Cookies When Making WCF Service Calls

2011-05-10T05:52:00.000-07:00

Introduction

This article presents an example on how to send cookies when making WCF service calls.

Background

Once in a while, you may find that you want to send some information in the form of "Cookies" to the server when making WCF calls. For example, if the WCF service is protected by a "Forms Authentication" mechanism, you will need to send the authentication cookie when making the WCF call to gain the required access to the service.

If you are calling a "REST" service using the "WebClient" class, this should not be a difficult task. You can simply work on the "CookieContainer" property of the "HttpWebRequest" class.
If you are calling a regular WCF service, and your client proxies are generated by the "Adding service reference" tool in the Visual Studio, the method to send cookies is not so obvious.

This article is to present an example on how to send cookies when making WCF calls using the Visual Studio generated client proxies.

The attached Visual Studio solution is developed in Visual Studio 2010. It has two projects:

The "WCFHost" is a simple ASP.NET MVC project that hosts the example WCF service.
The "WCFClient" is a simple WPF project. I will show you how to send cookies when calling WCF services in this project.

Let us start by first taking a look at the WCF service.

The WCF Service

The example WCF service is implemented in the "ServiceWithCookies.svc.cs" file in the "WCFHost" project.

See full details: http://www.codeproject.com/KB/WCF/WCFServiceCookie.aspx

ASP.net 4.0 Ajax

2011-05-09T11:47:00.000-07:00

jQuery Included with Web Forms and MVC

The Visual Studio templates for both Web Forms and MVC include the open-source jQuery library. When you create a new website or project, a Scripts folder containing the following 3 files is created:

jQuery-1.4.1.js – The human-readable, unminified version of the jQuery library.
jQuery-14.1.min.js – The minified version of the jQuery library.
jQuery-1.4.1-vsdoc.js – The Intellisense documentation file for the jQuery library.

Include the unminified version of jQuery while developing an application. Include the minified version of jQuery for production applications.

For example, the following Web Forms page illustrates how you can use jQuery to change the background color of ASP.NET TextBox controls to yellow when they have focus.

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

<!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>Show jQuery</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>

        <asp:TextBox ID="txtFirstName" runat="server" />
        <br />
        <asp:TextBox ID="txtLastName" runat="server" />
    </div>
    </form>
    <script src="Scripts/jquery-1.4.1.js" type="text/javascript"></script>

    <script type="text/javascript">

        $("input").focus( function() { $(this).css("background-color", "yellow"); });

    </script>
</body>
</html>

Content Delivery Network Support

The Microsoft Ajax Content Delivery Network (CDN) enables you to easily add ASP.NET Ajax and jQuery scripts to your Web applications. For example, you can start using the jQuery library simply by adding a

ASP.net 4.0 Core Services

2011-05-09T11:40:00.000-07:00

ASP.NET 4 introduces a number of features that improve core ASP.NET services such as output caching and session-state storage.

Web.config File Refactoring

The Web.config file that contains the configuration for a Web application has grown considerably over the past few releases of the .NET Framework as new features have been added, such as Ajax, routing, and integration with IIS 7. This has made it harder to configure or start new Web applications without a tool like Visual Studio. In .the NET Framework 4, the major configuration elements have been moved to the machine.config file, and applications now inherit these settings. This allows the Web.config file in ASP.NET 4 applications either to be empty or to contain just the following lines, which specify for Visual Studio what version of the framework the application is targeting:

<?xml version="1.0"?>
  <configuration>
   <system.web>
    <compilation targetFramework="4.0" />
   </system.web>
  </configuration>

Extensible Output Caching

Since the time that ASP.NET 1.0 was released, output caching has enabled developers to store the generated output of pages, controls, and HTTP responses in memory. On subsequent Web requests, ASP.NET can serve content more quickly by retrieving the generated output from memory instead of regenerating the output from scratch. However, this approach has a limitation — generated content always has to be stored in memory, and on servers that are experiencing heavy traffic, the memory consumed by output caching can compete with memory demands from other portions of a Web application.

ASP.NET 4 adds an extensibility point to output caching that enables you to configure one or more custom output-cache providers. Output-cache providers can use any storage mechanism to persist HTML content. This makes it possible to create custom output-cache providers for diverse persistence mechanisms, which can include local or remote disks, cloud storage, and distributed cache engines.

You create a custom output-cache provider as a class that derives from the newSystem.Web.Caching.OutputCacheProvider type. You can then configure the provider in the Web.config file by using the new providers subsection of the outputCache element, as shown in the following example:

<caching>
  <outputCache defaultProvider="AspNetInternalProvider">
    <providers>
      <add name="DiskCache"
          type="Test.OutputCacheEx.DiskOutputCacheProvider, DiskCacheProvider"/>
    </providers>
  </outputCache>

</caching>

By default in ASP.NET 4, all HTTP responses, rendered pages, and controls use the in-memory output cache, as shown in the previous example, where the defaultProvider attribute is set to AspNetInternalProvider. You can change the default output-cache provider used for a Web application by specifying a different provider name fordefaultProvider.

In addition, you can select different output-cache providers per control and per request. The easiest way to choose a different output-cache provider for different Web user controls is to do so declaratively by using the new providerName attribute in a control directive, as shown in the following example:

<%@ OutputCache Duration="60" VaryByParam="None" providerName="DiskCache" %>

Specifying a different output cache provider for an HTTP request requires a little more work. Instead of declaratively specifying the provider, you override the new GetOuputCacheProviderName method in theGlobal.asax file to programmatically specify which provider to use for a specific request. The following example shows how to do this.

public override string GetOutputCacheProviderName(HttpContext context)
{
    if (context.Request.Path.EndsWith("Advanced.aspx"))
       return "DiskCache";
    else
        return base.GetOutputCacheProviderName(context);
}

With the addition of output-cache provider extensibility to ASP.NET 4, you can now pursue more aggressive and more intelligent output-caching strategies for your Web sites. For example, it is now possible to cache the "Top 10" pages of a site in memory, while caching pages that get lower traffic on disk. Alternatively, you can cache every vary-by combination for a rendered page, but use a distributed cache so that the memory consumption is offloaded from front-end Web servers.

Auto-Start Web Applications

Some Web applications need to load large amounts of data or perform expensive initialization processing before serving the first request. In earlier versions of ASP.NET, for these situations you had to devise custom approaches to "wake up" an ASP.NET application and then run initialization code during the Application_Loadmethod in the Global.asax file.

A new scalability feature named auto-start that directly addresses this scenario is available when ASP.NET 4 runs on IIS 7.5 on Windows Server 2008 R2. The auto-start feature provides a controlled approach for starting up an application pool, initializing an ASP.NET application, and then accepting HTTP requests.

IIS Application Warm-Up Module for IIS 7.5

The IIS team has released the first beta test version of the Application Warm-Up Module for IIS 7.5. This makes warming up your applications even easier than previously described. Instead of writing custom code, you specify the URLs of resources to execute before the Web application accepts requests from the network. This warm-up occurs during startup of the IIS service (if you configured the IIS application pool as AlwaysRunning) and when an IIS worker process recycles. During recycle, the old IIS worker process continues to execute requests until the newly spawned worker process is fully warmed up, so that applications experience no interruptions or other issues due to unprimed caches. Note that this module works with any version of ASP.NET, starting with version 2.0.

For more information, see Application Warm-Up on the IIS.net Web site. For a walkthrough that illustrates how to use the warm-up feature, see Getting Started with the IIS 7.5 Application Warm-Up Module on the IIS.net Web site.

To use the auto-start feature, an IIS administrator sets an application pool in IIS 7.5 to be automatically started by using the following configuration in the applicationHost.config file:

<applicationpools>
  <add name="MyApplicationPool" startMode="AlwaysRunning" />
</applicationpools>

Because a single application pool can contain multiple applications, you specify individual applications to be automatically started by using the following configuration in the applicationHost.config file:

<sites>
  <site name="MySite" id="1">
    <application path="/"
      serviceAutoStartEnabled="true"
      serviceAutoStartProvider="PrewarmMyCache" >
      
    </application>
  </site>

</sites>

<serviceautostartproviders>
<add name="PrewarmMyCache"
type="MyNamespace.CustomInitialization, MyLibrary" />
</serviceautostartproviders>

When an IIS 7.5 server is cold-started or when an individual application pool is recycled, IIS 7.5 uses the information in the applicationHost.config file to determine which Web applications need to be automatically started. For each application that is marked for auto-start, IIS7.5 sends a request to ASP.NET 4 to start the application in a state during which the application temporarily does not accept HTTP requests. When it is in this state, ASP.NET instantiates the type defined by the serviceAutoStartProvider attribute (as shown in the previous example) and calls into its public entry point.

You create a managed auto-start type with the necessary entry point by implementing theIProcessHostPreloadClient interface, as shown in the following example:

public class CustomInitialization : System.Web.Hosting.IProcessHostPreloadClient
{
  public void Preload(string[] parameters)
  {
    // Perform initialization.
  }
}

After your initialization code runs in the Preload method and the method returns, the ASP.NET application is ready to process requests.

With the addition of auto-start to IIS .5 and ASP.NET 4, you now have a well-defined approach for performing expensive application initialization prior to processing the first HTTP request. For example, you can use the new auto-start feature to initialize an application and then signal a load-balancer that the application was initialized and ready to accept HTTP traffic.

Permanently Redirecting a Page

It is common practice in Web applications to move pages and other content around over time, which can lead to an accumulation of stale links in search engines. In ASP.NET, developers have traditionally handled requests to old URLs by using by using the Response.Redirect method to forward a request to the new URL. However, theRedirect method issues an HTTP 302 Found (temporary redirect) response, which results in an extra HTTP round trip when users attempt to access the old URLs.

ASP.NET 4 adds a new RedirectPermanent helper method that makes it easy to issue HTTP 301 Moved Permanently responses, as in the following example:

RedirectPermanent("/newpath/foroldcontent.aspx");

Search engines and other user agents that recognize permanent redirects will store the new URL that is associated with the content, which eliminates the unnecessary round trip made by the browser for temporary redirects.

Shrinking Session State

ASP.NET provides two default options for storing session state across a Web farm: a session-state provider that invokes an out-of-process session-state server, and a session-state provider that stores data in a Microsoft SQL Server database. Because both options involve storing state information outside a Web application's worker process, session state has to be serialized before it is sent to remote storage. Depending on how much information a developer saves in session state, the size of the serialized data can grow quite large.

ASP.NET 4 introduces a new compression option for both kinds of out-of-process session-state providers. When the compressionEnabled configuration option shown in the following example is set to true, ASP.NET will compress (and decompress) serialized session state by using the .NET FrameworkSystem.IO.Compression.GZipStream class.

<sessionState
  mode="SqlServer"
  sqlConnectionString="data source=dbserver;Initial Catalog=aspnetstate"
  allowCustomSqlDatabase="true"
  compressionEnabled="true"
/>

With the simple addition of the new attribute to the Web.config file, applications with spare CPU cycles on Web servers can realize substantial reductions in the size of serialized session-state data.

Expanding the Range of Allowable URLs

ASP.NET 4 introduces new options for expanding the size of application URLs. Previous versions of ASP.NET constrained URL path lengths to 260 characters, based on the NTFS file-path limit. In ASP.NET 4, you have the option to increase (or decrease) this limit as appropriate for your applications, using two new httpRuntimeconfiguration attributes. The following example shows these new attributes.

<httpRuntime maxRequestPathLength="260" maxQueryStringLength="2048" />

To allow longer or shorter paths (the portion of the URL that does not include protocol, server name, and query string), modify the maxRequestPathLength attribute. To allow longer or shorter query strings, modify the value of the maxQueryStringLength attribute.

ASP.NET 4 also enables you to configure the characters that are used by the URL character check. When ASP.NET finds an invalid character in the path portion of a URL, it rejects the request and issues an HTTP 400 error. In previous versions of ASP.NET, the URL character checks were limited to a fixed set of characters. In ASP.NET 4, you can customize the set of valid characters using the new requestPathInvalidChars attribute of thehttpRuntime configuration element, as shown in the following example:

<httpRuntime requestPathInvalidChars="<,>,*,%,&,:,\,?" />

By default, the requestPathInvalidChars attribute defines eight characters as invalid. (In the string that is assigned to requestPathInvalidChars by default, the less than (<), greater than (>), and ampersand (&) characters are encoded, because the Web.config file is an XML file.) You can customize the set of invalid characters as needed.

Note ASP.NET 4 always rejects URL paths that contain characters in the ASCII range of 0x00 to 0x1F, because those are invalid URL characters as defined in RFC 2396 of the IETF (http://www.ietf.org/rfc/rfc2396.txt). On versions of Windows Server that run IIS 6 or higher, the http.sys protocol device driver automatically rejects URLs with these characters.

Extensible Request Validation

ASP.NET request validation searches incoming HTTP request data for strings that are commonly used in cross-site scripting (XSS) attacks. If potential XSS strings are found, request validation flags the suspect string and returns an error. The built-in request validation returns an error only when it finds the most common strings used in XSS attacks. Previous attempts to make the XSS validation more aggressive resulted in too many false positives. However, customers might want request validation that is more aggressive, or conversely might want to intentionally relax XSS checks for specific pages or for specific types of requests.

In ASP.NET 4, the request validation feature has been made extensible so that you can use custom request-validation logic. To extend request validation, you create a class that derives from the newSystem.Web.Util.RequestValidator type, and you configure the application (in the httpRuntime section of theWeb.config file) to use the custom type. The following example shows how to configure a custom request-validation class:

<httpRuntime requestValidationType="Samples.MyValidator, Samples" />

The new requestValidationType attribute requires a standard .NET Framework type identifier string that specifies the class that provides custom request validation. For each request, ASP.NET invokes the custom type to process each piece of incoming HTTP request data. The incoming URL, all the HTTP headers (both cookies and custom headers), and the entity body are all available for inspection by a custom request validation class like that shown in the following example:

public class CustomRequestValidation : RequestValidator
{
  protected override bool IsValidRequestString(
      HttpContext context, string value, 
      RequestValidationSource requestValidationSource, 
      string collectionKey, 
      out int validationFailureIndex) 
    {...}
 }

For cases where you do not want to inspect a piece of incoming HTTP data, the request-validation class can fall back to let the ASP.NET default request validation run by simply calling base.IsValidRequestString.

Object Caching and Object Caching Extensibility

Since its first release, ASP.NET has included a powerful in-memory object cache (System.Web.Caching.Cache). The cache implementation has been so popular that it has been used in non-Web applications. However, it is awkward for a Windows Forms or WPF application to include a reference to System.Web.dll just to be able to use the ASP.NET object cache.

To make caching available for all applications, the .NET Framework 4 introduces a new assembly, a new namespace, some base types, and a concrete caching implementation. The new System.Runtime.Caching.dllassembly contains a new caching API in the System.Runtime.Caching namespace. The namespace contains two core sets of classes:

Abstract types that provide the foundation for building any type of custom cache implementation.
A concrete in-memory object cache implementation (the System.Runtime.Caching.MemoryCache class).

The new MemoryCache class is modeled closely on the ASP.NET cache, and it shares much of the internal cache engine logic with ASP.NET. Although the public caching APIs in System.Runtime.Caching have been updated to support development of custom caches, if you have used the ASP.NET Cache object, you will find familiar concepts in the new APIs.

An in-depth discussion of the new MemoryCache class and supporting base APIs would require an entire document. However, the following example gives you an idea of how the new cache API works. The example was written for a Windows Forms application, without any dependency on System.Web.dll.

private void btnGet_Click(object sender, EventArgs e) 
{ 
  //Obtain a reference to the default MemoryCache instance. 
  //Note that you can create multiple MemoryCache(s) inside 
  //of a single application. 
  ObjectCache cache = MemoryCache.Default; 
  
  //In this example the cache is storing the contents of a file string 
  fileContents = cache["filecontents"] as string;
  
  //If the file contents are not currently in the cache, then 
  //the contents are read from disk and placed in the cache. 
  if (fileContents == null) 
  {
    //A CacheItemPolicy object holds all the pieces of cache 
    //dependency and cache expiration metadata related to a single 
    //cache entry. 
    CacheItemPolicy policy = new CacheItemPolicy(); 
    
    //Build up the information necessary to create a file dependency. 
    //In this case we just need the file path of the file on disk. 
    List filePaths = new List(); 
    filePaths.Add("c:\\data.txt"); 
    
    //In the new cache API, dependencies are called "change monitors". 
    //For this example we want the cache entry to be automatically expired 
    //if the contents on disk change. A HostFileChangeMonitor provides 
    //this functionality. 
    policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths)); 
    
    //Fetch the file's contents 
    fileContents = File.ReadAllText("c:\\data.txt"); 
    
    //And then store the file's contents in the cache 
    cache.Set("filecontents", fileContents, policy); 
    
  } 
  MessageBox.Show(fileContents); 
}

Extensible HTML, URL, and HTTP Header Encoding

In ASP.NET 4, you can create custom encoding routines for the following common text-encoding tasks:

HTML encoding.
URL encoding.
HTML attribute encoding.
Encoding outbound HTTP headers.

You can create a custom encoder by deriving from the new System.Web.Util.HttpEncoder type and then configuring ASP.NET to use the custom type in the httpRuntime section of the Web.config file, as shown in the following example:

<httpRuntime encoderType="Samples.MyCustomEncoder, Samples" />

After a custom encoder has been configured, ASP.NET automatically calls the custom encoding implementation whenever public encoding methods of the System.Web.HttpUtility or System.Web.HttpServerUtility classes are called. This lets one part of a Web development team create a custom encoder that implements aggressive character encoding, while the rest of the Web development team continues to use the public ASP.NET encoding APIs. By centrally configuring a custom encoder in the httpRuntime element, you are guaranteed that all text-encoding calls from the public ASP.NET encoding APIs are routed through the custom encoder.

Performance Monitoring for Individual Applications in a Single Worker Process

In order to increase the number of Web sites that can be hosted on a single server, many hosters run multiple ASP.NET applications in a single worker process. However, if multiple applications use a single shared worker process, it is difficult for server administrators to identify an individual application that is experiencing problems.

ASP.NET 4 leverages new resource-monitoring functionality introduced by the CLR. To enable this functionality, you can add the following XML configuration snippet to the aspnet.config configuration file.

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
  <runtime>
    <appDomainResourceMonitoring enabled="true"/>
  </runtime>

</configuration>

Note The aspnet.config file is in the directory where the .NET Framework is installed. It is not theWeb.config file.

When the appDomainResourceMonitoring feature has been enabled, two new performance counters are available in the "ASP.NET Applications" performance category: % Managed Processor Time and Managed Memory Used. Both of these performance counters use the new CLR application-domain resource management feature to track estimated CPU time and managed memory utilization of individual ASP.NET applications. As a result, with ASP.NET 4, administrators now have a more granular view into the resource consumption of individual applications running in a single worker process.

Multi-Targeting

You can create an application that targets a specific version of the .NET Framework. In ASP.NET 4, a new attribute in the compilation element of the Web.config file lets you target the .NET Framework 4 and later. If you explicitly target the .NET Framework 4, and if you include optional elements in the Web.config file such as the entries for system.codedom, these elements must be correct for the .NET Framework 4. (If you do not explicitly target the .NET Framework 4, the target framework is inferred from the lack of an entry in theWeb.config file.)

The following example shows the use of the targetFramework attribute in the compilation element of theWeb.config file.

<compilation targetFramework="4.0"/>

Note the following about targeting a specific version of the .NET Framework:

In a .NET Framework 4 application pool, the ASP.NET build system assumes the .NET Framework 4 as a target if the Web.config file does not include the targetFramework attribute or if the Web.config file is missing. (You might have to make coding changes to your application to make it run under the .NET Framework 4.)

If you do include the targetFramework attribute, and if the system.codeDom element is defined in theWeb.config file, this file must contain the correct entries for the .NET Framework 4.

If you are using the aspnet_compiler command to precompile your application (such as in a build environment), you must use the correct version of the aspnet_compiler command for the target framework. Use the compiler that shipped with the .NET Framework 2.0 (%WINDIR%\Microsoft.NET\Framework\v2.0.50727) to compile for the .NET Framework 3.5 and earlier versions. Use the compiler that ships with the .NET Framework 4 to compile applications created using that framework or using later versions.

At run time, the compiler uses the latest framework assemblies that are installed on the computer (and therefore in the GAC). If an update is made later to the framework (for example, a hypothetical version 4.1 is installed), you will be able to use features in the newer version of the framework even though thetargetFramework attribute targets a lower version (such as 4.0). (However, at design time in Visual Studio 2010 or when you use the aspnet_compiler command, using newer features of the framework will cause compiler errors).

ASP.NET URL Rewriting with HttpHandler

2011-05-08T15:44:00.000-07:00

Most of the time when we start learning something or doing something we get the first question that how does it helps? Or where I can use in the real world?

Same thing goes in this technique as well. What are URL rewriting first of all then what is routing engine? Let us see some real issues in our code.

A. Case 1
One day you had a URL book marked as Http://abc.com/main/1.aspx. But now it is moved to Http://xyz.com/main/1.aspx, will it work now, no. But as a web site developer or architect how you will manages these kinds of broken links in web sites.

B. Case 2
Suppose we have two servers where each server has hosted with 50 pages. But all the links have to be made available for both web sites. How do we handle this situation?

C. Case 3

A website restructuring caused all of the Web pages in the /Admin/ directory to be moved to a /finance/Admin/ directory, you would want to use URL rewriting to check if a Web request was intended for a file in the /Admin/ directory. The request automatically should redirect the request to the same file, but in the /finance/Admin/ directory instead.

And there are many more, so how do we handle all these scenarios. In classic ASP ages, it was very difficult to handle these scenarios, where we suppose to play with the ISAPI filters. Off course some third party software's. In ASP.NET Http Modules to handle all these using URL Rewriting as an another option.

I. ASP.NET URL Rewriting
By using URL rewriting, we can intercept an incoming Web request and redirecting the request to a different resource page. When performing URL rewriting, typically the URL being requested is checked and, based on its value, the request is redirected to a different URL.
Please refer to my last post for what happens when request comes to IIS or Scott Mitchell blogs or books from Dino Esposito you will really love them. And it is must to understand this post.

II. Implementing URL Rewriting

In olden days URL rewriting was implemented with ISAPI filters at the IIS Web server level or some third party software's, which we are not going talk here. Our main focus is how to implement in ASP.NET. So, in ASP.NET URL rewriting can be implemented by using HTTP modules at the ASP.NET level.

Using Http Modules by utilize the HttpContext object RewritePath () method. Here I am not going to explain the HttpApplication or HttpContext assuming that you have read my last post. But can tell one thing that; HttpContext class contains information about a specific HTTP request that is received by the IIS. An HttpContext instance is created for that request. This object contains properties to access the intrinsic object like Request, Response which in turn access to Application, Session and User objects.

III. URL Rewriting with Built in HTTP Modules
We can use out of the box Http Modules to perform the URL rewriting. Let us understand what are they and which event they are tied to in IHttpHandler. Let us see some of the out of the modules that we use day to day, yes we are working with the models, don't say that I never worked on Http Modules.

1. FormsAuthenticationModule
This module sets the identity of the user (to an IPrincipal) in the HttpContext for an ASP.NET application when forms authentication is enabled. FormsAuthenticationModule exposes AuthenticateRequest event. Where we can check the user is authenticated or not. If not redirect to a login page. Usually what we do use is Response.Redirect() but Context.RewritePath() method is also good option
        void FormsAuthentication_OnAuthenticate(object sender, FormsAuthenticationEventArgs args)
        {
            if (FormsAuthentication.Authenticate("a", "a") != true)
            {
                Context.RewritePath("WebForm2.aspx");
            }        }

So how we implement in HttpModule is
namespace Chinna.SampleModules
{
    public class SampleModule : IHttpModule    {
        public void Dispose()
        { }
        public void Init(HttpApplication context)
        {
            context.AuthorizeRequest += new EventHandler(OnAuthorizeRequest);
        }
        void OnAuthenticate(object sender, EventArgs e)
        {
            HttpApplication app = (HttpApplication)sender;
            app.Context.RewritePath("WebForm1.aspx");
        }
    }
}

2. FileAuthorizationMoudle

When using Windows authentication, This HTTP module checks to ensure that the user account has adequate rights for the resource requested, and provides authorization services against file-system access-control lists (ACLs). Check the following code
            IntPtr userToken = System.Security.Principal.WindowsIdentity.GetCurrent().Token;
            if (FileAuthorizationModule.CheckFileAccessForUser("~/WebForm1.aspx", userToken, "GET") == true)
                Response.Write("You have access !!");
            else                Context.RewritePath("WebForm2.aspx");

So how we implement in HttpModule is
namespace Chinna.SampleModules
{public class SampleModule : IHttpModule{public void Dispose()
{}public void Init(HttpApplication context)
{
context.AuthorizeRequest += new EventHandler(OnAuthorizeRequest); }void OnAuthorizeRequest(object sender, EventArgs e)
{HttpApplication app = (HttpApplication)sender;
app.Context.RewritePath("WebForm1.aspx");
}
}}

3. UrlAuthorizationModule

The UrlAuthorizationModule determines whether the current user is permitted access to the requested URL. You can allow or deny a user or a role using allow or deny subelements in Authorization config element in the web.config, respectively.

Allow and deny subelements are interpreted in the order they appear in the configuration. Once an element specifies that access is allowed or denied, the UrlAuthorizationModule completes its authorization check. For example, the following authorization section from a Web.config file requires users to log on (by denying anonymous users), and then allows only users in the Administrators role to have access. Users not in the Administrators role are denied.

For example: The following code example grants access to Chinna and members of the Admins role, while denying it to Rick and all anonymous users.

See full details: http://www.c-sharpcorner.com/UploadFile/chinnasrihari/3180/

Basic concept and fundamentals of ASP.NET MVC (Model View Controller) Architecture

2011-05-07T11:55:00.000-07:00

This is basic concepts and fundamentals of ASP.NET Model View Controller (MVC) architecture workflow.

MVC is stands for MODEL VIEW CONTROLLER. ASP.NET MVC is an architecture to develop ASP.NET web applications in a different manner than the traditional ASP.NET web development. Web applications developed with ASP.NET MVC are even more SEO (Search Engine) friendly.

Microsoft .Net Framework 3.5 is minimum requirement to develop ASP.net MVC application.

MVC (Model View Controller) Interaction with Browser

Like a normal web server interaction, MVC application also accepts requests and responds to the web browser in the same way.

Inside MVC Architecture

The entire ASP.NET MVC architecture is based on Microsoft .NET Framework 3.5 and in addition uses LINQ to SQL Server.

What is a Model?

MVC model is basically a C# or VB.NET class
A model is accessible by both controller and view
A model can be used to pass data from Controller to view
A view can use model to display data in page.

What is a View?

View is an ASPX page without having a code behind file
All page specific HTML generation and formatting can be done inside view
One can use Inline code (server tags ) to develop dynamic pages
A request to view (ASPX page) can be made only from a controller’s action method

What is a Controller?

Controller is basically a C# or VB.NET class which inherits system.mvc.controller
Controller is a heart of the entire MVC architecture
Inside Controller’s class action methods can be implemented which are responsible for responding to browser OR calling views.
Controller can access and use model class to pass data to views
Controller uses ViewData to pass any data to view

MVC File Structure & File Naming Standards

MVC uses a standard directory structure and file naming standards which are a very important part of MVC application development.

Inside the ROOT directory of the application, there must be 3 directories each for model, view and Controller.

Apart from 3 directories, there must have a Global.asax file in root folder, and a web.config like a traditional ASP.NET application.

Root [directory]

Controller [directory]

Controller CS files

Models [directory]

Model CS files

Views [directory]

View CS files

Global.asax
Web.config

ASP.NET MVC Execution Life Cycle

Here is how MVC architecture executes the requests to browser and objects interactions with each other.

A step by step process is explained below [Refer to the figure as given below]:

Browser Request (Step 1)

Browser request happens with a specific URL. Let’s assume that the user enters URL like: [xyz.com]/home/index/

Job of Global.asax – MVC routing (Step 2)

The specified URL will first get parsed via application_start() method inside Global.asax file. From the requested URL, it will parse the Controller, Action and ID.

So for [xyz.com]/home/index/:

Controller = home
Action = index()
ID = empty — we have not specified ID in [xyz.com]/home/index/, so it will consider as empty string

Controller and Action methods (Step 3)

MVC now finds the home controller class in controller directory. A controller class contains different action methods,

There can be more than one action method, but MVC will only invoke the action method which has been parsed from the URL, its index() in our case.

So something like: homeController.index() will happen inside MVC controller class.

Invoking action method can return plain text string OR rendered HTML by using view.

Call to View (Step 4)

Invoking view will return view(). A call to view will access the particular ASPX page inside the view directory and generate the rendered HTML from the ASPX and will respond back to the browser.

In our case, controller was home and action was index(). So calling view() will return a rendered HTML from the ASPX page located at/views/home/index.aspx.

MVC Architecture Model In ASP.NET

2011-04-08T02:07:00.000-07:00

When developing ASP.NET applications the need of reducing code duplication increases along with their complexity. This is because testing and performing changes become very difficult tasks when having many different sources of code with the same functionality.

Model View Controller architecture (or pattern) allows us to separate different parts of our applications into tiers to fulfill this need.

MVC Overview

Model View Controller architecture aims to separate an application into three parts:
Model: It is the business logic of an application. From an object oriented perspective it would consist of a set of classes that implement the critical functionality of an application from a business point of view.
View: It can consist of every type of interface given to the user. In ASP.NET the view is the set of web pages presented by a web application.
Controller: This part of the architecture is the most difficult to explain, hence the most difficult to implement in many platforms. The controller is the object that allows the manipulation of the view. Usually many applications implement Model-Controller tiers that contain the business logic along with the necessary code to manipulate a user interface. In an ASP.NET application the controller is implicitly represented by the code-behind or the server side code that generates the HTML presented to the user.

Implementing MVC in ASP.NET

A basic diagram that would help us understand perfectly the specific parts that implement the Model View Controller architecture in an ASP.NET application is presented below:

MVC Model Implementation

When implementing the business logic of an application it is a must to use a Class Library project in order to generate a .dll file that will encapsulate all the functionality. This is critical as we as professional developers would not like to jeopardize the source code of a software product by placing the actual .cs files as a reference in a web application.
This type of project can be easily created in Visual Studio 2005 under the Visual C# or Visual Basic tabs:

As a tutorial example we will develop a simple calculator under a new namespace we will call "Math".
Once the project is created we will add a class called Calculator:

As the code is very simple and a sample is provided in this tutorial we will not get into much detail as far as how it is developed. The only important thing we need to mention is the way errors have to be handled in this class. Take a look at the following code:
1. protected float Divide(float fNumber1, float fNumber2)
2. {
3.   if (fNumber2 == 0)
4.  {
5.           throw new Exception( "Second number cannot be equal to zero.");
6.    }
7.   return (fNumber1 / fNumber2);
8. }

When implementing the Divide function we need to ensure that the user would not be able to set the "fNumber2" parameter (line 1) to zero as a division between zero does not exist. The validation statement in lines 3-6 takes care of this case but the important fact we need to notice is that this class will NEVER use specific methods to present errors like message boxes or writing into labels. Errors captured in the model part of the architecture ALWAYS have to be presented in the form of exceptions (line 5). This will allow us to use this object in several types of applications like ASP.NET applications, Windows applications, Web services, etc.
Once we have finished coding our Calculator class the project has to be built in order to get the .dll file we will use in our Web application.

MVC View-Controller Implementation

The View and the Controller objects will be implemented by using a common ASP.NET Website. Once we have created our project we need to add the reference to the .dll file we created before.
The option to do this can be found in the context menu when right-clicking the project in the solution explorer:

We can find the file in the path "\bin\Release" (or "\bin\Debug" depending on how you build your class library) inside our main folder containing the math class library project:

Once we have referenced our library we will create a simple web page that will allow us to choose between the four basic arithmetic operations and type two different numbers to operate.
The web page will look like this:

In the code behind we need to reference the Math namespace in order to use our Calculator class. The following statement will do that:
using Math;
As the code for this application is also simple we will only explain the method called when the "Operate!" button is clicked:
1. protected void btnOperate_Click(object sender, EventArgs e)
2. {
3.   if (pbValidateNumbers())
4.   {
5.        Calculator cOperator = new Calculator();
6.         try
7.         {
8.               txtResult.Text = cOperator.Operate(float.Parse(txtNumber1.Text.Trim()),float.Parse(txtNumber2.Text.Trim()), Convert.ToInt16(rblOperations.SelectedValue)).ToString();
9.               lbError.Text = "";
10.        }
11.        catch (Exception ex)
12.        {
13.              txtResult.Text = "";
14.              lbError.Text = ex.Message;
15.        }
16.  }
17.}
In line 3 we call the bool function "pbValidateNumbers" that will return true if the numbers typed in both textboxes are valid. These types of validations have to be performed by the controller object as they allow the interface to work properly and have nothing to do with the business logic.
In line 5 we create an instance of our Calculator class so we can perform the arithmetic operation. We call the method "Operate" (line 8) and return the value in another textbox. An important thing to mention is that we have to use a try-catch statement (lines 6-15) to handle any exception that could be thrown by our method "Operate" as every error caught in our Calculator class is handled by throwing a "digested" exception that is readable to the user.
In the code above we can appreciate how well encapsulated the business logic is, hence it can be reused in several applications without having to code it again.

Advantages of using MVC in ASP.NET

See full details: http://www.beansoftware.com/ASP.NET-Tutorials/MVC-Architecture-Model.aspx

LINQ Query Syntax Tutorial

2011-03-25T06:12:00.000-07:00

Probably the most exciting new feature of LINQ is the ability to write in line SQL style queries, known as query expressions (using query syntax). This tutorial introduces the basic concepts, and comes complete with source code and demo applications.

What is LINQ Query Syntax?

LINQ query syntax is a set of query keywords built into the .NET framework (3.5 and higher) that allow the developer to write SQL style commands in line straight in the code editor, without the use of quotes.

Introduction

The .NET framework 3.5 introduces us to the following query keywords;

from / in - Specifies the data source
where - Conditional boolean expression (e.g. i == 0)
orderby (ascending/descending) - Sorts the results into ascending or descending order
select - Adds the result to the return type
group / by - Groups the results based on a given key

There are more keywords that provide additional functionality, but they are outside the scope of this tutorial.

Writing your first query

The quickest easiest way to learn how to write query expressions is to go right ahead and just do it.

This tutorial assumes that we have the following Generic List, called "Characters", present in our project;

private readonly List<Character> Characters = new List<Character>

{

//Format: Character Name, Gender, Number of episodes

new Character("Charlie", Gender.Male, 162),

new Character("Alan", Gender.Male, 162),

new Character("Berta", Gender.Female, 117),

new Character("Jake", Gender.Male, 162),

new Character("Evelyn", Gender.Female, 78),

new Character("Judith", Gender.Female, 69)

};

Note: The Character class above is just a trivial class containing a string, enum and integer. You could do this same example with any data types.

Here is our first example;

IEnumerable<Character> results = from character in Characters

where character.Episodes > 120

select character;

Ok, lets just take a closer look;

from character in Characters

where character.Episodes > 120

select character;

We have three things going on here;

Specify the data source (Characters) and a temporary variable for each element within the data source (in this case a Generic List)
Create a condition with a boolean result used to query the data source
If the condition is met, select the temporary variable and add it to our results collection (IEnumerable)

The above statement returns a list of all the "characters" whom have appeared in more than 120 episodes. We can then use a foreach loop to iterate through the list of results and do whatever we need to do.

This is a good example of a basic LINQ query expression. We can also do more interesting things like;

Make our conditions as complicated as we need;

where character.Episodes > 120 && character.Episodes < 200

Order our results list in Ascending or Descending keywords;

from character in Characters

where character.Episodes > 120

orderby character.Name ascending

select character;

And even group the results;

from character in Characters

where character.Episodes > 0

group character by character.Episodes;

The demo project/source code available at the top of the page shows these scenarios in action.

Mixing Query Syntax and Extension Methods

The System.Linq namespace also gives us the ability to to use LINQ's built in extension methods on the results of our query expressions. For example, instead of storing the results of the query in a variable and then calling the Count extension method and storing the result in another variable, we can just do it all right on a single line;

int count = (from character in Characters

where character.Episodes > 120

select character).Count();

All we need to do to achieve this is wrap our expression in parenthesis.

See full details: http://www.c-sharpcorner.com/UploadFile/jonpreecebsc/3853/

Performance Tips of WPF

2011-02-23T12:49:00.000-08:00

WPF (Windows Presentation Foundation) provides a very easy way to develop rich user experiences. A drop shadow for example can added by inserting two simple lines of XML. But this simplicity can also mislead us to overuse them. This leads to performance issues. The following tips may help you to fix or avoid them.

1. Reduce the number of visuals by removing unneeded elements, combining layout panels and simplifying templates. This keeps the memory footprint small and improves the rendering performance.

2. Lower the framerate of animations by setting Storyboard.DesiredFrameRate to lower the CPU load. The default is 60 frames/second

3. Load resources when needed. Even thow it's the most comfortable way to merge all resources on application level it can also cost performance by loading all resources at startup. A better approach is to load only often used resources and load the other on view level.

4. Enable Container Recycling. Virtualization brings a lot of performance improvements, but the containers will be disposed and re created, this is the default. But you can gain more performance by recycle containers by setting VirtualizingStackPanel.VirtualizationMode="Recycling"

5. Disable Assembly localization if you don't need it. By using the [NeutralResourcesLanguageAttribute]. This prevents an expensive lookup for satelite assemblies

6. Dispatch expensive calls either within the UI thread with a lower DispatcherPriority by calling Dispatcher.BeginInvoke() or to a background thread by using a BackgroundWorker to keep the UI responsive.

7. Use StreamGeometries instead of PathGeometries if possible to draw complex 2D geometries, because they are much more efficient and consume less memory.

8. Prevent Software Rendering. The use of transparent windows by setting AllowsTransparency to true or using old BitmapEffects can cause WPF to render the UI in software on Windows XP, which is much slower.

9. Fix binding errors because they consume a lot of time, trying to resolve the path error, including searching for attached properties. You can find them by looking for System.Windows.Data Error in the Visual Studio output log.

10. Freeze Freezables by calling Freeze() in code or PresentationOptions:Freeze="true" in XAML. This reduces memory consumption and improves performance, because the system don't need to monitor for changes.

11. Virtualize lists and views by using a VirtualizingStackPanel as ItemsPanel for lists. This only creates the visible elements at load time. All other elements are lazy created when they get visible. Be aware that grouping or CanContextScrol="True" prevents virtualization!