Prawinway... small work arounds !!!!!!!!!!!!!!!!!!

Basics and sample example of Language Integrated Query –(LINQ to Dataset)

2010-02-02T08:31:00.001-08:00

Few Best Feature

Write query against in memory collection other quenchable sources using any . NET Language

Using LINQ to SQL we can directly write Db related queries in the code itself

We can write Data Access Code for XML using LINQ to XML

We can write common data access provider against different data source using LINQ to ENTITIES

We can write reach Queries against data using LINQ to DATASET

Simplicity:

simplify the data access code and maintainability of code

Query data in any .NET Programming Language:

we can write LINQ queries in the programming languages in stead of learning SQL dialect

ex – var employee = from emp in

tblemployee

where dept = 'sales'

select emp

Strongly Typed Object in our Data access code

Query against strongly typed data objects easily. Write data access code in object oriented manner as used in the rest of the application

Productivity

Increase productivity, reduce runtime errors by using strongly typed objects instead of traditional SQL queries

Optimize Development Efforts

Become more productive and optimize the overall development efforts by using the consistent query language for all aspect of the application

Reduce Bugs and Errors

Work with strongly typed CLR Objects that reduce runtime errors in the application, identify query related errors at the compile time and reduce the debugging efforts by using strongly typed objects

Be more productive with the visual studio

Flexibility

Use of consistent LINQ syntax across all data source. Use LINQ with any data source

LINQ to SQL, LINQ to DATASET, LINQ to XML and LINQ to Entities

LINQ Query

LINQ query consist of the Three part of the query operations

Obtain the data source
Create the query
Execute query

// The Three Parts of a LINQ Query:

// 1. Data source.

int[] numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };

// 2. Query creation.

// Array implicitly supports the generic IEnumerable<T> interface

// numQuery is an IEnumerable<int>

var numQuery =

from num in numbers

where (num % 2) == 0

select num;

// 3. Query execution.

foreach (int num in numQuery)

{

Console.Write("{0,1} ", num);

}

Developer who writes queries, most visible language integrated part of LINQ is the Query Expression, which is written in the declarative syntax, by using query syntax we can perform complex filtering, ordering and grouping operations on different data sources with minimum code.

Variable in query expression is strongly typed, although in many cases we don't need to provide type explicitly

LINQ queries can be written as Query Syntax and Method syntax

Most queries in the LINQ documentation are written in the query syntax however the CLR does not have any notion for query syntax itself therefore during compilation query expression are converted into something that CLR can understand These methods are called standard query operators, and they have names such as Where, Select, GroupBy, Join, Max, Average, and so on. You can call them directly by using method syntax instead of query syntax.

In general query syntax is preferred over the method syntax coz is is usually more simpler and can understand easily but in fact there is no semantic difference in between the query syntax and the method syntax there are some operation such as number of element that matched the specified condition, maximum value in the data source can be expressed only as the method syntax.

Query Expression syntax and Method syntax LINQ Query

int[] numbers = { 5, 10, 8, 3, 6, 12};

//Query syntax:

IEnumerable<int> numQuery1 =

from num in numbers

where num % 2 == 0

orderby num

select num;

//Method syntax:

IEnumerable<int> numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n => n);

foreach (int i in numQuery1)

{

Console.Write(i + " ");

}

Console.WriteLine(System.Environment.NewLine);

foreach (int i in numQuery2)

{

Console.Write(i + " ");

}

// Keep the console open in debug mode.

Console.WriteLine(System.Environment.NewLine);

Console.WriteLine("Press any key to exit");

Console.ReadKey();

Output:

6 8 10 12

output from the above two example is same.

To understand the query based syntax is very easy.

Now we will poke up in the Method based syntax

on the right side of the query expression where clause is expressed as the instance method on the numbers object like numbers.Where, here we will find the the where which is not the default method found on array but infact this is the extension method The standard query operators(like Where/Select/SelectMany/Join / and Orderby) are implemented as a new kind of method called extension methods. Extensions methods "extend" an existing type; they can be called as if they were instance methods on the type.

Lambda Expressions

In method syntax conditional expression (num % 2 == 0) is passed as Where(num => num % 2 == 0) This inline expression is called as Lambda Expression

This is the conveient way of writing the code otherwise which will be written in the cumbersome manner as anonymous method, generic expression or expression tree.

The symbaol (=>) read as GOES TO

num on the left side of the operator is the input body of the lambda is just same as the query expression or it can include any other complex logic return value is just expression result.

Query Exceution

Deferred Execution

In LINQ the excutio of query is different than the query itself.we will not receive any data by just creating the query variable.

Each query is not executable until we iterate over the query variable over foreach loop

A query is executed in a foreach statement, and foreach requires IEnumerable or IEnumerable<(Of <(T>)>). Types that support IEnumerable<(Of <(T>)>) or a derived interface such as the generic IQueryable<(Of <(T>)>) are called queryable types.

Because the query variable itself never holds the query results, you can execute it as often as you like. For example, you may have a database that is being updated continually by a separate application. In your application, you could create one query that retrieves the latest data, and you could execute it repeatedly at some interval to retrieve different results every time.

Forcing Immediate Execution

Queries that perform aggregation functions over a range of source elements must first irate through the source elements Queries such as Count, Max, Average, First These execute without the explicit foreach statement bcoz the query itself must use the foreach to return the resulted single value like this

var evenNumQuery =

from num in numbers

where (num % 2) == 0

select num;

int evenNumCount = evenNumQuery.Count();

to force immediate execution of any query and cache its result we can use ToList(TSource) or ToArray(TSource) methods like below

List<int> numQuery2 =

(from num in numbers

where (num % 2) == 0

select num).ToList();

// or like this:

// numQuery3 is still an int[]

var numQuery3 =

(from num in numbers

where (num % 2) == 0

select num).ToArray();

We can also force execution by putting the foreach loop immediately after the query expression. However, by calling ToList or ToArray We can also cache all the data in a single collection object.

Some RnD with LINQ to Dataset. Following example which is the simple empty aspx page to test the normal functionality of the LINQ. This is done as a part of digging the practice carried out by me to test the various simple aspect of the LINQ coding.

Following is the code behind code of the empty aspx page which we can use to test LINQ functionality on the fly along with the few basics mentioned in the c

using System;

using System.Configuration;

using System.Data;

using System.Reflection;

using System.Linq;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.HtmlControls;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

using System.Xml.Linq;

using System.Text;

using System.Collections.Generic;

public partial class _Default : System.Web.UI.Page

