Application Development

2010-08-28T03:13:00.000-07:00

Windows® Communication Foundation (WCF), formerly code-named "Indigo," is about to radically change the face of distributed programming for developers using the Microsoft® .NET Framework. WCF unifies the existing suite of .NET distributed technologies into a single programming model that improves the overall developer experience through a consistent architecture, new levels of functionality and interoperability, and all the extensibility points you could want. This article introduces you to WCF programming and shows you how to get started.

As its name suggests, WCF provides the .NET Framework with a basis for writing code to communicate across components, applications, and systems. WCF was designed according to the tenets of service orientation. A service is a piece of code you interact with through messages. Services are passive. They wait for incoming messages before doing any work. Clients are the initiators. Clients send messages to services to request work.

Figure 1 Services and Endpoints

Services expose one or more endpoints where messages can be sent. Each endpoint consists of an address, a binding, and a contract (see Figure 1). The address specifies where to send messages. The binding describes how to send messages. And the contract describes what the messages contain. Clients need to know this information before they can access a service.

Services can package up endpoint descriptions to share with clients, typically by using Web Services Description Language (WSDL). Then clients can use the provided service description to generate code within their environment capable of sending and receiving the proper messages (see Figure 2).

Figure 2 Sharing Endpoint Descriptions

Windows Communication Foundation provides a new library of classes found in the System.ServiceModel namespace that bring these service-oriented concepts to life. This is what's typically referred to as the WCF programming model.

WCF Programming Model

With WCF, you're either writing services that expose endpoints or you're writing clients that interact with endpoints. Hence, endpoints are central to the WCF programming model and infrastructure. WCF models endpoints with the .NET classes and interfaces shown in Figure 3. This mapping is true whether you're writing WCF clients or services.

Figure 3 WCF Classes and Interfaces

Element	Class or Interface
Endpoint	System.ServiceModel.ServiceEndpoint
Address	System.Uri
Binding	System.ServiceModel.Binding
Contract	Interfaces annotated with System.ServiceModel attributes

When building a WCF service, you typically start by defining a .NET interface definition to serve as the service contract. Then you implement the service contract in a .NET class, known as the service type, and configure its behavior. Next, you define the endpoints the service will expose, specifying the address, binding, and contract for each one. Finally, you host the service type in an application using the WCF hosting infrastructure. Once the service type is hosted, clients can retrieve its endpoint descriptions and begin integrating with it.

When building a WCF client, you first need the description of the target endpoint you want to access. The endpoint description can be used to dynamically create a typed proxy. WCF provides a tool named SvcUtil.exe for automating this process. Then you can write code against the typed proxy to access the service by sending the appropriate messages to the target endpoint.

Service Contracts and Dispatch Behavior

You model service contracts in .NET using traditional C# interface definitions. You can use any .NET interface as a starting point, such as the one shown here:

" href="javascript:CopyCode('ctl00_MTContentSelector1_mainContentContainer_ctl06_code');">

namespace ServiceLibrary

{

 public interface IEchoService

 {

     string Echo(string msg);

 }

}

To make this a WCF service contract, you must annotate the interface itself with [ServiceContract] and each operation you want to expose with [OperationContract]:

href="javascript:CopyCode('ctl00_MTContentSelector1_mainContentContainer_ctl07_code');">

using System.ServiceModel;



namespace ServiceLibrary

{

 [ServiceContract(Namespace="http://example.org/echo/")]

 public interface IEchoService

 {

     [OperationContract]

     string Echo(string msg);

 }

}

These attributes influence the mapping between the worlds of .NET and SOAP. WCF uses the information found in the service contract to perform dispatching and serialization. Dispatching is the process of deciding which method to call for an incoming SOAP message. Serialization is the process of mapping between the data found in a SOAP message and the corresponding .NET objects used in the method invocation. This mapping is controlled by an operation's data contract.

WCF dispatches based on the message action. Each method in a service contract is automatically assigned an action value based on the service namespace and method name. For example, the default action for the Echo method just shown is http://example.org/echo/Echo. You can customize the action value for each method using [OperationContract]. A value of * can be used for any action when a specific match doesn't exist.

In the following example, WCF will dispatch messages with an action of urn:echo:string to the Echo method. Messages with any other action are dispatched to the EchoMessage method:

[ServiceContract(Namespace="http://example.org/echo/")]

public interface IEchoService

{

 [OperationContract(Action="urn:echo:string")]

 string Echo(string msg);



 [OperationContract(Action="*")]

 Message EchoMessage(Message msg);

}

Data Contracts

Once the target method has been determined based on the action, WCF relies on the method's data contract to perform serialization. The data contract is defined by the types used in the method signature. In the previous example, EchoMessage is generic and could be used to process a variety of incoming SOAP messages. Therefore I've used Message to model the input and output. Message is a special type used to represent all messages flowing through WCF. When using Message, WCF does not perform type-based serialization. Instead, it just gives you direct access to what's found in the SOAP message.

When Message is not used, WCF performs serialization to map between the data found in the SOAP message and the corresponding .NET objects needed to invoke the method. For example, in the case of Echo, WCF maps the SOAP payload to a .NET string. WCF provides an implicit mapping for all .NET primitive types (string, int, double, and so on).

The way WCF serializes .NET classes depends on the serialization engine in use. The default serialization engine is known as DataContract, a simplified version of XmlSerializer, the default serialization engine used in ASMX today. DataContract defines attributes for annotating class definitions to influence the serialization process. Here's an example of it in use:

[DataContract(Namespace="http://example.org/person")]

public class Person

{

 [DataMember(Name="first", Order=0)]

 public string First;

 [DataMember(Name="last", Order=1)]

 public string Last;

 [DataMember(IsRequired=false, Order=2)]

 private string id;

 ...

}

With DataContract, only fields marked with DataMember will be serialized. And you can serialize private fields. This is much different from the way XmlSerializer works. Now you can use Person in an operation contract:

href="javascript:CopyCode('ctl00_MTContentSelector1_mainContentContainer_ctl10_code');">

[ServiceContract(Namespace="http://example.org/echo/")]

public interface IEchoService

{

 ... // previous methods omitted



 [OperationContract]

 Person EchoPerson(Person p);

}

When EchoPerson is invoked, WCF will serialize Person instances according to the DataContract attributes specified on the Person class. DataContract produces a very simple XML structure—a sequence of elements. You can control the name of each element, the order, and whether a particular element is required, but that's about it.

If you need to do anything more sophisticated, WCF lets you fall back to using XmlSerializer. You indicate your desire to use XmlSerializer by annotating the interface with [XmlSerializerFormat]:

" href="javascript:CopyCode('ctl00_MTContentSelector1_mainContentContainer_ctl11_code');">

[ServiceContract]

[XmlSerializerFormat]

public interface IEchoService { ... }

This tells WCF to use XmlSerializer for all types in the contract, according to the XmlSerializer defaults and the various System.Xml.Serialization customization attributes. This makes it much easier to move existing ASMX services forward to WCF.

WCF also supports serializing types marked with [Serializable], which allows .NET remoting types to work with WCF without change. WCF provides an implicit mapping for [Serializable] types where all public/private fields are automatically serialized.

Message and Service Contracts

All of the examples up to this point have relied on WCF to automatically map the method signature to the SOAP message. The parameter list and return type are always mapped to the SOAP body for the request and response, respectively. If you need to support headers, you can write another class that models the structure of the entire SOAP envelope for the particular operation, specifying which fields map to headers versus the body. You define this mapping with the [MessageContract] attributes:

" href="javascript:CopyCode('ctl00_MTContentSelector1_mainContentContainer_ctl12_code');">

[MessageContract]

public class EchoPersonMessage

{

 [MessageBody]

 public Person Person;

 [MessageHeader]

 public Authorization Authorization;

}

In this example, the Person field is mapped to the SOAP body while the Authorization field is mapped to a SOAP header. Now you can use EchoPersonMessage in an operation contract:

" href="javascript:CopyCode('ctl00_MTContentSelector1_mainContentContainer_ctl13_code');">

[ServiceContract]

public interface IEchoService

{

 ... // previous methods omitted



 [OperationContract]

 void EchoPerson(EchoPersonMessage msg);

}

Using MessageContract is a more advanced technique that is only necessary when you need direct control over the SOAP contract.

Implementing Service Contracts

Now you can implement the service contract by simply implementing the .NET interface in a class:

using System.ServiceModel;

namespace ServiceLibrary

{

 public class EchoService : IEchoService

 {

     public string Echo(string msg)

     {

         return msg;

     }

     ... // remaining methods omitted

 }

}

By doing this, EchoService is guaranteed to support the service contract defined by IEchoService. When using an interface to define the service contract, you don't need any contract-related attributes on the class definition. However, you may want to use [ServiceBehavior] to influence its local behavior:

using System.ServiceModel;



namespace ServiceLibrary

{

 ... // interface definition omitted



 [ServiceBehavior(

    InstanceContextMode=InstanceContextMode.Single,

    ConcurrencyMode=ConcurrencyMode.Multiple)]

 public class EchoService : IEchoService

 {

    ...

This particular example tells WCF to manage a singleton instance of the service type and to allow multithreaded access to the instance. There is also an [OperationBehavior] attribute for controlling operation-level behavior.

Behaviors influence processing within the host, but have no impact on the service contract whatsoever. Behaviors are one of the primary WCF extensibility points. Any class that implements IServiceBehavior can be applied to a service through the use of a custom attribute or configuration element.

Hosting the Service and Defining Endpoints

To use EchoService, you need to host it in a .NET-based application. The ServiceHost class gives you direct control over the WCF hosting infrastructure. You instantiate ServiceHost based on a particular service type. The following code shows how to do this in a console application:

using System;

using System.ServiceModel;

using ServiceLibrary;



class Program

{

 static void Main(string[] args)

