Windows Service (Part-2)

In last post we learn how to build windows service in Visual studio, but work does not complete here. Once windows service is developed we need to install it.

We didn’t talk about how to give name to myservice or what property should be set when building it.

Firstly in windows service, we have ServiceBase if you look on designer view, check properties windows of it. Set ServiceName property, this will be our service name.

As we discussed we should write code in OnStart and OnStop method, we can even override other methods OnPause and OnContinue. Pause service is continued to serve users who are already consuming it, but don’t serve to new request. OnContinue is called when service is resumed from stop. To implement these methods set CanPauseAndContinue to true.

To override OnShutdown method, set CanShutdown to true. This method is called at the time of shutdown of computer.

To override OnPowerEvent method, set CanHandlePowerEvent to true. This method is invoked at the time of suspended mode of computer.

As we know to consume windows service, firstly we need to install it. To install it .net has provided ServiceInstaller and ServiceProcessInstaller classes.

ServiceInstaller class is used to define service description, display name, service name and startup type.

ServiceProcessInstaller class is used to define service account information.

àBy right clicking on designer of ServiceBase we can add ProjectInstaller.

àSet StartType property of ProjectInstaller from below list

Automatic: The service starts automatically after the computer starts, whether or not a user logs in.

Manual: A user must start the service manually. This is the default.

Disabled: The service does not start automatically, and users cannot start the service without first changing the start-up type.

àSet Description and DisplayName properties.

àSet ServiceDependedOn property. It may be possible service which we create is depends on some of serviced provided by operating system. We can add one more service in this list.

àSet Security Context of your service by specifying your Account property from one of the following value.

LocalService: Runs in the context of an account that acts as a nonprivileged user on the local computer, and presents anonymous credentials to any remote server. Use LocalService to minimize security risks.

NetworkService: Enables the service to authenticate to another computer on the network. This authentication is not required for anonymous connections, such as most connections to a Web server.

LocalSystem: The service runs with almost unlimited privileges and presents the computer’s credentials to any remote server. Using this account type presents a severe security risk; any vulnerabilities in your application could be exploited to take complete control of the user’s computer.

User: Causes the system to prompt for a valid user name and password when the service is installed. You can set values for both the Username and Password properties of your ServiceProcessInstaller instance. This is the default.

àSet your service project startup object as we have set as startup form in windows application.

Now last task is to install service on computer, we can do that either manually or by creating installer with .msi file.

To manually install service run InstallUtil “service.exe”. here “service.exe” is name of service assembly. InstallUtil is available in ...windows\Microsoft.Net\Framework\Versoion\Folder…

For installer, we can add installer project to our service solution as per other project give Primary output in installer. In primary output give output of windows service.

Once service is installed, we can start , stop from services. Services can be accessed from administrative tools in control panel or by right clicking on mycomputer and manage of it. One of manage list have node services, that is showing all available list of windows service.

By right clicking on service we can pause, run, restart, and stop service. We can even set start up type form there.

Windows Service (Part-1)

Windows service are application that don’t have any visual element or visual effect, they run in back ground. Windows service run under particular user session as long as we have configured it.

Windows operating system it self provides many services we are familiar with IIS, telnet, Security Center services. We don’t use all services provided by operating system, sometime we require to have some application that run automatically and do work independently without interruption from user interaction. Application starts as we start our computer and run as long as computer don’t shutdown.

In such type of situation we can build up windows service application and host on our computer where we want to have automatic run and stop functionality.

Before we start to talk about how to develop windows service, we check how is it different from other application types?

We can’t run or debug windows service from visual studio development environment so there is no use of F5 and F11 in case of windows service project.

We have to create installer to run windows service, unlike other project we don’t have dll or exe files and can use easily. We need to install windows service by installing to a particular computer.

The main method of your windows service project must have run command, which loads service to service control manager on appropriate computer.

Unlike other application, you would not able to show message box when application crash, or something happened, it will run on background, you will not get any information once service start as after it fully controlled by operating system.

Windows services run on their own security context, we should take care of user account and security problem.

Creation of Windows service project

àChoose windows service template for windows project type.

àwrite your code on OnStart and OnStop procedures, we can override other methods too.

Once windows service started, we can’t have any control on it, we don’t get any thing, in that situation we can create timer object and start timer once windows service start. After that we can write event for timer time elapsed. In such a way we do useful work by using windows services.

