Now you might be thinking what else could be added to this avenue. First I will cover some of the points which all of us face today -

• As you are having multiple numbers, your friends relatives try to reach you over all these numbers.
• If someone is not able to reach after trying all these, he/she leaves a voice mail which you need to track by dialing voice mail box of the exact where the message was left.
• Also, voice messages are not stored forever.
• You also subscribe to multiple service providers with multiple device.

I think I have already raised some (may be few more)of our common problems which we face daily basis.

Now what could be a better option?

Yes, it’s Google and they have come up with Google Voice.

You must be eager to go through the features -

• Use one number to manage all your phones; your Google Voice number is tied to you, not to a particular device or location. You can choose to keep your existing number (few features will not be available in this case) or ask Google to provide a new number.
• You can configure Google Voice with all your other phones (cell phones and landlines) of home or work.Google Voice will route the call directly to voicemail or any of your phones. Google Voice ring all your phones and if you are not where you will be (at home or work), you can pick up the handiest one.
• Also Google Voice can store the voice mail so you do not have check all your voice mail inboxes.
• Voicemail like email: Save voicemail messages for as long as you’d like, star important ones, and search through them
• Voicemail transcription: Voicemail messages will be automatically transcribed to text and sent to you via email and/or SMS.
• Works with mobile phones, desk phones, and work phones. There’s nothing to download, upload, or install, and you don’t have to make or take calls using a computer
• Custom voicemail greetings: Customize your voicemail greeting based on who is calling.
• You can block the callers and many more features available with Google Voice.

I leave rest of the features to be explored by my readers

If you are in US, then you should try this out. But rest of the world have to wait till Google Voice is open for all other countries.

what’s new I am talking about. If you are working in an organization you will definitely be following your organization’s dress code.

But my point was a bit different..It’s not the dress code of any organization that attracted me..Similarity of dress code of

all developers which is of interest..

It’s coding which enourage the developers to grow the beard, dress casually and long hairs.

If you think this is silly, then please refer to this post where you can get statistics on dressing senses of all famous programmers in the world..

So what are you waiting for!!! Get growing your beard and hair

I think you also want to bag one. It will be of more plessure if you win one after competing with all technology specialists.

You have to write an article for iPad in Codeproject.

I think many of you might be intesrested so please hurry as the end date is July 12th 2010.

You can get this details by clicking here.

Find the thumbrules below -

Rule #1: Contrsuctors are called in descending order
Rule #2: In C# lexicology, a destructor and a finalizer refer to the same thing
Rule #3: Destructors are called in ascending order
Rule #4: Finalizers are a feature of GC-managed objects only
Rule #5: You cannot determine when finalizers would be called
Rule #6: C++/CLI differs between destructors and finalizers
Rule #7: In C++/CLI and classic C++, you can determine when destructors are called
Rule #8: In C++/CLI, destructors and finalizers are not called together
Rule #9: Beware of virtual functions in constructors
Rule #10: User has not control when Static constructor is invoked

The author of the article has nicely explained the first 9 rules in his article with code snippets. I this should be helpful to all the developers.

The Rule#10 is being added by me and I think the purpose of static constructor should be known to all of us. While using Static constructor we can not decide when this will be executed. Also the following rules are true for static constructor -

• A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced 
• Static Constructor can not be called directly.
• A static constructor does not take access modifiers or have parameter

A proper example of using static constructor will be logger classes which will be initialized before any instance is created in the application. Following code snippet will explain how the initialization is done automatically.

public class Logger
{
 // Static constructor:
 static Logger()
  {
	System.Console.WriteLine("The static constructor of Logger is invoked.");
  }
 public static void Log()
 {
	System.Console.WriteLine("The Log method is invoked.");
 }
}  

class LogTest
{
 static void Main()
 {
	Logger.Log();
 }
}

After executing the above code, following will be the output.

The static constructor of Logger is invoked.

The Log method is invoked.

This signifies that initialization is done automatically. For rest of the rules please read this article.

References

MSDN