 {

     using (ServiceHost host = new ServiceHost(

         typeof(EchoService), new Uri("http://localhost:8080/echo")))

     {

         ...

In addition to specifying the service type, you also specify the base addresses for the different transports you plan to use. In this example, I've specified a base address of http://localhost:8080/echo. This will be used as the base for any relative HTTP addresses I might specify when adding endpoints. The base HTTP address is also used as the default for retrieving the service description.

You then add the service endpoints. Again, a service may have one or more endpoints and each endpoint consists of an address, a binding, and a contract. You provide this information to your ServiceHost by calling AddServiceEndpoint. This is where you specify the service contract you defined earlier (IEchoService). For the binding, you typically choose from one of the many predefined bindings that ship with WCF and an appropriate address given the binding's transport. Here's an example:

host.AddServiceEndpoint(typeof(IEchoService),

 new BasicHttpBinding(), "svc");

host.AddServiceEndpoint(typeof(IEchoService),

 new NetTcpBinding(), "net.tcp://localhost:8081/echo/svc");

In this particular example, I've specified IEchoService as the contract for both endpoints, but with each endpoint using a different binding and address. The first endpoint uses the BasicHttpBinding and a relative HTTP address of svc (which would make its absolute address http://localhost:8080/echo/svc). The second endpoint uses the NetTcpBinding and an address of net.tcp://localhost:8081/echo/svc. Therefore, this service allows consumers to communicate with it over either HTTP or TCP using different WS-* protocols, as defined by each binding.

Choosing and Customizing Bindings

The WCF infrastructure relies heavily on endpoint definitions to control how messages are processed. In fact, WCF uses the endpoint definitions to dynamically build the appropriate message processing runtime within hosts and clients. The binding has the most significant influence on this process.

The binding controls three aspects of message communication: the suite of WS-* protocols, including WS-Security, WS-ReliableMessaging, and so on; the message encoding, such as XML 1.0, Message Transmission Optimization Mechanism (MTOM), and binary; and the transport protocol, including HTTP, TCP, and Microsoft Message Queuing (MSMQ). A given binding specifies one message encoding and one transport, but it can specify numerous WS-* protocols. Given that, there are an overwhelming number of permutations that could be used. To simplify things, WCF provides a set of predefined bindings that fit the most common use cases. Figure 4 lists some of these and describes what they embody.

Figure 4 Predefined WCF Bindings

Class Name	Element Name	Transport	Encoding	WS-* Protocols
BasicHttpBinding	basicHttpBinding	HTTP	XML 1.0	WS-I Basic Profile 1.1
WSHttpBinding	wsHttpBinding	HTTP	XML 1.0	Message security, reliable sessions, and transactions
WSDualHttpBinding	wsDualHttpBinding	HTTP	XML 1.0	Message security, reliable sessions, and transactions
NetTcpBinding	netTcpBinding	TCP	Binary	Transport security, reliable sessions, and transactions
NetNamedPipeBinding	netNamedPipeBinding	Named Pipes	Binary	Transport security, reliable sessions, and transactions
NetMsmqBinding	netMsmqBinding	MSMQ	Binary	Transport security and queue transactions

Developers who care primarily about interoperability and don't need WS-* functionality will typically use BasicHttpBinding. Developers who care about interoperability, but also need message-based security, reliable messaging, and transactions will typically choose WSHttpBinding. Developers using WCF on both sides (client and service) can choose from NetTcpBinding and NetNamedPipeBinding, which provide significant optimizations. Those building asynchronous systems can choose NetMsmqBinding. There are also a few bindings that aren't listed here, such as MsmqIntegrationBinding for integrating with existing MSMQ applications, NetPeerTcpBinding for building peer-to-peer services, and WSFederationBinding for federated security. A service can support any combination of these bindings.

Once you choose a binding and instantiate it, you can customize some of its characteristics through the properties exposed on the binding class. The following example shows how to enable transport-based security on the BasicHttpBinding:

BasicHttpBinding b = new BasicHttpBinding();

b.Security.Mode = BasicHttpSecurityMode.Transport;

b.Security.Transport.ClientCredentialType =

 HttpClientCredentialType.Basic;

host.AddServiceEndpoint(typeof(IEchoService), b, "svc");

If the predefined bindings and their customizations still don't fit your needs, you can also write a custom binding by implementing a class that derives from Binding.

Opening the Host

Now that you've configured the host with endpoint information, WCF can build the runtime needed to support your configuration. This occurs when you call Open on a particular ServiceHost:

host.Open();

Once the call to Open returns, the WCF runtime is built and ready to receive messages at the addresses specified by each endpoint. During this process, WCF generates an endpoint listener for each supplied endpoint and the code needed to support the WS-* protocols specified by the binding. (An endpoint listener is the piece of code that actually listens for incoming messages using the specified transport and address.)

You can retrieve information about the service at run time through the object model exposed by ServiceHost. This allows you to retrieve anything you might want to know about the initialized service, such as what endpoints it exposes and what endpoint listeners are currently active.

Figure 5 shows a complete example of the console application that hosts EchoService. Figure 6 shows the output. Notice there are two additional endpoint listener addresses that I didn't specify in a ServiceEndpoint. WCF automatically provided these using the base HTTP address for retrieving the service description.

Figure 5 Console App Hosting EchoService

class Program

{

 static void Main(string[] args)

 {

     using (ServiceHost host = new ServiceHost(

         typeof(EchoService), new Uri("http://localhost:8080/echo")))

     {

         // define the service endpoints

         host.AddServiceEndpoint(typeof(IEchoService),

             new BasicHttpBinding(), "svc");

         host.AddServiceEndpoint(typeof(IEchoService),

             new NetTcpBinding(), "net.tcp://localhost:8081/echo/svc");

         host.Open();



         Console.WriteLine(

             "{0} is open and has the following endpoints:\n",

             host.Description.ServiceType);



         int i=1;

         foreach (ServiceEndpoint end in host.Description.Endpoints)

         {

             Console.WriteLine("Endpoint #{0}", i++);

             Console.WriteLine("Address: {0}",

                 end.Address.Uri.AbsoluteUri);

             Console.WriteLine("Binding: {0}",

                 end.Binding.Name);

             Console.WriteLine("Contract: {0}\n",

                 end.Contract.Name);

         }



         Console.WriteLine(

             "The following EndpointListeners are active:\n");

         foreach (EndpointListener l in host.EndpointListeners)

             Console.WriteLine(l.Listener.Uri.AbsoluteUri);



         // keep the process alive

         Console.ReadLine();

     }

 }

}

Figure 6 Output of Console App

If you browse to http://localhost:8080/echo, you'll see the default WCF help page (see Figure 7) and if you browse to http://localhost:8080/echo?wsdl, you'll see the generated WSDL definition. The other endpoint listener (http://localhost:8080/echo/mex) knows how to speak WS-MetadataExchange. It's important to note that this sample is not using IIS in any way. WCF provides built-in integration with httpsys, which allows any application to automatically become an HTTP listener.

Figure 7 EchoService Help Page

Configuring Service Endpoints

Hardcoding endpoint information into the host application is not ideal since endpoint details may change over time. It's not hard to imagine how you could store the endpoint information in a configuration file or database and read it while initializing ServiceHost. Since this is a common need, WCF automatically provides this functionality through the predefined configuration section.

The following configuration file defines the same two endpoints that were specified by calling AddServiceEndpoint:

" href="javascript:CopyCode('ctl00_MTContentSelector1_mainContentContainer_ctl25_code');">

If you add this configuration file to the host application shown in Figure 5 and comment out the calls to AddServiceEndpoint, you'll see the same results in the output. This increases deployment flexibility since the communication details are completely factored out of the compiled code. You can also configure bindings within . Figure 8 shows how to configure basicHttpBinding to use transport security like I had done in code.

Figure 8 Configuring Transport Security

...

You can even define new custom bindings from scratch using the element, which would be equivalent to deriving a new class from Binding. When it comes to configuring endpoints, bindings, and even behaviors, anything you can do in code, you can also do through configuration.

Figure 9 Using the GUI to Define an Endpoint

Although IntelliSense® for the configuration file works well in Visual Studio® 2005, some developers still prefer to avoid XML altogether. The WinFX® SDK includes a tool called SvcConfigEditor, which provides a graphical interface for working with the various settings. Figure 9 shows how to configure endpoints using this tool.

Using Activation Services

Although I've been experimenting with console applications, ServiceHost makes it easy to host WCF services in a variety of applications, including Windows Forms applications and managed Windows Services. In all of these application scenarios, you're responsible for managing the process hosting WCF. This is known as self-hosting in WCF terms.

In addition to self-hosting, WCF also makes it possible to activate services by using IIS along with traditional Web hosting techniques. You can accomplish this by using a .svc file (similar to .asmx) that specifies the service type to host:

<%@Service class="ServiceLibrary.EchoService" %>

You place this file in a virtual directory and deploy your service type to its \bin directory or the Global Assembly Cache (GAC). When using this technique you specify the service endpoint in the web.config, but you don't need to specify the address since it's implied by the location of the .svc file.

...

Now if you browse to the .svc file, you'll notice the help page is displayed, showing that a ServiceHost was automatically created within an ASP.NET application domain. This is accomplished by an HTTP module that filters incoming .svc requests and automatically builds and opens the appropriate ServiceHost when needed.

If you install the WinFX extensions for Visual Studio 2005, you'll find a new Web Site project template called Indigo Service (this name will change). When you create a new Web site based on this template, it automatically gives you the .svc file along with the corresponding implementation class (found in App_Code). It also comes with a default endpoint configuration in web.config.

On IIS versions 5.1 and 6.0 the WCF activation model is tied to the ASP.NET pipeline, and therefore to HTTP. IIS 7.0, which is planned for release with Windows Vista™, introduces a transport-neutral activation mechanism known as Windows Activation Services (WAS). With WAS, you'll be able to leverage .svc-like activation over any transport.

Programming Clients

Programming WCF clients involves sending messages to a service endpoint according to its address, binding, and contract. To accomplish this, you first create a ServiceEndpoint representing the target endpoint. The following example shows how to create a ServiceEndpoint, based on the service's HTTP endpoint, in a client console application:

using System;

using System.ServiceModel;

using ServiceLibrary;



class Program

{

 static void Main(string[] args)

 {

     ServiceEndpoint httpEndpoint = new ServiceEndpoint(

         ContractDescription.GetContract(typeof(IEchoService)),

         new BasicHttpBinding(), new EndpointAddress(

             "http://localhost:8080/echo/svc");

This code assumes that the client has access to the same IEchoService interface definition that the service used and that the client knows what binding and address to use. Then you can create a ChannelFactory based on the ServiceEndpoint:

ChannelFactory factory =

 new ChannelFactory(httpEndpoint);

ChannelFactory creates typed proxies. In this case, it creates proxies of type IEchoService, which you can use to invoke the operations defined by the contract:

IEchoService svc = factory.CreateChannel();

Console.WriteLine(svc.Echo("Hello, world"));

If the service requires a customized binding, you will need to create the binding and customize it before creating ServiceEndpoint. If you want to access the TCP endpoint, simply create another ServiceEndpoint specifying the TCP endpoint details and supply it to ChannelFactory instead of the HTTP endpoint. Everything else would work the same.

The proxy shields you from the different addresses and bindings in use, allowing you to write application code against the service contract. Figure 10 shows the complete client console application.

Figure 10 EchoService Client App

using System; 

using System.ServiceModel;

using ServiceLibrary;



class Program

{

 static void Main(string[] args)

 {

     try

     {

         // define service endpoints on client

         ServiceEndpoint httpEndpoint = new ServiceEndpoint(

             ContractDescription.GetContract(

                typeof(IEchoService)),new BasicHttpBinding(),

             new EndpointAddress("http://localhost:8080/echo/svc"));



         ServiceEndpoint tcpEndpoint= new ServiceEndpoint(

             ContractDescription.GetContract(

                typeof(IEchoService)),

             new NetTcpBinding(), new EndpointAddress(

                "net.tcp://localhost:8081/echo/svc"));



         IEchoService svc = null;



         // create channel factory based on HTTP endpoint

         using (ChannelFactory httpFactory =

             new ChannelFactory(httpEndpoint))

         {

             // create channel proxy for endpoint

             svc = httpFactory.CreateChannel();

             // invoke service operation

             Console.WriteLine("Invoking HTTP endpoint: {0}",

                 svc.Echo("Hello, world"));

         }



         // create channel factory based on TCP endpoint

         using (ChannelFactory tcpFactory =

             new ChannelFactory(tcpEndpoint))

         {

             // create channel proxy for endpoint

             svc = tcpFactory.CreateChannel();

             // invoke service operation

             Console.WriteLine("Invoking TCP endpoint: {0}",

                 svc.Echo("Hello, world"));

         }

     }

     catch (Exception e)

     {

         Console.WriteLine(e);

     }

 }

}

Configuring Client Endpoints

Hardcoding endpoint information into client code is also less than ideal. So WCF provides a similar configuration mechanism for specifying client endpoints within . The following application configuration file specifies the same client endpoint details used in the code:

Notice that I've given each client endpoint a name. You can use this name in your code when creating a ChannelFactory, as illustrated in the following code:

using (ChannelFactory httpFactory =

 new ChannelFactory("httpEndpoint"))

{

 svc = httpFactory.CreateChannel();

 Console.WriteLine("Invoking HTTP endpoint: {0}",

     svc.Echo("Hello, world"));

}

Now when you want to create a ChannelFactory for the TCP endpoint, you can simply change the configuration name to tcpEndpoint. You can also configure bindings in the client configuration file just like I did in the service configuration file.

If you add this configuration file to the client console application shown in Figure 10, comment out the code to create the ServiceEndpoint objects, and specify the endpoint names when constructing each ChannelFactory, the result will be the same.

Generating Client Proxies

The preceding examples assumed the client had access to the same interface definition used to implement the service. This is common when .NET is used to implement both sides (in traditional .NET remoting scenarios), but that's not always the case, and it's never the case when the service wasn't implemented with the .NET Framework. The preceding examples also assumed the client knew the precise endpoint details in advance, which isn't always common either.

When clients don't have access to such information, they can discover it using the WS-MetadataExchange specification. Services share endpoint descriptions with clients through WSDL definitions. Most service platforms provide tools for generating client-side code from WSDL definitions. The WinFX SDK provides SvcUtil.exe for this purpose.

When executing SvcUtil.exe, you specify the URL of the WSDL definition and it will generate the necessary .NET code and configuration elements that define the endpoints and bindings used by the service endpoints. Figure 11 shows the output of running SvcUtil.exe against http://localhost:8080/echo. Notice that it generates two files: EchoService.cs and output.config.

Figure 11 SvcUtil.exe Output

EchoService.cs contains a .NET interface definition equivalent to the one the service implemented. Output.config contains the client endpoint information needed to access the service (similar to what I just wrote manually). You'll need to merge the contents of output.config with your application configuration file manually. With this in place, you can write client code using the same techniques shown in the previous examples, only using the generated interface and configuration file.

In general, the WCF client programming model is explicit about the service boundary. You create a typed channel against a specific service endpoint and then send messages through it. Although this helps emphasize the tenets of service orientation, it can be tedious to work at this level all the time. To help you, SvcUtil.exe also generates a proxy class that completely hides the ChannelFactory and ServiceEndpoint creation details. If you open EchoService.cs, you'll find the following class definition:

public partial class EchoServiceProxy :

System.ServiceModel.ClientBase, IEchoService

{

 public EchoServiceProxy()

 {

 } 

 public EchoServiceProxy(string endpointConfigurationName) :

         base(endpointConfigurationName)

 {

 }

...

This proxy class can simplify your client application code. All you have to do is instantiate the proxy, specify the name of the endpoint configuration, and make method calls. Here's an example:

using (EchoServiceProxy proxy = new EchoServiceProxy("IEchoService"))

{

 // invoke service operation

 Console.WriteLine("Invoking HTTP endpoint: {0}",

     proxy.Echo("Hello, world"));

}

using (EchoServiceProxy proxy = new EchoServiceProxy("IEchoService1"))

{

 // invoke service operation

 Console.WriteLine("Invoking TCP endpoint: {0}",

     proxy.Echo("Hello, world"));

}

The generated configuration file (output.config) defines the IEchoService and IEchoService1 endpoint configurations.

Logging Messages

As you begin working with the WCF programming model, you may find it useful to trace the SOAP messages traveling between clients and services. Windows Communication Foundation provides built-in support for message logging, which can be turned on through your application configuration file.

Figure 12 SvcTraceViewer.exe

SvcConfigEditor provides a Diagnostics tab where you can enable the messaging logging features. Once you enable messaging logging and rerun the app, you'll see the trace file appear in the specified location. The WinFX SDK also provides SvcTraceViewer.exe for viewing the information in a trace file (see Figure 12).

Conclusion

WCF is a new step in distributed programming for developers using the .NET Framework. If you currently build systems using any of today's .NET distributed technologies, it's time to start paying attention to WCF and the future it holds. It's only a matter of time before all .NET-targeted code related to communications will be written using WCF.

Note that all of the code samples shown in this article are based on Visual Studio 2005 and the WCF November 2005 CTP.

Refer to link: http://msdn.microsoft.com/hi-in/magazine/cc163647(en-us).aspx

LINQ To SQL

2009-07-02T03:37:00.000-07:00

Introduction

LINQ is one of the most important features in .NET Framework 3.5 (Visual Studio 2008). It's the new way to mapping database tables to classes, and as we know, we call this O/R Mapping. An article on how to write LINQ code quickly is always welcome for beginners, and I think that reading samples is the best way to learn a new technique.

These are samples created while I was learning and using LINQ, and I want to share them now. Hope they will be helpful. I will use Northwind database as a sample, which you can download from the link at the top of this article.

I recommend that you read 101 LINQ Samples if you would like to learn more.

// Basic
// Select * From Products
var query1 = from p in db.Products select p;
// Select ProductID, ProductName, UnitPrice From Products
var query2 = from p in db.Products select new
{
p.ProductID, p.ProductName, p.UnitPrice
};

Note: query2 will create a new class which contains three properties that map the ProductId, ProductName, and UnitPrice.

// Where // Select * From Products Where ProductID = 1
var query3 = from p in db.Products where p.ProductID == 1 select p;

// Select * From Products Where SupplierId =5 and UnitPrice > 20
var query4 = from p in db.Products where p.SupplierID == 5 && p.UnitPrice > 20 select p;

// Select * From Products Where SupplierId =5 Or SupplierId=6
var query5 = from p in db.Products where p.SupplierID == 5 || p.SupplierID == 6 select p;

Note: The condition in the where block is a logical express, a boolean value is returned just like in if().

// Order By
   // Select * From Products Order By ProductId
   var query6 = from p in db.Products
                orderby p.ProductID
                select p;

   // Select * From Products Order By ProductId Desc
   var query7 = from p in db.Products
                orderby p.ProductID descending
                select p;

   // Select * From Products Order By CategoryId, UnitPrice Desc
   var query8 = from p in db.Products
                orderby p.CategoryID, p.UnitPrice descending
                select p;

Note: The default order is ascending, the order by p.ProductID is same as order by p.ProductID ascending, just like in T-SQL.

// Top
   // Select Top 10 * From Products
   var query9 = (from p in db.Products
                select p).Take(10);

   // Select Top 1 * From Products
   var query10 = (from p in db.Products
                  select p).Take(1);
   // or
   var query11 = (from p in db.Products
                  select p).First();

Note: If it just returns one record, I recommend using First instead of Take(1).

// Top with Order By
   // Select Top 10 * From Products Order By ProductId
   var query12 = (from p in db.Products
                  orderby p.ProductID
                  select p).Take(10);

// Distinct
   // Select Distinct CategoryId From Products
   var query13 = (from p in db.Products
                  select p.CategoryID).Distinct();

// Group By
   // Select CategoryId, Count(CategoryID) As NewField
   // From Products Group By CategoryId
   var query14 = from p in db.Products
                 group p by p.CategoryID into g
                 select new {
                     CategoryId = g.Key,
                     NewField = g.Count()
                 };

   // Select CategoryId, Avg(UnitPrice) As NewField From Products Group By CategoryId
   var query15 = from p in db.Products
                 group p by p.CategoryID into g
                 select new {
                     CategoryId = g.Key,
                     NewField = g.Average(k => k.UnitPrice)
                 };

   // Select CategoryId, Sum(UnitPrice) As NewField From Products Group By CategoryId
   var query16 = from p in db.Products
                 group p by p.CategoryID into g
                 select new {
                     CategoryId = g.Key,
                     NewField = g.Sum(k => k.UnitPrice )
                 };

// Union
   // Select * From Products Where CategoryId =1 union Select *
   // From Products Where CategoryId = 2
   var query17 = (from p in db.Products
                  where p.CategoryID == 1
                  select p).Union(
                      from m in db.Products
                      where m.CategoryID == 2
                      select m
                  );

// Two tables
   // Select A.ProductId, A.ProductName, B.CategoryId, B.CategoryName
   // From Products A, Categories B
   //    Where A.CategoryID = B.CategoryID and A.SupplierId =1
   var query18 = from p in db.Products
                 from m in db.Categories
                 where p.CategoryID == m.CategoryID && p.SupplierID == 1
                 select new {
                     p.ProductID,
                     p.ProductName,
                     m.CategoryID,
                     m.CategoryName
                 };

Language Integrated Query (LINQ) to SQL

2009-07-02T03:30:00.000-07:00

Introducing LINQ to Relational Data

LINQ introduced the concept of a unified data access technique to eliminate challenges of accessing data from a disparity of sources. LINQ has been extended to include the ability to access relational data through LINQ to SQL and LINQ to Entities. LINQ to SQL offers a direct mapping to the Microsoft SQL Server family of databases and allows you to query and manipulate objects associated with database tables. LINQ to Entities offers a more flexible mapping to relational data stored in other databases beyond just SQL Server. You build against a conceptual schema that is mapped to an actual schema. The remainder of this article will concentrate on LINQ to SQL.

LINQ to SQL Object Model

LINQ to SQL allows you to query and manipulate objects associated with database tables. Creating an object model involves creating a typed object that represents the database connection along with classes that map to database entities. The following list of objects are involved:

DataContext - A base class that is a disposable type that gets extended to represent a strongly typed connection to the database.
Classes and Collections - Represent objects and collection of objects that map to database entities.
Methods - Are used to extend classes or to represent stored procedure calls.

There are a few different ways to create an object model. The two most straight forward approaches are to use the provided designer within Visual Studio 2008 to auto-generate the objects and mappings or adding attributes to existing objects. For this example I downloaded the Northwind sample database and loaded it in my SQL Server so that I could retrieve data from it for testing. I created a new solution and added a console application. I then added a LINQ to SQL data class to the console application. I used the Server Explorer to setup a new connection to the Northwind database my local SQL Server, and then dragged all of the tables from the Server Explorer on to the design surface for the data class. Finally I right clicked on the design surface and chose "Layout Diagram" to auto arrange all of the newly added tables and relationships. Refer to Figure 1 for an example of the completed design surface

Test Driving LINQ to SQL through Examples

Now that we've covered the background let's use a couple of examples of LINQ to SQL. Our examples will demonstrate the use of the DataContext object along with an example of querying the Northwind sample database using expressions.

Querying Data

The following example code uses LINQ syntax to query data from the database and then loop through it to print it to the console. You'll notice how the query expression syntax is the same as what you would find whether it be LINQ to XML or another form of LINQ. Also notice how the NorthwindDataClassesDataContext object is wrapped within a using construct. The NorthwindDataClassesDataContext is an object that extends the DataContext class and represents a strongly typed connection to our database. The NorthwindDataClassesDataContext is a disposable type, so wrapping it in a using block ensures it is properly disposed after use.

using (NorthwindDataClassesDataContext context = new NorthwindDataClassesDataContext()) {
var results = from customers in context.Customers where customers.City == "London" orderby customers.CompanyName select customers;
foreach (var customer in results)
{
Console.WriteLine("Company is {0} and contact is {1}", customer.CompanyName, customer.ContactName
);
} // Pause to see the output Console.ReadLine(); }

Modifying Data Using the Created Object Model

The previous example focused on the retrieval of data. We'll now examine the basic data manipulation, create, update, and delete operations and how LINQ to SQL makes them simple. The object model used to manipulate the data is the model generated in one of the earlier sections. After each operation we'll use the SubmitChanges() method to save the changes to the database. We'll execute some simple query expressions with the Count() method to verify the modifications were made as desired. As the example will show, you can use instance of objects, make modifications to them, and the changes that you make are tracked in a change set and pushed back to the database.

using (NorthwindDataClassesDataContext context = new NorthwindDataClassesDataContext()) {
// Add a new record and verify it exists through Count
var customer = new Customer()
{
CompanyName = "Drama Cafe", CustomerID = "DRACA", ContactName = "Tom Smith", City = "Beverly Hills", Address = "123 Melrose Place", PostalCode = "90210"
};
context.Customers.InsertOnSubmit(customer);
context.SubmitChanges();
Console.WriteLine("Number of DRACA records: {0}", context.Customers.Where(c => c.CustomerID == "DRACA").Count()); // Modify the record and verify it is changed through Count customer.ContactName = "Joe Smith";
context.SubmitChanges();
Console.WriteLine("Number of Joe Smith records: {0}", context.Customers.Where(c => c.ContactName == "Joe Smith").Count()); // Delete a record and verify it is removed through Count context.Customers.DeleteOnSubmit(customer);
context.SubmitChanges();
Console.WriteLine("Number of DRACA records: {0}", context.Customers.Where(c => c.CustomerID == "DRACA").Count());
// Pause to see the output Console.ReadLine();

Calling Stored Procedures

The previous retrieve, create, update, and delete operations involved dynamically generated SQL statements. It is also possible to call stored procedures in place of dynamically generated SQL. The sample code below demonstrates how to call stored procedures. The Northwind database has a stored procedure called "Ten Most Expensive Products" we will use for this example. Once again using the Server Explorer navigate to the Stored Procedures in the tree view and drag the stored procedure to the design surface. You'll want to right click on the design surface and select "Show Methods Pane" if it isn't already available. You should now see a method, Ten_Most_Expensive_Products(), that has been created and we'll use in our next code example to get the list of top products and display the prices to the console.

using (NorthwindDataClassesDataContext context = new NorthwindDataClassesDataContext()) {
// Use the ten most expensive products stored procedure var results = from products in context.Ten_Most_Expensive_Products() select products;
foreach (var product in results)
{
Console.WriteLine("Product price is {0}", product.UnitPrice);
} // Pause to see the output Console.ReadLine();

Scheduling and Event Logging Windows Service

2009-06-30T22:12:00.000-07:00

In previous post we had seen how to create a windows service. In this part we will see how can we log events in windows service and how to schedule service to occur at specific interval.

First we will see how we can Log events in EventViewer event of Windows Service. Steps are as follows.

- Add an EventLog to your windows service class, from Toolbox.

- Give an ID say "MyEventLog1", Set Log to "MyEventLog" and Source to "MyEventLogSource"

This will help you to differentiate your log in event viewer. And you can also create a new view of your event source log. Create new Log View on application and rename it to "MyEventLogSource". Now clear logs, then each new entry with log source "MyEventLogSource" will be logged in the new view.

Now how will we write a new log entry in Windows Service.

Write the following code in OnStart Code block of your Service.

MyEventLog1.WriteEntry("My Windows Service Started.......");

This will be write a log entry. But make sure that you write this code in try-catch block, because on some OS, Windows Service do not have permission to log events. At that time your service will generate an unhandeled exception and it will stop immediately and you will unable to identify the problem that why your service is stopped immediately after it starts.

There can be two types of windows service.

1) Windows service that run only once. There is no any scheduling of the service. If you want to run it again the you must start the service again. It will stop automatically after it complete its job.

2) Windows service that run at specific interval. This service is useful to run Insert command from one server to other backup server. Or it can be use to complete tasks that are added in Database.

The first type of Windows service is very easy. Just put your code in OnStart event of the Windows Service.

Scheduling Windows Service with Timer Control

For scheduling a Windows service declare two global variables in your service class (Make sure not in Service.designer.cs Designer class)
This timer control is not System.Timer, this control is
System.Threading.Timer

private Timer stateTimer;

private TimerCallback timerDelegate;

Timer is useful for creating the scheduling the Service. TimerCallback is useful for specifying the function which will be called when timer interval ends(Tick event fires).

Now write this code in your OnStart block.

timerDelegate = new TimerCallback(DoSomething);
stateTimer = new Timer(timerDelegate, null, 0, 5000); // 5000 = 5 secs

In above code the timerDelegate is a callback function which will specify the Function that will be called each time your timer fires tick event.

Now the stateTimer is assigned to a new timer object which specify timerDelegate, initial delay and interval. In above example '0' is initial delay which specify after timer object is created how much to delay for firing first Tick event. '5000' this specify the interval, this indicate the delay of firing the tick event since the last tick event is fired. Both Initial delay and Interval are specified in milisecond.

Now we will see how to create the function.

protected void DoSomething(object sender)
{
MyEventLog1.WriteEntry("Windows Service event fired at " + DateTime.Now.ToString());
}

Above I have specified the function to be fired at tick event of timer. It will log in EventViewer with date and time.

In next part we will see how can we add a configuration file to the Windows Service, how to install the service and common problem while using with Windows Server 2003 system.

Resizing Data Controls in ASP.NET Applications

2009-06-30T21:56:00.000-07:00

Introduction

This article explains about resizing web controls in runtime. In browser output, usually resizing is achieved during Development for fixing the control’s width and height. But sometimes we require resizing the DataGrid, DataList or other data controls to adjust for clearly reading the displayed data. It is rare to see the internet page's output to be adjustable, but it is possible with a few lines of JavaScript.

Event Types

The whole resize logic (column width increase or decrease) depends upon catching the co-ordinate where the user drags the column to be resized. Mouse capturing will be set on initially when the page loads. Events to be captured are the following:

· Mouse Over

· Mouse Down

· Mouse Up

Style Settings

Resizing can be done only on the column headers. Usually all data controls, like DataGrid, GridView or DataList, will be set with some style class for the header row. Here we take advantage of this style for tracking the user's mouse over an event on the header row. This event will initiate the trigger to start capturing the further events like mouse down and mouse up. There is no special style setting to be done other than the user’s look and feel styles. The JavaScript just requires a style name and that is it!

Mouse Capturing

The user will be automatically seeing the difference in the cursor which will signal to them that the DataGrid/GridView is ready for resizing. This will be done by the handler which we have set for document onmousemove. Whenever the user reaches the header row, the first level job is over and mouse down event will be ready to be raised for checking where the user clicks the mouse to start dragging. At this moment the mouse move event will again take over. Now the JavaScript will start handling mousedown and mousemove, which is equal to mouse drag. On the mouse drag, the column size and the table size will increase or decrease based on the mouse’s left or right movement respectively. Whenever the user makes the mouse go up (stops dragging and releasing the mouse), the resizing will get stopped and the current drag object will be destroyed.

More Technical Information on Events

There are some things to look into in the code for a clearer understanding. The column resize can be pulled into the picture by just adding the JavaScript file to the web page. Before that, define the header columns you use in the web pages to the JavaScript file (headerStyle).

Listing 1

var isDraggable = false;
var xX=0;anchorChild=0;anchorMain=0;
var objOn=null;gridMain=null;
var lastObj=undefined;
var headerStyle="DataGrid-HeaderStyle";

Other common settings to be made are the following:

isDraggable – This variable will be initially set to false to denote that dragging logic should not be called; this will become true whenever the mouse hovers over the datagrid’s header column’s border.

xX, anchorChild, anchorMain – These three variables will hold 0 initially on every mouse down event when the user starts dragging. xX will hold the x-axis position of the mouse, anchorChild will hold the width of the Current Resizing cell, and anchorMain will hold the width of the entire DataGrid or control.

objOn – This will hold the current object which is under dragging.

lastObj – This temp object loads the objOn object. This will be captured on mousedown and loaded to objOn during MouseMove.

Firefox – DOM Expressions differ from browser to browser, so we have a common variable which will be checked in every event. When the script is initialized, we initialize the FireFox by finding whether the current browser is Firefox or other.

Listing 2

var firefox = document.getElementById&&!document.all;

Mouse Events

OnMouseMove – This event is used to capture the current place in which the mouse is hovered and also to change the width of the cell and DataGrid while they drag. So first we will capture the object on which we hover the mouse.

Listing 3

objOn=(!firefox)?e.srcElement:e.target;

The line below will be used to load the last mouse over the object for reference.

Listing 4

if(lastObj!=undefined)objOn=lastObj;

Then we have to change the cursor to resizable if the mouse is hovered on the DataGrid header column’s borders.

Listing 5

document.body.style.cursor =(objOn.offsetWidth-e.offsetX < 10 &&
objOn.parentElement.className == headerStyle)?'e-resize':'default';

Now, we decide whether we should start dragging or not. It depends on whether the user has clicked the mouse for dragging which would have made the boolean isDraggable true.

Listing 6

if(isDraggable)
{ document.body.style.cursor='e-resize';
//Current_MouseX_Position - MouseX_DragStart + Cell_Width
ic=e.clientX-xX+anchorChild;
//Current_MouseX_Position - MouseX_DragStart + Table_Width
it=e.clientX-xX+anchorMain;
if(ic>0)
{
gridMain.style.width = it + "px"; //Increase Table Width
objOn.style.width = ic + "px"; //Increase Cell Width
}
}

The above piece of code will increase or decrease the size of the DataGrid based on the mouse movement.

OnMouseDown – This event is used to capture the point or pixel where the user has started to drag (if the user has the mouse pointer over the DataGrid header’s border). Here we will find the Cell’s Offset Position and Table’s Offset position which will give the current X-Axis width of the cell and the table respectively.

First we will capture the object over which we hover the mouse.

Listing 7

objOn=(!firefox)?e.srcElement:e.target;

Then we have to check whether the mouse is hovered on the DataGrid header column’s borders. If it is true, the following steps will be carried out.

Listing 8

if(objOn.parentElement.className == headerStyle &&
document.body.style.cursor=='e-resize')
{

Set the Boolean Flag isDraggable to denote that we are in draggable mode.

Listing 9

isDraggable = true;

Set the gridMain object with the DataGrid or GridView object.

Listing 10

gridMain = objOn.parentElement.parentElement.parentElement;

Get the object of main table which corresponds to current column's width variation.

Listing 11

xX = e.clientX;

Get the current Mouse X Position.

Listing 12

anchorChild = objOn.offsetWidth;

Getting the current Cell/Column Width

Listing 13

anchorMain = gridMain.offsetWidth;

Get the current Table Width.

Listing 14

lastObj = objOn;

This will be the else part of the Current IF Statement. If the mouse is clicked outside the header scope, the lastObj variable is set to undefined.

Listing 15

lastObj = undefined;

OnMouseUp – This event is used to stop the dragging. There is no specific code to stop the drag; the drag event will be fired based on mouseover and mousedown events. When the mouse click is up, lastObj object used in those events will be undefined and isDraggable boolean flag will be set to false to say that the drag has been stopped by the user.

Dragging Stop and Forget LastObj

Listing 16

isDraggable = false;
lastObj=undefined;

Here is full JavaScript Code

The New LinkedList Class and Iterator Class in C#

2009-01-13T01:21:00.000-08:00

we need a header field and a constructor method to instantiate the list.

public class LinkedList()
{
private Node header;
public LinkedList()
{

header = new Node("header");
}
public bool IsEmpty() {
return (header.Link == null);
}
public Node GetFirst() {
return header;
}
public void ShowList() {
Node current = header.Link;
while (!(current == null)) {
Console.WriteLine(current.Element);
current = current.Link;
}
}
}

Demonstrating the Iterator Class

Using the Iterator class, it’s easy to write an interactive program to move through a linked list. This also gives us a chance to put all the code for both the Iterator class and the LinkedList class in one place.

using System;
public class Node
{
public Object Element;
public Node Link;
public Node()
{
Element = null;
Link = null;
}
public Node(Object theElement)
{

Element = theElement;
Link = null;
}
}
public class InsertBeforeHeaderException : System.
ApplicationException
{
public InsertBeforeHeaderException(string message) :
base(message)
{
}
}
public class LinkedList

{
private Node header;
public LinkedList()

{
header = new Node("header");
}
public bool IsEmpty()

{
return (header.Link == null);
}
public Node GetFirst()

{
return header;
}
public void ShowList()

{
Node current = header.Link;
while (!(current == null))

{
Console.WriteLine(current.Element);
current = current.Link;
}
}
}
public class ListIter

{
private Node current;
private Node previous;
LinkedList theList;
public ListIter(LinkedList list)

{
theList = list;
current = theList.GetFirst();
previous = null;
}
public void NextLink()

{
previous = current;
current = current.Link;
}
public Node GetCurrent()

{
return current;
}
public void InsertBefore(Object theElement)

{

Node newNode = new Node(theElement);
if (previous.Link == null)
throw new InsertBeforeHeaderException
("Can't insert here.");
else {
newNode.Link = previous.Link;
previous.Link = newNode;
current = newNode;
}
}
public void InsertAfter(Object theElement)

{
Node newNode = new Node(theElement);
newNode.Link = current.Link;
current.Link = newNode;
NextLink();
}
public void Remove()

{
previous.Link = current.Link;
}
public void Reset()

{

current = theList.GetFirst();
previous = null;
}
public bool AtEnd() {
return (current.Link == null);
}
}
class chapter

{
static void Main()

{
LinkedList MyList = new LinkedList();
ListIter iter = new ListIter(MyList);
string choice, value;
try
{
iter.InsertAfter("David");
iter.InsertAfter("Mike");
iter.InsertAfter("Raymond");
iter.InsertAfter("Bernica");
iter.InsertAfter("Jennifer");
iter.InsertBefore("Donnie");
iter.InsertAfter("Michael");
iter.InsertBefore("Terrill");
iter.InsertBefore("Mayo");
iter.InsertBefore("Clayton");
while (true)
{
Console.WriteLine("(n) Move to next node");
Console.WriteLine("(g)Get value in current node");
Console.WriteLine("(r) Reset iterator");
Console.WriteLine("(s) Show complete list");
Console.WriteLine("(a) Insert after");
Console.WriteLine("(b) Insert before");
Console.WriteLine("(c) Clear the screen");
Console.WriteLine("(x) Exit");
Console.WriteLine();
Console.Write("Enter your choice: ");
choice = Console.ReadLine();
choice = choice.ToLower();
char[] onechar = choice.ToCharArray();
switch(onechar[0])
{
case 'n' :
if (!(MyList.IsEmpty()) &&
(!(iter.AtEnd())))
iter.NextLink();
else
Console.WriteLine("Can' move to
next link.");
break;
case 'g' :
if (!(MyList.IsEmpty()))
Console.WriteLine("Element: " +
iter.GetCurrent().Element);
else
Console.WriteLine ("List is empty.");
break;
case 'r' :
iter.Reset();
break;
case 's' :
if (!(MyList.IsEmpty()))
MyList.ShowList();
else
Console.WriteLine("List is empty.");
break;
case 'a' :
Console.WriteLine();
Console.Write("Enter value to insert:");
value = Console.ReadLine();
iter.InsertAfter(value);
break;
case 'b' :
Console.WriteLine();
Console.Write("Enter value to insert:");
value = Console.ReadLine();
iter.InsertBefore(value);
break;
case 'c' :
// clear the screen
break;
case 'x' :
// end of program
break;
}
}
}
catch (InsertBeforeHeaderException e)
{
Console.WriteLine(e.Message);
}
}
}

GENERIC LINKED LIST CLASS AND THE GENERIC NODE CLASS

The System.Collections.Generic namespace provides two generic classes for building linked lists: the LinkedList class and the LinkedListNode class. The Node class provides two data fields for storing a value and a link, whereas the LinkedList class implements a doubly linked list with methods for inserting before a node as well as inserting after a node. The class also provides method for removing nodes, finding the first and last nodes in the linked list, as well as other useful methods.

Generic Linked List Example

LinkedListNode node1 = new LinkedListNode_(“Raymond");
LinkedList names = new LinkedList();

From here, it’s just a matter of using the classes to build and use a linked list. A simple example demonstrates how easy it is to use these classes:

using System;
using System.Collections.Generic;
using System.Text;
class Program

{
static void Main(string[] args)

{
LinkedListNode node = new
LinkedListNode("Mike");
LinkedList names = new LinkedList();
names.AddFirst(node);
LinkedListNode node1 = new
LinkedListNode ("David");
names.AddAfter(node, node1);
LinkedListNode node2 = new
LinkedListNode ("Raymond");
names.AddAfter(node1, node2);
LinkedListNode node3 = new LinkedListNode (null);
LinkedListNode aNode = names.First;
while(aNode != null)

{
Console.WriteLine(aNode.Value);
aNode = aNode.Next;
}
aNode = names.Find("David");
if (aNode != null) aNode = names.First;
while (aNode != null)

{
Console.WriteLine(aNode.Value);
aNode = aNode.Next;
}
Console.Read()
}
}

The linked list in this example does not use a header node because
we can easily find the first node in the linked list with the First property.
Although it wasn’t used in this example, there is also a Last property
that could be used in the previous While loop to check for the end of the
list:
while (aNode != names.Last) {
Console.WriteLine(aNode.Value);
aNode = aNode.Next;
}
There are two other methods, not shown here, that could prove useful in a linked list implementation: AddFirst and AddLast. These methods can help you implement a linked list without having to provide header and tail nodes in your list.

USING AN ITERATOR CLASS in C#

2009-01-13T00:59:00.000-08:00

One problem the LinkedList class has is that you can’t refer to two positions in the linked list at the same time. We can refer to any one position in the list (the current node, the previous node, etc.), but if we want to specify two or more positions, such as if we want to remove a range of nodes from the list, we’ll need some other mechanism. This mechanism is an iterator class.
The iterator class consists of three data fields: a field that stores the linked list, a field that stores the current node, and a field that stores the current node. The constructor method is passed a linked list object, and the method sets the current field to the header node of the list passed into the method. Let’s look at our definition of the class so far:

public class ListIter
{
private Node current;
private Node previous;
LinkedList theList;
public ListIter(LinkedList list)
{
theList = list;
current = theList.getFirst();
previous = null;
}

The first thing we want an Iterator class to do is allow us to move from node to node through the list. The method nextLink does this:

public void NextLink()
{
previous = current;
current = current.link;
}

Notice that in addition to establishing a new current position, the previous node is also set to the node that is current before the method has finished executing. Keeping track of the previous node in addition to the current node makes insertion and removal easier to perform.
The getCurrent method returns the node pointed to by the iterator:
public Node GetCurrent()
{
return current;
}

Two insertion methods are built in the Iterator class: InsertBefore and InsertAfter. InsertBefore inserts a new node before the current node; InsertAfter inserts a new node after the current node. Let’s look at the Insert-Before method first.

The first thing we have to do when inserting a new node before the current object is check to see if we are at the beginning of the list. If we are, then we can’t insert a node before the header node, so we throw an exception. This exception is defined below. Otherwise, we set the new node’s Link field to the Link field of the previous node, set the previous node’s Link field to the new node, and reset the current position to the new node. Here’s the code:

public void InsertBefore(Object theElement)
{
Node newNode = new Node(theElement);
if (current == header)
throw new InsertBeforeHeaderException();
else
{
newNode.Link = previous.Link;
previous.Link = newNode;
current = newNode;
}
}

The InsertBeforeHeader Exception class definition is:

public class InsertBeforeHeaderException
{
public InsertBeforeHeaderException()
{
base("Can't insert before the header node.");
}
}

The InsertAfter method in the Iterator class is much simpler than the method we wrote in the LinkedList class. Since we already know the position of the current node, the method just needs to set the proper links and set the current node to the next node.

public void InsertAfter(Object theElement)
{
Node newnode = new Node(theElement);
newNode.Link = current.Link;
current.Link = newnode;
NextLink();
}

Removing a node from a linked list is extremely easy using an Iterator class. The method simply sets the Link field of the previous node to the node pointed to by the current node’s Link field:

public void Remove()
{
prevous.Link = current.Link;
}

Other methods we need in an Iterator class include methods to reset the iterator to the header node (and the previous node to null) and a method to test if we’re at the end of the list. These methods are shown as follows.

public void Reset()
current = theList.getFirst();
previous = null;
}
public bool AtEnd()
{
return (current.Link == null);
}

Circular Link List Implementation in C#

2009-01-12T23:33:00.000-08:00

Circularly Linked List

A circularly linked list is a list where the last node points back to the first node (which may be a header node).

public class Node
{
public Object Element;
public Node Flink;
public Node Blink;
public Node()
{
Element = null;
Flink = null;
Blink = null;
}
public Node(Object theElement)
{
Element = theElement;
Flink = null;
Blink = null;
}
}
public class LinkedList
{
protected Node current;

protected Node header;
private int count;
public LinkedList() {
count = 0;
header = new Node("header");
header.Link = header;
}
public bool IsEmpty() {
return (header.Link == null);
}
public void MakeEmpty() {
header.Link = null;
}
public void PrintList() {
Node current = new Node();
current = header;
while (!(current.Link.Element = "header")) {
Console.WriteLine(current.Link.Element);
current = current.Link;
}
}
private Node FindPrevious(Object n)
{
Node current = header;
while (!(current.Link == null) && current.Link.
Element != n)
current = current.Link;
return current;
}
private Node Find(Object n)
{
Node current = new Node();
current = header.Link;
while (current.Element != n)
current = current.Link;
return current;
}

public void Remove(Object n)
{
Node p = FindPrevious(n);
if (!(p.Link == null)
p.Link = p.Link.Link;
count--;
}
public void Insert(Object n1, n2)
{
Node current = new Node();
Node newnode = new Node(n1);
current = Find(n2);
newnode.Link = current.Link;
current.Link = newnode;
count++;
}
public void InsertFirst(Object n)
{
Node current = new Node(n);
current.Link = header;
header.Link = current;
count++;
}
public Node Move(int n)
{
Node current = header.Link;
Node temp;
for(int i = 0, i <= n; i++)
current = current.Link;
if (current.Element = "header")
current = current.Link;
temp = current;
return temp;
}
}
In the .NET Framework Library, the ArrayList data structure is implemented using a circularly linked list. There are also many problems that can be solved using a circularly linked list.

Doubly Link List Implementation in C#

2009-01-12T23:18:00.000-08:00

We first need to modify the Node class to add an extra link to the class. To distinguish between the two links, we’ll call the link to the next node the FLink, and the link to the previous node the BLink. These fields are set to Nothing when a Node is instantiated. Here’s the code:
public class Node
{
public Object Element;
public Node Flink;
public Node Blink;
public Node()
{
Element = null;
Flink = null;
Blink = null;
}
public Node(Object theElement)
{
Element = theElement;
Flink = null;
Blink = null;
}
}

Insertion method

public void Insert(Object newItem, Object after)

{
Node current = new Node();
Node newNode = new Node(newItem);
current = Find(after);
newNode.Flink = current.Link;
newNode.Blink = current;
current.Flink = newNode;
}

Remove method

We first need to find the node in the list; then we set the node’s back link property to point to the node pointed to in the deleted node’s forward link. Then we need to redirect the back link of the link the deleted node points to and point it to the node before the deleted node.

public void Remove(Object n)

{
Node p = Find(n);
if (!(p.Flink == null))

{
p.Blink.Flink = p.Flink;
p.Flink.Blink = p.Blink;
p.Flink = null;
p.Blink = null;
}
}

Printing the elements of a linked list in reverse order

First, we need a method that finds the last node in the list. This is just a matter of following each node’s forward link until we reach a link that points to null. This method, called FindLast, is defined as follows:
private Node FindLast()

{
Node current = new Node();
current = header;
while(!(current.Flink == null))
current = current.Flink;
return current;
}

Once we find the last node in the list, to print the list in reverse order we just follow the backward link until we get to a link that points to null, which indicates we’re at the header node. Here’s the code:
public void PrintReverse()

{
Node current = new Node();
current = FindLast();
while (!(current.Blink == null))

{
Console.WriteLine(current.Element);
current = current.Blink;
}
}

How to write to an event log by using Visual C#

2009-01-11T23:31:00.000-08:00

Requirements

The following list describes the recommended hardware, software, network infrastructure, and service packs that you will need:

Microsoft Windows 2000 Professional, Windows 2000 Server, Windows 2000 Advanced Server, or Windows NT 4.0 Server
Microsoft Visual Studio C#

Write to an event log

Event logging provides a standard, centralized way for your applications to record important software and hardware events. Windows supplies a standard user interface for viewing the logs, the Event Viewer. By using the common language's run-time EventLog component, you can connect to existing event logs easily, on both local and remote computers, and write entries to these logs. You can also read entries from existing logs and create your own custom event logs. In its simplest form, writing to an event log involves only a few steps to create a sample application. To do this, follow these steps:

Open Visual Studio C#.
Create a new Console application in Visual C#. The Console application creates a public class and an empty Main method for you.
Verify that the project references at least the System.dll file.
Use the using directive on the System and System.Diagnostics namespaces so that you do not have to qualify declarations from these namespaces later in your code. You must use these statements before any other declarations.
```
using System;
using System.Diagnostics;
```

To write to an event log, you must have several pieces of information: Your
message, the name of the log you to which you want to write (which will be
created if it does not already exist), and a string that represents the source
of the event. You can register a particular source with only a single event log;
if you want to write messages to more than one log, you must define multiple
sources.

string sSource;
string sLog;
string sEvent;

sSource = "dotNET Sample App";
sLog = "Application";
sEvent = "Sample Event";

Use two static methods of the EventLog class to check whether your source
exists, and then, if the source does not exist, to create this source that is
associated with a particular event log. If the log name that you specify does
not exist, the name is created automatically when you write your first entry to
the log. By default, if you do not supply a log name to the
CreateEventSource method, the log file is named "Application Log."

if (!EventLog.SourceExists(sSource))
 EventLog.CreateEventSource(sSource,sLog);

To write a message to an event log, you can use the EventLog.WriteEntry static method. This method has several different overloaded versions. The following sample code shows the simplest method, which takes a source string and your message, and one of the more complex methods, which supports specifying the event ID and event type:

EventLog.WriteEntry(sSource,sEvent);
EventLog.WriteEntry(sSource, sEvent, EventLogEntryType.Warning, 234);

Save your application. Run your application, and then check the Application log in the Event Viewer to see your new events.
Complete code listing

using System;
using System.Diagnostics;

namespace WriteToAnEventLog_csharp
{
 /// Summary description for Class1.
 class Class1
 {
  static void Main(string[] args)
  {
   string sSource;
   string sLog;
   string sEvent;

   sSource = "dotNET Sample App";
   sLog = "Application";
   sEvent = "Sample Event";

   if (!EventLog.SourceExists(sSource))
    EventLog.CreateEventSource(sSource,sLog);

   EventLog.WriteEntry(sSource,sEvent);
   EventLog.WriteEntry(sSource, sEvent,
    EventLogEntryType.Warning, 234);
  }
 }
}

Web Farming with the Network Load Balancing Service in Windows Server 2003

2009-01-11T23:22:00.000-08:00

Goto this link

http://www.west-wind.com/presentations/loadbalancing/networkloadbalancingwindows2003.asp

How to turn on remote debugging for Visual Studio 2005 in Windows XP with Service Pack 2

2009-01-11T23:15:00.000-08:00

The Windows Firewall feature in Windows XP SP2 includes significant enhancements over the earlier the Internet Connection Firewall (ICF) feature. These enhancements help protect the computer from attack by malicious users or by malicious software such as viruses. By default, Windows Firewall is turned on for all network connections including connections to the Internet.

Turn on remote debugging

To turn on remote debugging in Windows XP with SP2, you must configure Windows Firewall as follows:

If Windows Firewall is in "shielded" mode, you must perform the appropriate actions so that Windows Firewall is no longer in "shielded" mode.
If Windows Firewall is on, you must open some ports. You must also grant some permissions to Microsoft Visual Studio 2005 and to other executable programs that are used in remote debugging.
If Windows Firewall is off, you may not have to configure a firewall.
Additionally, if the user who runs Microsoft Visual Studio 2005 does not have Administrator user rights on the remote computer, you must configure the DCOM settings on the computer that is running Visual Studio 2005.

To turn on remote debugging, you must have Administrator user rights on the computer that is running Visual Studio 2005. These instructions are only for Internet Protocol version 4 (IPV4) based network settings.

Configure DCOM on the computer that is running Visual Studio 2005

Note After you make changes by using the DCOM Configuration tool (Dcomcnfg.exe), you must restart the computer for the changes to take effect.

At a command prompt, type dcomcnfg, and then press ENTER. Component Services opens.
In Component Services, expand Component Services, expand Computers, and then expand My Computer.
On the toolbar, click Configure My Computer. The My Computer dialog box appears.

Note If you cannot click Configure My Computer, go to the "Remove and then re-install the MSDTC service" section.
In the My Computer dialog box, click the COM Security tab.
Under Access Permission, click Edit Limits. The Access Permission dialog box appears.
Under Group or user names, click ANONYMOUS LOGON.
Under Permissions for ANONYMOUS LOGON, click to select the Remote Access check box, and then click OK.

Remove and then re-install the MSDTC service

If you cannot click Configure My Computer that is described in step 3 in the "Configure DCOM on the computer that is running Visual Studio 2005" section, follow these steps.

Important This section, method, or task contains steps that tell you how to modify the registry. However, serious problems might occur if you modify the registry incorrectly. Therefore, make sure that you follow these steps carefully. For added protection, back up the registry before you modify it. Then, you can restore the registry if a problem occurs. For more information about how to back up and restore the registry, click the following article number to view the article in the Microsoft Knowledge Base:

322756 (http://support.microsoft.com/kb/322756/ ) How to back up and restore the registry in Windows

Remove the Microsoft Distributed Transaction Service (MSDTC):
1. Click Start, click Run, type cmd, and then click OK.
2. At the command prompt, run the following command to stop the MSDTC service:
  Net stop msdtc
3. At the command prompt, run the following command to remove the MSDTC service:
  Msdtc –uninstall
  The command prompt will return without a message.
In Registry Editor, delete the HKEY_LOCAL_MACHINE\Software\Microsoft\MSDTC subkey.
Re-install and then start the MSDTC service:
1. At the command prompt, run the following command to re-install the MSDTC service:
  Msdtc –install
2. At the command prompt, run the following command to start the MSDTC service:
  Net start msdtc
Go to step 4 in the "Configure DCOM on the computer that is running Visual Studio 2005" section.

Configure the computer that is running Visual Studio 2005

Open Windows Firewall

To open Windows Firewall, click Start, click Run, type firewall.cpl, and then click OK.

Open TCP port 135

DCOM remote procedure call (RPC) uses Transfer Control Protocol (TCP) port 135. If the application uses DCOM to communicate with remote computers, port 135 must be open.

To open TCP port 135, follow these steps:

In Windows Firewall, click Add Port on the Exceptions tab. The Add a Port dialog box appears.
In the Name box, type TCP port 135.
In the Port Number box, type 135.
In the Protocol area, click TCP.
Click Change scope to open Change Scope dialog box, click My network (subnet) only, and then click OK. (This step is optional.)
In the Add a Port dialog box, click OK.

Open UDP port 4500

User Datagram Protocol (UDP) port 4500 is used for Internet Protocol security (IPsec). If your domain policy requires that all network communication be completed through IPsec, this port must be open for any network operation. If your domain policy does not require IPsec, go to the "Turn on file and print sharing" section.

To open UDP port 4500, follow these steps:

In Windows Firewall, click Add Port on the Exceptions tab. The Add a Port dialog box appears.
In the Name box, type UDP port 4500.
In the Port Number box, type 4500.
In the Protocol area, click UDP.
Click Change scope. The Change Scope dialog box appears. Click My network (subnet) only, and then click OK. (This step is optional.)
In the Add a Port dialog box, click OK.

Open UDP port 500

UDP port 500 is used for IPsec. If your domain policy requires that all network communication be completed through IPsec, this port must be open for any network operation. If your domain policy does not require IPsec, go to the "Turn on file and print sharing" section.

To open UDP port 500, follow these steps:

In Windows Firewall, click Add Port on the Exceptions tab. The Add a Port dialog box appears.
In the Name box, type UDP port 500.
In the Port Number box, type 500.
In the Protocol area, click UDP.
Click Change scope. The Change Scope dialog box appears. Click My network (subnet) only, and then click OK. (This step is optional.)
In the Add a Port dialog box, click OK.

Turn on file and print sharing

In the Programs and Services area of the Exceptions tab, click File and Print Sharing, and then click Edit. The Edit a Service dialog box appears.
In the Edit a Service dialog box, click to select the following check boxes:
- TCP 139
- TCP 445
- UDP 137
- UDP 138
Click Change scope. The Change Scope dialog box appears. Click My network (subnet) only, and then click OK. (This step is optional.)
In the Change Scope dialog box, click OK to save your settings.
Click OK to close the Edit a Service dialog box.

Add Devenv.exe to the application exceptions list

To enable applications that cannot run correctly unless the required ports are opened dynamically at runtime, you must add the applications to the application exceptions list.

To add the Visual Studio 2005 Development Environment (Devenv.exe) to the application exceptions list, follow these steps:

In Windows Firewall, click Add Program on the Exceptions tab. The Add a Program dialog box appears.
In the Add a Program dialog box, click Browse. Locate Devenv.exe, and then click OK.

Note The Devenv.exe file is typically located in the following folder:
C:\Program Files\Microsoft Visual Studio 8\Common7\IDE
Microsoft Visual Studio 2005 appears in the Add a Program dialog box.
Click Change scope. The Change Scope dialog box appears. Click My network (subnet) only, and then click OK. (This step is optional.)
In the Add a Program dialog box, click OK.
In Windows Firewall, click OK to save your settings.

Configure the remote computer

All the ports that you have opened on the debugger computer must also be open on the remote computer. To open the TCP 135 port, the UDP 4500 port, and the UDP 500 port, and to turn on file and print sharing, follow the steps in the "" section.

You must also add the Msvsmon.exe file to the application exceptions list.

Add MSVSMon.exe to the application exceptions list

In Windows Firewall, click Add Program on the Exceptions tab. The Add a Program dialog box appears.
In the Add a Program dialog box, click Browse. Locate Msvsmon.exe, and then click OK.

Note Depending on the computer architecture, the Msvsmon.exe file may be located in any one of the following folders:
- Drive:\Program Files\Microsoft Visual Studio 8\Common7\IDE\Remote Debugger\x86
- Drive:\Program Files\Microsoft Visual Studio 8\Common7\IDE\Remote Debugger\x64
- Drive:\Program Files\Microsoft Visual Studio 8\Common7\IDE\Remote Debugger\ia64
Visual Studio 2005 Remote Debugger appears in the Add a Program dialog box.
Click Change scope. The Change Scope dialog box appears. Click My network (subnet) only, and then click OK. (This step is optional.)
In the Add a Program dialog box, click OK.
In Windows Firewall, click OK to save your settings.

Enable Web server debugging

HTTP uses TCP port 80. To do Web-based debugging, you must open TCP port 80. This is true for Microsoft ASP.NET debugging, for classic ASP debugging, and for ATL Server debugging.

To open TCP port 80, follow these steps:

In Windows Firewall, click Add Port on the Exceptions tab. The Add a Port dialog box appears.
In the Name box, type TCP port 80.
In the Port Number box, type 80.
In the Protocol area, click TCP.
Click Change scope. The Change Scope dialog box appears. Click My network (subnet) only, and then click OK. (This step is optional.)
In the Add a Port dialog box, click OK.
In Windows Firewall, click OK to save your settings.

Enable script debugging

To debug script code that runs on a remote computer, you must add the process that hosts the script code to the application exceptions list. Typically, in classic ASP debugging, the Dllhost.exe process or the Inetinfo.exe process hosts the script code. However, for a script that runs in Microsoft Internet Explorer, the Iexplore.exe process or in the Explorer.exe process generally hosts the script code.

To add the process that hosts the script code to the application exceptions list, follow these steps:

Click Start, click Run, type firewall.cpl, and then click OK.
In Windows Firewall, click Add Program on the Exceptions tab. The Add a Program dialog box appears.
In the Add a Program dialog box, click Browse. Locate the process that hosts the script code, and then click OK. The application of the process that hosts the script code appears in the Add a Program dialog box.

For example, if you locate the iexplore.exe process in this step, Internet Explorer appears in the Add a Program dialog box.
In the Scope area, click My network (subnet) only. (This step is optional.)
In the Add a Program dialog box, click OK.
In Windows Firewall, click OK to save your settings.

Run the debugger as a typical user

If you want to run the debugger as a typical user, you must have full user rights to the folder where the executable files are located. Additionally, if you do not have Administrator user rights on the remote computer, you must have access permissions and start permissions to run the debugger as a typical user.

Note A typical user is a user who does not have Administrator user rights.

Note After you make changes by using the DCOM Configuration tool (Dcomcnfg.exe), you must restart the computer for the changes to take effect.

To grant access permissions and start permissions, you must have Administrator user rights. First, obtain Administrator user rights. Then, follow these steps:

At a command prompt, type dcomcnfg, and then press ENTER. Component Services opens.
In Component Services, expand Component Services, expand Computers, and then expand My Computer.
On the toolbar, click Configure My Computer. The My Computer dialog box appears.

Note If you cannot click Configure My Computer, go to the "Remove and then re-install the MSDTC service" section.
In the My Computer dialog box, click the COM Security tab.
Under Launch and Activate Permissions, click Edit Limits.
If your group or user name does not appear in the Groups or user names list in the Launch Permission dialog box, follow these steps:
1. In the Launch Permission dialog box, click Add.
2. In the Select Users or Groups dialog box, enter your user name and your group in the Enter the object names to select box, and then click OK.
In the Launch Permission dialog box, select your user name and your group in the Group or user names box.
In the Allow column under Permissions for User, select Remote Activation, and then click OK.

Note User is a placeholder for the user name or the group that is selected in the Group or user names box. Repeat steps 7 and 8 for all the users and groups for which you want to grant permissions.

Remove and then re-install the MSDTC service

If you cannot click Configure My Computer that is described in step 3 in the "Run the debugger as a typical user" section, follow these steps.

Important This section, method, or task contains steps that tell you how to modify the registry. However, serious problems might occur if you modify the registry incorrectly. Therefore, make sure that you follow these steps carefully. For added protection, back up the registry before you modify it. Then, you can restore the registry if a problem occurs. For more information about how to back up and restore the registry, click the following article number to view the article in the Microsoft Knowledge Base:

322756 (http://support.microsoft.com/kb/322756/ ) How to back up and restore the registry in Windows

Remove the MSDTC service:
1. Click Start, click Run, type cmd, and then click OK.
2. At the command prompt, run the following command to stop the MSDTC service:
  Net stop msdtc
3. At the command prompt, run the following command to remove the MSDTC service:
  Msdtc –uninstall
  The command prompt will return without a message.
In Registry Editor, delete the HKEY_LOCAL_MACHINE\Software\Microsoft\MSDTC subkey.
Re-install and then start the MSDTC service:
1. At the command prompt, run the following command to re-install the MSDTC service:
  Msdtc –install
2. At the command prompt, run the following command to start the MSDTC service:
  Net start msdtc
Go to step 4 in the "Run the debugger as a typical user" section.

MORE INFORMATION

For more information about Windows Firewall, click the following article number to view the article in the Microsoft Knowledge Base:

843090 (http://support.microsoft.com/kb/843090/ ) Description of the Windows Firewall feature in Windows XP Service Pack 2

For more information about Windows XP SP2, visit the following Microsoft Developer Network (MSDN) Web site:

http://msdn2.microsoft.com/en-us/security/aa570371.aspx (http://msdn2.microsoft.com/en-us/security/aa570371.aspx)

For more information about remote debugging, click the following article number to view the article in the Microsoft Knowledge Base:

833977 (http://support.microsoft.com/kb/833977/ ) How to turn on remote debugging in Windows XP with Service Pack 2

How To Create an ASP.NET HTTP Handler by Using Visual C# .NET

2009-01-11T23:09:00.000-08:00

Implement the Handler

Open Microsoft Visual Studio .NET. In Visual C# .NET, create a new Class Library project named MyHandler.
Set a reference to the System.Web.dll assembly.
Add the following directive to the class.

using System.Web;

4. Rename the class SyncHandler.cs, and then change the class definition to reflect this.
5.Implement the IHttpHandler interface. Your class definition should appear as follows:

public class SyncHandler : IHttpHandler

6. Implement the IsReusable property and the ProcessRequest method of the IHttpHandler interface. Because this is a synchronous handler, return False for the IsReusable property so that the handler is not pooled.

public bool IsReusable
{
get
{
return false;
}
}
public void ProcessRequest(HttpContext context)
{
context.Response.Write("Hello from custom handler.");
}

7. Compile the project.

Deploy the Handler

Create a new directory named Handler under the C:\Inetpub\Wwwroot directory.
Create a subdirectory named Bin in the newly created Handler directory. The resultant path is C:\Inetpub\Wwwroot\Handler\Bin.
Copy MyHandler.dll from your project's Bin\Debug directory to the C:\Inetpub\Wwwroot\Handler\Bin directory.
Follow these steps to mark the new Handler directory as a Web application:
1. Open Internet Services Manager.
2. Right-click the Handler directory, and then click Properties.
3. On the Directory tab, click Create.
Follow these steps to create an application mapping for the handler. For this handler, create a mapping to the Aspnet_isapi.dll file for the *.sync extension. Whenever a .sync file is requested, the request is routed to ASP.NET, and ASP.NET executes the code in the handler.
1. Right-click on the Handler Web application, and then click Properties.
2. On the Directory tab, click Configuration.
3. Click Add to add a new mapping.
4. In the Executable text box, type the following path: Microsoft Windows 2000:
  C:\WINNT\Microsoft.NET\Framework\\Aspnet_isapi.dll
  Microsoft Windows XP:
  C:\WINDOWS\Microsoft.NET\Framework\\Aspnet_isapi.dll
5. In the Extension text box, type .sync.
6. Make sure that the Check that file exists check box is cleared, and then click OK to close the Add/Edit Application Extension Mapping dialog box.
7. Click OK to close the Application Configuration and the Handler Properties dialog boxes.
Close Internet Services Manager.

Configure the System

In the C:\Inetpub\Wwwroot\Handler directory, create a new file named Web.config.
Add the following code to Web.config:

In the verb="*" attribute, we instruct the handler to process a request that uses any verb (for example, POST, HEAD, GET, and so on). If you want this handler to process only the POST request, change this to verb="POST".

In the path="*.sync" attribute, we instruct the handler to process any incoming requests for files with the .sync extension.

In the type="MyHandler.SyncHandler, MyHandler" attribute, we instruct the handler that processes the request to implement in the MyHandler.SyncHandler namespace, and this class resides in the MyHandler assembly.

Test the Module

To test a handler, a page does not need to exist in the file system. For example, request the Default.sync file in the Handler Web application (http:///Handler/Default.sync). You should receive the following results:

Hello from custom handler.

How to use the Debug and the Trace classes

2009-01-11T22:53:00.000-08:00

This article describes how to use the Debug and the Trace classes. These classes are available in the Microsoft .NET Framework. You can use these classes to provide information about the performance of an application either during application development, or after deployment to production. These classes are only one part of the instrumentation features that are available in the .NET Framework.

Requirements

The following list outlines the recommended hardware, software, network infrastructure, and service packs that you need:

Microsoft Windows 2000 or Microsoft Windows XP or Microsoft Windows Server 2003
Microsoft Visual C#

This article also assumes that you are familiar with program debugging.

Description Of Technique

The steps in the Create a Sample with the Debug Class section demonstrate how to create a console application that uses the Debug class to provide information about the program execution.

When the program is run, you can use methods of the Debug class to produce messages that help you to monitor the program execution sequence, to detect malfunctions, or to provide performance measurement information. By default, the messages that the Debug class produces appear in the Output window of the Visual Studio Integrated Development Environment (IDE).

The sample code uses the WriteLine method to produce a message that is followed by a line terminator. When you use this method to produce a message, each message appears on a separate line in the Output window.

When you use the Assert method of the Debug class, the Output window displays a message only if a specified condition evaluates to false. The message also appears in a modal dialog box to the user. The dialog box includes the message, the project name, and the Debug.Assert statement number. The dialog box also includes the following three command buttons:

Abort: The application stops running.
Retry: The application enters debug mode.
Ignore: The application proceeds.

The user must click one of these buttons before the application can continue.

You can also direct output from the Debug class to destinations other than the Output window. The Debug class has a collection named Listeners that includes Listener objects.

Each Listener object monitors Debug output and directs the output to a specified target.

Each Listener in the Listener collection receives any output that the Debug class generates. Use the TextWriterTraceListener class to define Listener objects. You can specify the target for a TextWriterTraceListener class through its constructor.

Some possible output targets include the following:

The Console window by using the System.Console.Out property.
A text (.txt) file by using the System.IO.File.CreateText("FileName.txt") statement.

After you create a TextWriterTraceListener object, you must add the object to the Debug.Listeners collection to receive Debug output

Create a Sample with the Debug Class

Start Visual Studio or Visual C# Express Edition.
Create a new Visual C# Console Application project named conInfo. Class1 is created in Visual Studio .NET. Program.cs is created in Visual Studio 2005.
Add the following namespace at top in Class1 or Program.cs.

using System.Diagnostics;

4.To initialize variables to contain information about a product, add the following declaration statements to Main method:

string sProdName = "Widget";
int iUnitQty = 100;
double dUnitCost = 1.03;

5.Specify the message that the class produces as the first input parameter of the
WriteLine method. Press the CTRL+ALT+O key combination to make sure that
the Output window is visible.

Debug.WriteLine("Debug Information-Product Starting ");

6.For readability, use the Indent method to indent subsequent messages in
the Output window:

Debug.Indent();

7.To display the content of selected variables, use the WriteLine method as
follows:

Debug.WriteLine("The product name is " + sProdName);
Debug.WriteLine("The available units on hand are" + iUnitQty.ToString());

8.You can also use the WriteLine method to display the namespace and the
class name for an existent object. For example, the following code displays the
System.Xml.XmlDocument namespace in the Output window:

System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();

9.To organize the output, you can include a category as an optional, second input
parameter of the WriteLine method. If you specify a category, the format
of the Output window message is "category: message." For example, the first line
of the following code displays "Field: The product name is Widget" in the Output
window:

Debug.WriteLine("The product name is " + sProdName,"Field");
Debug.WriteLine("The units on hand are" + iUnitQty,"Field");
Debug.WriteLine("The per unit cost is" + dUnitCost.ToString(),"Field");
Debug.WriteLine("Total Cost is  " + (iUnitQty * dUnitCost),"Calc");


Debug.WriteLine(oxml);


Debug.WriteLine("The per unit cost is " + dUnitCost.ToString());

10.The Output window can display messages only if a designated condition evaluates
to true by using the WriteLineIf method of the Debug class. The
condition to be evaluated is the first input parameter of the WriteLineIf
method. The second parameter of WriteLineIf is the message that appears
only if the condition in the first parameter evaluates to true.

Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear");

11.

Use the Assert method of the Debug class so that the Output window displays the message only if a specified condition evaluates to false:

Debug.Assert(dUnitCost > 1, "Message will NOT appear");
Debug.Assert(dUnitCost < 1, "Message will appear since dUnitcost < 1 is false");

Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");

12. Create the TextWriterTraceListener objects for the Console window (tr1) and for a text file named Output.txt (tr2), and then add each object to the Debug Listeners collection:

TextWriterTraceListener tr1 = new TextWriterTraceListener(System.Console.Out);
Debug.Listeners.Add(tr1);
      
TextWriterTraceListener tr2 = new TextWriterTraceListener(System.IO.File.CreateText("Output.txt"));

13.For readability, use the Unindent method to remove the indentation for
subsequent messages that the Debug class generates. When you use the
Indent and the Unindent methods together, the reader can
distinguish the output as group.

Debug.Unindent();
Debug.WriteLine("Debug Information-Product Ending");


Debug.Listeners.Add(tr2);

14. To make sure that each Listener object receives all its output, call the Flush method for the Debug class buffers:

Debug.Flush();

Using the Trace Class

You can also use the Trace class to produce messages that monitor the execution of an application. The Trace and Debug classes share most of the same methods to produce output, including the following:

WriteLine
WriteLineIf
Indent
Unindent
Assert
Flush

You can use the Trace and the Debug classes separately or together in the same application. In a Debug Solution Configuration project, both Trace and Debug output are active. The project generates output from both of these classes to all Listener objects. However, a Release Solution Configuration project only generates output from a Trace class. The Release Solution Configuration project ignores any Debug class method invocations.

Trace.WriteLine("Trace Information-Product Starting ");
Trace.Indent();

Trace.WriteLine("The product name is "+sProdName);
Trace.WriteLine("The product name is"+sProdName,"Field" );
Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Trace.Assert(dUnitCost > 1, "Message will NOT appear");
      
Trace.Unindent();
Trace.WriteLine("Trace Information-Product Ending");

Trace.Flush();

Console.ReadLine();

Verify That It Works

Make sure that Debug is the current solution configuration.
If the Solution Explorer window is not visible, press the CTRL+ALT+L key combination to display this window.
Right-click conInfo, and then click Properties.
In the left pane of the conInfo property page, under the Configuration folder, make sure that the arrow points to Debugging.

Note In Visual C# 2005 and in Visual C# 2005 Express Edition, click Debug in the conInfo page.
Above the Configuration folder, in the Configuration drop-down list box, click Active (Debug) or Debug, and then click OK. In Visual C# 2005 and in Visual C# 2005 Express Edition, click Active (Debug) or Debug in the Configuration drop-down list box in the Debug page, and then click Save on the File menu.
Press CTRL+ALT+O to display the Output window.
Press the F5 key to run the code. When the Assertion Failed dialog box appears, click Ignore.

In the Console window, press ENTER. The program should finish, and the Output window should display the output that resembles the following

    Debug Information-Product Starting
   The product name is Widget
   The available units on hand are100
   The per unit cost is 1.03
   System.Xml.XmlDocument
   Field: The product name is Widget
   Field: The units on hand are100
   Field: The per unit cost is1.03
   Calc: Total Cost is  103
   This message WILL appear
   ---- DEBUG ASSERTION FAILED ----
---- Assert Short Message ----
Message will appear since dUnitcost  < 1 is false
---- Assert Long Message ----


   at Class1.Main(String[] args)  <%Path%>\class1.cs(34)

   The product name is Widget
   The available units on hand are100
   The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
   The product name is Widget
   Field: The product name isWidget
   This message WILL appear
Trace Information-Product Ending

The Console window and the Output.txt file should display the following output:

The product name is Widget
   The available units on hand are 100
   The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
   The product name is Widget
   Field: The product name is Widget
   This message WILL appear
Trace Information-Product Ending

Note The Output.txt file is located in the same directory as the conInfo executable (conInfo.exe). Typically, this is the \bin folder where the project source is stored. By default, this is C:\Documents and Settings\User login\My Documents\Visual Studio Projects\conInfo\bin. In Visual C# 2005 and in Visual C# 2005 Express Edition, the Output.txt file is located in the following folder:

C:\Documents and Settings\User login\My Documents\Visual Studio 2005\Projects\conInfo\conInfo\bin\Debug

Complete Code Listing
using System;
using System.Diagnostics;

class Class1
{
[STAThread]
static void Main(string[] args)
{
string sProdName = "Widget";
int iUnitQty = 100;
double dUnitCost = 1.03;
Debug.WriteLine("Debug Information-Product Starting ");
Debug.Indent();
Debug.WriteLine("The product name is "+sProdName);
Debug.WriteLine("The available units on hand are"+iUnitQty.ToString()); Debug.WriteLine("The per unit cost is "+ dUnitCost.ToString());

System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();
Debug.WriteLine(oxml);
Debug.WriteLine("The product name is "+sProdName,"Field");
Debug.WriteLine("The units on hand are"+iUnitQty,"Field");
Debug.WriteLine("The per unit cost is"+dUnitCost.ToString(),"Field");
Debug.WriteLine("Total Cost is "+(iUnitQty * dUnitCost),"Calc");
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");
Debug.Assert(dUnitCost > 1, "Message will NOT appear");
Debug.Assert(dUnitCost < 1, "Message will appear since dUnitcost < 1 is false");

TextWriterTraceListener tr1 = new TextWriterTraceListener(System.Console.Out); Debug.Listeners.Add(tr1);
TextWriterTraceListener tr2 = new TextWriterTraceListener(System.IO.File.CreateText("Output.txt")); Debug.Listeners.Add(tr2);
Debug.WriteLine("The product name is "+sProdName);
Debug.WriteLine("The available units on hand are"+iUnitQty);
Debug.WriteLine("The per unit cost is "+dUnitCost);
Debug.Unindent();
Debug.WriteLine("Debug Information-Product Ending");
Debug.Flush();
Trace.WriteLine("Trace Information-Product Starting ");
Trace.Indent();
Trace.WriteLine("The product name is "+sProdName);

Trace.WriteLine("The product name is"+sProdName,"Field" );
Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Trace.Assert(dUnitCost > 1, "Message will NOT appear");
Trace.Unindent();
Trace.WriteLine("Trace Information-Product Ending");
Trace.Flush(); Console.ReadLine();
}
}

Link List (How to develop with C#)

2008-12-22T03:23:00.000-08:00

AN OBJECT-ORIENTED LINKED LIST DESIGN

Our design of a linked list will involve at least two classes.We’ll create a Node class and instantiate a Node object each time we add a node to the list. The nodes in the list are connected via references to other nodes. These references are set using methods created in a separate LinkedList class.Let’s start by looking at the design of the Node class.
The Node Class

A node is made up of two data members: Element, which stores the node’s data; and Link, which stores a reference to the next node in the list.We’ll use Object for the data type of Element, just so we don’t have to worry about what kind of data we store in the list. The data type for Link is Node, which seems strange but actually makes perfect sense. Since we want the link to point to the next node, and we use a reference to make the link, we have to assign a Node type to the link member.
To finish up the definition of the Node class, we need at least two constructor methods. We definitely want a default constructor that creates an empty Node, with both the Element and Link members set to null. We also need a parametrized constructor that assigns data to the Element member and sets the Link member to null.
Here’s the code for the Node class:

public class Node
{

public Object Element;
public Node Link;
public Node()
{
Element = null;
Link = null;
}
public Node(Object theElement)
{
Element = theElement;
Link = null;
}
}

The LinkedList Class
The LinkedList class is used to create the linkage for the nodes of our linked list. The class includes several methods for adding nodes to the list, removing nodes from the list, traversing the list, and finding a node in the list. We also need a constructor method that instantiates a list. The only data member in the class is the header node.

public class LinkedList
{
protected Node header;
public LinkedList()
{
header = new Node("header");
}
. . .
}

The header node starts out with its Link field set to null. When we add the first node to the list, the header node’s Link field is assigned a reference to the new node, and the new node’s Link field is assigned the null value.

To insert a new node after an existing node

To do this, we create a Private method, Find, that searches through the Element field of each node until a match is found.

private Node Find(Object item)

{
Node current = new Node();
current = header;
while(current.header != item)
current = current.Link;
return current;
}

Once we’ve found the “after” node, the next step is to set the new node’s Link field to the Link field of the “after” node, and then set the “after” node’s Link field to a reference to the new node. Here’s how it’s done:

public void Insert(Object newItem, Object after)

{
Node current = new Node();
Node newNode = new Node(newItem);
current = Find(after);

newNode.Link = current.Link;
current.Link = newNode;
}

Remove a node from a linked list

we simply have to change the link of the node that points to the removed node to point to the node after the removed node.

private Node FindPrevious(Object n)

{
Node current = header;
while(!(current.Link == null) && (current.Link.
Element != n))
current = current.Link;
return current;
}

Now we’re ready to see how the code for the Remove method looks:

public void Remove(Object n)

{
Node p = FindPrevious(n);
if (!(p.Link == null))
p.Link = p.Link.Link;
}

PrintList

public void PrintList()

{
Node current = new Node();
current = header;
while (!(current.Link == null))

{
Console.WriteLine(current.Link.Element);
current = current.Link;
}
}

Link List (Howz it works)

2008-12-22T02:11:00.000-08:00

A linked list is a collection of class objects called nodes. Each node is linked to its successor node in the list using a reference to the successor node. A node is made up of a field for storing data and the field for the node reference. The reference to another node is called a link. An example linked list is:

A major difference between an array and a linked list is that whereas the elements in an array are referenced by position (the index), the elements of a linked list are referenced by their relationship to the other elements of the array. From above example we can say that “Bread” follows “Milk”, not that “Bread” is in the second position. Moving through a linked list involves following the links from the beginning node to the ending node.
Another thing to notice that we mark the end of a linked list by pointing to the value null. Since we are working with class objects in memory, we use the null object to denote the end of the list.
Marking the beginning of a list can be a problem in some cases. It is common in many linked list implementations to include a special node, called the “header”, to denote the beginning of a linked list. The linked list in underlying figure is redesigned with a header node:

Insertion and Removal of an Item from Link List

Insertion becomes a very efficient task when using a linked list. All that is involved is changing the link of the node previous to the inserted node to point to the inserted node, and setting the link of the new node to point to the node the previous node pointed to before the insertion. In Figure (below) the item “Cookies” is added to the linked list after “Eggs”.

Removing an item from a linked list is just as easy. We simply redirect the link of the node before the deleted node to point to the node the deleted node points to and set the deleted node’s link to null. The diagram (below) we remove “Bacon” from the linked list.

Pointers and unsafe code in c#

2008-12-22T01:45:00.000-08:00

Introduction

We will see that C# allows suspending the verification of code by the CLR to allow developers to directly access memory using pointers. Hence with C#, you can complete, in a standard way, certain optimizations which were only possible within unmanaged development environments such as C++. These optimizations concern, for example, the processing of large amounts of data in memory such as bitmaps.

Pointers and unsafe code

C++ does not know the notion of code management. This is one of the advantages of C++ as it allows the use of pointers and thus allows developers to write optimized code which is closer to the target machine.

This is also a disadvantage of C++ since the use of pointers is cumbersome and potentially dangerous, significantly increasing the development effort and maintenance required.

Before the .NET platform, 100% of the code executed on the Windows operating system was unmanaged. This means the executable contains the code directly in machine instructions which are compatible with the type of processor (i.e. machine language code). The introduction of the managed execution mode with the .NET platform is revolutionary. The main sources of hard to track bugs are detected and resolved by the CLR. Amongst these:

Array access overflows (Now dynamically managed by the CLR).

Memory leaks (Now mostly managed by the garbage collector).

The use of an invalid pointer. This problem is solved in a radical way as the manipulation of pointers if forbidden in managed mode.

The CLR knows how to manipulate three kinds of pointers:

Managed pointers. These pointers can point to data contained in the object heap managed by the garbage collector. These pointers are not used explicitly by the C# code. They are thus used implicitly by the C# compiler when it compiles methods with out and ref arguments.

Unmanaged function pointers. The pointers are conceptually close to the notion of delegate. We will discuss them at the end of this article.

Unmanaged pointers. These pointers can point to any data contained in the user addressing space of the process. The C# language allows to use this type of pointers in zones of code considered unsafe. The IL code emitted by the C# compiler corresponding to the zones of code which use these unmanaged pointers make use of specialized IL instructions. Their effect on the memory of the process cannot be verified by the JIT compiler of the CLR. Consequently, a malicious user can take advantage of unsafe code regions to accomplish malicious actions. To counter this weakness, the CLR will only allow the execution of this code at run-time if the code has the SkipVerification CAS meta-permission.

Since it allows to directly manipulating the memory of a process through the use of an unmanaged pointer, unsafe code is particularly useful to optimize certain processes on large amounts of data stored in structures.

Compilation options to allow unsafe code

Unsafe code must be used on purpose and you must also provide the /unsafe option to the csc.exe compiler to tell it that you are aware that the code you wish to compile contains zones which will be seen as unverifiable by the JIT compiler. Visual Studio offers the Build Allow unsafe code project property to indicate that you wish to use this compiler option.

Declaring unsafe code in C#

In C#, the unsafe keyword lets the compiler know when you will use unsafe code. It can be used in three situations:

Before the declaration of a class or structure. In this case, all the methods of the type can use pointers.

Before the declaration of a method. In this case, the pointers can be used within the body of this method and in its signature.

Within the body of a method (static or not). In this case, pointers are only allowed within the marked block of code. For example:

unsafe
{
...
}

Let us mention that if a method accepts at least one pointer as an argument or as a return value, the method (or its class) must be marked as unsafe, but also all regions of code calling this method must also be marked as unsafe.

Using pointers in C#

Each object, whether it is a value or reference type instance, has a memory address at which it is physically located in the process. This address is not necessarily constant during the lifetime of the object as the garbage collector can physically move objects store in the heap.

.NET types that support pointers

For certain types, there is a dual type, the unmanaged pointer type which corresponds to the managed type. A pointer variable is in fact the address of an instance of the concerned type. The set of types which authorizes the use of pointers limits itself to all value types, with the exception of structures with at least one reference type field. Consequently, only instances of the following types can be used through pointers: primitive types; enumerations; structures with no reference type fields; pointers.

Declaring pointers

A pointer might point to nothing. In this case, it is extremely important that its value should be set to null (0). In fact, the majority of bugs due to pointers come from pointers which are not null but which point to invalid data. The declaration of a pointer on the FooType is done as follows:

FooType * pointeur;

For example:

long * pAnInteger = 0;

Note that the declaration...

int * p1,p2;

... makes it so that p1 is a pointer on an integer and p2 is a pointer.

Now let's see the first program

Program 1

using System;

class MyClass {
 public static void Main() {
  int iData = 10;
  int* pData = &iData;
  Console.WriteLine("Data is " + iData);
  Console.WriteLine("Address is " + (int)pData );
 }

Here I use a pointer in this program. Now compile this program. The compiler gives the error

Now let's change the program a little bit and add unsafe modifier with the function.

Program 2

using System;

class MyClass {
 public unsafe static void Main() {
  int iData = 10;
  int* pData = &iData;
  Console.WriteLine("Data is " + iData);
  Console.WriteLine("Address is " + (int)pData );
 }
Data is 10
Address is 1244316

It is not necessary that we define the unsafe modifier with the function. We can define a block of unsafe code. Let's change a program little bit more.

Program 3

using System;

class MyClass {
 public static void Main() {
  unsafe {
   int iData = 10;
   int* pData = &iData;
   Console.WriteLine("Data is " + iData);
   Console.WriteLine("Address is " + (int)pData );
  }
 }
}

In this program a block is defined with unsafe modifier. So we can use pointers in that code. The output of this program is the same as previous one.

Now let's change the program a little bit to get a value from the pointer.

Program 4

using System;

class MyClass {
 public static void Main() {
  unsafe {
   int iData = 10;
   int* pData = &iData;
   Console.WriteLine("Data is " + iData);
   Console.WriteLine("Data is " + pData->ToString() );
   Console.WriteLine("Address is " + (int)pData );
  }
 }
}
Program 5
using System;

class MyClass {
 public static void Main() {
  testFun();
 }

 public static unsafe void testFun() {
  int iData = 10;
  int* pData = &iData;
  Console.WriteLine("Data is " + iData);
  Console.WriteLine("Address is " + (int)pData );
 }

In this program a function with unsafe modifier is called from a normal function. This program shows that a managed code can call unmanaged functions. The output of the program is the same as previous program.

Now change the program little bit and make an unsafe function in another class.

Program 6

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.testFun();
 }
}

class TestClass {
 public unsafe void testFun() {
  int iData = 10;
  int* pData = &iData;
  Console.WriteLine("Data is " + iData);
  Console.WriteLine("Address is " + (int)pData );
 }
}

The output of the program is same as previous one.

Now try to pass pointer as a parameter. Let’s see this program.

Program 7

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.testFun();
 }
}

class TestClass {
 public unsafe void testFun() {
  int x = 10;
  int y = 20;
  Console.WriteLine("Before swap x = " + x + " y= " + y);
  swap(&x, &y);
  Console.WriteLine("After swap x = " + x + " y= " + y);
 }

 public unsafe void swap(int* p_x, int *p_y) {
  int temp = *p_x;
  *p_x = *p_y;
  *p_y = temp;
 }
}

In this program the unsafe function testFun() calls the classic swap() function to interchange the value of two variables passing by reference. Now change the program a little bit.

Program 8

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  unsafe {
   int x = 10;
   int y = 20;
   Console.WriteLine("Before swap x = " + x + " y= " + y);
   Obj.swap(&x, &y);
   Console.WriteLine("After swap x = " + x + " y= " + y);
  }
 }
}

class TestClass {
 public unsafe void swap(int* p_x, int* p_y) {
  int temp = *p_x;
  *p_x = *p_y;
  *p_y = temp;
 }
}

This program does the same job as previous one. But in this program we write only one unsafe function and call this function from the unsafe block in Main.

Now let's see another program which show the usage of array in C#

Program 9

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.fun();
 }
}

class TestClass {
 public unsafe void fun() {
  int [] iArray = new int[10];

  // store value in array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   iArray[iIndex] = iIndex * iIndex;
  }

  // get value from array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   Console.WriteLine(iArray[iIndex]);
  }
 }
}

This program display the square of numbers from zero to 9.

Let's change the program a little bit and pass the array as a parameter to a function.

Program 10

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.fun();
 }
}

class TestClass {
 public unsafe void fun() {
  int [] iArray = new int[10];

  // store value in array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   iArray[iIndex] = iIndex * iIndex;
  }

  testFun(iArray);
 }

 public unsafe void testFun(int [] p_iArray) {

  // get value from array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   Console.WriteLine(p_iArray[iIndex]);
  }
 }
}

The output of the program is same as previous one.

Now let's change the program a little bit and try to get the value of the array from a pointer rather than an index.

Program 11

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.fun();
 }
}

class TestClass {
 public unsafe void fun() {
  int [] iArray = new int[10];

  // store value in array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   iArray[iIndex] = iIndex * iIndex;
  }

  // get value from array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   Console.WriteLine(*(iArray + iIndex) );
  }
 }
}

Here in this program we try to access the value of the array from *(iArray + iIndex) rather than iArray[iIndex]. But the program gives the following error.

Microsoft (R) Visual C# Compiler Version 7.00.9030 [CLR version 1.00.2204.21]
Copyright (C) Microsoft Corp 2000. All rights reserved.

um11.cs(21,24): error CS0019: Operator '+' cannot be applied to operands of type 'int[]' and 'int'

In C# int* and in[] are not treated the same. To understand it more let's see one more program.

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.fun();
 }
}

class TestClass {
 public unsafe void fun() {
  int [] iArray = new int[10];
  iArray++;

  int* iPointer = (int*)0;
  iPointer++;

 }
}

There are two different types of variable in this program. First, the variable iArray is declared an array and the second variable iPointer is a pointer variable. Now I am going to increment both. We can increment the pointer variable because it is not fixed in memory but we can't increment the iArray, because the starting address of the array is stored in iArray and if we are allowed to increment this then we will lose starting address of array.

The output of the program is an error.

Microsoft (R) Visual C# Compiler Version 7.00.9030 [CLR version 1.00.2204.21]
Copyright (C) Microsoft Corp 2000. All rights reserved.

um12.cs(13,3): error CS0187: No such operator '++' defined for type 'int[]'

To access the element of the array via a pointer we have to fix the pointer so it can't be incremented. C# uses the fixed reserve word to do this.

Program 13

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.fun();
 }
}

class TestClass {
 public unsafe void fun() {
  int [] iArray = new int[10];

  // store value in array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   iArray[iIndex] = iIndex * iIndex;
  }

