The ASP.NET Worker Process and application domains (AppDomain)

Overview

This article is an overview of the ASP.NET worker process in IIS5. IIS6 offers a slightly different architecture (maybe my next article).

Introduction

One of the most important requirements for ASP.NET framework applications is reliability. The architecture of applications running inside the server process (in IIS, Inetinfo.exe) does not produce a solid foundation for building reliable applications that can continue to run over a long period of time. Too many resources are shared on the process level, and it is too easy for an error to bring down the entire server process.

To solve this problem, ASP.NET provides an out-of-process execution model, which protects the server process from user code. It also enables you to apply heuristics to the lifetime of the process to improve the availability of your web applications. Does it scale up to its promises? Lets see, but before that, we should have a concept of AppDomains, marshalling and inter-process communication.

ASP.NET & application domains (AppDomain)

Every Windows application runs inside a certain process. Processes on the other hand own resources like memory and kernel objects. One single process can have multiple threads running inside it, which executes the code loaded in the process. Operating system takes the responsibility to protect processes from unexpectedly running into each other. Possible reasons behind this can be memory leaks in applications, out of bound memory access, null object referencing (GC not involved in this case) etc. If for some reason, one of the applications crashes; other applications running in other processes remain undisturbed. Processes provide a high level of application fault tolerance, which is why IIS and COM+ use them, when running in high isolation mode.

So far so good, but there is one big problem with processes, which is they are an extremely expensive resource to produce and manage, since every process consumes memory. It is quite impractical to use large number of processes since they don’t scale well. Apart from that, communication between processes is also very resource consuming since we have to marshal objects by reference, serialize/deserialize and cross process boundaries, which passes several layers including operating system checks.

However if we run multiple applications in the same process, we will use fewer resources, thus resulting in a faster execution cycle, since DLLs will only be loaded once, and we don’t have to sacrifice for out of boundary calls. There are downsides to this approach, as one application fails, others will be affected as well.

To overcome such issues, .NET introduced application domains, which have the same benefits as the process, but multiple application domains can run within a single process. Application domains can run safely in one single process because of the code verification feature of the CLR, which ensures that the code is managed and safe to run. Every instance of an ASP.NET application is created in an application domain within the ASP.NET worker process.

Worker process creation and recycling

Whenever an old worker process recycles, a newer one is created, which replaces the old one to serve requests. The configuration settings for the creation and control of the worker process are stored in the root configuration file for the computer, Machine.config. The process model is enabled by default. The process model supports two types of recycling: reactive and proactive. The 'userName' and 'password' attributes define the account under which the ASP.NET worker process runs. These default to 'machine' and 'autogenerate' respectively. These values tell ASP.NET to use the built-in ASPNET account and to use a cryptographically strong random password stored in the Local Security Authority (LSA) for that account.

Reactive process recycling

Reactive process recycling occurs when a process is misbehaving or unable to serve requests. The process typically displays detectable symptoms, such as deadlocks, access violations, memory leaks, and so on, in order to trigger a process recycle. You can control the conditions that trigger a process restart by using the configuration settings described in the following table.

Setting description 

• requestQueueLimit: Handles deadlock conditions. The DWORD value is set to the maximum allowed number of requests in the queue, after which the worker process is considered to be misbehaving. When the number is exceeded, a new process is launched and the requests are reassigned. The default is 5000 requests.
• memoryLimit: Handles memory leak conditions. The DWORD value is set to the percentage of physical memory that the worker process can consume before it is considered to be misbehaving. When that percentage is exceeded, a new process is launched and the requests are reassigned. The default is 60%.
• shutdownTimeout: Specifies the amount of time the worker process has to shut itself down gracefully (string value in hr:min:sec format). When the time out expires, the ASP.NET ISAPI shuts down the worker process. The default is 00:00:05.

Proactive process recycling

Proactive process recycling restarts the worker process periodically even if the process is healthy. This can be a useful way to prevent denials of service due to conditions the process model is unable to detect. A process can be restarted after a specific number of requests or after a time-out period has elapsed.

Setting description

• timeout: String value in hr:min:sec format that configures the time limit after which a new worker process will be launched to take the place of the current one. The default is Infinite, a keyword indicating that the process should not be restarted.  
• idleTimeout: String value in hr:min:sec format that configures the amount of inactivity, after which the worker process is automatically shut down. The default is Infinite, a keyword indicating that the process should not be restarted.
• requestLimit: DWORD value set to the number of requests after which a new worker process will be launched to take the place of the current one. The default is Infinite, a keyword indicating that the process should not be restarted.