Application Domain and its configuration (Part-2)

In previous post we see how to create application domain, how to load and unload application domain. Sometime we don’t have idea of running assembly as we have loaded it from internet or some third party vendor. Such type of assembly may have possibly contains code, which create security vulnerabilities. Malicious code may corrupt your file system, application and damage to your hardware. To reduce this attack we can allow assembly to run in application domain but with limited privileges.

When you create an application domain, you have complete control over host evidence. Host evidence is the information of assembly, form which code group assembly belongs to.

With help of System.Security and System.Security.Policy you can provide evidence for particular application domain.

You can pass zone or code group for assembly when creating application domain with help of System.Security.Policy.Zone and System.Security.SecurityZone enumeration.

object[] hostEvidence = {new Zone(SecurityZone.Internet)};

Evidence internetEvidence = new Evidence(hostEvidence, null);

AppDomain myDomain = AppDomain.CreateDomain("MyAppDomain");

myDomain.ExecuteAssembly("myAssembly.exe", internetEvidence);

In above sample code we have created hostEvidence object with Internet code group and passed evidence object to ExecuteAssembly method.

Now “MyAppDomain” application domain will run “myAssembly.exe” with internet group privileges. As we know there is a very low control to run code which has been downloaded from internet or running directly from internet. By default Internet zone has very limited permission. There are other code groups are exist like “MyComputer” they can be useful when we want to give more permission to executable assembly in application domain.

We can pass evidence object when creating application domain as.

object [] hostEvidence = {new Zone(SecurityZone.Internet)};

Evidence appDomainEvidence = new Evidence(hostEvidence, null);

AppDomain d = AppDomain.CreateDomain("MyAppDomain", appDomainEvidence);

d.ExecuteAssembly("myAssembly.exe");

To fully customize application domain environment .net has provided AppDomainSetup class. By assigning various property and method to this class we can built up environment for new application domain.

AppDomainSetup has some properties like ApplicaitonBase which used to set root path for assembly, ApplicationName, ConfigurationFile, LicenceFile most of them are self describing from their name.

We can examine current application domains by using.

AppDomainSetup ads = AppDomain.CurrentDomain.SetupInformation;

Application Domain and its configuration (Part-1)

In .net all application assembly run under an application domain that is created by default for each application, we don’t need to create it. Common Language Runtime does it for application.

Application domain is logical unit to run different application in a single process. IIS is the very good example of it, in IIS more than one website or application are hosted, still they run independent with out interfering to any other application, hosted on same IIS.

Application domain creates a separate layer for application; .net run time is responsible for the various application runtime, while operating system manage process. In a process, we can run more than one application domain and each application domain has one or more assembly, application running. Each of these application domains can’t access resource or memory used by another application domain.

To create an application domain is as simple as we create an object of a class. The benefit of application domain is that when we don’t require or our work has been completed we can unload resource occupied by application runtime.

System.AppDomain class provides many methods and property to manipulate application domain.

-->Create an application domain
AppDomain ad = new AppDomain(“myAppDomain”);

We can run our assembly under this newly created Application domain.
ad.ExecuteAssembly(“myAssembly.exe”);

We can either call ExecuteAssemblyByName method to run assembly, in that case we need to pass name of assembly.
ad.ExecuteAssembly(“myAssembly.exe”);

There are so many properties and methods provide by AppDomain which gives ability to specify ID to process, friendlyname etc. Methods like Load, ApplyPolicy,CreateIntance etc.

If you notice in above code, we don’t have any constructor to create application domain, we are using static method of AppDomain class.

We can access current domains by ..


AppDomain myCurrentDomain = AppDomain.CurrentDomain;
To unload application domain, call Unload method of AppDomain

AppDomain.Unload(ad);

Threading in .net (Part -2)

In previous post, we have got idea of what is threading and how it can be done easily by calling ThreadPool.QueueUserWorkItem. But threading is not that mean only we need more control on our threading activity.

Like we need to ensure that all thread must work, give priority to my thread than other once, weather my thread has been completed or not, what is status of my thread etc.. all thing can be done by various type of mechanism provided by .net. Yes it’s surely a tedious and complex task to implement but if we do it carefully it not only reduces response time but application behaves very nicely and manages resources.