  // get value from array
  fixed(int* pInt = iArray)
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   Console.WriteLine(*(pInt + iIndex) );
  }
 }
}

We can use the same technique to pass the array to a function which receives the pointer as a parameter.

Program 14

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.fun();
 }
}

class TestClass {
 public unsafe void fun() {
  int [] iArray = new int[10];

  // store value in array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   iArray[iIndex] = iIndex * iIndex;
  }

  // get value from array
  fixed(int* pInt = iArray)
  testFun(pInt);
 }

 public unsafe void testFun(int* p_pInt) {

  for (int iIndex = 0; iIndex < 10; iIndex++) {
   Console.WriteLine(*(p_pInt + iIndex) );
  }
 }
}

The output of the program is the same as the previous one. If we try to access beyond the array limit then it will print garbage.

Program 15

using System;

class MyClass {
 public static void Main() {
  TestClass Obj = new TestClass();
  Obj.fun();
 }
}

class TestClass {
 public unsafe void fun() {
  int [] iArray = new int[10];

  // store value in array
  for (int iIndex = 0; iIndex < 10; iIndex++) {
   iArray[iIndex] = iIndex * iIndex;
  }

  // get value from array
  fixed(int* pInt = iArray)
  testFun(pInt);
 }

 public unsafe void testFun(int* p_pInt) {

  for (int iIndex = 0; iIndex &lt 20; iIndex++) {
   Console.WriteLine(*(p_pInt + iIndex) );
  }
 }
}