Conclusion

We are not done yet; the next part of this article will explain session state management, issues regarding working process recycling, best practices and performance tips. Please feel free to report things, which I have missed out or misreported. I will update them. I can be reached at hisandeepkiet@gmail.com.

References

I have collected some text from the following resources:

• www.vbcentral.net
• Professional ASP.NET by WROX

How do I improve ASP.NET MVC application performance?

A compiled list of possible sources of improvement are below:

General

• Make use of a profiler to discover memory leaks and performance problems in your application. personally I suggest dotTrace
• Run your site in Release mode, not Debug mode, when in production, and also during performance profiling. Release mode is much faster. Debug mode can hide performance problems in your own code.

Caching

• Use CompiledQuery.Compile() recursively avoiding recompilation of your query expressions
• Cache not-prone-to-change content using OutputCacheAttribute to save unnecessary and action executions
• Use cookies for frequently accessed non sensitive information
• Utilize ETags and expiration - Write your custom ActionResult methods if necessary
• Consider using the RouteName to organize your routes and then use it to generate your links, and try not to use the expression tree based ActionLink method.
• Consider implementing a route resolution caching strategy
• Put repetitive code inside your PartialViews, avoid render it xxxx times: if you end up calling the same partial 300 times in the same view, probably there is something wrong with that. Explanation And Benchmarks

Routing

• Use Url.RouteUrl("User", new { username = "joeuser" }) to specify routes. ASP.NET MVC Perfomance by Rudi Benkovic
• Cache route resolving using this helper UrlHelperCached ASP.NET MVC Perfomance by Rudi Benkovic

Security

• Use Forms Authentication, Keep your frequently accessed sensitive data in the authentication ticket

DAL

• When accessing data via LINQ rely on IQueryable
• Leverage the Repository pattern
• Profile your queries i.e. Uber Profiler
• Consider second level cache for your queries and add them an scope and a timeout i.e. NHibernate Second Cache

Load balancing