Codeproject

I hope you will love to do the following stuffs –
1. Override or disable Windows shortcut keys like [Windows] + E and [Windows] + R
2. Close unwanted windows the moment they appear
3. Make any window transparent, always-on-top, or alter its shape.
4. Customize the tray icon menu with your own icon, tooltip, menu items, and submenus
5. Display dialog boxes, tooltips, balloon tips, and popup menus to interact with the user

And many more features are availble in AutoHotKey.

Autohotkey is basically open-source utility for Windows.

Most importantly, this is free.

As part of regular Internet Browsing, I came across about Web Deployment Tool. Microsoft has made life easier for the developers and the administrators.In this post, I will high light the features which attracted me. First and foremost, I look for the free tools which can be leveraged to organization level. Web Deployment Tool is certainly one of those.

What’s Web Deployment Tool?

The Web Deployment Tool is an IIS extension, containing essentially a set of tools and a managed framework for simplifying the deployment, management and migration of Web applications, sites and even entire servers.It is a free download and there are no plans to charge for this IIS extension in the future.

In nutshell, this tool simplifies the migration,management and deployment of IIS Web servers, Web Application and Web Sties.Administrators can use command-line scripting with the Web Deployment Tool to synchronize IIS 6.0 and IIS 7.0 servers or to migrate an IIS 6.0 server to IIS 7.0. The Web Deployment Tool also enables administrators and delegated users to use IIS Manager to deploy ASP.NET and PHP applications to an IIS 7.0 server.

Easy Migration of Web applications between IIS 6.0 and IIS 7.0

This tool simplifies the migration of web applications between IIS 6.0 to IIS 7.0. This tool determines the incompatibilities and suggests the proposed changes before the process gets started. Knowledge of potential issues in advance, will help the IT People to take corrective actions by simplifying the migration plan.

Efficient Server Farm Synchronization

I think this will be very much useful for web-farm scenarios. From my personal experience also, organizations having different environments (like DEV, QA, Integration, Staging and PROD) with multiple servers face difficulties to synchronize the boxes. When different teams work on multiple enhancements, projects the servers become out-of-sync sometimes.

The tool simplifies the synchronization process by automatically determining the configuration, content and certificates to be synchronized for a specific site. In addition to the default behavior, you still have the option to specify additional providers for the synchronization, including databases, COM objects, GAC assemblies and registry settings.

The tool can be used to synchronize a web farm, including deploying new applications or just keeping changes synchronized between the web farm servers. The tool does not currently support a central UI or configuration store for a list of servers in a farm (i.e., syncing multiple machines at once), but you can simply store this list of servers and perform sync operations against each server. These can easily be scheduled using System Center or another scheduling mechanism. Resources that can be synchronized include Web sites or applications, content folders and files, databases, registry keys, assemblies in the GAC and more. You can also build custom “providers” that understand other types of resources that are not supported in-the-box.

Package, archive and deploy Web applications more easily

The Web Deployment Tool enables you to package configuration and content of your installed Web applications, including databases, and use the packages for storage or redeployment. These packages can be deployed using IIS Manager without requiring administrative privileges. The tool integrates with Visual Studio 2010 to help developers streamline the deployment of Web applications to the Web server. The tool also integrates with the Web Platform Installer to allow you to simply and easily install community web applications.

Key Features

• Seamless integration with IIS 7.0 Manager and Visual Studio 2010 interface for creating packages and deploying them onto a machine, both locally and remotely.
• Seamless integration with the Web Platform Installer to install community web applications simply and easily.
• Web application packaging:
  • Ability to package a Web application or an entire site, including the associated databases.
  • Ability to package ACLs, COM, GAC and registry settings.
  • Supports both live servers and zipped packages as a source or destination.
• Web application deployment:
  • Administrative privileges are not required in order to deploy Web applications.
  • Ability to add powerful parameters to change text in files when they are deployed (such as prompting to replace a connection string when deploying from QA to staging environments).
  • Integration with the IIS 7.0 Web Management Service (WMSVC) for remote deployment by non-administrators.
  • Server administrators have granular control over the operations that can be performed and can delegate tasks to non-administrators.