ThreadPool.QueueUserWorkItem provides a way to run thread in back ground and let it run until it finish. For more control on thread we can create instance of thread, we can even control start, pause, abort, priority. We can handle ThreadAbortException when thread has been aborted.

àCreate thread instance

Thread myThread = new Thread(new ThreadStart(myWork));

àStart thread

myThread.Start();

àWait for some time to run myThread

Thread.Sleep(2000);

àAbort myThread

myThread.Abort();

myWork method has following implementation

public static void myWork()

{

Console.WriteLine("myWork is running on another thread.");

try

{

Thread.Sleep(5000);

}

catch (ThreadAbortException ex)

{

Console.WriteLine("myWork was aborted.");

}

finally

{

Console.WriteLine("Use finally to close all open resources.");

}

Console.WriteLine("myWork has ended.");

}

In above code “myWork has ended” will never display as I have aborted thread. If I comment that line that it will be displayed.

We can call Thread.Suspend and Thread.Resume to stop and resume thread execution but sometime they can create problem. Say for example I am stopping a thread which has acquired my printer, so it will create deadlock condition as my other thread may need printer.

We can set thread priority before starting thread by ThreadPriority enumeration. Enumeration has following values.

àHighest

àAboveNormal

àNormal

àBelowNormal

àLowest

By default foreground and background run on normal priority.

Thread’s state can be checked with Thread.ThreadState property. There are various types of it like Unstarted, Running, Stopped, Suspended, Aborted etc. At a time a thread may have one or more thread state.

Sometime there is requirement to know status of thread which is running in background we want to pass some data to thread and let us know what is the output of that data after certain time elapsed. We can achieve this task by creating delegate and callback. For that we need to create a delegate at class level and a method to handle that delegate. Create a class for which you want to run in background, add delegate to class. Create an instance of class and in constructor pass delegate with appropriate method.

When there are more than one thread runs simultaneously, situation may happen it acquires resource and in turn deadlock. So it means instead of improvement in performance our application become slow and unresponsive. At that time we need to manage resource by synchronizing thread resource.

Use lock keyword in C# and SynLock keyword in vb.net. It does not allow using resource of any other thread till it completes it work. One thing should be kept in mind that these keywords work only with reference type not on value type.

When there is requirement of separate read and write lock on resource we can use ReaderWriterLock class. Create instance of this class and use separate read and write lock.

ReaderWriterLock rwl = new ReaderWriterLock()

To acquire read lock

rwl.AcquireReaderLock(10000);

Release reader lock

rwl.ReleaseReaderLock();

Acquire writer lock and release it.

rwl.AcquireWriterLock(10000);

rwl.ReleaseWriterLock();

Another method to synchronize thread is to use object of Interlocked class. It will add numeric value to thread. It also provides various numeric methods.

There are also so many things to wait for thread to complete and start another thread once complete previous one.

NOTE: In visual basic we need to add attribute to main method to run main thread as multithread. MTA (Multithread Apartment) is by default provided in C#, so there is no need to add it. MTA supports calling WaitHandle.WaitAll.

Threading in .net (Part -1)

Most of the time developer chooses to develop program in linear way. In this mechanism user would need to wait sometime in some situation like application is going to download page from server, application is going to print document, applications is going to access remote database. Those cases are time consuming, user needs to wait till main thread completes work, sometime user get frustrated by response time, and application does not response to user till task has been completed.

To overcome, .net has provided threading mechanism. Our main thread executes as and in background we can execute process. So user will not feel that application is not responding, in background thread method executes and once result will be available, it would be shown to user.

Threading means in a single process execute more than one task among different processors. Now days most of computers are more than one core, we can use another core when main core is busy to complete task. We can distribute work task among different processors.

Though multithreading seems to be very complex, .net has provided a simple way to implement in programming. At a time there can be more than 250 threads run in back ground. We can even change it to more if require.

To work with thread we need to add System.Threading namespace to our application. We can run background thread by using ThreadPool.QueueUserWorkItem and passing method name or address of in vb.net.

static void Main(string[] args)

{

int workerThreads;

int completionPortThreads;

ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);

ThreadPool.QueueUserWorkItem(ThreadProc, "Thread 1");

ThreadPool.QueueUserWorkItem(ThreadProc, "Thread 2");

ThreadPool.QueueUserWorkItem(ThreadProc, "Thread 3");