• Utilize reverse proxies, to spread the client load across your app instance. (Stack Overflow uses HAProxy (MSDN).
• Use Asynchronous Controllers to implement actions that depend on external resources processing.

Client side

• Optimize your client side, use a tool like YSlow for suggestions to improve performance
• Use AJAX to update components of your UI, avoid a whole page update when possible.
• Consider implement a pub-sub architecture -i.e. Comet- for content delivery against reload based in timeouts.
• Move charting and graph generation logic to the client side if possible. Graph generation is a expensive activity. Deferring to the client side your server from an unnecessary burden, and allows you to work with graphs locally without make a new request (i.e. Flex charting, jqbargraph, MoreJqueryCharts).
• Use CDN's for scripts and media content to improve loading on the client side (i.e. Google CDN)
• Minify -Compile- your JavaScript in order to improve your script size
• Keep cookie size small, since cookies are sent to the server on every request.
• Consider using DNS and Link Prefetching when possible.

Global configuration

• If you use Razor, add the following code in your global.asax.cs, by default, Asp.Net MVC renders with an aspx engine and a razor engine. This only uses the RazorViewEngine.
  ViewEngines.Engines.Clear(); ViewEngines.Engines.Add(new RazorViewEngine());
• Add gzip (HTTP compression) and static cache (images, css, ...) in your web.config<system.webServer> <urlCompression doDynamicCompression="true" doStaticCompression="true" dynamicCompressionBeforeCache="true"/> </system.webServer>
• Remove unused HTTP Modules
• Flush your HTML as soon as it is generated (in your web.config) and disable viewstate if you are not using it <pages buffer="true" enableViewState="false"

The basic suggestion is to follow REST principles and the following points ties some of these principals to the ASP.NET MVC framework:

1. Make your controllers stateless - this is more of a 'Web performance / scalability' suggestion (as opposed to micro/machine level performance) and a major design decision that would affect your applications future - especially in case it becomes popular or if you need some fault tolerance for example.
   • Do not use Sessions
   • Do not use tempdata - which uses sessions
   • Do not try to 'cache' everything 'prematurely'.
2. Use Forms Authentication
   • Keep your frequently accessed sensitive data in the authentication ticket
3. Use cookies for frequently accessed non sensitive information
4. Make your resources cachable on the web
   • Utilize ETags
   • Use expiration
   • Write your custom ActionResult classes if necessary
   • Utilize reverse proxies
5. Compile your JavaScript. There is Closure compiler library to do it as well (sure there are others, just search for 'JavaScript compiler' too)
6. Use CDNs (Content Delivery Network) - especially for your large media files and so on.
7. Consider different types of storage for your data, for example, files, key/value stores, etc. - not only SQL Server
8. Last but not least, test your web site for performance

Difference between Html.BeginForm() and ajax.beginform()

Ajax.BeginForm()

1. Won't redirect the form even you do a RedirectAction().
2. Will perform save , update and any modification operations asynchronously.
3. Validate the Form using FormMethods - OnSubmit. So you are abort the Post
4. This creates a form that submits its values using an asynchronous ajax request. This allows a portion of the page to be update without requiring that the entire page be refreshed.
5. Ajax.BeginForm() creates a form that submits its values using an asynchronous ajax request. This allows a portion of the page to be update without requiring that the entire page be refreshed.

Html.BeginForm()

1. Will redirect the form.
2. Will perform operations both Synchronously and Asynchronously (With some extra code and care).
3. Html.BeginForm will always use RouteTable to detrmine the action attribute value.
4. This will create a form on the page that submits its values to the server as a synchronous HTTP request, refreshing the entire page in the process.
5. Html.BeginForm() will create a form on the page that submits its values to the server as a synchronous HTTP request, refreshing the entire page in the process.

When to use StringBuilder?

Rules Of Thumb

So, when should you use StringBuilder, and when should you use the string concatenation operators?

• Definitely use StringBuilder when you're concatenating in a non-trivial loop - especially if you don't know for sure (at compile time) how many iterations you'll make through the loop. For example, reading a file a character at a time, building up a string as you go using the += operator is potentially performance suicide.
• Definitely use the concatenation operator when you can (readably) specify everything which needs to be concatenated in one statement. (If you have an array of things to concatenate, consider calling String.Concat explicitly - or String.Join if you need a delimiter.)
• Don't be afraid to break literals up into several concatenated bits - the result will be the same. You can aid readability by breaking a long literal into several lines, for instance, with no harm to performance.
• If you need the intermediate results of the concatenation for something other than feeding the next iteration of concatenation, StringBuilder isn't going to help you. For instance, if you build up a full name from a first name and a last name, and then add a third piece of information (the nickname, maybe) to the end, you'll only benefit from using StringBuilder if you don't need the (first name + last name) string for other purpose (as we do in the example which creates a Person object).
• If you just have a few concatenations to do, and you really want to do them in separate statements, it doesn't really matter which way you go. Which way is more efficient will depend on the number of concatenations the sizes of string involved, and what order they're concatenated in. If you really believe that piece of code to be a performance bottleneck, profile or benchmark it both ways.

Why/Where do We need Web Services?

You can use the Web Services for the following requirements.

1. Web API : Where you need to expose your service to others such as Payment Gateway, Travel and Cinema Bookings.. etc.,
2. Mobile Development: Web Service consume by Android and iOS Devices (Mobile, Tablet)
3. Cross Platform Applications: ASP.NET Web Services can consume by Java, PHP appications
4. Same Platform but diffrent applications: Windows Applications, Web Applications and Windows Serivces

Types of Constructor in C# with Example

Constructor is a special method of a class which will invoke automatically whenever instance or object of class is created. Constructors are responsible for object initialization and memory allocation of its class. If we create any class without constructor, the compiler will automatically create one default constructor for that class. There is always at least one constructor in every class.

Here you need to remember that a class can have any number of constructors and constructors don’t have any return type, not even void and within a class we can create only one static constructor.

Generally constructor name should be same as class name. If we want to create constructor in a class we need to create a constructor method name same as class name check below sample method for constructor

class SampleA { public SampleA() { Console.WriteLine("Sample A Test Method"); } }

Types of Constructors

Basically constructors are 5 types those are

      1.    Default Constructor

      2.    Parameterized Constructor

      3.    Copy Constructor

      4.    Static Constructor

      5.    Private Constructor

Default Constructor

A constructor without having any parameters called default constructor. In this constructor every instance of the class will be initialized without any parameter values like as shown below

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; public Sample()     // Default Constructor { param1 = "Welcome"; param2 = "Aspdotnet-Suresh"; } } class Program { static void Main(string[] args) { Sample obj=new Sample();   // Once object of class created automatically constructor will be called Console.WriteLine(obj.param1); Console.WriteLine(obj.param2); Console.ReadLine(); } } }

When we run above program it will show output like as shown below

Output

Welcome Aspdotnet-Suresh

Parameterized Constructors

A constructor with at least one parameter is called as parameterized constructor. In parameterized constructor we can initialize each instance of the class to different values like as shown below

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; public Sample(string x, string y)     // Declaring Parameterized constructor with Parameters { param1 = x; param2 = y; } } class Program { static void Main(string[] args) { Sample obj=new Sample("Welcome","Aspdotnet-Suresh");   // Parameterized Constructor Called Console.WriteLine(obj.param1 +" to "+ obj.param2); Console.ReadLine(); } } }

When we run above program it will show output like as shown below

Output

Welcome to Aspdotnet-Suresh

Constructor Overloading

In c# we can overload constructor by creating another constructor with same method name and different parameters like as shown below

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; public Sample()     // Default Constructor { param1 = "Hi"; param2 = "I am Default Constructor"; } public Sample(string x, string y)     // Declaring Parameterized constructor with Parameters { param1 = x; param2 = y; } } class Program { static void Main(string[] args) { Sample obj = new Sample();   // Default Constructor will Called Sample obj1=new Sample("Welcome","Aspdotnet-Suresh");   // Parameterized Constructor will Called Console.WriteLine(obj.param1 + ", "+obj.param2); Console.WriteLine(obj1.param1 +" to " + obj1.param2); Console.ReadLine(); } }

When we run above program it will show output like as shown below

Output

Hi, I am Default Constructor Welcome to Aspdotnet-Suresh

Copy Constructor

A parameterized constructor that contains a parameter of same class type is called as copy constructor. Main purpose of copy constructor is to initialize new instance to the values of an existing instance. Check below example for this

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; public Sample(string x, string y) { param1 = x; param2 = y; } public Sample(Sample obj)     // Copy Constructor { param1 = obj.param1; param2 = obj.param2; } } class Program { static void Main(string[] args) { Sample obj = new Sample("Welcome", "Aspdotnet-Suresh");  // Create instance to class Sample Sample obj1=new Sample(obj); // Here obj details will copied to obj1 Console.WriteLine(obj1.param1 +" to " + obj1.param2); Console.ReadLine(); } } }

When we run above program it will show output like as shown below

Output

Welcome to Aspdotnet-Suresh

Static Constructor

When we declared constructor as static it will be invoked only once for any number of instances of the class and it’s during the creation of first instance of the class or the first reference to a static member in the class. Static constructor is used to initialize static fields of the class and to write the code that needs to be executed only once.

using System; namespace ConsoleApplication3 { class Sample { public string param1, param2; static Sample() { Console.WriteLine("Static Constructor"); } public Sample() { param1 = "Sample"; param2 = "Instance Constructor"; } } class Program { static void Main(string[] args) { // Here Both Static and instance constructors are invoked for first instance Sample obj=new Sample(); Console.WriteLine(obj.param1 + " " + obj.param2); // Here only instance constructor will be invoked Sample obj1 = new Sample(); Console.WriteLine(obj1.param1 +" " + obj1.param2); Console.ReadLine(); } } }

When we run above program we will get output like as shown below

Output

Static Constructor Sample Instance Constructor Sample Instance Constructor

Importance points of static constructor

-      Static constructor will not accept any parameters because it is automatically called by CLR.

-      Static constructor will not have any access modifiers.

-      Static constructor will execute automatically whenever we create first instance of class

-      Only one static constructor will allowed.

Private Constructor

Private constructor is a special instance constructor used in a class that contains static member only. If a class has one or more private constructor and no public constructor then other classes is not allowed to create instance of this class this mean we can neither create the object of the class nor it can be inherit by other class. The main purpose of creating private constructor is used to restrict the class from being instantiated when it contains every member as static.

using System; namespace ConsoleApplication3 { public class Sample { public string param1, param2; public Sample(string a,string b) { param1 = a; param2 = b; } private Sample()  // Private Constructor Declaration { Console.WriteLine("Private Constructor with no prameters"); } } class Program { static void Main(string[] args) { // Here we don't have chance to create instace for private constructor Sample obj = new Sample("Welcome","to Aspdotnet-Suresh"); Console.WriteLine(obj.param1 +" " + obj.param2); Console.ReadLine(); } } }

Output

Welcome to Aspdotnet-Suresh

In above method we can create object of class with parameters will work fine. If create object of class without parameters it will not allow us create.

// it will works fine Sample obj = new Sample("Welcome","to Aspdotnet-Suresh"); // it will not work because of inaccessability Sample obj=new Sample();

Important points of private constructor

-      One use of private construct is when we have only static member.

-      Once we provide a constructor that is either private or public or any, the compiler will not allow us to add public constructor without parameters to the class.

-      If we want to create object of class even if we have private constructors then we need to have public constructor along with private constructor