Here we try to read 20 elements from array but there are only 10 elements in the array so it will print garbage after printing the elements of array.

Program 16

using System;

struct Point {
 public int iX;
 public int iY;
}

class MyClass {
 public unsafe static void Main() {

  // reference of point
  Point refPoint = new Point();
  refPoint.iX = 10;
  refPoint.iY = 20;

  // Pointer of point
  Point* pPoint = &refPoint;

  Console.WriteLine("X = " + pPoint->iX);
  Console.WriteLine("Y = " + pPoint->iY);

  Console.WriteLine("X = " + (*pPoint).iX);
  Console.WriteLine("Y = " + (*pPoint).iY);

 }
}

Here pPoint is the pointer of Point class instance. We can access the element of it by using the -> Operator.

Change in Beta 2

When you want to compile program using command line switch you type the program name after the compiler name; for example if your program name is prog1.cs then you will compile this:

scs prog1.cs

This works fine for unsafe code while you are programming in beta 1. In beta 2 Microsft added one more switch to command line compiler of C# for writing unsafe code. Now if you want to write unsafe code then you have to specify the /unsafe command line switch with command line compiler otherwise the compiler gives an error. In beta 2 if you want to write unsafe code in your program then you compile your programas follows:

csc /unsafe prog1.cs

Cryptography in .NET