ThreadPool.QueueUserWorkItem(ThreadProc, "Thread 4");

ThreadProc("ForgroundThread");

Thread.Sleep(1000);

Console.WriteLine("Worker Threads: {0} CompletePortThreads: {1}", workerThreads, completionPortThreads);

ThreadPool.QueueUserWorkItem(ThreadProc, "Thread 5");

ThreadPool.QueueUserWorkItem(ThreadProc, "Thread 6");

Console.WriteLine("Now main is continue");

}

Above code shows how many threads can be run, default value is 250. We have used ThreadProc method which will run in background thread. When main thread has no work at that time background thread will run and execute code. We can add as many threads as we wish as per limit of 250 and if required we can increase this maximum thread limit.

Thread which runs first is called Forground and other called background.

static void ThreadProc(object msg)

{

string threadMsg = (string)msg;

if (Thread.CurrentThread.IsBackground)

{

Console.WriteLine("Background Thread");

Console.WriteLine("My Threading method with:" + threadMsg);

}

else

{

Console.WriteLine("Forground Thread");

Console.WriteLine("My Threading method with:" + threadMsg);

}

}

We can check weather thread is background or not with Thread.CurrentThread.IsBackGround property.

Some time threading also overheads on processors, so need to take care while implementing threading as it distribute loads to different processor, more memory is required to manage resource.

Wise use of threading may improve application’s performance. It depends on requirement and application problem to use of Threading.

Custom Serialization (Part -3)

.Net has provided a way to serialize object as you wish, you can have all control when serializing and deserializing any object. You even decided format of storing serialized object. All custom serialization can be done by implementing ISerializable interface and applying Serializable attribute to class.

[Serializable]

class ShoppingCartItem : ISerializable

{

public Int32 productId;

public decimal price;

public Int32 quantity;

[NonSerialized]

public decimal total;

// Constructor used to initialized member of my ShoppingCartItem object.

public ShoppingCartItem(int _productID, decimal _price, int _quantity)

{

productId = _productID;

price = _price;

quantity = _quantity;

total = price * quantity;

}

// Constructor will be called on deserialization

protected ShoppingCartItem(SerializationInfo info,

StreamingContext context)

{

productId = info.GetInt32("Product ID");

price = info.GetDecimal("Price");

quantity = info.GetInt32("Quantity");

total = price * quantity;

}

// The following method is called during serialization

[SecurityPermissionAttribute(SecurityAction.Demand,

SerializationFormatter=true)]

public virtual void GetObjectData(SerializationInfo info,

StreamingContext context)

{

info.AddValue("Product ID", productId);

info.AddValue("Price", price);

info.AddValue("Quantity", quantity);

}

}

Above class shows how to implement custom serialization, we have implemented a constructor, that is called on deserialization. That will assign value to our object member.

We have also added a method, GetObjectData which is used to store value at the time of Serialization.

If we notice on constructor and methods, it uses SerializationInfo object that is used to convert value to different datatype combatable to our member’s type.

BinaryFormatter provides a way to handle serialized and deserialized events. There are four types of events

Serializing: This event is raised just before serialization takes place. Apply the

OnSerializing attribute to the method that should run in response to this event.

Serialized: This event is raised just after serialization takes place. Apply the OnSerialized attribute to the method that should run in response to this event.

Deserializing: This event is raised just before deserialization takes place. Apply the OnDeserializing attribute to the method that should run in response to this event.

Deserialized: This event is raised just after deserialization takes place and after IDeserializationCallback.OnDeserialization has been called. Apply the OnDeserialized attribute to the method that should run in response to this event.

Respond to one of the above events methods should follow below criteria

àStreamingContext object passed to method as parameter

àReturn Void

àAppropriate attribute should be specified on the method.

[OnSerializing]

void CalculateTotal(StreamingContext sc)

{

total = price * quantity;

}

[OnDeserialized]

void CheckTotal(StreamingContext sc)

{

if (total == 0) { CalculateTotal(sc); }

}

We can add above methods to our class to handle serialized events.

With the help of StrreamingContext, application can decide how to serialize or deserailzed object, we get idea of platform, weather object is serialized with same process or else, from where object is coming, object location etc.

To create custom formatter we should implement IFormatter interface, both of the BinaryFormatter and SoapFormatter have implementation of IFormatter. IFormatter provides many method to implement serialization and deserialization as per own custom way.