• Web server migration and synchronization:
  • Ability to synchronize or migrate the entire Web server, a Web site or application.
  • Synchronizes only the data that has changed.
  • Ability to detect missing dependencies during synchronization.
  • Automatically gathers content, IIS configuration, SSL certificates and ASP.NET configuration when you sync a Web site.
• In addition to the IIS Manager and Visual Studio 10, tasks can be performed using the command-line, PowerShell cmdlets or public APIs.

References

Overview of the Web Deployment Tool

Web Deployment Tool

It’s very common that we need to provide custom functionalities in our applications to the users in many respect. So that the user can do some operations at runtime. Sometimes user can resize the form, user can change the color, user can change the text etc. Obviously if our application provides all such customizations then only user can do. Now the challenge comes – when user customizes the forms of our application and wants to hold that state when he restarts the application. Per industry’s terminology this is attributed as User Preferences. In this post I would cover a very basic and easy of doing that.

Suppose, the original look and feel of the form of an application is shown in the above left image. This is the form developer has created with a bluish background and some text. Now the application provides an option to customize the Form’s as well as button’s properties to be modified by the user at runtime. Now user has preferred to save the reddish form and wants to load this next time onwards. I think this problem statement can site a User preference case study. In this post I would take this one as example and would solve this with source code as well.   

Approach for implementation of User Preferences

The better option would have been to store the Form’s state in a serialized format. As Forms are not serializable it would require custom serialization through out the application with some specific properties based on the requirement.

To have some generic approach with a small piece of custom coding we can achieve the same with Application Settings.

What are Application Settings?

Application settings allow a Windows Forms or ASP.NET application to store and retrieve application-scoped and user-scoped settings. A "setting", in this context, is any piece of information that may be specific to the application or specific to the current user – anything from a database connection string to the user’s preferred default window size. Application settings works by persisting data as XML to configuration (.config) files. In most cases, the application-scoped settings are read-only; because they are program information. By contrast, user-scoped settings can be read and written safely at run time.

If you use Visual Studio, you can define settings within the Windows Forms Designer using the (ApplicationSettings) property in the Properties window. Once the applications settings are created the wrapper class with all those setting are created automatically by Visual Studio.We will discuss later in detail how applications settings are added/deleted/accessed. Now if you want to create your own custom wrapper class to have more control over the settings then this can be achived by writing class inheriting from ApplicationSettingsBase class. Custom controls can also save their own settings by implementing the IPersistComponentSettings interface, which exposes the SaveSettings method.

Implement User Preferences

So far we have come to know what’s application scope and user scope. Now we will concentrate on user scope settings with the example shown in above screenshots.

In this example I have created one form on which a button is placed to save the User Preferences. In the form I kept one Tab control with two tab pages each has PropertyGrid to change the properties of Form and Button. First tab page is to change the properties of form whereas second one is for the button.

Now we will create some application settings with user-scope.

To create new Application Settings using Visual Studio -

• Select the form or control whose properties you want to bind to the new application setting.

• In the Property Editor, expand the (Application Settings) item, and then click the ellipsis next to the (PropertyBindings) item underneath it.

• In the Application Settings dialog box, click the drop-down menu for the property you want to bind and select the New command.

• In the New Application Setting dialog box, configure the setting by giving it a name (e.g. FormForeColor) and a default value (e.g. ControlText) and setting its scope (e.g. User).

For the form I have created some application settings as shown in the red marked section in the Property Grid. Also, for the button I have created few application settings like ButtonBackColor, SaveButtonText.

To Access Application Settings

Once this is done, a wrapper class Settings is created under the Properties folder. Any of these settings can be accessed by Settings class. Now for this example the the FormForeColor can be accessed as shown below.

UserPreferenceSample.Settings defaultSettings= new Settings();
defaultSettings.FormForeColor = this.ForeColor;

Save User Preferences