2008-12-09T20:11:00.000-08:00

This article gives a brief overview of Cryptography and the Cryptography support provided by the .NET Framework. I begin by introducing Cryptography and then proceed to examine the various types of it. In particular, I review and analyze the various cryptography algorithms and objects supported by .NET. I conclude after proposing and briefly discussing the algorithmic technique that would work best for you.
Cryptography
I remember as kids, we would often play a game called 'jumble the word', where in we would replace an alphabet of a word with another. This way, A would be replaced with C; B with D and so on. Only someone who could understand this algorithm( in this case shift by 2), could decipher these messages and tell the word. Well in fact, this is 'Cryptography'. Surprisingly, we often use cryptography without consciously knowing it. For example, you may've tried to pass on a secret message to your friend using signals that only the two of you understood, or scribbled some text whose meaning was known only to you. We have all done that. Well....so we begin.
Cryptography is the science of scrambling meaningful characters into non-meaningful characters so that people who do not have access to the data cannot read it. The science of cryptography has been around for many years, even long before computers. Cryptography, over the ages, has been an art practiced by many who have devised different techniques to meet some of the information security requirements. The last twenty years have been a period of transition as the discipline moved from an art to a science. With the advent of computers, however, the science was able to produce almost unbreakable codes.
Well, Cryptography has been considered as one of the most complex aspect used by a developer. Using cryptographic algorithms and techniques is not considered a child's play, as it requires a high level of mathematical knowledge. Fortunately, with Microsoft .NET, newly created classes wrap up these sophisticated algorithms into fairly easy-to-use properties and methods. This article gives you an overview of the cryptography support that is provided by the .NET Framework.
However lets first look into a few jargons to make you familiar with cryptography :
1. Data that can be read and understood without any special measures is called 'plaintext' or 'cleartext'
2.The method of disguising plaintext in such a way as to hide its meaning is called 'Encryption'.
3.Encrypting plaintext results in unreadable chunks of data called 'Ciphertext'. You use encryption to make sure that information is hidden from anyone for whom it is not intended, even those who can see the encrypted data.
4.The process of reverting ciphertext to its original plaintext is called 'Decryption'.
5.And finally 'key' is a string of bits used for encrypting and decrypting information to be transmitted. It is a randomly generated set of numbers/ characters that is used to encrypt/decrypt information.
Types of Cryptography
After getting familiar with the terminology, let's delve into the types of Cryptography. There are two types of cryptography: private-key encryption and public-key encryption
Private key Encryption
Private Key encryption, also referred to as conventional or symmetric or single-key encryption was the only available option prior to the advent of Public Key encryption in 1976. This form of encryption was used by emperors like Julius Caesar and other military organizations to convey secret messages. This key requires all communicating parties, to share a common key. With private-key encryption, you encrypt a secret message using a key that only you know. To decrypt the message, you need to use the same key. Private-key cryptography is effective only if the key can be kept secret. Despite the potential weakness of private-key encryption, it is very easy to implement and computationally doesn't consume excessive resources.
Lets see an example - Imagine Julius is trying to send a secret message to his army chief, using a private key. In order for his chief to decrypt the secret message, he must know the private key. So Julius needs to send the key to him. But if the secrecy of his key is known to his opponents somehow , the message remains no longer secure. Moreover, if the Chief tells his subordinate about the private key, he can then also decrypt the message.
Public-key encryption
Public key encryption algorithms are based on the premise that each sender and recipient has a private key, known only to him/her and a public key, which can be known by anyone. Each encryption/decryption process requires at least one public key and one private key. Each is related to the other mathematically, such that messages encrypted with the public key can only be decrypted with the corresponding private key.
Lets see an example - Before Julius sends a message to his chief, he needs to generate the key pair containing the private key and the public key. The chief then freely distributes the public key to his subordinates but keeps the private key to himself. When Julius wants to send a message to his chief, he uses his public key to encrypt the message and then send it to him. Upon receiving the encrypted message, the Chief proceeds to decrypt it with his private key. In this case, he's the only one who can decrypt the message, since the key pair works in such a way that only messages encrypted with the public key can be decrypted with the private key. Also, there's no need to exchange secret keys, thus eliminating the risk of compromising the secrecy of the key.The reverse can happen as well. Suppose the Chief sends a message encrypted with his private key to Julius. To decrypt the message, Julius need his public key. But what's the point of that? The public key isn't a secret-everyone knows it. However, using this method guarantees that the message hasn't been tampered with and is indeed from his chief and not his opponents. If the message had been modified, Julius wouldn't be able to decrypt it.
I wish he was here to read all this!!!
.NET and Cryptography
.NET provides a set of cryptographic objects, supporting well-known algorithms and common uses including hashing, encryption, and generating digital signatures. These objects are designed in a manner that facilitates the incorporation of these basic capabilities into more complex operations, such as signing and encrypting a document. Cryptographic objects are used by .NET to support internal services, but are also available to developers who need cryptographic support. The .NET Framework provides implementations of many such standard cryptographic algorithms and objects. Similar to the ready availability of simple authentication features within the .NET Framework, cryptographic primitives are also easily accessible to developers via stream-based managed code libraries for encryption, digital signatures, hashing, and random number generation. The System.Security.Cryptography namespace in the .NET Framework provides these cryptographic services. The Algorithm support includes:
RSA and DSA public key (asymmetric) encryption - Asymmetric algorithms operate on fixed buffers. They use a public-key algorithm for encryption/decryption. An example for asymmetric algorithms is the RSA algorithm which is so named after its three inventors Rivest, Shamir, and Adleman. It is a popular public-key algorithm - the de facto standard - for digital signatures and can be used for encryption as well. The DSA_CSP is an implementation of the digital signature algorithm (DSA). This is a public-key algorithm. It can be used to create and verify a digital signature.
DES, TripleDES, and RC2 private key (symmetric) encryption - Symmetric algorithms are used to modify variable length buffers and perform one operation for periodical data input. They use a single secret key to encrypt and decrypt data.The Data Encryption Standard (DES) is a world-wide standard for data encryption, which was published in the early 1970s. It is the most popular encryption algorithm. It is implemented by the DES_CSP class. This class represents a stream where you pour in data that is encrypted/decrypted using a single key. The Triple DES encryption algorithm operates on a block of data three times using one key. RC2 stands for Rivest Cipher or "Ron's Code", which is the name of its inventor. RC2 is a symmetric encryption algorithm and works with a variable key-size. it is a block cipher, like many other .NET cryptography algorithms, that operates on groups of bits in contrast to stream cipher algorithms.
MD5 and SHA1 hashing - MD5 - Message Digest 5-is a one-way hash algorithm. Given variable length data as input it always produces a 128-bit hash value. The Secure Hash Algorithm (SHA) also is a one-way hash algorithm that produces a 160-bit hash value, which is longer than the MD5 produced hash value.
(You must have observed the word CSP. Well CSP is a Cryptographic Service Provider. It is the entity that performs the cryptographic computations. The CSP classes are derived from the corresponding base classes and implement a solution for a specific algorithm. For example, the DESCryptoServiceProvider class is derived from the DES class and implements the digital encryption standard. You can use the provided classes or implement your own solution. )