{

protected void Page_Load(object sender, EventArgs e)

{

FewBasicsofLinq();

LessThanGreaterThanTest();

DataSet ds = CreateSampleDataset();

SimpleWhereCondition(ds);

LinqtoObjectTest(ds);

FieldTExample(ds);

DelegateLinqTest(ds);

DataRowComparerUniontest(ds);

ShapingQueries(ds);

GropuingResults(ds);

JoinExample(ds);

AsDataViewTestExample(ds);

CopyToDattableTestExample(ds);

}

protected void FewBasicsofLinq()

{

Response.Write("###################################################################################");

Response.Write("1) LINQ queries target IEnumerable<T> sources. The DataSets DataTable and the DataTables DataRowCollection do not implement IEnumerable<DataRow> so these types cannot be used as sources for LINQ query expressions. To work around this issue, an extension method called AsEnumerable was added to the DataTable type. This extension method takes a source DataTable and wraps it in an object of the type EnumerableRowCollection which implements IEnumerable<DataRow>. This allows DataTables to be a source for LINQ query expressions.");

Response.Write("2) In fact, the DataTable.AsEnumerable method turns a given DataTable into a sequence of objects where the element type is DataRow. (see linqtoobject");

Response.Write("3) As a general rule, all access to DataRow column values should be done through the Field<T> method when developing LINQ to DataSet query expressions. This makes the query expression much less error prone and generally provides much cleaner code. ");

Response.Write("4) DataSet is an entirely in-memory cache, all LINQ queries against it are translated directly into .NET IL (intermediate language). This is different from LINQ technologies such as LINQ to SQL or LINQ to Entities which require the LINQ query to be translated to the target source's query language, and are therefore limited by what can be translated. As a result, LINQ to DataSet queries can be arbitrarily complex and can contain anything that can be expressed in the host language. ");

Response.Write("5) When working with LINQ to DataSet, you should also keep in mind how the LINQ set query operators (Union, Distinct, Intersection, Except) work. These operators all have two overloads, one which takes an IEqualityComparer<T> and one that does not. When calling one of the set query operators where the source(s) is IEnumerable<DataRow>, the set operator implementation will call DataRow.Equals() to compare elements when an IEqualityComparer<DataRow> comparer is not passed in. For developers familiar with the well known relational semantics of set operators, the results will be quite unexpected since the DataRow.Equals method will compare DataRow references and not the underlying values. To support more traditional relational semantics LINQ to DataSet includes a type called DataRowComparer which includes a default DataRow comparer for comparing two DataRows. ");

Response.Write("###################################################################################");

}

protected void LessThanGreaterThanTest()

{

int[] no = { 10, 13, 1, 4, 12, 3, 4, 9, 8, 120, 1234 };

var nogreaterthan80 = from n in no

where n > 80

orderby n ascending

select n;

Response.Write("No Greater Than 80 : ");

foreach (var number in nogreaterthan80)

{

Response.Write(number + "");

}

Response.Write("###################################################################################");

var nolessthan120 = from n in no

where n < 120

orderby n descending

select n;

Response.Write("No Less Than 120 : ");

foreach (var number in nolessthan120)

{

Response.Write(number + "");

}

Response.Write("###################################################################################");

}

protected DataSet CreateSampleDataset()

{

Response.Write("###################################################################################");

DataSet ds = new DataSet("Parks");

DataTable parksDataTable = ds.Tables.Add("National Parks");

parksDataTable.Columns.Add("ID", typeof(int));

parksDataTable.Columns.Add("Name", typeof(string));

parksDataTable.Columns.Add("YearEstablished", typeof(int));

parksDataTable.Columns.Add("Country", typeof(string));

parksDataTable.Columns.Add("Rating", typeof(int));

DataTable countriesDataTable = ds.Tables.Add("Countries");

countriesDataTable.Columns.Add("ID", typeof(int));

countriesDataTable.Columns.Add("Name", typeof(string));

countriesDataTable.Columns.Add("Population", typeof(long));

countriesDataTable.Columns.Add("ContinentID", typeof(int));

DataTable continentsDataTable = ds.Tables.Add("Continents");

continentsDataTable.Columns.Add("ID", typeof(int));

continentsDataTable.Columns.Add("Name", typeof(string));

DataRelation ContinentCountryDataRelation = ds.Relations.Add(

continentsDataTable.Columns["ID"],

countriesDataTable.Columns["ContinentID"]);

continentsDataTable.Rows.Add(

new object[] { 1, "North America" });

continentsDataTable.Rows.Add(

new object[] { 2, "South America" });

continentsDataTable.Rows.Add(

new object[] { 3, "Asia" });

countriesDataTable.Rows.Add(

new object[] { 1, "Canada", 31612000, 1 });

countriesDataTable.Rows.Add(

new object[] { 2, "USA", 302249000, 1 });

countriesDataTable.Rows.Add(

new object[] { 3, "Argentina", 39921833, 2 });

countriesDataTable.Rows.Add(

new object[] { 4, "Japan", 127433000, 3 });

countriesDataTable.Rows.Add(

new object[] { 5, "South Korea", 49024737, 3 });

parksDataTable.Rows.Add(

new object[] { 1, "Jasper", 1907, "Canada", 8 });

parksDataTable.Rows.Add(

new object[] { 2, "Yoho", 1886, "Canada", 7 });

parksDataTable.Rows.Add(

new object[] { 3, "North Cascade", 1968, "USA", 9 });

parksDataTable.Rows.Add(

new object[] { 4, "Lago Puelo", 1971, "Argentina", 8 });

parksDataTable.Rows.Add(

new object[] { 5, "Bandai-Asahi", 1950, "Japan", null });

parksDataTable.Rows.Add(

new object[] { 6, "Saikai", 1955, "Japan", 6 });

parksDataTable.Rows.Add(

new object[] { 7, "Jirisan", 1967, "South Korea", 8 });

Response.Write("Dataset Created !!!! ");

Response.Write("###################################################################################");

return ds;

}

protected void SimpleWhereCondition(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("Simple where condition ");

var wherecountryname = from park in ds.Tables["National Parks"].AsEnumerable()

where (string)park["Country"] == "Japan"

select park;

DumpResults(wherecountryname);

Response.Write("###################################################################################");

}

protected void LinqtoObjectTest(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("Linq To Object ");

List<DataRow> list = new List<DataRow>(ds.Tables["Continents"].Rows.Cast<DataRow>());

var querylinqtoobject = from park in list

where (string)park["Name"] == "Asia"

select park;

DumpResults(querylinqtoobject);

Response.Write("###################################################################################");

}

protected void FieldTExample(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("field<T> Example ");

var fldtex = from park in ds.Tables["National Parks"].AsEnumerable()

where park.Field<int?>("Rating") > 8

select park;

DumpResults(fldtex);

Response.Write("###################################################################################");

}

//CALLING DELEGATE checkPopulation from linq to dataset queries

protected void DelegateLinqTest(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("Delgate Linq Example ");

Func<long, bool> checkPopulation = delegate(long i)

{return i < 100000000;};

var delgatelinqtest = from country in

ds.Tables["Countries"].AsEnumerable()

where country.Field<string>("Name").Length > 3 &&

!country.HasErrors &&

checkPopulation(

country.Field<long>("Population"))

select country;

DumpResults(delgatelinqtest);

Response.Write("###################################################################################");

}

protected void DataRowComparerUniontest(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("Data Row comparer Union Test ");

var source1 = from park in ds.Tables["National Parks"].AsEnumerable()

where park.Field<int?>("Rating") < 8

select park;

var source2 = from park in ds.Tables["National Parks"].AsEnumerable()

where park.Field<int>("YearEstablished") > 1960

select park;

var unionResults = source1.Union(source2, DataRowComparer.Default);

DumpResults(unionResults);

Response.Write("###################################################################################");

//use DataRowCompared for explanation view the head topic no 5)

}

protected void ShapingQueries(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("Shaping Queries ");

var shapingqueries = from park in ds.Tables["National Parks"].AsEnumerable()

orderby park.Field<int>("YearEstablished")

select new

{

ParkName = park.Field<string>("Name"),

Established =

park.Field<int>("YearEstablished")

};

DumpResults(shapingqueries);

Response.Write("###################################################################################");

//use DataRowCompared for explanation view the head topic no 5)

}

protected void GropuingResults(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("Grouping Results ");

var groupingrslt = from park in ds.Tables["National Parks"].AsEnumerable()

group park by park.Field<string>("Country") into g

select new { Country = g.Key, Count = g.Count() };

DumpResults(groupingrslt);

Response.Write("###################################################################################");

//use DataRowCompared for explanation view the head topic no 5)

}

protected void JoinExample(DataSet ds)

{

//Response.Write("###################################################################################");

//Response.Write("Join Example Results ");

//var joinexampl = from park in ds.Tables["National Parks"].AsEnumerable()

// join country in ds.Tables["Countries"].AsEnumerable()

// on park.Field<string>("Country") equals

// country.Field<string>("Name")

// select new

// {

// ParkName = park.Field<string>("Name"),

// Country = country.Field<string>("Name"),

// Continent = country.

// GetParentRow(

// ContinentCountryDataRelation)

// .Field<string>("Name")

// };

//DumpResults(joinexampl);

//Response.Write("###################################################################################");

//use DataRowCompared for explanation view the head topic no 5)

}

protected void AsDataViewTestExample(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("AsDataViewTest Example Results ");

DataView dataView = (from park in

ds.Tables["National Parks"].AsEnumerable()

where park.Field<int?>("YearEstablished") < 1960

orderby park.Field<string>("Country")

select park).AsDataView();

DataRowView[] drv = dataView.FindRows("Canada");

foreach (object obj in drv.Cast<Object>())

{

Response.Write(obj);

}

Response.Write("###################################################################################");

//use DataRowCompared for explanation view the head topic no 5)

}

protected void CopyToDattableTestExample(DataSet ds)

{

Response.Write("###################################################################################");

Response.Write("CopyToDattableTest Example Results ");

DataTable newParksTable = (from park in

ds.Tables["National Parks"].AsEnumerable()

where park.Field<int?>("YearEstablished") < 1960

orderby park.Field<int?>("YearEstablished")

select park).CopyToDataTable();

Response.Write("###################################################################################");

//use DataRowCompared for explanation view the head topic no 5)

}

//Method to Display the query result

public void DumpResults<T>(IEnumerable<T> source)

{

StringBuilder sb = new StringBuilder();

if (typeof(T) == typeof(DataRow))

{

foreach (DataRow dr in source.Cast<DataRow>())

{

foreach (object o in dr.ItemArray)

{

sb.Append((o == DBNull.Value ? "DBNull" : o) + " ");

}

sb.Append(" ");

}

else

{

foreach (T t in source)

{

foreach (PropertyInfo pi in typeof(T).GetProperties())

{

object o = pi.GetValue(t, null);

sb.Append(o + " ");

}

sb.Append(" ");

}

Response.Write(sb.ToString());

}

LAMBDA EXPRESSION

Lambda expression is the anonymous function which can contain the expression and statement can can be used to create delegate and expression tree

Lambda expression use the Lambda Operator(=>) read as GOES TO .

The left side of the lambda expression specifies the input if any and right side holds the expression or statement block. The lambda expression p => p * p read as "p goes to p time p" this expression can be assigned as delegate types as follows

delegate int del(int i);

static void Main(string[] args)

{

del myDelegate = p => p * p;

int j = myDelegate(5); //j = 25

}

Lambdas are not allowed on the left side of the is or as operator.

All restrictions that apply to anonymous methods also apply to lambda expressions.

Expression Lambadas

A lambda expression with an expression on the right hand side is called expression lambda. Expression lambda are used extensively in the construction of the expression trees

An expression lambda returns the expression result and takes the following basic form

(input parameter) => expression

parenthesis are optional if the input parameter is single otherwise it is compulsory. Two or more parameter enclosed in the parenthesis separated by comma

(x, y) => x == y

sometime it is difficult or impossible for compiler to infer the input data type, in that case we can specify the data type explicitly as follows

(int x, string s) => s.Length > x

even we can specify zero input parameter with empty parenthesis like as

() => SomeMethod()

Statement Lambda

statement lambda resembles the expression lambda except that the statement is enclosed in the parenthesis

(input parameter ) => (statement;)

body of the statement lambda can consist of any number of lines but practically they are not more than two three lines

delegate void TestDelegate(string s);

…

TestDelegate myDel = n => { string s = n + " " + "World"; Console.WriteLine(s); };

myDel("Hello");

Statement lambdas, like anonymous methods, cannot be used to create expression trees.

WCF Basics / fundamentals how to

2010-01-17T04:04:00.001-08:00

Overview

Windows Communication Foundation takes combines many existing communication technologies, such as Web Services, Windows Remoting, Microsoft Message Queuing (MSMQ), and abstracts them into a single technology (WCF). In most cases, this simplifies the way WE communicate with other applications. It also allows us to communicate with other applications without being coupled to a specific technology. Therefore, we could use Web Services over SOAP to begin with, and later move to remote procedure calls (RPC) without changing our code

The Basics

Conceptual Overview

Windows Communication Foundation (WCF) is a runtime and a set of APIs for creating systems that send messages between services and clients.

The same infrastructure and APIs are used to create applications that communicate with other applications on the same computer system or on a system that resides in another company and is accessed over the Internet.

Messaging and Endpoints

WCF is based on the notion of message-based communication, and anything that can be modeled as a message (for example, an HTTP request or an MSMQ message) can be represented in a uniform way in the programming model. This enables a unified API across different transport mechanisms.

The model distinguishes between clients, which are applications that initiate communication, and services, which are applications that wait for clients to communicate with them and respond to that communication. A single application can act as both a client and a service.

Messages are sent between endpoints. Endpoints are places where messages are sent or received (or both), and they define all the information required for the message exchange. A service exposes one or more application endpoints (as well as zero or more infrastructure endpoints), and the client generates an endpoint that is compatible with one of the service's endpoints.

An endpoint describes in a standard-based way where messages should be sent, how they should be sent, and what the messages should look like. A service can expose this information as metadata that clients can process to generate appropriate WCF clients and communication stacks.

Communication Protocols

One required element of the communication stack is the transport protocol. Messages can be sent over intranets and the Internet using common transports, such as HTTP and TCP. Other transports are included that support communication with Microsoft Message Queuing (MSMQ) applications and nodes on a Peer Networking mesh. More transport mechanisms can be added using the built-in extension points of WCF.

Another required element in the communication stack is the encoding that specifies how any given message is formatted. WCF provides the following encodings:

Text encoding, an interoperable encoding.
Message Transmission Optimization Mechanism (MTOM) encoding, which is an interoperable way for efficiently sending unstructured binary data to and from a service.
Binary encoding for efficient transfer.

More encoding mechanisms (for example, a compression encoding) can be added using the built-in extension points of WCF.

Message Patterns

WCF supports several messaging patterns, including request-reply, one-way, and duplex communication. Different transports support different messaging patterns, and thus affect the types of interactions that they support. The WCF APIs and runtime also help you to send messages securely and reliably.

WCF Terms

Other concepts and terms used in the WCF documentation include the following.

message

A message is a self-contained unit of data that may consist of several parts, including a body and headers.

service

A service is a construct that exposes one or more endpoints, with each endpoint exposing one or more service operations.

endpoint

An endpoint is a construct at which messages are sent or received (or both). It comprises a location (an address) that defines where messages can be sent, a specification of the communication mechanism (a binding) that described how messages should be sent, and a definition for a set of messages that can be sent or received (or both) at that location (a service contract) that describes what message can be sent.

An WCF service is exposed to the world as a collection of endpoints.

application endpoint

An endpoint exposed by the application and that corresponds to a service contract implemented by the application.

infrastructure endpoint

An endpoint that is exposed by the infrastructure to facilitate functionality that is needed or provided by the service that does not relate to a service contract. For example, a service might have an infrastructure endpoint that provides metadata information.

address

An address specifies the location where messages are received. It is specified as a Uniform Resource Identifier (URI). The URI schema part names the transport mechanism to use to reach the address, such as HTTP and TCP. The hierarchical part of the URI contains a unique location whose format is dependent on the transport mechanism.

The endpoint address enables you to create unique endpoint addresses for each endpoint in a service, or under certain conditions share an address across endpoints. The following example shows an address using the HTTPS protocol with a non-default port:

HTTPS://prawinway:8005/ServiceModelSamples/CalculatorService

binding

A binding defines how an endpoint communicates to the world. It is constructed of a set of components called binding elements that "stack" one on top of the other to create the communication infrastructure. At the very least, a binding defines the transport (such as HTTP or TCP) and the encoding being used (such as text or binary). A binding can contain binding elements that specify details like the security mechanisms used to secure messages, or the message pattern used by an endpoint. For more information, see Configuring Windows Communication Foundation Services.

binding element

A binding element represents a particular piece of the binding, such as a transport, an encoding, an implementation of an infrastructure-level protocol (such as WS-ReliableMessaging), or any other component of the communication stack.

behaviors

A behavior is a component that controls various run-time aspects of a service, an endpoint, a particular operation, or a client. Behaviors are grouped according to scope: common behaviors affect all endpoints globally, service behaviors affect only service-related aspects, endpoint behaviors affect only endpoint-related properties, and operation-level behaviors affect particular operations. For example, one service behavior is throttling, which specifies how a service reacts when an excess of messages threaten to overwhelm its handling capabilities. An endpoint behavior, on the other hand, controls only aspects relevant to endpoints, such as how and where to find a security credential.

system-provided bindings

WCF includes a number of system-provided bindings. These are collections of binding elements that are optimized for specific scenarios. For example, the WSHttpBinding is designed for interoperability with services that implement various WS-* specifications. These predefined bindings save time by presenting only those options that can be correctly applied to the specific scenario. If a predefined binding does not meet your requirements, you can create your own custom binding.

configuration versus coding

Control of an application can be done either through coding, through configuration, or through a combination of both. Configuration has the advantage of allowing someone other than the developer (for example, a network administrator) to set client and service parameters after the code is written and without having to recompile. Configuration not only enables you to set values like endpoint addresses, but also allows further control by enabling you to add endpoints, bindings, and behaviors. Coding allows the developer to retain strict control over all components of the service or client, and any settings done through the configuration can be inspected and if needed overridden by the code.

service operation

A service operation is a procedure defined in a service's code that implements the functionality for an operation. This operation is exposed to clients as methods on a WCF client. The method may return a value, and may take an optional number of arguments, or take no arguments, and return no response. For example, an operation that functions as a simple "Hello" can be used as a notification of a client's presence and to begin a series of operations.

service contract

The service contract ties together multiple related operations into a single functional unit. The contract can define service-level settings, such as the namespace of the service, a corresponding callback contract, and other such settings. In most cases, the contract is defined by creating an interface in the programming language of your choice and applying the ServiceContractAttribute attribute to the interface. The actual service code results by implementing the interface.

operation contract

An operation contract defines the parameters and return type of an operation. When creating an interface that defines the service contract, you signify an operation contract by applying the OperationContractAttribute attribute to each method definition that is part of the contract. The operations can be modeled as taking a single message and returning a single message, or as taking a set of types and returning a type. In the latter case, the system will determine the format for the messages that need to be exchanged for that operation.

message contract

A message contract describes the format of a message. For example, it declares whether message elements should go in headers versus the body, what level of security should be applied to what elements of the message, and so on.

fault contract

A fault contract can be associated with a service operation to denote errors that can be returned to the caller. An operation can have zero or more faults associated with it. These errors are SOAP faults that are modeled as exceptions in the programming model.

data contract

The data types a service uses must be described in metadata to enable others to interoperate with the service. The descriptions of the data types are known as the data contract, and the types can be used in any part of a message, for example, as parameters or return types. If the service is using only simple types, there is no need to explicitly use data contracts.

hosting

A service must be hosted in some process. A host is an application that controls the lifetime of the service. Services can be self-hosted or managed by an existing hosting process.

self-hosted service

A self-hosted service is one that runs within a process application that the developer created. The developer controls its lifetime, sets the properties of the service, opens the service (which sets it into a listening mode), and closes the service.

hosting process

A hosting process is an application that is designed to host services. These include Internet Information Services (IIS), Windows Activation Services (WAS), and Windows Services. In these hosted scenarios, the host controls the lifetime of the service. For example, using IIS you can set up a virtual directory that contains the service assembly and configuration file. When a message is received, IIS starts the service and controls its lifetime.

instancing

A service has an instancing model. There are three instancing models: "single," in which a single CLR object services all the clients; "per call," in which a new CLR object is created to handle each client call; and "per session," in which a set of CLR objects are created, one for each separate session. The choice of an instancing model depends on the application requirements and the expected usage pattern of the service.

client application

A client application is a program that exchanges messages with one or more endpoints. The client application begins by creating an instance of a WCF client and calling methods of the WCF client. It is important to note that a single application can be both a client and a service.

channel

A channel is a concrete implementation of a binding element. The binding represents the configuration, and the channel is the implementation associated with that configuration. Therefore, there is a channel associated with each binding element. Channels stack on top of each other to create the concrete implementation of the binding: the channel stack.

WCF client

A WCF client is a client-application construct that exposes the service operations as methods (in the .NET Framework programming language of your choice, such as Visual Basic or Visual C#). Any application can host a WCF client, including an application that hosts a service. Therefore, it is possible to create a service that includes WCF clients of other services.

A WCF client can be automatically generated by using the ServiceModel Metadata Utility Tool (Svcutil.exe) and pointing it at a running service that publishes metadata.

metadata

The metadata of a service describes the characteristics of the service that an external entity needs to understand to communicate with the service. Metadata can be consumed by the ServiceModel Metadata Utility Tool (Svcutil.exe) to generate a WCF client and accompanying configuration that a client application can use to interact with the service.

The metadata exposed by the service includes XML schema documents, which define the data contract of the service, and WSDL documents, which describe the methods of the service.

When enabled, metadata for the service is automatically generated by WCF by inspecting the service and its endpoints. To publish metadata from a service, you must explicitly enable the metadata behavior.

security

Security in WCF includes confidentiality (encryption of messages to prevent eavesdropping), integrity (the means for detection of tampering with the message), authentication (the means for validation of servers and clients), and authorization (the control of access to resources). These functions are provided by either leveraging existing security mechanisms, such as TLS over HTTP (also known as HTTPS), or by implementing one or more of the various WS-* security specifications.

transport security mode

Security can be provided by one of three modes: transport mode, message security mode, and transport with message credential mode. The transport security mode specifies that confidentiality, integrity, and authentication are provided by the transport layer mechanisms (such as HTTPS). When using a transport like HTTPS, this mode has the advantage of being efficient in its performance, and well understood because of its prevalence on the Internet. The disadvantage is that this kind of security is applied separately on each hop in the communication path, making the communication susceptible to a "man in the middle" attack.

message security mode

Message security mode specifies that security is provided by implementing one or more of the security specifications, such as the specification named "Web Services Security: SOAP Message Security" (available at http://go.microsoft.com/fwlink/?LinkId=94684). Each message contains the necessary mechanisms to provide security during its transit, and to enable the receivers to detect tampering and to decrypt the messages. In this sense, the security is encapsulated within every message, providing end-to-end security across multiple hops. Because security information becomes part of the message, it is also possible to include multiple kinds of credentials with the message (these are referred to as claims). This approach also has the advantage of enabling the message to travel securely over any transport, including multiple transports between its origin and destination. The disadvantage of this approach is the complexity of the cryptographic mechanisms employed, resulting in performance implications.

transport with message credential security mode

This mode uses the transport layer to provide confidentiality, authentication, and integrity of the messages, while each of the messages can contain multiple credentials (claims) required by the receivers of the message

There are a few basic tasks when creating a WCF service. The basic tasks that must be

performed are, in order:

Define the service contract. A service contract specifies the signature of a service, the data it exchanges, and other contractually required data.
Implement the contract. To implement a service contract, create the class that implements the contract and specify some custom behaviors that the runtime should have.
Configure the service by specifying endpoint information and other behavior information.
Host the service in an application.
Build a client application.

For more information, see http://msdn2.microsoft.com/en-us/library/ms732098.aspx

Example

To display a step-by-step enactment of the above steps, let's define a web service that reports the current date/time:

1.1 Define a Service Contract

First, let's create a project to house our service contract. Let's call it WCFDateTime.Service.

1.2 Define a Service Contract

Then, let's define an interface that represents the service we're going to provide. In this case, let's call it IDateTimeService.

public interface IDateTimeService

{

}

1.3 Define a Service Contract

We need to add a method to our service that will return the current date/time:

public interface IDateTimeService

{

DateTime GetCurrentDateTime();

}

1.4 Define a Service Contract

Now, we need to decorate our code with attributes so that WCF will recognize our interface and its methods. Namely, we will add the following attributes:

ServiceContractAttribute
- Identifies an interface as a WCF service contract
OperationContractAttribute
- Identifies methods of an interface as WCF service operations, that is, methods that can be called through WCF

using System.ServiceModel;

[ServiceContract]

public interface IDateTimeService

{

[OperationContract]

DateTime GetCurrentDateTime();

}

In order to use the above attributes, you'll need to add a reference to the System.ServiceModel assembly. The service contract is now ready to be used.

2.1 Implement the Contract

Now that we've defined our service contract, we can move on to implementing it. First, let's create another project to house our server application. Let's call it WCFDateTime.Server, and make it a Console Application project.

2.2 Implement the Contract

Now, let's implement the IDateTimeService. The implementation is going to run on our server, to provide the date/time to whoever is going to consume our service.

In the WCFDateTime.Server project, let's create a class called DateTimeService and have it implement IDateTimeService:

using WCFDateTime.Service;

public class DateTimeService : IDateTimeService

{

}

Remember to add a reference to the WCFDateTime.Service project so you can use IDateTimeService.

2.3 Implement the Contract

The above code will obviously not compile, because we did not implement the GetCurrentDateTime method:

public class DateTimeService : IDateTimeService

{

public DateTime GetCurrentDateTime()

{

return DateTime.Now;

}

That's it! The DateTimeService is now ready to be used.

3.1 Configure the Service

Now we need to configure our service so it can be consumed by client applications. The simplest way to accomplish this is by adding an application configuration file (app.config or web.config) to the WCFDateTime.Server project:

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

<system.serviceModel>

<endpoint

address="http://localhost:8081/DateTimeService"

binding="wsHttpBinding"

contract="WCFDateTime.Service.IDateTimeService" />

</service>

</services>

</system.serviceModel>

</configuration>

When defining an endpoint for WCF, remember your A-B-Cs:

Address (where)
Binding (how)
Contract (what)

The address specifies the address where you want the service to be located.

The binding specifies the transport you want to use in order to provide the service.

The contract specifies what service will be provided

4.1 Host the Service in an Application

Now that WCF has been configured, the simplest way to host this service is to create a Console Application and use the ServiceHost class. First, add a reference to the System.ServiceModel assembly. Then, In the program.cs file of WCFDateTime.Server, do the following:

using System.ServiceModel;

namespace WCFDateTime.Server

{

class Program

{

static public void Main(string[] args)

{

// Get a host for our service

ServiceHost serviceHost = new ServiceHost(

typeof(DateTimeService)

);

// Open the service host to start listening for incoming requests

serviceHost.Open();

// The service can now be accessed

Console.WriteLine("The service is ready.");

Console.WriteLine("Press <ENTER> to terminate service.");

Console.ReadLine();

// Close the service host

serviceHost.Close();

}

By simply running this application, we expose our service so that client applications can use it.

1 Build a Client Application

To build a client application, we must create a new project for it. Let's call it WCFDateTime.Client, and make it a Console Application as well.

2 Build a Client Application

Now, we need to add an Application Configuration file, and give it some settings that will allow us to connect to the service we just created:

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

<system.serviceModel>

<endpoint

address="http://localhost:8081/DateTimeService"

binding="wsHttpBinding"

contract="WCFDateTime.Service.IDateTimeService"

name="MyDateTimeService">

</endpoint>

</client>

</system.serviceModel>

</configuration>

Now that our we've configured our WCF client, we can connect to it. There are two ways to connect to the WCF service we previously created:

Client proxy generation
Channel factories

Most Microsoft articles will point you in the direction of using client proxies; however, for our purposes, channel factories are quicker to implement and more robust in a Model/View/Presenter architecture.

3 Build a Client Application

Now, add a reference to the System.ServiceModel and WCFDateTime.Service assemblies, and then add the following to the program.cs file:

using System.ServiceModel;

using WCFDateTime.Service;

class Program

{

public static void Main(string[] args)

{

// Get a channel factory for our service,

// using the configuration for "MyDateTimeService"

// in the application configuration file.

ChannelFactory<IDateTimeService> channelFactory =

new ChannelFactory<IDateTimeService>("MyDateTimeService");

// Get an instance of our service

IDateTimeService service = channelFactory.CreateChannel();

// Get the server's date/time

DateTime dt = service.GetCurrentDateTime();

// Write the current server date/time

Console.WriteLine("The current server time is " + dt);

// Close the connection to our service

channelFactory.Close();

}

4 Build a Client Application

Your client application is now ready to run! Simply start the WCFDateTime.Server application, and once it's running, run the WCFDateTime.Client application to see it work!

This example is ok for testing purpose but when it comes to real time implementation of WCF things goes something unexpected as excepted ;)

Resizing youtube videos in asp.net pages

2009-07-28T02:27:00.000-07:00

how can i make the videos size smaller or bigger that i have embdded in the asp.net pages ?

how can i resize the videos embedded ??

Whenever we embed the video in asp.net pages we get the object code which contians the
height=”xxx” width=”xxx” – it should be near the very beginning of object.

This is the code which tells html page the size of the video.

I tried to change it but nothing was happening.

There is one trick which we have to follow to achive this.

youtube videos have the sixe of width="560" and height="340" by default.

we have to adjust height and width so that the ratio of width to height remains same.

for example consider if we have to make the video size half as the default we have to change the height and width keeping the ration of height and width as the same as default.

for this we have to make the width="280" , height="170"

see the following exapmle

This is the example

this is the half of the above size

:)

Capturing the actual video URL from the embed code of the You tube Video


Regex r = new Regex ("src=\"(?http://www\\.youtube\\.com\\S*)\"");
    Match m = r.Match(txtuploadvideo.Text);

    if (m.Success)
       string actualvideopath = m.ToString();
    Response.Write(

actualvideopath

);

Where in

txtuploadvideo.Text is the actual embed object which we get from the youtube.

in string

actualvideopath we get the actual url of the video of the youtube,Which we can save it in the database and at runtime we can dispaly it as after concatnating it in the desired format.

where in we can get control over the height and width in the display.

Reading web.config files in asp.net web project for cookie time out.

2009-07-21T00:58:00.001-07:00

In one of my project I had to implement and use the following method which will read timeout property from the web.config

In this way we can read any web.config setting programtically.for saving any values we have to use save and save as method.

/// <summary>

/// Retrieves cookie timeout value in the <forms></forms>

/// section in the web.config file as this

/// value is not accessable via the FormsAuthentication or any other built in class

/// </summary>

/// <returns></returns>

private static int GetCookieTimeoutValue()

{

int timeout = 30; //Default timeout is 30 minutes

XmlDocument webConfig = new XmlDocument();

webConfig.Load(HttpContext.Current.Server.MapPath("web.config"));

XmlNode node = webConfig.SelectSingleNode("/configuration/" +

"system.web/authentication/forms");

if (node != null && node.Attributes["timeout"] != null)

{

timeout = int.Parse(node.Attributes["timeout"].Value);

}

return timeout;

}

After doing this, the system was able to read the "timeout" value from the web.config property.

ASP.NET Caching: Techniques and Best Practices

2009-07-21T00:55:00.001-07:00

ASP.NET provides three primary forms of caching:

Page level output caching
User control level output caching (or fragment caching)
Cache API.

Output caching and fragment caching are very easy to implement, and are sufficient in many cases.

The cache API provides quite a lot additional flexibility, and can be used to take advantage of caching throughout every layer of an application.

Caching has the greatest potential impact on an application's performance, out of all the other features in ASP.NET, and it is one of the things that allow ASP.NET developers to accept the additional overhead of building sites using rather heavy controls like Grid View without fear that performance will suffer too much.

In order to see the most benefit from caching in your applications, you should consider ways of implementing caching at all levels of your program.

Cache Early; Cache Often

Implement caching at every layer of your application. Add caching support to the data , business logic, and UI/output layer.

Caching Hides Many Sins

Caching can be a good way to get "good enough" performance without requiring a lot of time and analysis.

Page Level Output Caching

The simplest form of caching, output caching simply keeps a copy of the HTML that was sent in response to a request in memory. Subsequent requests are then sent the cached output until the cache expires, resulting in potentially very large performance gains (depending on how much effort was required to create the original page output—sending cached output is always very fast and fairly constant).

Implementation

To implement page output caching, simply add an OutputCache directive to the page.

<%@ OutputCache Duration="60" VaryByParam="*" %>

This directive, as with other page directives should appear at the top of the ASPX page, before any output. It supports five attributes (or parameters), two of which are required.

Duration		Required. Time, in seconds, the page should be cached. Must be a positive integer.
Location		Specifies where the output should be cached. If specified, must be one of: Any, Client, Downstream, None, Server or ServerAndClient.
VaryByParam		Required. The names of the variables in the Request, which should result in, separate cache entries. "none" can be used to specify no variation. "*" can be used to create new cache entries for every different set of variables. Separate variables with ";".
VaryByHeader		Varies cache entries based on variations in a specified header.
VaryByCustom		Allows custom variations to be specified in the global.asax (for example, "Browser").

Most situations can be handled with a combination of the required Duration and VaryByParam options. For instance, if you have a product catalog that allows the user to view pages of the catalog based on a categoryID and a page variable, you could cache it for some period of time (an hour would probably be acceptable unless the products change all the time, so a duration of 3600 seconds) with a VaryByParam of "categoryID;page". This would create separate cache entries for every page of the catalog for each category. Each entry would persist for one hour from its first request.

VaryByHeader and VaryByCustom are primarily used to allow customization of the page's look or content based on the client that is accessing them. Perhaps the same URL renders output for both browsers and mobile phone clients, and needs to cache separate versions based on this. Or perhaps the page is optimized for IE but needs to be able to degrade gracefully for Netscape or Opera (instead of just breaking). This last example is common enough that we'll show an example of how to do it:

Example: VaryByCustom to support browser customization

In order to enable separate cache entries for each browser, VaryByCustom can be set to a value of "browser". This functionality is built into the caching module, and will insert separate cached versions of the page for each browser name and major version.

<%@ OutputCache Duration="60" VaryByParam="None" VaryByCustom="browser" %>

Fragment Caching, User Control Output Caching

Often, caching an entire page is not feasible, because certain parts of the page are customized for the user. However, there may be other parts of the page that are common to the entire application. These are perfect candidates for caching, using fragment caching and user controls. Menus and other layout elements, especially ones that are dynamically generated from a data source, should be cached with this technique. If need be, the cached controls can be configured to vary based on the changes to its controls (or other properties) or any of the other variations supported by page level output caching. Hundreds of pages using the same controls can also share the cached entries for those controls, rather than keeping separate cached versions for each page.

Implementation

Fragment caching uses the same syntax as page level output caching, but applied to a user control (.ascx file) instead of to a web form (.aspx file). All of the attributes supported by the OutputCache directive on a web form are also supported for user controls except for the Location attribute. User controls also support an OutputCache attribute called VaryByControl, which will vary the caching of the user control depending on the value of a member of that control (typically a control on the page, such as a DropDownList). If VaryByControl is specified, VaryByParam may be omitted. Finally, by default each user control on each page is cached separately. However, if a user control does not vary between pages in an application and is named the same across all such pages, the Shared="true" parameter can be applied to it, which will cause the cached version(s) of the user control to be used by all pages referencing that control.

Examples

<%@ OutputCache Duration="60" VaryByParam="*" %>

This would cache the user control for 60 seconds, and would create a separate cache entry for every variation of querystring and for every page this control is placed on.

<%@ OutputCache Duration="60" VaryByParam="none"

VaryByControl="CategoryDropDownList" %>

This would cache the user control for 60 seconds, and would create a separate cache entry for each different value of the CategoryDropDownList control, and for each page this control is placed on.

<%@ OutputCache Duration="60" VaryByParam="none" VaryByCustom="browser"

Shared="true %>

Finally, this would cache the user control for 60 seconds, and would create one cache entry for each browser name and major version. The cache entries for each browser would then be shared by all pages referencing this user control (as long as all pages refer to the control with the same ID).

Caching API, Using the Cache Object

Page and user control level output caching can be a quick and easy way to boost performance of your site, but the real flexibility and power of caching in ASP.NET is exposed via the Cache object. Using the Cache object, you can store any serializeable data object, and control how that cache entry expires based on a combination of one or more dependencies. These dependencies can include time elapsed since the item was cached, time elapsed since the item was last accessed, changes to files and/or folders, changes to other cached items, or (with a little work) changes to particular tables in a database.

Storing Data in the Cache

The simplest way to store data in the Cache is simply to assign it, using a key, just like a HashTable or Dictionary object:

Cache["key"] = "value";

This will store the item in the cache without any dependencies, so it will not expire unless the cache engine removes it in order to make room for additional cached data. To include specific cache dependencies, the Add() or Insert() method is used. Each of these has several overloads. The only difference between Add() and Insert() is that Add() returns a reference to the cached object, while has no return value (void in C#, Sub in VB).

Examples

Cache.Insert("key", myXMLFileData, new

System.Web.Caching.CacheDependency(Server.MapPath("users.xml")));

This would insert xml data from a file into the cache, eliminating the need to read from the file on subsequent requests. The CacheDependency will ensure that when the file changes, the cache will immediately expire, allowing the latest data to be pulled from the file and re-cached. An array of filenames can also be specified if the cached data depends on several files.

Cache.Insert("dependentkey", myDependentData, new

System.Web.Caching.CacheDependency(new string[] {}, new string[]

{"key"}));

This example would insert a second piece of data that depended on the existence of the first piece (with a key value of "key"). If no key existed in the cache called "key", or if the item associated with that key expires or is updated, then the cache entry for "dependentkey" would expire.

Cache.Insert("key", myTimeSensitiveData, null,

DateTime.Now.AddMinutes(1), TimeSpan.Zero);

Absolute Expiration: This example will cache the time sensitive data for one minute, at which point the cache will expire. Note that absolute expiration and sliding expiration (below) cannot be used together.

Cache.Insert("key", myFrequentlyAccessedData, null,

System.Web.Caching.Cache.NoAbsoluteExpiration,

TimeSpan.FromMinutes(1));

Sliding Expiration: This example will cache some frequently used data. The data will remain in the cache until one minute passes without anything referencing it. Note that sliding expiration and absolute expiration cannot be used together.

More Options

In addition to the dependencies described above, we can also specify the priority of the item (from low to high to NotRemovable, defined in the System.Web.Caching.CacheItemPriority enumeration) and a CacheItemRemovedCallback function to call when the item expires from the cache. Most of the time, the default priority will suffice—let the caching engine do what it's good at and handle the cache's memory management. The CacheItemRemovedCallback option allows for some interesting possibilities, but in practice it too is rarely used. However, to demonstrate the technique, I'll provide an example of its usage:

CacheItemRemovedCallback example

System.Web.Caching.CacheItemRemovedCallback callback = new System.Web.Caching.CacheItemRemovedCallback (OnRemove);

Cache.Insert("key",myFile,null,

System.Web.Caching.Cache.NoAbsoluteExpiration,

TimeSpan.Zero,

System.Web.Caching.CacheItemPriority.Default, callback);

. . .

public static void OnRemove(string key,

object cacheItem,

System.Web.Caching.CacheItemRemovedReason reason)

{

AppendLog("The cached value with key '" + key +

"' was removed from the cache. Reason: " +

reason.ToString());

}

This will log the reason for the expiration of data from the cache using whatever logic is defined in the AppendLog() method

One potential use for this feature would be to refresh cached data in the background so that users never need to wait for the data to be populated, but the data is kept relatively fresh. Unfortunately in practice, this doesn't work very well with the current version of the caching API, because the callback doesn't fire or complete execution prior to the cached item being removed from the cache. Thus, a user will frequently make a request that will try to access the cached value, find that it is null, and be forced to wait for it to repopulate. In a future version of ASP.NET, I would like to see an additional callback, which might be called CachedItemExpiredButNotRemovedCallback, which if defined must complete execution before the cached item is removed.

Cached Data Reference Pattern

Whenever an attempt is made to access data from the cache, it should be with the assumption that the data might not be there anymore. Thus, the following pattern should be universally applied to your access of cached data. In this case, we're going to assume the object that has been cached is a DataTable.

public DataTable GetCustomers(bool BypassCache)

{

string cacheKey = "CustomersDataTable";

object cacheItem = Cache[cacheKey] as DataTable;

if((BypassCache) || (cacheItem == null))

{

cacheItem = GetCustomersFromDataSource();

Cache.Insert(cacheKey, cacheItem, null,

DateTime.Now.AddSeconds(GetCacheSecondsFromConfig(cacheKey),

TimeSpan.Zero);

}

return (DataTable)cacheItem;

}

There are several points I'd like to make about this pattern:

Values, like cacheKey, cacheItem and the cache duration, are defined once and only once.
The cache can be bypassed as needed—for example, after registering a new customer and redirecting to a list of customers, it would probably be best to bypass the cache and repopulate it with the latest data, which would include the newly inserted customer.
Cache is only accessed once. This has performance benefits and ensures that NullReferenceExceptions don't occur because the item was present the first time it was checked but had expired before the second check.
The pattern uses strong type checking. The "as" operator in C# will attempt to cast an object to a type and will simply return null if it fails or if the object is null.
The duration is stored in a configuration file. All cache dependencies, whether file-based, time-based, or otherwise, should ideally be stored in a configuration file so that changes can be made and performance measured easily. I also recommend that a default cache duration be specified, and that the GetCacheSecondsFromConfig() method uses the default if no duration is specified for the cacheKey being used.

Caching can provide huge performance benefits to applications, and should therefore be considered when an application is being designed as well as when it is being performance tested. I have yet to encounter an application that could not benefit from caching in some capacity, though certainly some applications are better suited than others. A solid understanding of the caching options available in ASP.NET is an important skill for any ASP.NET developer to master

Orignal Link - http://msdn.microsoft.com/en-us/library/aa478965.aspx

How to DBCC SHRINKFILE to shrink the transaction log file in SQL Server 2005

2009-07-07T06:29:00.001-07:00

In MS SQL Server 2005, we can shrink a transaction log file in a database to remove unused pages. The database engine reuses space effectively. However, when a transaction log file grows unexpectedly, we may have to shrink the transaction log file manually.

In SQL Server 2005, a shrink operation (DBCC SHRINKFILE) tries to shrink the specified transaction log file to the requested size immediately. To shrink the transaction log file manually under the full recovery model, first back up the transaction log file. Then, use the DBCC SHRINKFILE statement to shrink the transaction log file.

When you try to shrink a transaction log file that has little free space in SQL Server 2005, we may have to perform an additional log backup operation. The additional log backup operation truncates the transaction log file to a smaller size. This log backup operation is in addition to the three steps that we perform to shrink the transaction log file in SQL Server 2000. To shrink a transaction log file that has little free space in SQL Server 2005, follow these steps:

Back up the transaction log file to make most of the active virtual log files inactive. Therefore, the inactive virtual log files can be removed in a later step. To do this, run a Transact-SQL statement that is similar to the following Transact-SQL statement.
BACKUP LOG <DatabaseName> TO DISK = '<BackupFile>'
Note In this statement, <DatabaseName> is a placeholder for the name of the database that you are backing up. In this statement, <BackupFile> is a placeholder for the full path of the backup file.
For example, run the following Transact-SQL statement.
BACKUP LOG TestDB TO DISK='C:\TestDB1.bak'
Shrink the transaction log file. To do this, run a Transact-SQL statement that is similar to the following Transact-SQL statement.
DBCC SHRINKFILE (<FileName>, <TargetSize>) WITH NO_INFOMSGS
Note In this statement, <FileName> is a placeholder for the name of the transaction log file. In this statement, <TargetSize> is a placeholder for the target size that you want the transaction log file to be. The target size must be reasonable. For example, you cannot shrink the transaction log file to a size that is less than 2 virtual log files.
If the DBCC SHRINKFILE statement does not shrink the transaction log file to the target size, run the BACKUP LOG statement that is mentioned in step 1 to make more of the virtual log files inactive.
Run the DBCC SHRINKFILE statement that is mentioned in step 2. After this operation, the transaction log file should be similar to the target size.

In summary, the log manager's algorithm for picking up the next virtual log file changed in SQL Server 2005. Therefore, shrinking the transaction log file in SQL Server 2005 may differ from shrinking the transaction log file in SQL Server 2000:

If a log file has lots of free space, shrinking the transaction log file in SQL Server 2005 is faster than shrinking the transaction log file in SQL Server 2000.
If a log file has no free space, shrinking the transaction log file in SQL Server 2005 is the same as shrinking the transaction log file in SQL Server 2000.
If a log file has little free space, you may have to perform an additional log backup operation in SQL Server 2005 than you have to perform in SQL Server 2000.

MS SQL SERVER DATE FORMAT

2009-06-20T06:10:00.001-07:00

As How to format date time value or column in to format specific date is the frequent question whenever we do some common operation on the date time related values.

Here I have a summary of the different date time format of the MS SQL Server as a part of CONVERT Function

Output of the following sample queries is in the VARCHAR data type and not of DATETIME data type.

Standard Date Format:

Date Format	Standard	SQL Statement	Output
Mon DD YYYY ¹ HH:MIAM (or PM)	Default	SELECT CONVERT(VARCHAR(20), GETDATE(), 100)	Jan 1 2005 1:29PM ¹
MM/DD/YY	USA	SELECT CONVERT(VARCHAR(8), GETDATE(), 1) AS [MM/DD/YY]	11/23/98
MM/DD/YYYY	USA	SELECT CONVERT(VARCHAR(10), GETDATE(), 101) AS [MM/DD/YYYY]	11/23/1998
YY.MM.DD	ANSI	SELECT CONVERT(VARCHAR(8), GETDATE(), 2) AS [YY.MM.DD]	72.01.01
YYYY.MM.DD	ANSI	SELECT CONVERT(VARCHAR(10), GETDATE(), 102) AS [YYYY.MM.DD]	1972.01.01
DD/MM/YY	British/French	SELECT CONVERT(VARCHAR(8), GETDATE(), 3) AS [DD/MM/YY]	19/02/72
DD/MM/YYYY	British/French	SELECT CONVERT(VARCHAR(10), GETDATE(), 103) AS [DD/MM/YYYY]	19/02/1972
DD.MM.YY	German	SELECT CONVERT(VARCHAR(8), GETDATE(), 4) AS [DD.MM.YY]	25.12.05
DD.MM.YYYY	German	SELECT CONVERT(VARCHAR(10), GETDATE(), 104) AS [DD.MM.YYYY]	25.12.2005
DD-MM-YY	Italian	SELECT CONVERT(VARCHAR(8), GETDATE(), 5) AS [DD-MM-YY]	24-01-98
DD-MM-YYYY	Italian	SELECT CONVERT(VARCHAR(10), GETDATE(), 105) AS [DD-MM-YYYY]	24-01-1998
DD Mon YY ¹	-	SELECT CONVERT(VARCHAR(9), GETDATE(), 6) AS [DD MON YY]	04 Jul 06 ¹
DD Mon YYYY ¹	-	SELECT CONVERT(VARCHAR(11), GETDATE(), 106) AS [DD MON YYYY]	04 Jul 2006 ¹
Mon DD, YY ¹	-	SELECT CONVERT(VARCHAR(10), GETDATE(), 7) AS [Mon DD, YY]	Jan 24, 98 ¹
Mon DD, YYYY ¹	-	SELECT CONVERT(VARCHAR(12), GETDATE(), 107) AS [Mon DD, YYYY]	Jan 24, 1998 ¹
HH:MM:SS	-	SELECT CONVERT(VARCHAR(8), GETDATE(), 108)	03:24:53
Mon DD YYYY HH:MI:SS:MMMAM (or PM) ¹	Default + milliseconds	SELECT CONVERT(VARCHAR(26), GETDATE(), 109)	Apr 28 2006 12:32:29:253PM ¹
MM-DD-YY	USA	SELECT CONVERT(VARCHAR(8), GETDATE(), 10) AS [MM-DD-YY]	01-01-06
MM-DD-YYYY	USA	SELECT CONVERT(VARCHAR(10), GETDATE(), 110) AS [MM-DD-YYYY]	01-01-2006
YY/MM/DD	-	SELECT CONVERT(VARCHAR(8), GETDATE(), 11) AS [YY/MM/DD]	98/11/23
YYYY/MM/DD	-	SELECT CONVERT(VARCHAR(10), GETDATE(), 111) AS [YYYY/MM/DD]	1998/11/23
YYMMDD	ISO	SELECT CONVERT(VARCHAR(6), GETDATE(), 12) AS [YYMMDD]	980124
YYYYMMDD	ISO	SELECT CONVERT(VARCHAR(8), GETDATE(), 112) AS [YYYYMMDD]	19980124
DD Mon YYYY HH:MM:SS:MMM(24h) ¹	Europe default + milliseconds	SELECT CONVERT(VARCHAR(24), GETDATE(), 113)	28 Apr 2006 00:34:55:190 ¹
HH:MI:SS:MMM(24H)	-	SELECT CONVERT(VARCHAR(12), GETDATE(), 114) AS [HH:MI:SS:MMM(24H)]	11:34:23:013
YYYY-MM-DD HH:MI:SS(24h)	ODBC Canonical	SELECT CONVERT(VARCHAR(19), GETDATE(), 120)	1972-01-01 13:42:24
YYYY-MM-DD HH:MI:SS.MMM(24h)	ODBC Canonical (with milliseconds)	SELECT CONVERT(VARCHAR(23), GETDATE(), 121)	1972-02-19 06:35:24.489
YYYY-MM-DDTHH:MM:SS:MMM	ISO8601	SELECT CONVERT(VARCHAR(23), GETDATE(), 126)	1998-11-23T11:25:43:250
DD Mon YYYY HH:MI:SS:MMMAM ¹	Kuwaiti	SELECT CONVERT(VARCHAR(26), GETDATE(), 130)	28 Apr 2006 12:39:32:429AM ¹
DD/MM/YYYY HH:MI:SS:MMMAM	Kuwaiti	SELECT CONVERT(VARCHAR(25), GETDATE(), 131)	28/04/2006 12:39:32:429AM

Here are some more date formats that does not come standard in SQL Server as part of the CONVERT function.

Extended Date Format:

Date Format	SQL Statement	Output
YY-MM-DD	SELECT SUBSTRING(CONVERT(VARCHAR(10), GETDATE(), 120), 3, 8) AS [YY-MM-DD] SELECT REPLACE(CONVERT(VARCHAR(8), GETDATE(), 11), '/', '-') AS [YY-MM-DD]	99-01-24
YYYY-MM-DD	SELECT CONVERT(VARCHAR(10), GETDATE(), 120) AS [YYYY-MM-DD] SELECT REPLACE(CONVERT(VARCHAR(10), GETDATE(), 111), '/', '-') AS [YYYY-MM-DD]	1999-01-24
MM/YY	SELECT RIGHT(CONVERT(VARCHAR(8), GETDATE(), 3), 5) AS [MM/YY] SELECT SUBSTRING(CONVERT(VARCHAR(8), GETDATE(), 3), 4, 5) AS [MM/YY]	08/99
MM/YYYY	SELECT RIGHT(CONVERT(VARCHAR(10), GETDATE(), 103), 7) AS [MM/YYYY]	12/2005
YY/MM	SELECT CONVERT(VARCHAR(5), GETDATE(), 11) AS [YY/MM]	99/08
YYYY/MM	SELECT CONVERT(VARCHAR(7), GETDATE(), 111) AS [YYYY/MM]	2005/12
Month DD, YYYY ¹	SELECT DATENAME(MM, GETDATE()) + RIGHT(CONVERT(VARCHAR(12), GETDATE(), 107), 9) AS [Month DD, YYYY]	July 04, 2006 ¹
Mon YYYY ¹	SELECT SUBSTRING(CONVERT(VARCHAR(11), GETDATE(), 113), 4, 8) AS [Mon YYYY]	Apr 2006 ¹
Month YYYY ¹	SELECT DATENAME(MM, GETDATE()) + ' ' + CAST(YEAR(GETDATE()) AS VARCHAR(4)) AS [Month YYYY]	February 2006 ¹
DD Month ¹	SELECT CAST(DAY(GETDATE()) AS VARCHAR(2)) + ' ' + DATENAME(MM, GETDATE()) AS [DD Month]	11 September ¹
Month DD ¹	SELECT DATENAME(MM, GETDATE()) + ' ' + CAST(DAY(GETDATE()) AS VARCHAR(2)) AS [Month DD]	September 11 ¹
DD Month YY ¹	SELECT CAST(DAY(GETDATE()) AS VARCHAR(2)) + ' ' + DATENAME(MM, GETDATE()) + ' ' + RIGHT(CAST(YEAR(GETDATE()) AS VARCHAR(4)), 2) AS [DD Month YY]	19 February 72 ¹
DD Month YYYY ¹	SELECT CAST(DAY(GETDATE()) AS VARCHAR(2)) + ' ' + DATENAME(MM, GETDATE()) + ' ' + CAST(YEAR(GETDATE()) AS VARCHAR(4)) AS [DD Month YYYY]	11 September 2002 ¹
MM-YY	SELECT RIGHT(CONVERT(VARCHAR(8), GETDATE(), 5), 5) AS [MM-YY] SELECT SUBSTRING(CONVERT(VARCHAR(8), GETDATE(), 5), 4, 5) AS [MM-YY]	12/92
MM-YYYY	SELECT RIGHT(CONVERT(VARCHAR(10), GETDATE(), 105), 7) AS [MM-YYYY]	05-2006
YY-MM	SELECT RIGHT(CONVERT(VARCHAR(7), GETDATE(), 120), 5) AS [YY-MM] SELECT SUBSTRING(CONVERT(VARCHAR(10), GETDATE(), 120), 3, 5) AS [YY-MM]	92/12
YYYY-MM	SELECT CONVERT(VARCHAR(7), GETDATE(), 120) AS [YYYY-MM]	2006-05
MMDDYY	SELECT REPLACE(CONVERT(VARCHAR(10), GETDATE(), 1), '/', '') AS [MMDDYY]	122506
MMDDYYYY	SELECT REPLACE(CONVERT(VARCHAR(10), GETDATE(), 101), '/', '') AS [MMDDYYYY]	12252006
DDMMYY	SELECT REPLACE(CONVERT(VARCHAR(10), GETDATE(), 3), '/', '') AS [DDMMYY]	240702
DDMMYYYY	SELECT REPLACE(CONVERT(VARCHAR(10), GETDATE(), 103), '/', '') AS [DDMMYYYY]	24072002
Mon-YY ¹	SELECT REPLACE(RIGHT(CONVERT(VARCHAR(9), GETDATE(), 6), 6), ' ', '-') AS [Mon-YY]	Sep-02 ¹
Mon-YYYY ¹	SELECT REPLACE(RIGHT(CONVERT(VARCHAR(11), GETDATE(), 106), 8), ' ', '-') AS [Mon-YYYY]	Sep-2002 ¹
DD-Mon-YY ¹	SELECT REPLACE(CONVERT(VARCHAR(9), GETDATE(), 6), ' ', '-') AS [DD-Mon-YY]	25-Dec-05 ¹
DD-Mon-YYYY ¹	SELECT REPLACE(CONVERT(VARCHAR(11), GETDATE(), 106), ' ', '-') AS [DD-Mon-YYYY]	25-Dec-2005 ¹

¹ To make the month name in upper case, simply use the UPPER string function.

This post is for the general look up for my personal use

'this.get_element().style' is null or not an object

2009-06-19T03:29:00.001-07:00

The error occurs in the function "Sys$UI$_UpdateProgress$_startRequest()"
It fails on : " this.get_element().style.display = 'block';"

function Sys$UI$_UpdateProgress$_startRequest() { if (this._pageRequestManager.get_isInAsyncPostBack()) { if (this._dynamicLayout) this.get_element().style.display = 'block'; else this.get_element().style.visibility = 'visible'; } this._timerCookie = null; }

Solution to this problems are

1) had the same problem when the UpdatePanel content was updating really fast and i constantly repeated clicking the update button

Changing the DisplayAfter property to 50 solved it:

DisplayAfter="50" ID="UpdatePanel1Progress" AssociatedUpdatePanelID="UpdatePanel1">

2) Place the UpdateProgress outside the UpdatePanel.

Reason : get_element() is used to get the dom element the behavior is attached to. the
error displayed means the dom object does not have a style property, so its
not a true dom object.

this means that you UpdateProgress control is setup wrong. either you are
missing the template, or gave it a bad AssociatedUpdatePanelID

Sys.InvalidOperationException: ScriptLoader.loadScripts cannot be called while the ScriptLoader is already loading scripts

2009-05-02T02:53:00.000-07:00

whenever we do some quick ajax request in asp.net 3.5 ajax application, for sure we will one javascript error
Sys.InvalidOperationException: ScriptLoader.loadScripts cannot be called while the ScriptLoader is already loading scripts.

The following javascript code is to prevent double postback
on any of the buttons while an async post back is already happening

/*

<script type="text/javascript" language="javascript">
var prm = Sys.WebForms.PageRequestManager.getInstance();
prm.add_initializeRequest(initializeRequest);
prm.add_endRequest(endRequest);var postbackElement;

// checks the PageRequestManager if there is already a postback being processed

// and aborts the postback (question: which postback does it abort?)

// See details here: http://microsoftmiles.blogspot.com/2006/11/maintaining-gridview-scroll-position-in.html

// and http://geekswithblogs.net/rashid/archive/2007/08/08/Asp.net-Ajax-UpdatePanel-Simultaneous-Update---A-Remedy.aspx

function initializeRequest(sender, args)
{
document.body.style.cursor = "wait";
if (prm.get_isInAsyncPostBack())

{

//debugger

args.set_cancel(true);

}

function endRequest(sender, args) {document.body.style.cursor = "default";

}

>

*/

we can get detialed information about this on orignal link -

http://forums.asp.net/p/1173891/1976235.aspx#1976235
http://www.codeplex.com/AjaxControlToolkit/WorkItem/View.aspx?WorkItemId=14712

Regular Expression for asp.net - Most Frequently used

2009-04-14T07:36:00.000-07:00

This post consist of the frequently used regular expression with the asp.net.
with the in short over view with of the regular expression elemnt.

It is collection of the regular expression which i encounter frequently.

Regular Expression Elements

Some of the commonly used regular expression elements are:

^ Matches start of input

$ Matches end of input

. Matches any character except new line

| OR

* Match the preceding expression 0 or more number of times

+ Match the preceding expression 1 or more number of times

? Match the preceding expression 0 or 1 number of times

() Logical group / sub-expression (capture as auto number group)

(?(exp)) Named capture group

(?=exp) Match any position preceding a suffix exp

(?<=exp) Match any position following a prefix exp (?!exp) Match any position after which exp is not found (?]*>(.*?)”

Indian Mobile No

^((\+){0,1}91(\s){0,1}(\-){0,1}(\s){0,1}){0,1}9[0-9](\s){0,1}(\-){0,1}(\s){0,1}[1-9]{1}[0-9]{7}$

Matches
9836193498 +919836193498 9745622222
Non-Matches
+9197456222222 8745622222 9836193481

IsAlphaNumeric

^a-zA-Z0-9

Start With Character and contian alphanumeric

^[a-zA-Z][a-zA-Z0-9]*$

Contianing format like this 12345-67890

^[0-9]{5}[-][0-9]{5}$

Mobile numbar validation start with 9 and 9 digit long

^[9][0-9]{9}$

trailing and leading spaces

^[ \t]+|[ \t]+$

NameValidationRegularExpression = "^[a-zA-Z]+(([\'\\,\\.\\-][a-zA-Z])?[a-zA-Z]*)*$"; ^[a-zA-Z0-9]+(([\'\\,\\.\\-][a-zA-Z0-9])?[a-zA-Z0-9]*)*$ ;

NumberValidationRegularExpression = "^([1-9]([0-9])+)$";

AlphaNumericValidationRegularExpression = "^([a-zA-Z0-9]+)$"; , ^[a-zA-Z0-9]+(\s*)

DateValidationRegularExpression = "^(01|1|02|2|3|03|5|05|4|04|06|6|7|07|8|08|10|9|09|11|12)[/-]((31(?! (02|04|06|09|11|2|4|6|9)))|((30|29)(?! 02))|(29(?= 02 (((1[6-9]|[2-9]\\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)))))|(0?[1-9])|1\\d|2[0-8])[/-]((1[6-9]|[2-9]\\d)\\d{2})$";

EmailIdValidationRegularExpression = "^([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\.)+))([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$";

ZipCodeValidationRegularExpression = "^\\d{5}((-|\\s)?\\d{4})?$";

PhoneValidationRegularExpression = "((\$\\d{3}\$ ?)|(\\d{3}-))?\\d{3}-\\d{4}";

CurrencyValidationRegularExpression = "^\\$?\\-?([1-9]{1}[0-9]{0,2}(\\,\\d{3})*(\\.\\d{0,2})?|[1-9]{1}\\d{0,}(\\.\\d{0,2})?|0(\\.\\d{0,2})?|(\\.\\d{1,2}))$|^\\-?\\$?([1-9]{1}\\d{0,2}(\\,\\d{3})*(\\.\\d{0,2})?|[1-9]{1}\\d{0,}(\\.\\d{0,2})?|0(\\.\\d{0,2})?|(\\.\\d{1,2}))$|^\$\\$?([1-9]{1}\\d{0,2}(\\,\\d{3})*(\\.\\d{0,2})?|[1-9]{1}\\d{0,}(\\.\\d{0,2})?|0(\\.\\d{0,2})?|(\\.\\d{1,2}))\$$";

NameValidationRegularExpression = "^([a-zA-Z0-9-]{1,25})$";

GuidValidationRegularExpression ="^\\{?[a-zA-Z\\d]{8}-([a-zA-Z\\d]{4}-){3}[a-zA-Z\\d]{12}\\}?$";

URLValidationExpression = "^(http|https|ftp)\\://((([a-z_0-9\\-]+)+(([\\:]?)+([a-z_0-9\\-]+))?)(\\@+)?)?(((((([0-1])?([0-9])?[0-9])|(2[0-4][0-9])|(2[0-5][0-5])))\\.(((([0-1])?([0-9])?[0-9])|(2[0-4][0-9])|(2[0-5][0-5])))\\.(((([0-1])?([0-9])?[0-9])|(2[0-4][0-9])|(2[0-5][0-5])))\\.(((([0-1])?([0-9])?[0-9])|(2[0-4][0-9])|(2[0-5][0-5]))))|((([a-z0-9\\-])+\\.)+([a-z]{2}\\.[a-z]{2}|[a-z]{2,4})))(([\\:])(([1-9]{1}[0-9]{1,3})|([1-5]{1}[0-9]{2,4})|(6[0-5]{2}[0-3][0-6])))?$";

FederalIDValidationExpression = "^([a-zA-Z 0-9\\-]+)$";

Name = ^[a-zA-Z0-9'@#_\-\*\./\\:`~\s\^]+(\s*)

Decimal(11,3)--- ^[1-9]\d{0,10}(\.\d{0,3})?$

Only Small case alphabates - ^[a-z]*$

credit card (card number which has totally 16 digit

after every 4 digit it has "-" or not contain.) - ^(\d{4}-){3}\d{4}$|^(\d{4} ){3}\d{4}$|^\d{16}$

URL - ?(http:[/][/]|www.)([a-z]|[A-Z]|[0-9]|[/.]|[~])*

IPAddress - ?:(?:25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)(?(?=\.?\d)\.)){4}$

email address - ^([a-zA-Z0-9_\-\.]+)@([a-zA-Z0-9_\-\.]+)\.([a-zA-Z]{2,5})$

Time - ?^(?:0?[1-9]:[0-5]|1(?=[012])\d:[0-5])\d(?:[ap]m)?

ShortDate - ?\d{1,2})/(?\d{1,2})/(?(?:\d{4}|\d{2}

Long Date - 31(?!\ (Feb(ruary)?|Apr(il)?|June?|(Sept|Nov)(ember)?)))|((30|29)(?!\ Feb(ruary)?))|(29(?=\ Feb(ruary)?\ (((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)))))|(0?[1-9])|1\d|2[0-8])\ (Jan(uary)?|Feb(ruary)?|Ma(r(ch)?|y)|Apr(il)?|Ju((ly?)|(ne?))|Aug(ust)?|Oct(ober)?|(Sept|Nov|Dec)(ember)?)\ ((1[6-9]|[2-9]\d)\d{2})$

Not Natural - [^0-9]

Natural - 0*[1-9][0-9]*

Whole No - [^0-9]

IsAlpha - [^a-zA-Z]

Is AlphaNumeric - [^a-zA-Z0-9]

date Format (for MM/DD/YYYY format) - ([1-9]|1[012])[- /.]([1-9]|[12][0-9]|3[01])[- /.](19|20)\d\d

date Format (for DD/MM/YYYY format) - (0[1-9]|[12][0-9]|3[01])[- /.](0[1-9]|1[012])[- /.](19|20)\d\d

for Day - ^((([1-9]?)|([1-2][0-9])?)|([3][0-1]?))$

for Month - ^((([1-9]?)|([0][1-9])?)|([1][0-2]?))$

for year - [0-9]{4}

Strip html tags from string - <(.|\n)+?>

Us Telephone pattern - ^($\d{3}$[- ]?|\d{3}[- ])?\d{3}[- ]\d{4}$

Matches
(555)555-5555 | (555) 555-5555 | 555-5555
Non-Matches
5555555555 | 555.555.5555 | (555 555-5555

here are some Regular expressions for html parsing . you can use it in your application while parsing html table to fetch data from it

1.
Table Expression = “]*>(.*?)”
2.
Header Expression = “]*>(.*?)”
3. Row Expression = “]*>(.*?)”
4. Column Expression = “]*>(.*?)”

Script Block Parser

(?<=src=")[^"]*(?="))[^>]*)|[^>]*)>(?(?:(?:\n|.)(?!(?:\n|.)

Programmatically adding JavaScript File to Asp.Net page ( Using code behind)

2009-04-08T03:42:00.001-07:00

we can programmaticaly add javascript file to the aspx page if we dont want to add our JavaScript file declaratively via HTML to our ASP.Net page.

We can add this just like this...
its very simple --- only once we use it or know about it :)

we just have to add following code like this

protected void Page_Init(object sender, EventArgs e)
{
HtmlGenericControl js = new HtmlGenericControl("script");
js.Attributes["type"] = "text/javascript";
js.Attributes["src"] = "js/myfunctions.js";
Page.Header.Controls.Add(js);
}

we can use this approach in adding the conditional javascrip file to our page for the SEO purpose...or it depends upon the context how to use it...but we can

ASP.NET Event Order Pages, UserControls, MasterPages and HttpModules

2009-03-14T01:46:00.000-07:00

I found article that shows the order of events for Pages, UserControls, Master Pages and HttpModules I am going to use it as easy to find collection.

You can find the entire orignal post here http://forums.asp.net/t/1191194.aspx

Special thanks to Mike Banavige.

Understanding the Page Life Cycle can be very important as you begin to build Pages with MasterPages and UserControls.

Does the Init event fire first for the Page, the MasterPage or the UserControl?
What about the Load event?

If you make an incorrect assumption about the sequence that these events fire, then you may end up with a page that simply doesn't behave the way you had anticipated.

By running a simple test, we can see exactly when each event fires. Our test setup is composed of a Page, MasterPage, UserControl, Nested UserControl and Button control as follows:

*
The Page is tied to the MasterPage
*
The UserControl is on the Page
*
The Nested UserControl is on the UserControl
*
The Button is on the Nested UserControl.
*
Clicking the Button calls the Page.DataBind method

Each event on these controls has been set to call Debug.WriteLine as each event is raised. In addition to the events that get raised for regular pages, I've also set up an HttpModule and wired up all of those events as well. The results in the Debug output window of running this page and Clicking the Button are as follows:

BeginRequest - HttpModule
AuthenticateRequest - HttpModule
PostAuthenticateRequest - HttpModule
PostAuthorizeRequest - HttpModule
ResolveRequestCache - HttpModule
PostResolveRequestCache - HttpModule
PostMapRequestHandler - HttpModule
AcquireRequestState - HttpModule
PostAcquireRequestState - HttpModule
PreRequestHandlerExecute - HttpModule

PreInit - Page

Init - ChildUserControl
Init - UserControl
Init - MasterPage
Init - Page

InitComplete - Page

LoadPageStateFromPersistenceMedium - Page

ProcessPostData (first try) - Page

PreLoad - Page

Load - Page
Load - MasterPage
Load - UserControl
Load - ChildUserControl

ProcessPostData (second try) - Page

RaiseChangedEvents - Page
RaisePostBackEvent - Page

Click - Button - ChildUserControl

DataBinding - Page
DataBinding - MasterPage
DataBinding - UserControl
DataBinding - ChildUserControl

LoadComplete - Page

PreRender - Page
PreRender - MasterPage
PreRender - UserControl
PreRender - ChildUserControl

PreRenderComplete - Page

SaveViewState - Page
SavePageStateToPersistenceMedium - Page
SaveStateComplete - Page

Unload - ChildUserControl
Unload - UserControl
Unload - MasterPage
Unload - Page

PostRequestHandlerExecute - HttpModule
ReleaseRequestState - HttpModule
PostReleaseRequestState - HttpModule
UpdateRequestCache - HttpModule
PostUpdateRequestCache - HttpModule
EndRequest - HttpModule
PreSendRequestHeaders - HttpModule
PreSendRequestContent - HttpModule

Mike Banavige
~~~~~~~~~~~~

Pivot Query With SQL Server 2005

2009-03-03T22:59:00.000-08:00

In SQL Server 2005 we have operator called PIVOT with this operater CASE statement and GROUP BY statements are no longer necessary.

Every PIVOT Query involves the aggregation of some type so we can omit the GROUP BY Statement.PIVOT Operator provides the same functionality that we can achieve with the CASE Statement.

PIVOT Operator allows us to rotate row level data into the tabular level data without use of the case statement.

we will see the one simple example which i did as a RnD for the same...

for example purpose we will create one simple table as like this

create table pwPIVOTrnd
(
pwCol1 int,
pwCol2 int
)

after this we will insert some dummy data to the table

insert into pwPIVOTrnd values (1, 2)
insert into pwPIVOTrnd values (2, 22)
insert into pwPIVOTrnd values (3, 370)

after this we sil see the output of the

select * from pwPIVOTrnd

output will look like this

pwCol1 pwCol2
1 2
2 22
3 370

Now we want to rotate all rows of pwCol2 into the single row :)

means 2, 22 , 370 will come in the one single row

we will see the query and its result so that it will be crystal clear

select distinct [1]as IstRowAsIstCol, [2] as SecondRowAsSecondCol, [3] as ThirdRowAsThirdCol
from
(
select pwCol1, pwCol2 from pwPIVOTrnd tp
) as H
pivot
(
avg(pwCol2)
For pwCol1 in ([1], [2], [3])
) as pvt

IstRowAsIstCol SecondRowAsSecondCol ThirdRowAsThirdCol
2 22 370

so we got the out like above...same result can be achived with using the CASE but it will take more coding and time.

for column in([1],[2],[3]) we have to mention therow data which we want to select as column, so [1],[2],[3] are the row data of column1

Limitation of PIVOT Operator

Much of the functionality provided by the PIVOT Operator requires to "HARDCORE" the fields that we are pivoting into columnar data.

other one thing is that with PIVOT we can aggregate only one field in resultset where as with the case we can aggregate with more than one field.

Empty data template for repeater control

2009-02-28T03:07:00.000-08:00

In one of my project i need to use the repeater control plenty of times and considering the problem of the empty template i though to Google it out

mean while i got plenty of reference on the net...few are really good which will check the item count in the repeater and based on it it repeater's visible property is changed.

means if count is 0 den make the repeater as visible="false" this is ok for the condition where we need it on 2-3 pages...

i was looking around for an article on how to extend the repeater control to add an empty data template similar to the Grid View control.

here is the code...

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.Collections;
using System.Web.UI.WebControls;

///

/// Summary description for MyRepeater
///

namespace prawinway.test
{
public class MyRepeater : Repeater
{

public ITemplate EmptyDataTemplate{get;set;}

protected override void CreateControlHierarchy( bool useDataSource )
{
IEnumerable data = GetData();
if (EmptyDataTemplate != null && data != null && !data.GetEnumerator().MoveNext())
{
WebControl control = new WebControl( HtmlTextWriterTag.Div );
EmptyDataTemplate.InstantiateIn(control);
Controls.Add( control );
}
else
{
base.CreateControlHierarchy( useDataSource );
}
}
}
}

herw we are extending MyRepeater class from the Repeater and added one propert for EmptyDataTemplate.

we can register this within our aspx page as :

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="myrepeatertest.aspx.cs" Inherits="myrepeatertest" %>
<%@ Register TagPrefix="prawinway" Namespace="prawinway.test" Assembly="MyRepeater" %>

Total HTML for this will look like this

It will run like a charm...even we can ad the additional functionality like custom paging and sorting with some modification with extending repeater control.

Happy Programming

SQL Stored Procedure Paging With the Dynamic Query

2009-02-26T00:00:00.000-08:00

SQL Procedure Paging With Dynamic query :

In the previous post i have written the Dynamic Query generation with the stored procedure. It runs like a charm.

But my requirement changed a often...as i have to display search data in the repeater with paging.
In the database i have huge data and doing traditional paging is not the advisable way to do it.

So i thought to write the some logic which will fetch only records which we have to display on the page.
means if i have to display page number 1 with 10 records on each page i will fetech only 10 records from the database.

The procedure which i have written for Generating dynamic Query with the Stored procedure Based on the optional input parameter.

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
go

/* This is sample stored procedure that builds dynamic SQL for product search */

ALTER Procedure [dbo].[Usprpm_SearchProduct]

/* Input Parameters it will take all parametet on which the user can search the product(all parameters are optional) */

@dresstype VARCHAR(50) = NULL,
@worktype VARCHAR(50) = NULL,
@material VARCHAR(50) = NULL,
@category VARCHAR(50) = NULL,
@keyword VARCHAR(50) = NULL,
@catalog VARCHAR(50) = NULL,
@weight FLOAT = NULL,
@pricelow DECIMAL(18,0) = NULL,
@pricehigh DECIMAL(18,0) = NULL,
@color VARCHAR(50) = NULL,
@code VARCHAR(50) = NULL,
@sizetype VARCHAR(50) = NULL,
@newarrival BIT = NULL

AS
Set NoCount ON

/* Variable Declaration */

Declare @SQLstrquesry AS NVarchar(4000)

Declare @ParameterDefinition AS NVarchar(2000)

/* Build the Transact-SQL String with the input parameters */

Set @SQLstrquesry = 'Select * from rpm_product where (1=1) '

/* check for the condition and build the WHERE clause accordingly */

If @dresstype Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (dresstype = @dresstype)'

If @worktype Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (worktype = @worktype)'

If @material Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (material = @material)'

If @category Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (category = @category)'

If @keyword Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (keyword = @keyword)'

If @material Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (material = @material)'

If @weight Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (weight <= @weight)'

If @color Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (color LIKE % @color %)'

If @code Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (code = @code)'

If @sizetype Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (sizetype = @sizetype)'

-- this section is used to check for the lower and upper limit of the price...user can select none, lowest price, highest price or the none

if ((@pricelow Is Not Null) and (@pricehigh Is Not Null))
Set @SQLstrquesry = @SQLstrquesry + ' And (price BETWEEN @pricelow AND @pricehigh)'

else if(@pricelow Is Not Null)
Set @SQLstrquesry = @SQLstrquesry + ' And (price >= @pricelow)'

else if (@pricehigh Is Not Null)
Set @SQLstrquesry = @SQLstrquesry + ' And (price <= @pricehigh)'

-- checking if the user wants to check with the newarrival if yes then
if ((@newarrival Is Not Null) and (@newarrival=1))
Set @SQLstrquesry = @SQLstrquesry + ' And (newarrival = 1 )'

/* Specify Parameter Format for all input parameters included
in the stmt */

Set @ParameterDefinition =
'@dresstype VARCHAR(50),
@worktype VARCHAR(50),
@material VARCHAR(50),
@category VARCHAR(50),
@keyword VARCHAR(50),
@catalog VARCHAR(50),
@weight FLOAT,
@pricelow DECIMAL(18,0),
@pricehigh DECIMAL(18,0),
@color VARCHAR(50),
@code VARCHAR(50),
@sizetype VARCHAR(50),
@newarrival BIT'

/* Execute the Transact-SQL String with all parameter value's
Using sp_executesql Command */

Execute sp_Executesql @SQLstrquesry,
@ParameterDefinition,
@dresstype,
@worktype,
@material,
@category,
@keyword,
@catalog,
@weight,
@pricelow,
@pricehigh,
@color,
@code,
@sizetype,
@newarrival

If @@ERROR <> 0 GoTo ErrorHandler
Set NoCount OFF
Return(0)

ErrorHandler:

Return(@@ERROR)

We can check it like this.

EXEC Usprpm_SearchProduct 'dress type', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ,NULL, NULL

after thinking i have written one stroed produre( actually i taken help of google/live -
and there are lot of sample to do it...i have taken the basic idea from there)

and for test the procedure which will fetech the records based on the pageno and number of records is like this -

CREATE PROCEDURE uspPagingTest

@Int_PageNo int,
@Int_RecordPerPage int

AS
Declare @Int_From_Page int,@int_To_Page int,@Int_Total_Records int

set @Int_From_Page = ((@Int_PageNo-1)*@Int_RecordPerPage)+1

set @int_To_Page = @Int_PageNo*@Int_RecordPerPage

print @Int_From_Page

print @int_To_Page

SET NOCOUNT ON;

Select @Int_Total_Records=Count(*) From rpm_product;

DECLARE @tblTemprpm_product TABLE
(
nID INT IDENTITY,
productid INT,
dresstype VARCHAR(50),
color VARCHAR(50),
code VARCHAR(50),
imgsmall1 VARCHAR(80)
)

INSERT INTO @tblTemprpm_product
(
productid,
dresstype,
color,
code,
imgsmall1
)SELECT
productid,
dresstype,
color,
code,
imgsmall1
FROM rpm_product
ORDER BY
productid

SELECT productid,
dresstype,
color,
code,
imgsmall1
FROM @tblTemprpm_product
WHERE nID BETWEEN @Int_From_Page and @int_To_Page
ORDER BY
nID ASC

We can check it

exec uspPagingTest 1, 9
exec uspPagingTest 2, 9

now main thing is that i have to integrating these two stored procedure to create one robust stroed procedure
which will generate the dynamic query based on the optional search parameter and the paging with
the required record fetching instead of unnecessarily fetching all records for every request.

Now one things come under the scanner for each request
we have to pass the all parameter (first sp and second sp parameter in a single sp)
or call one sp in the other.

even though we can archive it in both way.
I have decided to call one procedure through the other.

I have decided to call Usprpm_SearchProduct from uspPagingTest:

instead of inserting records from rpm_product table i have decided to insert records
to our temptable from the search query which we will get from the Usprpm_SearchProduct stored procedure.

Means we have to pass all parameter to our uspPagingTest stored procedure
which will internally call our dynamic query generation stored procedure to insert
the records in our temp table and we will get each the required records from that temp table to display.

final stored procedure will look like this.

CREATE PROCEDURE Usprpm_PagingResult

@Int_PageNo int,
@Int_RecordPerPage int,

--these input parameter are added

@dresstype VARCHAR(50) = NULL,
@worktype VARCHAR(50) = NULL,
@material VARCHAR(50) = NULL,
@category VARCHAR(50) = NULL,
@keyword VARCHAR(50) = NULL,
@catalog VARCHAR(50) = NULL,
@weight FLOAT = NULL,
@pricelow DECIMAL(18,0) = NULL,
@pricehigh DECIMAL(18,0) = NULL,
@color VARCHAR(50) = NULL,
@code VARCHAR(50) = NULL,
@sizetype VARCHAR(50) = NULL,
@newarrival BIT = NULL

AS
Declare @Int_From_Page int,@int_To_Page int,@Int_Total_Records int

set @Int_From_Page = ((@Int_PageNo-1)*@Int_RecordPerPage)+1

set @int_To_Page = @Int_PageNo*@Int_RecordPerPage

print @Int_From_Page

print @int_To_Page

SET NOCOUNT ON;

DECLARE @tblTemprpm_product TABLE
(
nID INT IDENTITY,
productid INT,
dresstype VARCHAR(50),
worktype VARCHAR(50),
material VARCHAR(50),
category VARCHAR(50),
keyword VARCHAR(50),
catalog VARCHAR(50),
weight FLOAT,
price Decimal,
color VARCHAR(50),
sizetype VARCHAR(50),
code VARCHAR(50),
imgsmall1 VARCHAR(80),
imgmedium1 VARCHAR(80),
imgbig1 VARCHAR(80),
imgsmall2 VARCHAR(80),
imgmedium2 VARCHAR(80),
imgbig2 VARCHAR(80),
issingleimage BIT,
isleftorrightimage BIT,
adjoiningproductid VARCHAR(50),
instock BIT,
isdisplay BIT,
newarrival BIT
)

INSERT INTO @tblTemprpm_product
(
productid,
dresstype,
worktype,
material,
category,
keyword,
catalog,
weight,
price,
color,
sizetype,
code,
imgsmall1,
imgmedium1,
imgbig1,
imgsmall2,
imgmedium2,
imgbig2,
issingleimage,
isleftorrightimage,
adjoiningproductid,
instock,
isdisplay,
newarrival
)
EXEC Usprpm_SearchProduct @dresstype, @worktype, @material,
@category, @keyword, @catalog, @weight,
@pricelow, @pricehigh, @color, @code,
@sizetype, @newarrival

--here I have applied the logiv of fetehcing the records based on the search parameter
-- I am calling the search dymanmic query genration stored procedure.

Select @Int_Total_Records=Count(*) From @tblTemprpm_product;

SELECT productid,
dresstype,
worktype,
material,
category,
keyword,
catalog,
weight,
price,
color,
sizetype,
code,
imgsmall1,
imgmedium1,
imgbig1,
imgsmall2,
imgmedium2,
imgbig2,
issingleimage,
isleftorrightimage,
adjoiningproductid,
instock,
isdisplay,
newarrival
FROM @tblTemprpm_product
WHERE nID BETWEEN @Int_From_Page and @int_To_Page
ORDER BY
nID ASC

and the stored procedure which we have used earlier called Usprpm_SearchProduct will be same.

Even we can use out parameter for the Total number of records for the search result.

Off course there are many other way to archive this..but at the moment
i felt this is easy and efficient solution for my problem.Even we can customize it and write it more efficiently for achieving even more efficient results.

Happy programming and cheers !!!!

Dynamic SQL Query with Stored Procedure

2009-02-23T01:25:00.000-08:00

Dynamic SQL Query with Stored Procedure

Generally we need the Dynamic SQL Queries when we want to fetch the records based on the criteria for the given context from the database.

Given the context I wanted to write the search for the product where user can search the product based on the various parameter with all parameter having the optional base.

after looking the requirement i though to write the query based on the given condtion directly in to the coding but taking security and the performance thread into the account i decided to write the Dynamic SQL Query in the Stored Procedure itself.

Even you can find the other article on the net which does the same work and may be they are more efficient than this.

This just for the my own future reference...so that whenever need arise in future i can just look into it....and after doing few modification...i can use it again.

This is what the sole purpose of this post.

/* This is sample stored procedure that builds dynamic SQL for product search */

ALTER Procedure Usprpm_SearchProduct

/* Input Parameters it will take all parametet on which the user can search the product(all parameters are optional) */

@dresstype VARCHAR(50) = NULL,
@worktype VARCHAR(50) = NULL,
@material VARCHAR(50) = NULL,
@category VARCHAR(50) = NULL,
@keyword VARCHAR(50) = NULL,
@catalog VARCHAR(50) = NULL,
@weight FLOAT = NULL,
@pricelow DECIMAL(18,0) = NULL,
@pricehigh DECIMAL(18,0) = NULL,
@color VARCHAR(50) = NULL,
@code VARCHAR(50) = NULL,
@sizetype VARCHAR(50) = NULL,
@newarrival BIT = NULL

AS
Set NoCount ON

/* Variable Declaration */

Declare @SQLstrquesry AS NVarchar(4000)

Declare @ParameterDefinition AS NVarchar(2000)

/* Build the Transact-SQL String with the input parameters */

Set @SQLstrquesry = 'Select * from rpm_product where (1=1) '

/* check for the condition and build the WHERE clause accordingly */

If @dresstype Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (dresstype = @dresstype)'

If @worktype Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (worktype = @worktype)'

If @material Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (material = @material)'

If @category Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (category = @category)'

If @keyword Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (keyword = @keyword)'

If @material Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (material = @material)'

If @weight Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (weight <= @weight)'

If @color Is Not Null
Set @SQLstrquesry = @SQLstrquesry + ' And (color LIKE % @color %)'

If @code Is Not Null Set @SQLstrquesry = @SQLstrquesry + ' And (code = @code)'

If @sizetype Is Not Null Set @SQLstrquesry = @SQLstrquesry + ' And (sizetype = @sizetype)'

-- this section is used to check for the lower and upper limit of the price...user can select none, lowest price, highest price or the none

if ((@pricelow Is Not Null) and (@pricehigh Is Not Null))
Set @SQLstrquesry = @SQLstrquesry + ' And (price BETWEEN @pricelow AND @pricehigh)'
else if(@pricelow Is Not Null) Set @SQLstrquesry = @SQLstrquesry + ' And (price >= @pricelow)'
else if (@pricehigh Is Not Null)
Set @SQLstrquesry = @SQLstrquesry + ' And (price <= @pricehigh)' -- checking if the user wants to check with the newarrival if yes then
if ((@newarrival Is Not Null) and (@newarrival=1)) Set @SQLstrquesry = @SQLstrquesry + ' And (newarrival = 1 )'
/* Specify Parameter Format for all input parameters included in the stmt */
Set @ParameterDefinition = ' @dresstype VARCHAR(50),
@worktype VARCHAR(50),
@material VARCHAR(50),
@category VARCHAR(50),
@keyword VARCHAR(50),
@catalog VARCHAR(50),
@weight FLOAT,
@pricelow DECIMAL(18,0),
@pricehigh DECIMAL(18,0),
@color VARCHAR(50),
@code VARCHAR(50),
@sizetype VARCHAR(50),
@newarrival BIT'

/* Execute the Transact-SQL String with all parameter value's Using sp_executesql Command */

Execute sp_Executesql @SQLstrquesry, @ParameterDefinition, @dresstype, @worktype, @material, @category, @keyword, @catalog, @weight, @pricelow, @pricehigh, @color, @code, @sizetype, @newarrival If @@ERROR <> 0 GoTo ErrorHandler

Set NoCount OFF
Return(0)

ErrorHandler:

Return(@@ERROR)

GO

after creating the procdure we can execute it for test as follows

EXEC Usprpm_SearchProduct 'dress type', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ,NULL, NULL

this will return all the matching records based on the search paramater we passed

Happy programming :)

What we can do with Global.asax in asp.net

2009-02-21T01:43:00.000-08:00

What we can do with Global.asax in asp.net

Writing logic at the application level.
Handling events or error at the application level.
Defining Even handler with the application or session-wide scope.

:)

The Global.asax -

Also known as the ASP.NET application file.
Located in the root directory of an ASP.NET application.
This file contains code that is executed in response to application-level and session-level events raised by ASP.NET or by HTTP modules.
We can also define ‘objects’ with application-wide or session-wide scope in the Global.asax file. These events and objects declared in the Global.asax are applied to all resources in that web application.
The Global.asax is an optional file. Use it only when there is a need for it.
If a user requests the Global.asax file, the request is rejected. External users cannot view the file.
The Global.asax file is parsed and dynamically compiled by ASP.NET. WE deploy this file as an assembly in the \bin directory of an ASP.NET application.

Adding global.asax file to our project(web) is simple - (in VS2005 and VS2008)

Create a new website > Go to the Solution Explorer > Add New Item > Global Application Class > Add

In Global.asax methods fires corresponding to events and there are two sets which fires corrosponding to the event -

1) Enovokes on every request
2) Does not envoke on every request

Envokes on every request :

These are the methods corresponding to events that fire on each request.

Application_BeginRequest() – fired when a request for the web application comes in we can use it for application level use when the application starts.

Application_AuthenticateRequest() –fired just before the user credentials are authenticated. We specify your own authentication logic over here.

Application_AuthorizeRequest() – fired on successful authentication of user’s credentials. We use this method to give authorization rights to user.

Application_ResolveRequestCache() – fired on successful completion of an authorization request.

Application_AcquireRequestState() – fired just before the session state is retrieved for the current request.

Application_PreRequestHandlerExecute() - fired before the page framework begins before executing an event handler to handle the request.

Application_PostRequestHandlerExecute() – fired after HTTP handler has executed the request.

Application_ReleaseRequestState() – fired before current state data kept in the session collection is serialized.

Application_UpdateRequestCache() – fired before information is added to output cache of the page.

Application_EndRequest() – fired at the end of each request

Does not envoke on every request :

These are the methods corresponding to events that do not fire on each request

Application_Start() – fired when the first resource is requested from the web server and the web application starts.

Session_Start() – fired when session starts on each new user requesting a page.

Application_Error() – fired when an error occurs.

Session_End() – fired when the session of a user ends.

Application_End() – fired when the web application ends.

Application_Disposed() - fired when the web application is destroyed.

A Simple example shows how we can catach unhandled errors that occur at the application level.

void Application_Error(object sender, EventArgs e)

{

// This code will runs whenever unhandled error occurs in the
// Here we can write logic for error log or something

Exception objError = Server.GetLastError().GetBaseException();

string error =
"Error in: " + Request.Url.ToString() + "Error Message:" + objError.Message.ToString();

}

In one case i have used application_start to count the no of user visiting to the sites and display it.

We can use this little file as per our requirement with the some logic on the particular event amazingly.....

happy programming !!!!!!!!!!

F# - functional programming language for the .NET Framework.

2009-02-14T01:58:00.000-08:00

F# is a functional programming language for the .NET Framework. It combines the succinct, expressive, and compositional style of functional programming with the runtime, libraries, interoperability, and object model of .NET.

you can get additional in detials information about the language on the microsoft website

http://msdn.microsoft.com/en-us/fsharp/default.aspx

The best times for using it are for things that involve doing some number crunching and string manipulation.

For those of you that have not looked at F# yet, you can learn about it here.

Also, there is a download available for Visual Studio 2008 that lets you start using it.

This is also some great information in hubFS. That is a great place to see example code and ask people how to do some things in F#. I would also suggest checking out this post, The F# Operators and Basic Functions.

Keep in mind that F# is a functional programming language. So this allows you to have all the power of a functional language, and still be in .NET and use tools you are familiar with.

One example of using F# is Luca Bolognese’s Financial Functions.

Hope programmer will like this language.