Till now we have the knowledge of the creation of application settings and accessing those. So it’s only the way you want to have your User Preferences to be implemented. In this example user can change the properties of Form and Button using the PropertyGrid. Also, I provided textboxes where user can provide his/her preferred texts for Form and the Button. Once user has modified all these and clicked the save button, Application Settings have been updated with the user’s selected ones.

//UserPreferenceSample.Settings defaultSettings= new Settings();
//- already instantiated
//Save button's settings

 defaultSettings.ButtonBackColor = btnSave.BackColor;

 defaultSettings.SaveButtonText = btnSave.Text;
//Save the Form's Settings
 defaultSettings.FirstFormHeader = this.Text;

 defaultSettings.FormBackColor = this.BackColor;

 defaultSettings.FormForeColor = this.ForeColor;

 defaultSettings.FormOpacity = this.Opacity;

 defaultSettings.FormWindowState = this.WindowState; 

 defaultSettings.Save();

Now onwards, whenever user starts the application he/she can see preferred view.

Sample config File

Find the sample config file entries as shown below.

<configuration>
  <configSections>
    <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
      <section name="UserPreferencesExample.Properties.Settings"   type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"   allowExeDefinition="MachineToLocalUser"   requirePermission="false" />
    </sectionGroup>
  </configSections>
  <userSettings>
    <UserPreferencesExample.Properties.Settings>
      <setting name="FirstFormHeader" serializeAs="String">
        <value>My First Form</value>
      </setting>
      <setting name="SaveButtonText" serializeAs="String">
        <value>&Save</value>
      </setting>
      <setting name="FormWindowState" serializeAs="String">
        <value>Normal</value>
      </setting>
      <setting name="FormForeColor" serializeAs="String">
        <value>ControlText</value>
      </setting>
      <setting name="FormOpacity" serializeAs="String">
        <value>1</value>
      </setting>
      <setting name="FormBackColor" serializeAs="String">
        <value>Control</value>
      </setting>
      <setting name="ButtonBackColor" serializeAs="String">
        <value>Control</value>
      </setting>
    </UserPreferencesExample.Properties.Settings>
  </userSettings>
</configuration>

Limitation of Application Settings

You cannot use application settings in an unmanaged application that hosts the .NET Framework. Settings will not work in such environments as Visual Studio add-ins, C++ for Microsoft Office, control hosting in Internet Explorer, or Microsoft Outlook add-ins and projects.

You currently cannot bind to some properties in Windows Forms. The most notable example is the ClientSize property.

Application settings has no built-in facility for encrypting information automatically. You should never store security-related information, such as database passwords, in clear text.

References

You can get the source code of the example here.

I always suggest and prefer to read MSDN. You can refer the followings articles which helped me a lot to understand this.

http://msdn.microsoft.com/en-us/library/wabtadw6.aspx

http://msdn.microsoft.com/en-us/library/fwc80dzb.aspx

http://msdn.microsoft.com/en-us/library/8eyb2ct1.aspx

CodeProject

What’s WSDL File and how it’s generated?

Web Services Description Language is an XML format for describing network services as a set of endpoints operating on messages containing either document-oriented or procedure-oriented information. In a single sentence – it defines the Web Service which can be used by the clients to subscribe the web service.In case you are not aware of generating a WSDL file of a Web Service, then follow the steps mentions below –

1. Type in your Web Service URL along with the ASMX file in the web browser.
2. Then just append “?wsdl” at the end of URL your required WSDL will be generated in the browser. So if your URL is http://localhost/HelloWorldWebService/HelloWorldService.asmx then if you type in http://localhost/HelloWorldWebService/HelloWorldService.asmx?wsdl to generate the wsdl for your web service.

How to reference a Web Service?

This is quite easy for Visual Studio users. Using the wizard of Add Web Reference (as shown below in the images), the developer just needs to provide the URL of the Web Service. This would generate the proxy and the developer does not even need to create the WSDL separately.

Another approach could be generation of proxy class from WSDL file by using the WSDL.exe. Once proxy is generated, proxy class could be used for interaction with the Web Service.