Here is a general guideline to help you decide when to use which method
Symmetric, or secret key, algorithms are extremely fast and are well suited for encrypting large streams of data. These algorithms, both encrypt and decrypt data. While these are fairly secure, they do have the potential to be broken given enough time, as someone could do a search on every known key value combination. Since each of these algorithms uses a fixed key length or ASCII characters, it is feasible that a computer program could try every possible combination of keys and eventually stumble onto the right one. A common use of these types of algorithms is for storing and retrieving connection strings to databases.
Asymmetric, or public key, algorithms are not as fast as symmetric, but are much harder codes to break. These algorithms rely on two keys, one is Private and the other is Public. The public key is used to encrypt a message. The Private key is the only one that can decrypt the message. The public and private keys are mathematically linked and thus both are needed for this cryptographic exchange to occur successfully. Asymmetric algorithms are not well suited to large amounts of data due to performance. One common use of asymmetric algorithms is to encrypt and transfer to another party a symmetric key and initialization vector. The symmetric algorithm is then used for all messages being sent back and forth.
Hash values are used when you do not wish to ever recover the original value and you especially wish for no one else to discover the original value as well. Hashes will take any arbitrary string length and hash it to a fixed set of bytes. This operation is one-way, and thus is typically used for small amounts of data, like a password. If a user inputs a user password into a secure entry screen, the program can hash this value and store the hashed value into a database. Even if the database were compromised, no one would be able to read the password since it was hashed. When the user then logs into the system to gain entry, the password typed in is hashed using the same algorithm, and if the two hashed values match, then the system knows the input value was the same as the saved value from before.
Everyone Loves an Example
Everyone needs and loves a good example. After having read about the various algorithms available, lets see an example of encrypting and decrypting files using the System.Security.Cryptography namespace. I have used the Rijndael Managed encryption method. The Rijndael Managed class accesses the managed version of the Rijndael algorithm. This class cannot be inherited. The Rijndael class represents the base class from which all implementations of the Rijndael symmetric encryption algorithm must inherit.
The hierarchy is as follows
System.Object
System.Security.Cryptography.SymmetricAlgorithm
System.Security.Cryptography.Rijndael
System.Security.Cryptography.RijndaelManaged
// Encrypting and decrypting files using the Rijndael Managed encryption method.
using System;
using System.IO;
using System.Security.Cryptography;
class CryptoEx
{
public static void Main(string[] args)
{
if (args.Length!=1)
{
Console.WriteLine("FileName Not Entered. Specify a filename to encrypt.");
return;
}
string file = args[0];
string tempfile = Path.GetTempFileName(); // Open the file to read
FileStream fsIn = File.Open(file,FileMode.Open,FileAccess.Read);
FileStream fsOut = File.Open(tempfile, FileMode.Open,FileAccess.Write);
SymmetricAlgorithm symm = new RijndaelManaged();
//creating an instance
ICryptoTransform transform = symm.CreateEncryptor();
//and calling the CreateEncryptor method which
//creates a symmetric encryptor object.
CryptoStream cstream = new CryptoStream(fsOut,transform,CryptoStreamMode.Write); BinaryReader br = new BinaryReader(fsIn);
cstream.Write(br.ReadBytes((int)fsIn.Length),0,(int)fsIn.Length);
cstream.FlushFinalBlock();
cstream.Close();
fsIn.Close();
fsOut.Close();
Console.WriteLine("Created Encrypted File {0}", tempfile);
fsIn = File.Open(tempfile,FileMode.Open,FileAccess.Read);
transform = symm.CreateDecryptor();
cstream = new CryptoStream(fsIn,transform,CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cstream);
Console.WriteLine("Decrypted the File: " + sr.ReadToEnd());
fsIn.Close();
}
Summary :
We saw that the .NET Framework supports encryption by means of cryptographic streaming objects based on the primitives. It also supports digital signatures, message authentication codes (MACs)/keyed hash, pseudo-random number generators (PRNGs), and authentication mechanisms. New or pre-standard primitives as SHA-256 or XMLDSIG are already supported. The ready availability of such libraries is hopefully going to drive more widespread reliance on Cryptography to fortify the security of everyday applications. Based on our own experiences, we can confidently state that well-implemented cryptography dramatically increases the security of many aspects of a given application.

The HTML tag

2008-11-23T07:38:00.000-08:00

You must aware of HTML tags. There are several tags that define elements and linked resources of the web pages. Have you ever use the HTML link tag ? Its so stupid question but there is reason behind putting this question , The HTML link tag is very useful and amazing.

It has three main attribute

1. rel
2. type
3. href

The rel attribute define the relationship between page and linked web resource that could be a stylesheet, bookmark, alternate url and so on.

The type attribute define MIME(Multipurpose Mail Extension) of the web resource.

The href attribute define url of the web resource to be linked with page.

Syntax:

<link rel="Relationship" type="MIME Type" href="URL" / >

Here is the list of possible values of the rel attribute:

* alternate - an alternate version of the document(print page, translated/mirror)
* stylesheet - an external style sheet for the document
* shortcut icon - the fevicon of the document
* start - the first document in a selection
* next - the next document in the current selection
* prev - the previous document in the current selection
* contents - a table of contents for the document
* index - an index for the document
* glossary - a glossary (explanation) of words used in the document
* copyright - a document containing copyright information
* chapter - a chapter of a selection of documents
* section - a section of a selection of documents
* subsection - a subsection of a selection of documents
* appendix - an appendix of a selection of documents
* help - a help document
* bookmark - a related document

Note: Most browsers do not use this attribute in any way. However, search engines, and some browsers, may us this attribute to get more information about the link.

Linking a stylesheet with the page is one of most commonly used purpose of the HTML link tag. Here I'm going to show you more interesting uses of this tag.

Example 1:
This example with show a small icon in the browser's address bar before the URL

<link rel="shortcut icon" type="image/x-icon" href="fevicon.ico" / >

Example 2:
This example will show a RSS link in the browser's address bar after the URL

<link rel="alternate" type="application/rss+xml" title="RSS" href="http://www.mysite.com/rss.xml">

Example 3:
This example will show company's copyright information

<link rel="copyright" href="/copyright.shtml" title="Copyright">

Example 4:
This will link Author information with the page

<link rel="author" href="/about/index.shtml" title="About">

Example 5:
We can have link tag for many purposes

<HEAD>
<TITLE>Document Tags</TITLE>
<LINK REL=HOME TITLE="Home Page" HREF="http://www.mydomain.com">
<LINK REL=PREVIOUS TITLE="URLs" HREF="../urls/">
<LINK REL=NEXT TITLE="Lines and Paragraphs" HREF="../linepar/">
<LINK REV=MADE TITLE="Ravindra Patel" HREF="mailto:ravipatel.write@gmail.com">
<LINK REL=COPYRIGHT TITLE="copyright info" HREF="copyright.html">
<LINK REL=STYLESHEET TITLE="style sheet" HREF="stdstyles.css">
</HEAD>

There are much more on link tag. Post your comments if you want to know more about the HTML tags

ASP.NET From PHP Perspective

2008-11-23T06:21:00.000-08:00

You Can also follow the URL:
http://in.youtube.com/watch?v=aEIwEGyK_Ns

Using LINQ

2008-11-23T02:09:00.000-08:00

http://in.youtube.com/watch?v=B0gD0NqbGHk

An Introduction to Microsoft Silverlight

2008-11-23T01:27:00.000-08:00

You can also follow the URLs
http://in.youtube.com/watch?v=Carpbkwxem0
http://in.youtube.com/watch?v=m47xvHbdzLY&feature=related
http://in.youtube.com/watch?v=dUWIOBMNhbI&feature=related

Basics of Jquery

2008-11-13T08:21:00.000-08:00

You can also use the following link for the video
http://in.youtube.com/watch?v=CNw2wVDWYaU&feature=related

Asp.Net 2.0 Membership I LoginStatus LoginName

2008-11-13T07:54:00.000-08:00

How to: Create an ASP.NET Login Page

2008-11-13T07:08:00.000-08:00

You can create a login page by using the ASP.NET login control. The control consists of text boxes, a check box and a button control. The text boxes collect username and password information from the user. The check box is used to remember the user's credentials and the button is used to submit the information the user provides. The login control simplifies creating login pages for form authentication. This login control takes a user name and password and uses ASP.NET membership and forms authentication to verify the user's credentials and create an authentication ticket. For information about how to configure ASP.NET membership and forms authentication. If a user selects the Remember me next time check box, the control creates a persistent cookie that remembers the user's credentials.

The login control functions as expected when you create an ASP.NET Web site with membership, configure membership, and create a membership user.

To create a login page

Create an ASP.NET Web application that uses ASP.NET membership.
Create an ASP.NET Web page named Login.aspx in your application.( By default, ASP.NET forms authentication is configured to use a page named Login.aspx. You can change the default login page name in the Web.config file for your application using the Login Url property.)
Add a Login control to the page.
Set the control's Designation page Url property to the name of the page that the user will be redirected to after they log in. For example, you can set the DestinationPageUrl property to DestinationPageUrl="~/Membership/MembersHome.aspx", a members only page. If you do not specify a value for the Designation Page Url property, the user will be redirected to the original page the user requested after successfully logging in.
The following example shows the markup for a Login control:

About IIS(Internet Information Servicces)

2008-11-04T23:10:00.000-08:00

Overview
Over the years, it has become simple for advanced Web users to create their own Web site. Once an end-user has registered their domain name, there are various types of hosters to choose from. Web hosters are available throughout the world to meet the demands of end customers. But regardless of which hoster is chosen, the scenario of signing up and creating a web site is similar in all cases.
Initially, a new user account needs to be established for the user. Once the account has been set up, the end user decides what features and options the site should incorporate: for instance, how much disk space, FTP capability, creation of virtual directories, whether or not databases are needed, etc. Hosters build control panels or dashboard applications that allow end users to create and manage these features.
There are a number of ways that these capabilities can be implemented into the control panel. In this section, we look at implementing the provisioning aspect of these features through managed code. An outline of the features is as follows:
Provision new user account
Create content storage
Create Application Pool
Create Web site
Create binding
Create root application
Create Virtual directory
Create FTP site
Provision New User Account
A user account is needed for the site owner who manages and maintains the site. The account can either be an Active Directory Account, or a local user account. To simplify the scenario, we only illustrate creating a local user account.
The following code fragments demonstrate the creation of a local account.
The System.DirectoryServices namespace must be specified.

public static bool CreateLocalUserAccount(string userName, string password)
{
try
{
if (string.IsNullOrEmpty(userName))
throw new ArgumentNullException("userName", "Invalid User Name.");
if (string.IsNullOrEmpty(password))
throw new ArgumentNullException("password", "Invalid Password.");
DirectoryEntry directoryEntry = new DirectoryEntry("WinNT://" + Environment.MachineName + ",computer");
bool userFound = false;
try
{
if (directoryEntry.Children.Find(userName, "user") != null)
userFound = true;
}
catch
{
userFound = false;
}
if (!userFound)
{
DirectoryEntry newUser = directoryEntry.Children.Add(userName, "user"); newUser.Invoke("SetPassword", new object[] { password });
newUser.Invoke("Put", new object[] { "Description", "Application Pool User Account" }); newUser.CommitChanges();
newUser.Close();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
} return true;
}
Create Content Storage
The content storage requires specific permissions configured for users to manage their own contents. The following code fragment demonstrates how to set directory permissions using managed code in C#:

InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType controlType)
{
try
{
// Create a new DirectoryInfo object.
DirectoryInfo dInfo = new DirectoryInfo(directoryPath);
// Get a DirectorySecurity object that represents the
// current security settings.
DirectorySecurity dSecurity = dInfo.GetAccessControl();
// Add the FileSystemAccessRule to the security settings.
dSecurity.AddAccessRule(new FileSystemAccessRule(userAccount, rights, inheritanceFlags, propagationFlags, controlType));
// Set the new access settings.
dInfo.SetAccessControl(dSecurity);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return true;
}
Furthermore, if disk quota is restricted, the following code fragment demonstrates how to set disk quota using managed code. To use the disk quota management, you must add reference to Windows Disk Quota management component; it resides under window\system32\dskquota.dll.

public static bool AddUserDiskQuota(string userName, double quota, double quotaThreshold, string diskVolume)
{
try
{
DiskQuotaControlClass diskQuotaCtrl = GetDiskQuotaControl(diskVolume); diskQuotaCtrl.UserNameResolution = UserNameResolutionConstants.dqResolveNone; DIDiskQuotaUser diskUser = diskQuotaCtrl.AddUser(userName);
diskUser.QuotaLimit = quota;
diskUser.QuotaThreshold = quotaThreshold;
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return true;
}

Create Application Pool
An application pool defines the settings for a worker process that hosts one or more IIS 7.0 applications, carrying out their request processing. The application pool is a unit of process isolation, since all request processing for an application runs within its application pool's worker processes.
It is also a unit of isolation from a security perspective, since the application pool can run with a different identity, and ACL all needed resources exclusively for itself to prevent applications in other application pools from being able to access its resources. The following code fragment demonstrates the creation of an application pool, setting the identity, and setting properties.

public static bool CreateApplicationPool(string applicationPoolName, ProcessModelIdentityType identityType, string applicationPoolIdentity, string password, string managedRuntimeVersion, bool autoStart, bool enable32BitAppOnWin64,ManagedPipelineMode managedPipelineMode, long queueLength, TimeSpan idleTimeout, long periodicRestartPrivateMemory, TimeSpan periodicRestartTime)
{
try
{
if (identityType == ProcessModelIdentityType.SpecificUser)
{
if (string.IsNullOrEmpty(applicationPoolName))
throw new ArgumentNullException("applicationPoolName", "CreateApplicationPool: applicationPoolName is null or empty.");
if (string.IsNullOrEmpty(applicationPoolIdentity))
throw new ArgumentNullException("applicationPoolIdentity", "CreateApplicationPool: applicationPoolIdentity is null or empty.");
if (string.IsNullOrEmpty(password))
throw new ArgumentNullException("password", "CreateApplicationPool: password is null or empty.");
}
using (ServerManager mgr = new ServerManager())
{
ApplicationPool newAppPool = mgr.ApplicationPools.Add(applicationPoolName);
if (identityType == ProcessModelIdentityType.SpecificUser)
{
newAppPool.ProcessModel.IdentityType = ProcessModelIdentityType.SpecificUser; newAppPool.ProcessModel.UserName = applicationPoolIdentity; newAppPool.ProcessModel.Password = password;
}
else
{
newAppPool.ProcessModel.IdentityType = identityType;
}
if (!string.IsNullOrEmpty(managedRuntimeVersion)) newAppPool.ManagedRuntimeVersion = managedRuntimeVersion; newAppPool.AutoStart = autoStart;
newAppPool.Enable32BitAppOnWin64 = enable32BitAppOnWin64; newAppPool.ManagedPipelineMode = managedPipelineMode;
if (queueLength > 0)
newAppPool.QueueLength = queueLength;
if (idleTimeout != TimeSpan.MinValue)
newAppPool.ProcessModel.IdleTimeout = idleTimeout;
if (periodicRestartPrivateMemory > 0) newAppPool.Recycling.PeriodicRestart.PrivateMemory = periodicRestartPrivateMemory; if (periodicRestartTime != TimeSpan.MinValue) newAppPool.Recycling.PeriodicRestart.Time = periodicRestartTime;
mgr.CommitChanges();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return true;
}

Using LINQ to Create a Pager for SQL Data in C#

2008-11-04T22:35:00.000-08:00

Using LINQ to SQL, we can make use of the built-in methods to page the database data a lot easier than with using SQL alone. LINQ to SQL can make it extremely easy for us to create pages from our data source using just two methods - Skip and Take.Skip allows us to skip a certain number of records, and Take allows us to select a certain number of records.
In this tutorial, we will be creating a SQL database and adding a LINQ to SQL Class that Visual Studio creates to represent our database. We will then extend the class to support paging of the data, using the methods mentioned above.Let's start by creating our database. In this example, we will use one table named tblEmployees with three columns - id, name, position.Once the database is set up, we will add some sample data - we will need at least 5 records to make use of the paging feature.
Once we have our database set up and have added data to it, we then need to create a representation of our database using a LINQ to SQL Class. Right-click your project in the Solution Explorer, and goto Add ASP.NET Folder > App_Code. Now right-click the App_Code folder and choose Add New Item.. LINQ to SQL Classes. This will bring up the Object Relationship Designer. All we need to do here is drag the tables we will be working with into the Designer, from the Server Explorer, and then Save. This will allow Visual Studio to create a representation of our database. For this example, we will name it Employees.dbml
Now we will create an extension of this class by again right-clicking the App_Code folder and choose Add New Item.. Class. We will also name this Employees and change the public class to public partial class. We may need to also add extra assembly references; we will be using the System.Collections.Generic, System.Data.Linq and System.Linq in particular.We are going to extend this class by providing methods to select the data in pages. Our first method will select all the data:
public static IEnumerable Select()
{
EmployeesDataContext db = new EmployeesDataContext();
return db.tblEmployees;
}
Notice the EmployeesDataContext refers to our LINQ to SQL class.Next, we add a method to move between the pages of the data:
public static IEnumerable SelectPage(int startRowIndex, int maximumRows)
{
return Select().Skip(startRowIndex).Take(maximumRows);
}
This method will be called when a new page is requested through PostBack. The GridView's paging links will provide the variables required for this method.Finally, we create a method that will get the number of records in the database:
public static int SelectCount()
{
return Select().Count();
}
The entire class extension will look something like this:
using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Data.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.Collections.Generic;
///

/// Extension class for Employees.dbml///

public partial class Employees{
public static IEnumerable Select()
{
EmployeesDataContext db = new EmployeesDataContext();return db.tblEmployees;
}
public static IEnumerable SelectPage(int startRowIndex, int maximumRows)
{
return Select().Skip(startRowIndex).Take(maximumRows);
}
public static int SelectCount()
{
return Select().Count();
}
}
Now we are done with the class, and can implement the functionality into our ASPX page. To make this work, we will need to use a GridView control and an ObjectDataSource:

Because we are using VS.NET 2008, we can simply add AJAX Functionality to our web application using a ScriptManager and UpdatePanel.In order to implement paging, we need to set the EnablePaging attributes on both of our controls. We also set the Method attributes of the ObjectDataSource to reflect those we created in our partial class - note that the TypeName refers to our class name.
NOTE: We can change the PageSize to set the number of items on each page.

Adding to XML File using LINQ and C#

2008-11-04T21:59:00.000-08:00

This tutorial was created with Visual Studio 2008, but can be replicated in 2005 if you download and install Microsoft's LINQ Community Technology Preview release, which can be downloaded from here.
LINQ has the amazing ability to communicate and interact with many various data sources - databases, XML and varying objects. In this tutorial, we will be using a Windows Form to look at how we can use LINQ to add data to an XML file for storage. This is a quick and easy alternative to using a database. An XML file would be good for storing less information, which is not sensitive.

The XML file we will be using in this example is as follows:

We will create a Windows Form to view the XML file, and also to add new data to it. We will add three textboxes to the form - for name, city and age; two buttons - for adding and viewing XML data; and a Rich Text Box for viewing the XML data. We can also add labels to the text boxes.
Once our form is ready, we can move to the code-behind and add the namespaces we are going to use. The majority of which are added automatically. We may need to add System.Xml.Linq, however. It will look something like this:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Xml.Linq;
Once we have added our references, we will create an on-click handler for the view button. We will add the following code-behind:
private void button1_Click(object sender, EventArgs e){
XDocument xmlDoc = XDocument.Load("People.xml");
var persons = from person in xmlDoc.Descendants("Person")
select new{
Name = person.Element("Name").Value,
City = person.Element("City").Value,
Age = person.Element("Age").Value,
};
txtResults.Text = "";
foreach (var person in persons){
txtResults.Text = txtResults.Text + "Name: " + person.Name + "\n";
txtResults.Text = txtResults.Text + "City: " + person.City + "\n";
txtResults.Text = txtResults.Text + "Age: " + person.Age + "\n\n";
}
if (txtResults.Text == "")
txtResults.Text = "No Results.";
}
This code-block utilizes LINQ, first loading the XML file into memory, and then selecting all the data from within. The LINQ query looks similar to a SQL statement. We select all data from the XML file and then loop through this data, outputting all results into the text box. Finally, we check to see if the XML file is empty.
Next, we will add the code for the button to add new data to the XML file. We create another handler for the other button:
private void button2_Click(object sender, EventArgs e){
XDocument xmlDoc = XDocument.Load("People.xml");
xmlDoc.Element("Persons").Add(new XElement("Person", new XElement("Name", txtName.Text),
new XElement("City", txtCity.Text), new XElement("Age", txtAge.Text)));
xmlDoc.Save("People.xml");
}
Similar to the other button, this one also opens the XML file, to enable us to edit it. We then simply add an element to the XML file, into the Persons element.Now our Window Form can both read and write to the XML file. The entire code-behind looks something like this:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Xml.Linq;

namespace LINQtoXML_cs{
public partial class Form1 : Form{
public Form1(){
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e){
XDocument xmlDoc = XDocument.Load("People.xml");
var persons = from person in xmlDoc.Descendants("Person")
select new{
Name = person.Element("Name").Value,
City = person.Element("City").Value,
Age = person.Element("Age").Value,
};
txtResults.Text = "";
foreach (var person in persons){
txtResults.Text = txtResults.Text + "Name: " + person.Name + "\n";
txtResults.Text = txtResults.Text + "City: " + person.City + "\n";
txtResults.Text = txtResults.Text + "Age: " + person.Age + "\n\n";
}
if (txtResults.Text == "")
txtResults.Text = "No Results.";
}
private void button2_Click(object sender, EventArgs e)
{
XDocument xmlDoc = XDocument.Load("People.xml");xmlDoc.Element("Persons").Add(new XElement("Person", new XElement("Name", txtName.Text),
new XElement("City", txtCity.Text), new XElement("Age", txtAge.Text)));xmlDoc.Save("People.xml");
}
}
}

Performance Tips and Tricks in .NET Applications

2008-11-04T21:48:00.000-08:00

Summary: This article is for developers who want to tweak their applications for optimal performance in the managed world. Sample code, explanations and design guidelines are addressed for Database, Windows Forms and ASP applications, as well as language-specific tips for Microsoft Visual Basic and Managed C++. (25 printed pages)
Contents
Overview Performance Tips for All Applications Tips for Database Access Performance Tips for ASP.NET Applications Tips for Porting and Developing in Visual Basic Tips for Porting and Developing in Managed C++Additional Resources Appendix: Cost of Virtual Calls and Allocations
Overview
This white paper is designed as a reference for developers writing applications for .NET and looking for various ways to improve performance. If you are a developer who is new to .NET, you should be familiar with both the platform and your language of choice. This paper strictly builds on that knowledge, and assumes that the programmer already knows enough to get the program running. If you are porting an existing application to .NET, it's worth reading this document before you begin the port. Some of the tips here are helpful in the design phase, and provide information you should be aware of before you begin the port.
This paper is divided into segments, with tips organized by project and developer type. The first set of tips is a must-read for writing in any language, and contains advice that will help you with any target language on the Common Language Runtime (CLR). A related section follows with ASP-specific tips. The second set of tips is organized by language, dealing with specific tips about using Managed C++ and Microsoft® Visual Basic®.
Due to schedule limitations, the version 1 (v1) run time had to target the broadest functionality first, and then deal with special-case optimizations later. This results in a few pigeonhole cases where performance becomes an issue. As such, this paper covers several tips that are designed to avoid this case. These tips will not be relevant in the next version (vNext), as these cases are systematically identified and optimized. I'll point them out as we go, and it is up to you to decide whether it is worth the effort.
Performance Tips for All Applications
There are a few tips to remember when working on the CLR in any language. These are relevant to everyone, and should be the first line of defense when dealing with performance issues.
Throw Fewer Exceptions
Throwing exceptions can be very expensive, so make sure that you don't throw a lot of them. Use Perfmon to see how many exceptions your application is throwing. It may surprise you to find that certain areas of your application throw more exceptions than you expected. For better granularity, you can also check the exception number programmatically by using Performance Counters.
Finding and designing away exception-heavy code can result in a decent perf win. Bear in mind that this has nothing to do with try/catch blocks: you only incur the cost when the actual exception is thrown. You can use as many try/catch blocks as you want. Using exceptions gratuitously is where you lose performance. For example, you should stay away from things like using exceptions for control flow.
Here's a simple example of how expensive exceptions can be: we'll simply run through a For loop, generating thousands or exceptions and then terminating. Try commenting out the throw statement to see the difference in speed: those exceptions result in tremendous overhead.

public static void Main(string[] args){
int j = 0;
for(int i = 0; i < j =" i;" href="http://msdn.microsoft.com/en-us/library/04fy9ya1.aspx">gritty details of marshalling can be explored further on the MSDN Library. I recommend reading it carefully if you spend a lot of your time marshalling.
Design with ValueTypes
Use simple structs when you can, and when you don't do a lot of boxing and unboxing. Here's a simple example to demonstrate the speed difference:
using System;
namespace ConsoleApplication{
public struct foo{
public foo(double arg){ this.y = arg; }
public double y;
}
public class bar{
public bar(double arg){ this.y = arg; }
public double y;
}
class Class1{
static void Main(string[] args){
System.Console.WriteLine("starting struct loop...");
for(int i = 0; i < test =" new" i =" 0;" test2 =" new" href="http://msdn.microsoft.com/en-us/library/ms973838.aspx">Performance Considerations of Run-Time Technologies in the .NET Framework.
Use AddRange to Add Groups
Use AddRange to add a whole collection, rather than adding each item in the collection iteratively. Nearly all windows controls and collections have both Add and AddRange methods, and each is optimized for a different purpose. Add is useful for adding a single item, whereas AddRange has some extra overhead but wins out when adding multiple items. Here are just a few of the classes that support Add and AddRange:
StringCollection, TraceCollection, etc.
HttpWebRequest
UserControl
ColumnHeader
Trim Your Working Set
Minimize the number of assemblies you use to keep your working set small. If you load an entire assembly just to use one method, you're paying a tremendous cost for very little benefit. See if you can duplicate that method's functionality using code that you already have loaded.
Keeping track of your working set is difficult, and could probably be the subject of an entire paper. Here are some tips to help you out:
Use vadump.exe to track your working set. This is discussed in another white paper covering various tools for the managed environment.
Look at Perfmon or Performance Counters. They can give you detail feedback about the number of classes that you load, or the number of methods that get JITed. You can get readouts for how much time you spend in the loader, or what percent of your execution time is spent paging.
Use For Loops for String Iteration—version 1
In C#, the foreach keyword allows you to walk across items in a list, string, etc. and perform operations on each item. This is a very powerful tool, since it acts as a general-purpose enumerator over many types. The tradeoff for this generalization is speed, and if you rely heavily on string iteration you should use a For loop instead. Since strings are simple character arrays, they can be walked using much less overhead than other structures. The JIT is smart enough (in many cases) to optimize away bounds-checking and other things inside a For loop, but is prohibited from doing this on foreach walks. The end result is that in version 1, a For loop on strings is up to five times faster than using foreach. This will change in future versions, but for version 1 this is a definite way to increase performance.
Here's a simple test method to demonstrate the difference in speed. Try running it, then removing the For loop and uncommenting the foreach statement. On my machine, the For loop took about a second, with about 3 seconds for the foreach statement.

public static void Main(string[] args) {
string s = "monkeys!";
int dummy = 0;

System.Text.StringBuilder sb = new System.Text.StringBuilder(s);
for(int i = 0; i < s =" sb.ToString();" i =" 0;" name="dotnetperftips_topic2a">Use StringBuilder for Complex String Manipulation
When a string is modified, the run time will create a new string and return it, leaving the original to be garbage collected. Most of the time this is a fast and simple way to do it, but when a string is being modified repeatedly it begins to be a burden on performance: all of those allocations eventually get expensive. Here's a simple example of a program that appends to a string 50,000 times, followed by one that uses a StringBuilder object to modify the string in place. The StringBuilder code is much faster, and if you run them it becomes immediately obvious.

namespace ConsoleApplication1.Feedback

using System;

public class Feedback{
public Feedback(){
text = "You have ordered: \n";
}

public string text;

public static int Main(string[] args) {
Feedback test = new Feedback();
String str = test.text;
for(int i=0;i<50000;i++){ str =" str" href="javascript:CopyCode(">

namespace ConsoleApplication1.Feedback

using System;

public class Feedback{
public Feedback(){
text = "You have ordered: \n";
}

public string text;

public static int Main(string[] args) {
Feedback test = new Feedback();
System.Text.StringBuilder SB =
new System.Text.StringBuilder(test.text);
for(int i=0;i<50000;i++){ name="dotnetperftips_topic3">Tips for Database Access
The philosophy of tuning for database access is to use only the functionality that you need, and to design around a 'disconnected' approach: make several connections in sequence, rather than holding a single connection open for a long time. You should take this change into account and design around it.
Microsoft recommends an N-Tier strategy for maximum performance, as opposed to a direct client-to-database connection. Consider this as part of your design philosophy, as many of the technologies in place are optimized to take advantage of a multi-tired scenario.
Use the Optimal Managed Provider
Make the correct choice of managed provider, rather than relying on a generic accessor. There are managed providers written specifically for many different databases, such as SQL (System.Data.SqlClient). If you use a more generic interface such as System.Data.Odbc when you could be using a specialized component, you will lose performance dealing with the added level of indirection. Using the optimal provider can also have you speaking a different language: the Managed SQL Client speaks TDS to a SQL database, providing a dramatic improvement over the generic OleDbprotocol.
Pick Data Reader Over Data Set When You Can
Use a data reader whenever when you don't need to keep the data lying around. This allows a fast read of the data, which can be cached if the user desires. A reader is simply a stateless stream that allows you to read data as it arrives, and then drop it without storing it to a dataset for more navigation. The stream approach is faster and has less overhead, since you can start using data immediately. You should evaluate how often you need the same data to decide if the caching for navigation makes sense for you. Here's a small table demonstrating the difference between DataReader and DataSet on both ODBC and SQL providers when pulling data from a server (higher numbers are better):

ADO
SQL
DataSet
801
2507
DataReader
1083
4585
As you can see, the highest performance is achieved when using the optimal managed provider along with a data reader. When you don't need to cache your data, using a data reader can provide you with an enormous performance boost.
Use Mscorsvr.dll for MP Machines
For stand-alone middle-tier and server applications, make sure mscorsvr is being used for multiprocessor machines. Mscorwks is not optimized for scaling or throughput, while the server version has several optimizations that allow it to scale well when more than one processor is available.
Use Stored Procedures Whenever Possible
Stored procedures are highly optimized tools that result in excellent performance when used effectively. Set up stored procedures to handle inserts, updates, and deletes with the data adapter. Stored procedures do not have to be interpreted, compiled or even transmitted from the client, and cut down on both network traffic and server overhead. Be sure to use CommandType.StoredProcedure instead of CommandType.Text
Be Careful About Dynamic Connection Strings
Connection pooling is a useful way to reuse connections for multiple requests, rather than paying the overhead of opening and closing a connection for each request. It's done implicitly, but you get one pool per unique connection string. If you're generating connection strings dynamically, make sure the strings are identical each time so pooling occurs. Also be aware that if delegation is occurring, you'll get one pool per user. There are a lot of options that you can set for the connection pool, and you can track the performance of the pool by using the Perfmon to keep track of things like response time, transactions/sec, etc.
Turn Off Features You Don't Use
Turn off automatic transaction enlistment if it's not needed. For the SQL Managed Provider, it's done via the connection string:

SqlConnection conn = new SqlConnection(
"Server=mysrv01;
Integrated Security=true;
Enlist=false");
When filling a dataset with the data adapter, don't get primary key information if you don't have to (e.g. don't set MissingSchemaAction.Add with key):

public DataSet SelectSqlSrvRows(DataSet dataset,string connection,string query){
SqlConnection conn = new SqlConnection(connection);
SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = new SqlCommand(query, conn);
adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
adapter.Fill(dataset);
return dataset;
}
Avoid Auto-Generated Commands
When using a data adapter, avoid auto-generated commands. These require additional trips to the server to retrieve meta data, and give you a lower level of interaction control. While using auto-generated commands is convenient, it's worth the effort to do it yourself in performance-critical applications.
Beware ADO Legacy Design
Be aware that when you execute a command or call fill on the adapter, every record specified by your query is returned.
If server cursors are absolutely required, they can be implemented through a stored procedure in t-sql. Avoid where possible because server cursor-based implementations don't scale very well.
If needed, implement paging in a stateless and connectionless manner. You can add additional records to the dataset by:
Making sure PK info is present
Changing the data adapter's select command as appropriate, and
Calling Fill
Keep Your Datasets Lean
Only put the records you need into the dataset. Remember that the dataset stores all of its data in memory, and that the more data you request, the longer it will take to transmit across the wire.
Use Sequential Access as Often as Possible
With a data reader, use CommandBehavior.SequentialAccess. This is essential for dealing with blob data types since it allows data to be read off of the wire in small chunks. While you can only work with one piece of the data at a time, the latency for loading a large data type disappears. If you don't need to work the whole object at once, using Sequential Access will give you much better performance.
Performance Tips for ASP.NET Applications
Cache Aggressively
When designing an app using ASP.NET, make sure you design with an eye on caching. On server versions of the OS, you have a lot of options for tweaking the use of caches on the server and client side. There are several features and tools in ASP that you can make use of to gain performance.
Output Caching—Stores the static result of an ASP request. Specified using the <@% OutputCache %> directive:
Duration—Time item exists in the cache
VaryByParam—Varies cache entries by Get/Post params
VaryByHeader—Varies cache entries by Http header
VaryByCustom—Varies cache entries by browser
Override to vary by whatever you want:
Fragment Caching—When it is not possible to store an entire page (privacy, personalization, dynamic content), you can use fragment caching to store parts of it for quicker retrieval later.
a) VaryByControl—Varies the cached items by values of a control
Cache API—Provides extremely fine granularity for caching by keeping a hashtable of cached objects in memory (System.web.UI.caching). It also:
a) Includes Dependencies (key, file, time)
b) Automatically expires unused items
c) Supports Callbacks
Caching intelligently can give you excellent performance, and it's important to think about what kind of caching you need. Imagine a complex e-commerce site with several static pages for login, and then a slew of dynamically-generated pages containing images and text. You might want to use Output Caching for those login pages, and then Fragment Caching for the dynamic pages. A toolbar, for example, could be cached as a fragment. For even better performance, you could cache commonly used images and boilerplate text that appear frequently on the site using the Cache API. For detailed information on caching (with sample code), check out the ASP. NET Web site.
Use Session State Only If You Need To
One extremely powerful feature of ASP.NET is its ability to store session state for users, such as a shopping cart on an e-commerce site or a browser history. Since this is on by default, you pay the cost in memory even if you don't use it. If you're not using Session State, turn it off and save yourself the overhead by adding <@% EnabledSessionState = false %> to your asp. This comes with several other options, which are explained at the ASP. NET Web site.
For pages that only read session state, you can choose EnabledSessionState=readonly. This carries less overhead than full read/write session state, and is useful when you need only part of the functionality and don't want to pay for the write capabilities.
Use View State Only If You Need To
An example of View State might be a long form that users must fill out: if they click Back in their browser and then return, the form will remain filled. When this functionality isn't used, this state eats up memory and performance. Perhaps the largest performance drain here is that a round-trip signal must be sent across the network each time the page is loaded to update and verify the cache. Since it is on by default, you will need to specify that you do not want to use View State with <@% EnabledViewState = false %>. You should read more about View State on the the ASP. NET Web site to learn about some of the other options and settings to which you have access.
Avoid STA COM
Apartment COM is designed to deal with threading in unmanaged environments. There are two kinds of Apartment COM: single-threaded and multithreaded. MTA COM is designed to handle multithreading, whereas STA COM relies on the messaging system to serialize thread requests. The managed world is free-threaded, and using Single Threaded Apartment COM requires that all unmanaged threads essentially share a single thread for interop. This results in a massive performance hit, and should be avoided whenever possible. If you can't port the Apartment COM object to the managed world, use <@%AspCompat = "true" %> for pages that use them. For a more detailed explanation of STA COM, see the MSDN Library.
Batch Compile
Always batch compile before deploying a large page into the Web. This can be initiated by doing one request to a page per directory and waiting until the CPU idles again. This prevents the Web server from being bogged down with compilations while also trying to serve out pages.
Remove Unnecessary Http Modules
Depending on the features used, remove unused or unnecessary http modules from the pipeline. Reclaiming the added memory and wasted cycles can provide you with a small speed boost.
Avoid the Autoeventwireup Feature
Instead of relying on autoeventwireup, override the events from Page. For example, instead of writing a Page_Load() method, try overloading the public void OnLoad() method. This allows the run time from having to do a CreateDelegate() for every page.
Encode Using ASCII When You Don't Need UTF
By default, ASP.NET comes configured to encode requests and responses as UTF-8. If ASCII is all your application needs, eliminated the UTF overhead can give you back a few cycles. Note that this can only be done on a per-application basis.
Use the Optimal Authentication Procedure
There are several different ways to authenticate a user and some of more expensive than others (in order of increasing cost: None, Windows, Forms, Passport). Make sure you use the cheapest one that best fits your needs.
Tips for Porting and Developing in Visual Basic
A lot has changed under the hood from Microsoft® Visual Basic® 6 to Microsoft® Visual Basic® 7, and the performance map has changed with it. Due to the added functionality and security restrictions of the CLR, some functions are simply unable to run as quickly as they did in Visual Basic 6. In fact, there are several areas where Visual Basic 7 gets trounced by its predecessor. Fortunately, there are two pieces of good news:
Most of the worst slowdowns occur during one-time functions, such as loading a control for the first time. The cost is there, but you only pay it once.
There are a lot of areas where Visual Basic 7 is faster, and these areas tend to lie in functions that are repeated during run time. This means that the benefit grows over time, and in several cases will outweigh the one-time costs.
The majority of the performance issues come from areas where the run time does not support a feature of Visual Basic 6, and it has to be added to preserve the feature in Visual Basic 7. Working outside of the run time is slower, making some features far more expensive to use. The bright side is that you can avoid these problems with a little effort. There are two main areas that require work to optimize for performance, and few simple tweaks you can do here and there. Taken together, these can help you step around performance drains, and take advantage of the functions that are much faster in Visual Basic 7.
Error Handling
The first concern is error handling. This has changed a lot in Visual Basic 7, and there are performance issues related to the change. Essentially, the logic required to implement OnErrorGoto and Resume is extremely expensive. I suggest taking a quick look at your code, and highlighting all the areas where you use the Err object, or any error-handling mechanism. Now look at each of these instances, and see if you can rewrite them to use try/catch. A lot of developers will find that they can convert to try/catch easily for most of these cases, and they should see a good performance improvement in their program. The rule of thumb is "if you can easily see the translation, do it."
Here's an example of a simple Visual Basic program that uses On Error Goto compared with the try/catch version.

Sub SubWithError(

On Error Goto SWETrap
Dim x As Integer
Dim y As Integer
x = x / y
SWETrap:
Exit Sub
End Sub

Sub SubWithErrorResumeLabel()
On Error Goto SWERLTrap
Dim x As Integer
Dim y As Integer
x = x / y
SWERLTrap:
Resume SWERLExit
End Sub

SWERLExit:
Exit Sub

Sub SubWithError(

Dim x As Integer
Dim y As Integer
Try
x = x / y
Catch
Return
End Try
End Sub

Sub SubWithErrorResumeLabel()
Dim x As Integer
Dim y As Integer
Try
x = x / y
Catch
Goto SWERLExit
End Try

SWERLExit:
Return
End Sub

The speed increase is noticeable. SubWithError() takes 244 milliseconds using OnErrorGoto, and only 169 milliseconds using try/catch. The second function takes 179 milliseconds compared to 164 milliseconds for the optimized version.
Use Early Binding
The second concern deals with objects and typecasting. Visual Basic 6 does a lot of work under the hood to support casting of objects, and many programmers aren't even aware of it. In Visual Basic 7, this is an area that out of which you can squeeze a lot of performance. When you compile, use early binding. This tells the compiler to insert a Type Coercion is only done when explicitly mentioned. This has two major effects:
Strange errors become easier to track down.
Unneeded coercions are eliminated, leading to substantial performance improvements.
When you use an object as if it were of a different type, Visual Basic will coerce the object for you if you don't specify. This is handy, since the programmer has to worry about less code. The downside is that these coercions can do unexpected things, and the programmer has no control over them.
There are instances when you have to use late binding, but most of the time if you're not sure then you can get away with early binding. For Visual Basic 6 programmers, this can be a bit awkward at first, since you have to worry about types more than in the past. This should be easy for new programmers, and people familiar with Visual Basic 6 will pick it up in no time.
Turn On Option Strict and Explicit
With Option Strict on, you protect yourself from inadvertent late binding and enforce a higher level of coding discipline. For a list of the restrictions present with Option Strict, see the MSDN Library. The caveat to this is that all narrowing type coercions must be explicitly specified. However, this in itself may uncover other sections of your code that are doing more work than you had previously thought, and it may help you stomp some bugs in the process.
Option Explicit is less restrictive than Option Strict, but it still forces programmers to provide more information in their code. Specifically, you must declare a variable before using it. This moves the type-inference from the run time into compile time. This eliminated check translates into added performance for you.
I recommend that you start with Option Explicit, and then turn on Option Strict. This will protect you from a deluge of compiler errors, and allow you to gradually start working in the stricter environment. When both of these options are used, you ensure maximum performance for your application.
Use Binary Compare for Text
When comparing text, use binary compare instead of text compare. At run time, the overhead is much lighter for binary.
Minimize the Use of Format()
When you can, use toString() instead of format(). In most cases, it will provide you with the functionality you need, with much less overhead.
Use Charw
Use charw instead of char. The CLR uses Unicode internally, and char must be translated at run time if it is used. This can result in a substantial performance loss, and specifying that your characters are a full word long (using charw) eliminates this conversion.
Optimize Assignments
Use exp += val instead of exp = exp + val. Since exp can be arbitrarily complex, this can result in lots of unnecessary work. This forces the JIT to evaluate both copies of exp, and many times this is not needed. The first statement can be optimized far better than the second, since the JIT can avoid evaluating the exp twice.
Avoid Unnecessary Indirection
When you use byRef, you pass pointers instead of the actual object. Many times this makes sense (side-effecting functions, for example), but you don't always need it. Passing pointers results in more indirection, which is slower than accessing a value that is on the stack. When you don't need to go through the heap, it is best to avoid it.
Put Concatenations in One Expression
If you have multiple concatenations on multiple lines, try to stick them all on one expression. The compiler can optimize by modifying the string in place, providing a speed and memory boost. If the statements are split into multiple lines, the Visual Basic compiler will not generate the Microsoft Intermediate Language (MSIL) to allow in-place concatenation. See the StringBuilder example discussed earlier.
Include Return Statements
Visual Basic allows a function to return a value without using the return statement. While Visual Basic 7 supports this, explicitly using return allows the JIT to perform slightly more optimizations. Without a return statement, each function is given several local variables on stack to transparently support returning values without the keyword. Keeping these around makes it harder for the JIT to optimize, and can impact the performance of your code. Look through your functions and insert return as needed. It doesn't change the semantics of the code at all, and it can help you get more speed from your application.
Tips for Porting and Developing in Managed C++
Microsoft is targeting Managed C++ (MC++) at a specific set of developers. MC++ is not the best tool for every job. After reading this document, you may decide that C++ is not the best tool, and that the tradeoff costs are not worth the benefits. If you aren't sure about MC++, there are many good resources to help you make your decision This section is targeted at developers who have already decided that they want to use MC++ in some way, and want to know about the performance aspects of it.
For C++ developers, working Managed C++ requires that several decisions be made. Are you porting some old code? If so, do you want to move the entire thing to managed space or are you instead planning to implement a wrapper? I'm going to focus on the 'port-everything' option or deal with writing MC++ from scratch for the purposes of this discussion, since those are the scenarios where the programmer will notice a performance difference.
Benefits of the Managed World
The most powerful feature of Managed C++ is the ability to mix and match managed and unmanaged code at the expression level. No other language allows you to do this, and there are some powerful benefits you can get from it if used properly. I'll walk through some examples of this later on.
The managed world also gives you huge design wins, in that a lot of common problems are taken care of for you. Memory management, thread scheduling and type coercions can be left to the run time if you desire, allowing you to focus your energies on the parts of the program that need it. With MC++, you can choose exactly how much control you want to keep.
MC++ programmers have the luxury of being able to use the Microsoft Visual C® 7 (VC7) backend when compiling to IL, and then using the JIT on top of that. Programmers that are used to working with the Microsoft C++ compiler are used to things being lightning-fast. The JIT was designed with different goals, and has a different set of strengths and weaknesses. The VC7 compiler, not bound by the time restrictions of the JIT, can perform certain optimizations that the JIT cannot, such as whole-program analysis, more aggressive inlining and enregistration. There are also some optimizations that can be performed only in typesafe environments, leaving more room for speed than C++ allows.
Because of the different priorities in the JIT, some operations are faster than before while others are slower. There are tradeoffs you make for safety and language flexibility, and some of them aren't cheap. Fortunately, there are things a programmer can do to minimize the costs.
Porting: All C++ Code Can Compile to MSIL
Before we go any further, it's important to note that you can compile any C++ code into MSIL. Everything will work, but there's no guarantee of type-safety and you pay the marshalling penalty if you do a lot of interop. Why is it helpful to compile to MSIL if you don't get any of the benefits? In situations where you are porting a large code base, this allows you to gradually port your code in pieces. You can spend your time porting more code, rather than writing special wrappers to glue the ported and not-yet-ported code together if you use MC++, and that can result in a big win. It makes porting applications a very clean process. To learn more about compiling C++ to MSIL, take a look at the /clr compiler option.
However, simply compiling your C++ code to MSIL doesn't give you the security or flexibility of the managed world. You need to write in MC++, and in v1 that means giving up a few features. The list below is not supported in the current version of the CLR, but may be in the future. Microsoft chose to support the most common features first, and had to cut some others in order to ship. There is nothing that prevents them from being added later, but in the meantime you will need to do without them:
Multiple Inheritance
Templates
Deterministic Finalization
You can always interoperate with unsafe code if you need those features, but you will pay the performance penalty of marshalling data back and forth. And bear in mind that those features can only be used inside the unmanaged code. The managed space has no knowledge of their existence. If you are deciding to port your code, think about how much you rely on those features in your design. In a few cases, the redesign is too expensive and you will want to stick with unmanaged code. This is the first decision you should make, before you start hacking.
Advantages of MC++ Over C# or Visual Basic
Coming from an unmanaged background, MC++ preserves a lot of the ability to handle unsafe code. MC++'s ability to mix managed and unmanaged code smoothly provides the developer with a lot of power, and you can choose where on the gradient you want to sit when writing your code. On one extreme, you can write everything in straight, unadulterated C++ and just compile with /clr. On the other, you can write everything as managed objects and deal with the language limitations and performance problems mentioned above.
But the real power of MC++ comes when you choose somewhere in between. MC++ allows you to tweak some of the performance hits inherent in managed code, by giving you precise control over when to use unsafe features. C# has some of this functionality in the unsafe keyword, but it's not an integral part of the language and it is far less useful than MC++. Let's step through some examples showing the finer granularity available in MC++, and we'll talk about the situations where it comes in handy.
Generalized "byref" pointers
In C# you can only take the address of some member of a class by passing it to a ref parameter. In MC++, a byref pointer is a first-class construct. You can take the address of an item in the middle of an array and return that address from a function:

Byte* AddrInArray( Byte b[] ) {
return &b[5];
}
We exploit this feature for returning a pointer to the "characters" in a System.String via our helper routine, and we can even loop through arrays using these pointers:

System::Char* PtrToStringChars(System::String*);
for( Char*pC = PtrToStringChars(S"boo");
pC != NULL;
pC++ )
{
... *pC ...
}
You can also do a linked-list traversal with injection in MC++ by taking the address of the "next" field (which you cannot do in C#):

Node **w = &Head;
while(true) {
if( *w == 0 val < (*w)->val ) {
Node *t = new Node(val,*w);
*w = t;
break;
}
w = &(*w)->next;
}
In C#, you can't point to "Head", or take the address of the "next" field, so you have make a special-case where you're inserting at the first location, or if "Head" is null. Moreover, you have to look one node ahead all the time in the code. Compare this to what a good C# would produce:

if( Head==null val < t =" new" head =" t;" w="Head;" next ="=" t =" new" next =" t;" w =" w.next;" href="javascript:CopyCode(">
__value struct V {
int i;
};
int main() {
V v = {10};
__box V *pbV = __box(v);
pbV->i += 10; // update without casting
}
In C# you have to unbox to a "v", then update the value and re-box back to an Object:

struct B { public int i; }
static void Main() {
B b = new B();
b.i = 5;
object o = b; // implicit box
B b2 = (B)o; // explicit unbox
b2.i++; // update
o = b2; // implicit re-box
}
STL Collections vs. Managed Collections—v1
The bad news: In C++, using the STL Collections was often just as fast as writing that functionality by hand. The CLR frameworks are very fast, but they suffer from boxing and unboxing issues: everything is an object, and without template or generic support, all actions have to be checked at run time.
The good news: In the long term, you can bet that this problem will go away as generics are added to the run time. Code you deploy today will experience the speed boost without any changes. In the short term, you can use static casting to prevent the check, but this is no longer safe. I recommend using this method in tight code where performance is absolutely critical, and you've identified two or three hot spots.
Use Stack Managed Objects
In C++, you specify that an object should be managed by the stack or the heap. You can still do this in MC++, but there are restrictions you should be aware of. The CLR uses ValueTypes for all stack-managed objects, and there are limitations to what ValueTypes can do (no inheritance, for example). More information is available on the MSDN Library.
Corner Case: Beware Indirect Calls Within Managed Code—v1
In the v1 run time, all indirect function calls are made natively, and therefore require a transition into unmanaged space. Any indirect function call can only be made from native mode, which means that all indirect calls from managed code need a managed-to-unmanaged transition. This is a serious problem when the table returns a managed function, since a second transition must then be made to execute the function. When compared to the cost of executing a single Call instruction, the cost is fifty- to one hundred times slower than in C++!
Fortunately, when you are calling a method that resides within a garbage-collected class, optimization removes this. However, in the specific case of a regular C++ file that has been compiled using /clr, the method return will be considered managed. Since this cannot be removed by optimization, you are hit with the full double-transition cost. Below is an example of such a case.

//////////////////////// a.h: //////////////////////////
class X {
public:
void mf1();
void mf2();
};

typedef void (X::*pMFunc_t)();

////////////// a.cpp: compiled with /clr /////////////////
#include "a.h"

int main(){
pMFunc_t pmf1 = &X::mf1;
pMFunc_t pmf2 = &X::mf2;

X *pX = new X();
(pX->*pmf1)();
(pX->*pmf2)();

return 0;
}

////////////// b.cpp: compiled without /clr /////////////////
#include "a.h"

void X::mf1(){}

////////////// c.cpp: compiled with /clr ////////////////////
#include "a.h"
void X::mf2(){}
There are several ways to avoid this:
Make the class into a managed class ("__gc")
Remove the indirect call, if possible
Leave the class compiled as unmanaged code (e.g. do not use /clr)
Minimize Performance Hits—version 1
There are several operations or features that are simply more expensive in MC++ under version 1 JIT. I'll list them and give some explanation, and then we'll talk about what you can do about them.
Abstractions—This is an area where the beefy, slow C++ backend compiler wins heavily over the JIT. If you wrap an int inside a class for abstraction purposes, and you access it strictly as an int, the C++ compiler can reduce the overhead of the wrapper to practically nothing. You can add many levels of abstraction to the wrapper, without increasing the cost. The JIT is unable to take the time necessary to eliminate this cost, making deep abstractions more expensive in MC++.
Floating Point—The v1 JIT does not currently perform all the FP-specific optimizations that the VC++ backend does, making floating point operations more expensive for now.
Multidimensional Arrays—The JIT is better at handling jagged arrays than multidimensional ones, so use jagged arrays instead.
64 bit Arithmetic—In future versions, 64-bit optimizations will be added to the JIT.
What You Can Do
At every phase of development, there are several things you can do. With MC++, the design phase is perhaps the most important area, as it will determine how much work you end up doing and how much performance you get in return. When you sit down to write or port an application, you should consider the following things:
Identify areas where you use multiple inheritance, templates, or deterministic finalization. You will have to get rid of these, or else leave that part of your code in unmanaged space. Think about the cost of redesigning, and identify areas that can be ported.
Locate performance hot spots, such as deep abstractions or virtual function calls across managed space. These will also require a design decision.
Look for objects that have been specified as stack-managed. Make sure they can be converted into ValueTypes. Mark the others for conversion to heap-managed objects.
During the coding stage, you should be aware of the operations that are more expensive and the options you have in dealing with them. One of the nicest things about MC++ is that you come to grips with all the performance issues up front, before you start coding: this is helpful in paring down work later on. However, there are still some tweaks you can perform while you code and debug.
Determine which areas make heavy use of floating point arithmetic, multidimensional arrays or library functions. Which of these areas are performance critical? Use profilers to pick the fragments where the overhead is costing you most, and pick which option seems best:
Keep the whole fragment in unmanaged space.
Use static casts on the library accesses.
Try tweaking boxing/unboxing behavior (explained later).
Code your own structure.
Finally, work to minimize the number of transitions you make. If you have some unmanaged code or an interop call sitting in a loop, make the entire loop unmanaged. That way you'll only pay the transition cost twice, rather than for each iteration of the loop.
Additional Resources
Related topics on performance in the .NET Framework include:
Performance Considerations of Run-Time Technologies in the .NET Framework
Watch for future articles currently under development, including an overview of design, architectural and coding philosophies, a walkthrough of performance analysis tools in the managed world, and a performance comparison of .NET to other enterprise applications available today.
Appendix: Cost of Virtual Calls and Allocations
Call Type
# Calls/sec
ValueType Non-Virtual Call
809971805.600
Class Non-Virtual Call
268478412.546
Class Virtual Call
109117738.369
ValueType Virtual (Obj Method) Call
3004286.205
ValueType Virtual (Overridden Obj Method) Call
2917140.844
Load Type by Newing (Non-Static)
1434.720
Load Type by Newing (Virtual Methods)
1369.863
Note The test machine is a PIII 733Mhz, running Windows 2000 Professional with Service Pack 2.
This chart compares the cost associated with different types of method calls, as well as the cost of instantiating a type that contains virtual methods. The higher the number, the more calls/instantiations-per-second can be performed. While these numbers will certainly vary on different machines and configurations, the relative cost of performing one call over another remains significant.
ValueType Non-Virtual Call: This test calls an empty non-virtual method contained within a ValueType.
Class Non-Virtual Call: This test calls an empty non-virtual method contained within a class.
Class Virtual Call: This test calls an empty virtual method contained within a class.
ValueType Virtual (Obj Method) Call: This test calls ToString() (a virtual method) on a ValueType, which resorts to the default object method.
ValueType Virtual (Overridden Obj Method) Call: This test calls ToString() (a virtual method) on a ValueType that has overridden the default.
Load Type by Newing (Static): This test allocates space for a class with only static methods.
Load Type by Newing (Virtual Methods): This test allocates space for a class with virtual methods.
One conclusion you can draw is that Virtual Function calls are about two times as expensive as regular calls when you're calling a method in a class. Bear in mind that calls are cheap to begin with, so I wouldn't remove all virtual calls. You should always use virtual methods when it makes sense to do so.
The JIT cannot inline virtual methods, so you lose a potential optimization if you get rid of non-virtual methods.
Allocating space for an object that has virtual methods is slightly slower than the allocation for an object without them, since extra work must be done to find space for the virtual tables.
Notice that calling a non-virtual method within a ValueType is more than three times as fast as in a class, but once you treat it as a class you lose terribly. This is characteristic of ValueTypes: treat them like structs and they're lighting fast. Treat them like classes and they're painfully slow. ToString() is a virtual method, so before it can be called, the struct must be converted to an object on the heap. Instead of being twice as slow, calling a virtual method on a ValueType is now eighteen times as slow! The moral of the story? Don't treat ValueTypes as classes.

What is LINQ?

2008-11-04T21:27:00.000-08:00

Microsoft Babies
Microsoft new baby yes I am talking about LINQ stand for Language-Integrated Query is now available as a integral part of Visual Studio Orcas. Microsoft releases the new Visual Studio with the name of Orcas and all Microsoft previous efforts (Windows Communication Foundation WCF, Windows Workflow Foundation WWF, Windows Presentation Foundation WPF, Windows CardSpace and LINQ) are integrated in this Studio. From last one and half years Anders Hejlsberg team done a tremendous job in the overcoming the gap between the data impedance. Mr. Anders team gives a native syntax to developers in the form LINQ to C# and VB.Net for accessing data from any repository. The repository could be in memory object, database (still MS SQL Server only) and XML files.

What is LINQ?
Still lots of folks don’t understand what LINQ is doing. Basically LINQ address the current database development model in the context of Object Oriented Programming Model. If some one wants to develop database application on .Net platform the very simple approach he uses ADO.Net. ADO.Net is serving as middle ware in application and provides complete object oriented wrapper around the database SQL. Developing application in C# and VB.Net so developer must have good knowledge of object oriented concept as well as SQL, so it means developer must be familiar with both technologies to develop an application. If here I can say SQL statements are become part of the C# and VB.Net code so it’s not mistaken in form of LINQ. According to Anders Hejlsberg the chief architect of C#.

“Microsoft original motivation behind LINQ was to address the impedance mismatch between programming languages and database.”

LINQ has a great power of querying on any source of data, data source could be the collections of objects, database or XML files. We can easily retrieve data from any object that implements the IEnumerable interface. Microsoft basically divides LINQ into three areas and that are give below.

LINQ to Object {Queries performed against the in-memory data}
LINQ to ADO.Net
LINQ to SQL (formerly DLinq) {Queries performed against the relation database only Microsoft SQL Server Supported}
LINQ to DataSet {Supports queries by using ADO.NET data sets and data tables}
LINQ to Entities {Microsoft ORM solution}
LINQ to XML (formerly XLinq) { Queries performed against the XML source}

I hope few above lines increase your concrete knowledge about Microsoft LINQ and now we write some code snippet of LINQ.
Code Snippet
int[] nums = new int[] {0,1,2};
var res = from a in nums
where a < nums =" int[]" result =" nums.Sum();">Aggregation
Aggregate , Average ,Count ,LongCount, Max, Min, Sum
Conversion
Cast,OfType,ToArray,ToDictionary, ToList, ToLookup, ToSequence
Element
DefaultIfEmpty, ElementAt, ElementAtOrDefault, First, FirstOrDefault, Last, LastOrDefault, Single, SingleOrDefault
Equality
EqualAll
Generation
Empty, Range, Repeat
Grouping
GroupBy
Joining
GroupJoin, Join
Ordering
OrderBy, ThenBy, OrderByDescending, ThenByDescending, Reverse
Partitioning
Skip, SkipWhile, Take, TakeWhile
Quantifiers
All, Any, Contains
Restriction
Where
Selection
Select, SelectMany
Set
Concat, Distinct, Except, Intersect, Union
To the good use of above operator types I need samle patient class so here it
using System;
public class Patient
{
// Fields
private string _name;
private int _age;
private string _gender;
private string _area;
// Properties
public string PatientName
{
get { return _name; }
set { _name = value; }
}

public string Area
{
get { return _area; }
set { _area = value; }
}
public String Gender
{
get { return _gender; }
set { _gender = value; }
}
public int Age
{
get { return _age; }
set { _age = value; }
}
}

Here is my code that intiliaze patients object with following data.

List patients = new List {
new Patient { PatientName="Ali Khan", Age=20, Gender="Male" , Area = "Gulshan"},
new Patient { PatientName="Ahmed Siddiqui", Age=25 ,Gender="Male", Area = "NorthKarachi" },
new Patient { PatientName="Nida Ali", Age=20, Gender="Female", Area = "NorthNazimabad"},
new Patient { PatientName="Sana Khan", Age=18, Gender="Female", Area = "NorthNazimabad"},
new Patient { PatientName="Shahbaz Khan", Age=19, Gender="Male", Area = "Gulshan"},
new Patient { PatientName="Noman Altaf", Age=19, Gender="Male", Area = "Gulshan"},
new Patient { PatientName="Uzma Shah", Age=23, Gender="Female", Area = "NorthKarachi"}};

Patient p = new Patient();
p.Age =33; p.Gender = "male";
p.PatientName = "Hammad Ali";
p.Area = "Defence";
patients.Add(p);

This code snippet fetch those records whose gender is equal to “Male”.
gdView.DataSource = from pa in patients
where pa.Gender == "Male"
orderby pa.PatientName, pa.Gender, pa.Age
select pa;
gdView.DataBind();

The following code snippet uses the selection operator type, which brings all those records whose age is more than 20 years.
var mypatient = from pa in patients
where pa.Age > 20
orderby pa.PatientName, pa.Gender, pa.Age
select pa;

foreach(var pp in mypatient)
{
Debug.WriteLine(pp.PatientName + " "+ pp.Age + " " + pp.Gender);
}
The following code snippet uses the grouping operator type that group patient data on the bases area.
var op = from pa in patients
group pa by pa.Area into gselect new {area = g.Key, count = g.Count(), allpatient = g};

foreach(var g in op)
{
Debug.WriteLine(g.count+ "," + g.area);
foreach(var l in g.allpatient)
{
Debug.WriteLine("\t"+l.PatientName);
}
}
This code snippet determine the count of those records, which lay in above 20 years.
int patientCount = (from pa in patients
where pa.Age > 20
orderby pa.PatientName, pa.Gender, pa.Age
select pa).Count();
All the above codes are few example of LINQ to Object technique of LINQ. In my up coming post you will see both LINQ to SQL and LINQ to XML code snippets.

XSLT transformation with c#

2008-11-03T21:05:00.000-08:00

Figure 1 - XSL Transforming an XML Data File based on Radio Selection
XSL (eXtensible Stylesheet Language) is a powerful XML language that enables you to specify how you want your XML data to appear on your Web Page. Table 1 shows a list of common XSL commands and what they do:
In our ASP.NET application we want to take a list of customers and display them nicely on a web page. The XSL code in listing 1a cycles through each customer in the XML customer data shown in listing 1b and transforms the information into a readable HTML Table (listing 2). The transform uses the XSL for-each select command to loop and builds the table row by row. Within the loop, the transform fills the appropriate customer information using the XSL value-of select command, selecting on each Customer node in the XML file.

If the XSL transform in listing 1a is applied to the XML Data in listing 1b, the HTML table output in listing 2 results:
Listing 2 - Output resulting from the xsl transform of listing 1a applied to xml data in listing 1b
Using ASP.NET to Transform XML
ASP.NET comes with an XML control that allows you to transform an XML file using XSL. You just need to do 2 things: (1) assign an XmlDocument containing the XML you want to transform to the XML control's Document property. (2) assign an XslTransform class containing the XSL to the Transform property of the XML control.
Listing 3 - Making the transform happen using the Xml class
// get the physical directory path of the root default page's directory
string path = Path.GetDirectoryName(Request.PhysicalPath);
// Create the Xml Document
XmlDocument xmlDoc = new XmlDocument();
// load the xml customer database from the customers.xml file
xmlDoc.Load(String.Format("{0}/Docs/{1}", path, "customers.xml"));
If we just wanted to use the existing XSL contained in the customerformat.xsl file, then the process of retrieving the XSL is fairly straightforward. Simply construct the XslTransform object and call the Load method, just like we did with the XmlDocument.

Listing 5 - Loading a StyleSheet into an XslTransform object
// by loading it indirectly with an XmlReader

XslTransform xslTransform = new XslTransform();

xslTransform.Load(String.Format("{0}/Docs/{1}",path, Session["TransformFile"]));

However, we would like to do something a bit more interesting. We want to be able to manipulate the XSL in memory. Therefore we need a way to read the XSL, convert it to a string, alter it, and then shove the string into an XslTransform object. This turns out to be a little less straightforward. The XSL we want to load into memory is shown below in listing 6. Note that this XSL differs from the XSL in listing 1a with just one xsl command, xsl:if. We want to be able to dynamically replace the expression with a boolean expression of our choosing, such as . In the case of our ASP.NET program, we want to replace the expression {0} with something that is always true (such as the boolean expression 1 > 0) when Employees Only is not checked, but we want to filter on the condition 'Employee='yes' when Employees Only is checked. This way, all workers (consultants and employees) will be shown when the employees checkbox is not checked, but only employees will be shown when the employees check box is checked.

Listing 6 - XSL Transform with xsl:if to produce a table based on a given condition

In order to read the XSL into a string that we can manipulate in memory we will use a StreamReader. Then we'll replace the {0} in the string with the appropriate boolean expression using the string Replace method. Next we'll read the string into a memory stream and then use the memory stream to construct an XmlTextReader containing the string. Finally, we will construct the XslTransform object with the XmlTextReader containing the manipulated XSL string. As convoluted as this sounds, it is a workable approach. However, it would have been faster if there were a XslTransform method you could call that took a string containing the XSL.

Listing 7 - Dynamically changing XSL inside a string and loading the string into and XslTransform object

// need to go through a bit of a convoluted task// to load the transform with a string// by loading it indirectly with an XmlReader
XslTransform xslTransform = new XslTransform();

xslTransform.Load(String.Format("{0}/Docs/{1}",path, Session["TransformFile"]));

StreamReader sr = new StreamReader(String.Format("{0}/Docs/{1}", path, Session["TransformFile"]));

string xslBlock = sr.ReadToEnd();

sr.Close();
// alter the 'xsl:if' statement in the xsl string // to test for filtering on employees

if (chkEmployee.Checked)

{

// if 'only employees' is checked,

// put a condition to test whether or not

// we have an employee

// in the xsl:if expression

xslBlock = xslBlock.Replace("{0}", "Employee = \'yes\'");

}

else

{

// if 'only employees' is not checked,

// put a condition that is always true (1>0)

// in the xsl:if expression

xslBlock = xslBlock.Replace("{0}", "1 > 0");

}
// need to convert the xsl string to a memory stream

// in order to put it in the xml reader.

MemoryStream ms = new MemoryStream(System.Text.ASCIIEncoding.ASCII.GetBytes(xslBlock));

XmlReader reader = new XmlTextReader(ms);

// load the tranform with the XmlReader containing

// the xsl transform string

xslTransform.Load(reader);

Conclusion
Although XSL may seem complex, it is actually a useful language for taking an XML file containing data and presenting it effectively on a web page. This article has shown you how you can take advantage of the features in ASP.NET to alter XSL on the fly in response to input from the web browser and display your XML data differently. So add a bit of style to your ASP.NET apps, to C a sharper view of your data with a combination of stylesheets and .NET.

Object Serialization

2008-10-22T06:48:00.000-07:00

In simple words serialization is a process of storing the object instance to a disk file. Serialization stores state of the object i.e. member variable values to disk. Deserialization is reverse of serialization i.e. it's a process of reading objects from a file where they have been stored. In this code sample we will see how to serialize and deserialize objects using C#.

Namespaces involved

Following namespaces are involved in serialization process :

System.Runtime.Serialization
System.Runtime.Serialization.Formatters.Binary

Example 1

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
public class SerialTest
{
public void SerializeNow()
{
ClassToSerialize c=new ClassToSerialize();
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Create);
BinaryFormatter b=new BinaryFormatter();
b.Serialize(s,c);
s.Close();
}
public void DeSerializeNow()
{
ClassToSerialize c=new ClassToSerialize();
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Open);
BinaryFormatter b=new BinaryFormatter();
c=(ClassToSerialize)b.Deserialize(s);
Console.WriteLine(c.name);
s.Close();
}
public static void Main(string[] s)
{
SerialTest st=new SerialTest();
st.SerializeNow();
st.DeSerializeNow();
}
}
public class ClassToSerialize
{
public int age=100;
public string name="bipin";
}

Explanation

Here we have our own class named ClassToSerialize. This class has two public valiables name and age with some default values. We will write this class to a disk file (temp.dat) using SerializeTest class.

SerializeTest class has two methods SerializeNow() and DeSerializeNow() which perform the task of serialization and deserialization respectively.

The general steps for serializing are :

Create an instance of File that will store serialized object.
Create a stream from the file object.
Create an instance of BinaryFormatter.
Call serialize method of the instance passing it stream and object to serialize.

The steps for de-serializing the object are similar. The only change is that you need to call deserialize method of BinaryFormatter object.

Now, let us see an example where we have used 'real' class with public and shared members and properties to encapsulate them. The class also uses another supporting class. This is just to make clear that if your class contains further classes, all the classes in the chain will be serialized.

Example 2

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
public class SerialTest
{
public void SerializeNow()
{
ClassToSerialize c=new ClassToSerialize();
c.Name="bipin";
c.Age=26;
ClassToSerialize.CompanyName="xyz";
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Create);
BinaryFormatter b=new BinaryFormatter();
b.Serialize(s,c);
s.Close();
}
public void DeSerializeNow()
{
ClassToSerialize c=new ClassToSerialize();
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Open);
BinaryFormatter b=new BinaryFormatter();
c=(ClassToSerialize)b.Deserialize(s);
Console.WriteLine("Name :" + c.Name);
Console.WriteLine("Age :" + c.Age);
Console.WriteLine("Company Name :" + ClassToSerialize.CompanyName);
Console.WriteLine("Company Name :" + c.GetSupportClassString());
s.Close();
}
public static void Main(string[] s)
{
SerialTest st=new SerialTest();
st.SerializeNow();
st.DeSerializeNow();
}
}
public class ClassToSerialize
{
private int age;
private string name;
static string companyname;
SupportClass supp=new SupportClass();
public ClassToSerialize()
{
supp.SupportClassString="In support class";
}
public int Age
{
get
{
return age;
}
set
{
age=value;
}
}
public string Name
{
get
{
return name;
}
set
{
name=value;
}
}
public static string CompanyName
{
get
{
return companyname;
}
set
{
companyname=value;
}
}
public string GetSupportClassString()
{
return supp.SupportClassString;
}
}
public class SupportClass
{
public string SupportClassString;
}

Example 3

The final example shows how to serialize array of objects.

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
public class SerialTest
{
public void SerializeNow()
{
ClassToSerialize[] c=new ClassToSerialize[3];
c[0]=new ClassToSerialize();
c[0].Name="bipin";
c[0].Age=26;
c[1]=new ClassToSerialize();
c[1].Name="abc";
c[1].Age=75;
c[2]=new ClassToSerialize();
c[2].Name="pqr";
c[2].Age=50;
ClassToSerialize.CompanyName="xyz";
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Create);
BinaryFormatter b=new BinaryFormatter();
b.Serialize(s,c);
s.Close();
}
public void DeSerializeNow()
{
ClassToSerialize[] c;
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Open);
BinaryFormatter b=new BinaryFormatter();
c=(ClassToSerialize[])b.Deserialize(s);
Console.WriteLine("Name :" + c[2].Name);
Console.WriteLine("Age :" + c[2].Age);
Console.WriteLine("Company Name :" + ClassToSerialize.CompanyName);
s.Close();
}
public static void Main(string[] s)
{
SerialTest st=new SerialTest();
st.SerializeNow();
st.DeSerializeNow();
}
}
public class ClassToSerialize
{
private int age;
private string name;
static string companyname;
public int Age
{
get
{
return age;
}
set
{
age=value;
}
}
public string Name
{
get
{
return name;
}
set
{
name=value;
}
}
public static string CompanyName
{
get
{
return companyname;
}
set
{
companyname=value;
}
}
}