SOAP and SOAP XML

Simple Object Access Protocol is a simple XML-based protocol to let applications exchange information over HTTP. SOAP is a protocol for accessing a Web Service.

A SOAP message is an ordinary XML document containing the following elements:

• An Envelope element that identifies the XML document as a SOAP message
• A Header element that contains header information
• A Body element that contains call and response information
• A Fault element containing errors and status information

Following image displays a sample SOAP Request and Response XML.

What’s SOAP Extension – TraceExtension?

SOAP Extensions allow developers to create very interesting applications on top of the core SOAP architecture found within .NET. It allows developers to implement encryption algorithm, compression routine, SOAP attachments etc. In this article we will focus on logging the SOAP request/response XML.

For this we need to create couple of classes -

• Create a class that derives from System.Web.Services.Protocols.SoapExtension – TraceExtension class has been created for this
• Create a class that derives from System.Web.Services.Protocols.SoapExtensionAttribute – TraceExtensionAttribute class has been created for this

A sample Web Service application

To understand the functionality of TraceExtension class, I will take a sample WebService and a client which subscribes that service.

• HelloWorldWebService – This is a web service with a web method HelloWorld.

public class HelloWorldService : System.Web.Services.WebService
{

    [WebMethod]
    public string HelloWorld(string myString)
    {
        return "Hello World Service returns - " + myString;
    }
}

• ClientSubscriber – This is a simple windows form application consuming the web reference of HelloWorldWebService. In the form, there’s a textbox and button. On click of this button, the text of the textbox will send to the web service and the result will displayed in a message box.
• SoapMessageUtility – This utility has the actual implementation of TraceExtension. The client application has a reference to this utility to log the SOAP request/response XML.

The sample source code and binaries are available here.

Implementation of TraceExtension

We will implement the TraceExtension in the client side consuming the web service. So the Request/Response SOAP XML logs will be created in the client side.

First we will take look at the TraceExtensionAttribute class inherited from SoapExtensionAttribute. TraceExtensionAttribute must override the ExtensionType property to return the type of extension that is associated with the attribute. In this case this is nothing but TraceExtension.

public override Type ExtensionType
{
    get { return typeof(TraceExtension); }
}

For setting the priority of the ‘SoapExtension’, Priority property has been overridden also.

To have some flexibilities, few properties are created in the TraceExtensionAttribute which can be passed as parameters in the constructor.

1. LogTypeMode – This denotes which SOAP XML to log – None, RequestOnly, ResponseOnly, RequestReponse.
2. ReqFileName – The file name where Request SOAP XML will be logged
3. ResFileName – The file name where Response SOAP XML will be logged

TraceExtensionAttribute class can be used at method level as shown below.

[TraceExtensionAttribute(LogType.RequestReponse,"C:\\Log\\MyReq.log","C:\\Log\\MyRes.log")]
[System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/HelloWorld", RequestNamespace="http://tempuri.org/", ResponseNamespace="http://tempuri.org/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
public string HelloWorld(string myString) {
    object[] results = this.Invoke("HelloWorld", new object[] {
                myString});
    return ((string)(results[0]));
}

Now we will look into the TraceExtension class inherited from SoapExtension. The core piece of implementation is the ProcessMessage method of the SoapExtension class. This method should be overridden to have the proper implementation. Before this implementation we should be very much aware of the flow of SOAP message from the client to Web Service.

1. When a web method in the client proxy is called, framework checks if any SOAP extensions to be invoked or not and if so, then those are called with BeforeSerialize stage.
2. Once the serialization is done, then the extensions are called with AfterSerialize stage.
3. The SOAP message is sent to the server and server figures out which method to route to.
4. Then the server checks to see if any SOAP extensions (that’s us!) should be invoked, and if so, invokes them with the BeforeDeserialize event stage.
5. The server deserializes the stream and invokes all the extensions for the AfterDeserialize stage.
6. After the web method execution server invokes all the extensions with BeforeSerialize stage.
7. Once the server serializes the result stream, the SOAP extensions are called with AfterSerialize stage.
8. Result is sent back to client
9. Now client receives the result stream and framework invokes the SOAP extensions with BeforeDeserialize event stage.
10. Once client deserializes the result stream, SOAP extensions with AfterDeserialize stage is invoked.

In our case, we will be focused in the client side i.e. points 1,2,9 and 10. 

The key is the AfterSerialize stage (i.e. point 2) in the client, the request SOAP XML can be logged at this moment.

public void WriteOutput(SoapMessage message)
{
    FileStream fs;
    StreamWriter w = null; 

    try
    {
        if (_logTypeMode.Equals(LogType.RequestOnly) || _logTypeMode.Equals(LogType.RequestReponse))
        {
            _newStream.Position = 0;
            fs = new FileStream(_reqFilename, FileMode.Append,
                FileAccess.Write);
            w = new StreamWriter(fs);

            string soapString = "SoapRequest";
            w.WriteLine("-----" + soapString + " at " + DateTime.Now);
            w.Flush();
            Copy(_newStream, fs);
            w.Close();

        }
    }
    catch (Exception ex)
    {
    }
    finally
    {
        if (w != null)
            w.Close();
        _newStream.Position = 0;
        Copy(_newStream, _oldStream);
    }
}

The same is applicable for the BeforeDeserialize stage (i.e. point 9) to log the response SOAP XML. The WriteInput method logs the response XML.

Safety and Configurability

The whole purpose of this article is to log the request-response SOAP XML. In case of any exception while logging would cause interruption in the web service invocation. So the WriteInput and WriteOutput methods in TraceExtension class should take care of proper exception handling. In my case I kept a blank catch block which can be modified with some exception logging mechanism but that should not impact the normal web service invocation.

Already I tried to provide some flexibilities in the TraceExtensionAttribute with few properties. These can be set while instantiating the attribute in the method level. Also, TraceExtension class can support the following entries in (config files web.config/app.config).

<appSettings>
  <add key ="REQ_LOGFILE" value="c:\log\SOAPReq_log.txt"/>
  <add key ="RES_LOGFILE" value="c:\log\SOAPRes_log.txt"/>

  <add key ="LogTypeMode" value="3"/>
<!-- None = 0,
      RequestOnly = 1,
      ResponseOnly = 2,
      RequestReponse = 3 -->
</appSettings>

If both config entries and attribute parameters are provided, then config entries would override that. So my utility (i.e. SoapMessageUtility.dll) can be directly used with the above configuration entries.

References

You can download the code and binaries by clicking here. I would suggest you all to have a look into the MSDN link on this. Also for beginners to SOAP, the tutorial from w3schools might be helpful.

CodeProject

If you want to have the same feature in your blog, you can try out the approach discussed below.Before doing that I must thank my friend Abhijit who noticed this and asked me on this. So I thought to share with all of you though there might be some other way (if any let me know) to do this.

Steps to Customize URL Icon

1. You have to select any theme which has "Custom Header" e.g. Rubric

2. Once this theme is activated,  you can see Custom Header option under "Appearance" menu.

3. In this option you can set Header Image (which will be ultimately shown as icon image) to be displayed. Once you do that, you can see the same image in the URL,Icon as well as in Header.

4. Now you can remove the Header Image by “Restore Original Header”. Now your purpose is over. So you can remove this theme and go back to your old theme.

5. You might need to open a new browser after clearing cache and all to reflect the changes. You should be able to get the icon in your URL.

How Windows Mobile Applications can be tested with Visual Studio
To test/execute any Windows Mobile application you should be having an Microsoft Device Emulator in case you do not have the actual device (which I assumed through out the article).

Hello World application is loaded in Device Emulator

This emulator would load the application and give you the same kind of virtual look and feel as device would do.

In development system, you can start coding in Windows Mobile Application by selecting the type of the project and the target platform. Now from your visual studio you can create any Mobile app (say any Hello World) and execute through Microsoft Device Emulator which is invoked through the Visula Studio itself.
You actually do not even need to bother what Visual Studio is doing behind the scene to load application in the emulator.

Select SmartDevice Project option

Select the Compact Framework version and Target Platform

Now when you do not have the Visual Studio installed in your system (which means you do not have the Microsoft Device Emulator installed also) then the probelm comes. In following sections I would describe how you can execute or test your application in an Emulator directly without Visual Studio.

CAB Deployment

Create a Smart Device CAB project for deployment

The deployment unit for a Windows Mobile application is a CAB file created on top the application. I would cover the packaging and deployment of Windows Mobile application in one my coming posts. For the time being you can create a Smart Device CAB project and add the Project Output of the Windows Mobile applications in the Application Folder. Just as an information, our main target is now to install this CAB in the Emulator to get the application installed. 

Loading Applications through Emulator without Visual Studio
There are two ways which you can follow. In both the cases, Visual Studio will not be any dependency to execute the application in an emulator.
Option 1

This approach would store the state of the emulator in some developer’s system. Then loading the same state in the target system (the testing system with out Visual Studio).
1. Start the emulator in developer’s system from command line. Also provide a file (EmulatorState.dess) where the state can be stored -
“C:\Program Files\Microsoft Device Emulator\1.0\DeviceEmulator.exe” “C:\Program Files\Windows Mobile 6 SDK\PocketPC\Deviceemulation409\PPC_USA.BIN” /memsize 128 /s “d:\EmulatorState.dess”
2. Once the emulator is opened, save the state (File -> Save State and Exit). This would save the state in EmulatorState.dess file.
3. Copy the EmulatorState.dess file to the target system (suppose “d:\EmulatorState.dess”). Now install the Microsoft Device Emulator 3.0 Standalone Release to the target system.
4. Now run the Device emulator manager (C:\Program Files\Microsoft Device Emulator\1.0\dvcemumanager.exe). Open the file (”d:\EmulatorState.dess”) by File -> Open from Device Manager.
The same step can be done through the command line by invoking device emulator -
“C:\Program Files\Microsoft Device Emulator\1.0\DeviceEmulator.exe” /s “d:\EmulatorState.dess”

Create a share folder for Emulator

5. Now the application to be installed in the emulator. From the Emulator select File -> Configure. In the General tab, select the Shared Folder (suppose C:\ShareFolder) in the target system. Now keep the cab file (created on top of the mobile application) in that shared folder.

Use the storage card in Emulator to access the shared folder in your desktop

You can browse to same cab file in the emulator by Start -> Programs -> File Explorer. In the File Explorer select “Storage Card” from dropdown in the top section. Now you can click the cab file to install in the emulator.
Option 2

This approach needs installtion of Emulator and the images of Windows Mobile 6 in the target system (where you donot need Visual Studio).
1. Install the Standalone Device Emulator 1.0 with Windows Mobile OS Images. I tried with the Microsoft Device Emulator 3.0 Standalone Release also.
2. Now install the the Windows Mobile 5.0 MSFP operating system images (efp.msi file which is in the same link of Standalone Device Emulator 1.0 with Windows Mobile OS) that you can use with the Device Emulator. Also, you can have the different images for Windows Mobile 6.0 (Standalone Device Emulator 1.0 with Windows Mobile OS). This phase of installion would help you to run the emulator with proper mobile like images.
3. While installing the point 2 items you might need to install the Microsoft Virtual PC 2007 which contains the required network drivers that the emulator uses.
4. Now you can launch the emulator from Start -> Programs -> Microsoft Windows Mobile 5.0 MSFP Emulator Images or Start -> Programs -> Windows Mobile 6 SDK. In both the case share your folder to execute the cab file as mentioned in the 5th point of Option 1.

I hope this might help you all from Googling and doing some R&D work
I would soon post another interesting item on deployment of this mobile applications.

I revisited this post to elaborate it based on the comments received. Keep sending your feedback.

Same blog is available at Codeproject