Object Pooling

The COM+ Object Pooling service enables you to reduce the overhead of creating each object from scratch. When an object is activated, it is pulled from the pool. When the object is deactivated, it is placed back into the pool to await the next request.
You can configure object pooling by applying the ObjectPoolingAttribute attribute to a class that derives from the System.EnterpriseServices.ServicedComponent class.
Object pooling lets you control the number of connections you use, as opposed to connection pooling, where you control the maximum number reached. Following are important differences between object pooling and connection pooling:

• Creation. When using connection pooling, creation is on the same thread, so if there is nothing in the pool, a connection is created on your behalf. With object pooling, the pool might decide to create a new object. However, if you have already reached your maximum, it instead gives you the next available object. This is crucial behavior when it takes a long time to create an object, but you do not use it for very long.
• Enforcement of minimums and maximums. This is not done in connection pooling. The maximum value in object pooling is very important when trying to scale your application. You might need to multiplex thousands of requests to just a few objects. (TPC/C benchmarks rely on this.)

COM+ object pooling is practically identical to .NET Framework managed SQL Client connection pooling. For example, creation is on a different thread and minimums and maximums are enforced.

Note   Application domains affect the behavior of object pooling. In Microsoft Windows 2000, when application activation is set to Library and you have multiple application domains, pooled objects are all created in the default application domain and shared between multiple clients. In the same situation, using Microsoft Windows XP and Windows Server 2003, there is one object pool per application domain. Using either operating system with multiple application domains and your application activation set to server, out-of-process clients use the object pool in the default application domain.                                                 By.http://msdn.microsoft.com

Code 1: Object Pool and Employee class.

 

using System;

using System.Collections;

 

namespace ObjectPooling

{

    class Factory

    {

        // Maximum objects allowed!

        private static int _PoolMaxSize = 2;

 

        // My Collection Pool

        private static readonly Queue objPool = new Queue(_PoolMaxSize);  

 

        public Employee GetEmployee()

        {

            Employee oEmployee;

 

            // check from the collection pool. If exists return object else create new

            if (Employee.Counter >= _PoolMaxSize && objPool.Count>0)

            {

                // Retrieve from pool

                oEmployee = RetrieveFromPool();

            }

            else

            {

                oEmployee = GetNewEmployee();

            }

            return oEmployee;

        }

 

        private Employee GetNewEmployee()

        {

            // Creates a new employee

            Employee oEmp = new Employee();

            objPool.Enqueue(oEmp);

            return oEmp;

        }

       

        protected Employee RetrieveFromPool()

        {

            Employee oEmp;

 

            // if there is any objects in my collection

            if (objPool.Count>0)

            {

                oEmp = (Employee)objPool.Dequeue();

                Employee.Counter--;

            }

            else

            {

                // return a new object

                oEmp = new Employee();

            }

            return oEmp;

        }

    }

 

    class Employee

    {

        public static int Counter = 0;

        public Employee()

        {

            ++Counter;

        }

 

        private string _Firstname;

        public string Firstname

        {

            get

            {

                return _Firstname;

            }

            set

            {

                _Firstname = value;

            }

        } 

    }

}

 

Code 2: How to use it?

 

private void button1_Click(object sender, EventArgs e)

{

    Factory fa = new Factory();

 

    Employee myEmp = fa.GetEmployee();

    Console.WriteLine("First object");

 

    Employee myEmp1 = fa.GetEmployee();

    Console.WriteLine("Second object")

}

Dot Net Framework Interview Questions

1.What is the Microsoft.NET?

.NET is a set of technologies designed to transform the internet into a full scale distributed platform. It provides new ways of connecting systems, information and devices through a collection of web services. It also provides a language independent, consistent programming model across all tiers of an application.

The goal of the .NET platform is to simplify web development by providing all of the tools and technologies that one needs to build distributed web applications.

2.What is the .NET Framework?

The .NET Framework is set of technologies that form an integral part of the .NET Platform. It is Microsoft's managed code programming model for building applications that have visually stunning user experiences, seamless and secure communication, and the ability to model a range of business processes.

The .NET Framework has two main components: the common language runtime (CLR) and .NET Framework class library. The CLR is the foundation of the .NET framework and provides a common set of services for projects that act as building blocks to build up applications across all tiers. It simplifies development and provides a robust and simplified environment which provides common services to build application. The .NET framework class library is a collection of reusable types and exposes features of the runtime. It contains of a set of classes that is used to access common functionality.

3.What is CLR?

The .NET Framework provides a runtime environment called the Common Language Runtime or CLR. The CLR can be compared to the Java Virtual Machine or JVM in Java. CLR handles the execution of code and provides useful services for the implementation of the program. In addition to executing code, CLR provides services such as memory management, thread management, security management, code verification, compilation, and other system services. It enforces rules that in turn provide a robust and secure execution environment for .NET applications.

4.What is CTS?

Common Type System (CTS) describes the datatypes that can be used by managed code. CTS defines how these types are declared, used and managed in the runtime. It facilitates cross-language integration, type safety, and high performance code execution. The rules defined in CTS can be used to define your own classes and values.

5.What is CLS?

Common Language Specification (CLS) defines the rules and standards to which languages must adhere to in order to be compatible with other .NET languages. This enables C# developers to inherit from classes defined in VB.NET or other .NET compatible languages.

6.What is managed code?

The .NET Framework provides a run-time environment called the Common Language Runtime, which manages the execution of code and provides services that make the development process easier. Compilers and tools expose the runtime's functionality and enable you to write code that benefits from this managed execution environment. The code that runs within the common language runtime is called managed code.

7.What is MSIL?

When the code is compiled, the compiler translates your code into Microsoft intermediate language (MSIL). The common language runtime includes a JIT compiler for converting this MSIL then to native code.

MSIL contains metadata that is the key to cross language interoperability. Since this metadata is standardized across all .NET languages, a program written in one language can understand the metadata and execute code, written in a different language. MSIL includes instructions for loading, storing, initializing, and calling methods on objects, as well as instructions for arithmetic and logical operations, control flow, direct memory access, exception handling, and other operations.

8.What is JIT?

JIT is a compiler that converts MSIL to native code. The native code consists of hardware specific instructions that can be executed by the CPU.

Rather than converting the entire MSIL (in a portable executable[PE]file) to native code, the JIT converts the MSIL as it is needed during execution. This converted native code is stored so that it is accessible for subsequent calls.

9.What is portable executable (PE)?PE is the file format defining the structure that all executable files (EXE) and Dynamic Link Libraries (DLL) must use to allow them to be loaded and executed by Windows. PE is derived from the Microsoft Common Object File Format (COFF). The EXE and DLL files created using the .NET Framework obey the PE/COFF formats and also add additional header and data sections to the files that are only used by the CLR.

10.What is an application domain?

Application domain is the boundary within which an application runs. A process can contain multiple application domains. Application domains provide an isolated environment to applications that is similar to the isolation provided by processes. An application running inside one application domain cannot directly access the code running inside another application domain. To access the code running in another application domain, an application needs to use a proxy.

11.How does an AppDomain get created? AppDomains are usually created by hosts. Examples of hosts are the Windows Shell, ASP.NET and IE. When you run a .NET application from the command-line, the host is the Shell. The Shell creates a new AppDomain for every application. AppDomains can also be explicitly created by .NET applications.

12.What is an assembly?

An assembly is a collection of one or more .exe or dll’s. An assembly is the fundamental unit for application development and deployment in the .NET Framework. An assembly contains a collection of types and resources that are built to work together and form a logical unit of functionality. An assembly provides the CLR with the information it needs to be aware of type implementations.

13.What are the contents of assembly?

A static assembly can consist of four elements:

·         Assembly manifest - Contains the assembly metadata. An assembly manifest contains the information about the identity and version of the assembly. It also contains the information required to resolve references to types and resources.

·         Type metadata - Binary information that describes a program.

·         Microsoft intermediate language (MSIL) code.

·         A set of resources.

14.What are the different types of assembly?

Assemblies can also be private or shared. A private assembly is installed in the installation directory of an application and is accessible to that application only. On the other hand, a shared assembly is shared by multiple applications. A shared assembly has a strong name and is installed in the GAC.

We also have satellite assemblies that are often used to deploy language-specific resources for an application.

15.What is a dynamic assembly?

A dynamic assembly is created dynamically at run time when an application requires the types within these assemblies.

16.What is a strong name?

You need to assign a strong name to an assembly to place it in the GAC and make it globally accessible. A strong name consists of a name that consists of an assembly's identity (text name, version number, and culture information), a public key and a digital signature generated over the assembly.  The .NET Framework provides a tool called the Strong Name Tool (Sn.exe), which allows verification and key pair and signature generation.

17.What is GAC? What are the steps to create an assembly and add it to the GAC?

The global assembly cache (GAC) is a machine-wide code cache that stores assemblies specifically designated to be shared by several applications on the computer. You should share assemblies by installing them into the global assembly cache only when you need to.

Steps

- Create a strong name using sn.exe tool eg: sn -k mykey.snk

- in AssemblyInfo.cs, add the strong name eg: [assembly: AssemblyKeyFile("mykey.snk")]

- recompile project, and then install it to GAC in two ways :

·         drag & drop it to assembly folder (C:\WINDOWS\assembly OR C:\WINNT\assembly) (shfusion.dll tool)

·         gacutil -i abc.dll

18.What is the caspol.exe tool used for?

The caspol tool grants and modifies permissions to code groups at the user policy, machine policy, and enterprise policy levels.

19.What is a garbage collector?

A garbage collector performs periodic checks on the managed heap to identify objects that are no longer required by the program and removes them from memory.

20.What are generations and how are they used by the garbage collector?

Generations are the division of objects on the managed heap used by the garbage collector. This mechanism allows the garbage collector to perform highly optimized garbage collection. The unreachable objects are placed in generation 0, the reachable objects are placed in generation 1, and the objects that survive the collection process are promoted to higher generations.

21.What is Ilasm.exe used for?

Ilasm.exe is a tool that generates PE files from MSIL code. You can run the resulting executable to determine whether the MSIL code performs as expected.

22.What is Ildasm.exe used for?

Ildasm.exe is a tool that takes a PE file containing the MSIL code as a parameter and creates a text file that contains managed code.

23.What is the ResGen.exe tool used for?

ResGen.exe is a tool that is used to convert resource files in the form of .txt or .resx files to common language runtime binary .resources files that can be compiled into satellite assemblies.

24.What is CODE Access security?
CAS is part of .NET security model that determines whether or not a piece of code is allowed to run and what resources it can use while running. Example CAS will allow an application to read but not to write and delete a file or a resource from a folder.

25.What is reflection?
All .NET assemblies have metadata information stored about the types defined in modules. This metadata information can be accessed by mechanism called as "Reflection".System. Reflection can be used to browse through the metadata information.                                                                     

Software design pattern

a design pattern is a general reusable solution to a commonly occurring problem within a given context insoftware design. It is a description or template for how to solve a problem that can be used in many different situations. Patterns are formalized best practices that the programmer must implement themselves in the application.^[1] Object-oriented design patterns typically show relationships andinteractions between classes or objects, without specifying the final application classes or objects that are involved. Many patterns imply object-orientation or more generally mutable state, and so may not be as applicable in functional programming languages, in which data is immutable or treated as such.
Design patterns reside in the domain of modules and interconnections. At a higher level there are architectural patterns that are larger in scope, usually describing an overall pattern followed by an entire system.

Design Pattern Type 

Creational

Creational patterns are ones that create objects for you, rather than having you instantiate objects directly. This gives your program more flexibility in deciding which objects need to be created for a given case.

• Abstract Factory groups object factories that have a common theme.
• Builder constructs complex objects by separating construction and representation.
• Factory Method creates objects without specifying the exact class to create.
• Prototype creates objects by cloning an existing object.
• Singleton restricts object creation for a class to only one instance.

[edit]Structural

These concern class and object composition. They use inheritance to compose interfaces and define ways to compose objects to obtain new functionality.

• Adapter allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class.
• Bridge decouples an abstraction from its implementation so that the two can vary independently.
• Composite composes zero-or-more similar objects so that they can be manipulated as one object.
• Decorator dynamically adds/overrides behaviour in an existing method of an object.
• Facade provides a simplified interface to a large body of code.
• Flyweight reduces the cost of creating and manipulating a large number of similar objects.
• Proxy provides a placeholder for another object to control access, reduce cost, and reduce complexity.

[edit]Behavioral

Most of these design patterns are specifically concerned with communication between objects.

• Chain of responsibility delegates commands to a chain of processing objects.
• Command creates objects which encapsulate actions and parameters.
• Interpreter implements a specialized language.
• Iterator accesses the elements of an object sequentially without exposing its underlying representation.
• Mediator allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
• Memento provides the ability to restore an object to its previous state (undo).
• Observer is a publish/subscribe pattern which allows a number of observer objects to see an event.
• State allows an object to alter its behavior when its internal state changes.
• Strategy allows one of a family of algorithms to be selected on-the-fly at runtime.
• Template method defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior.
• Visitor separates an algorithm from an object structure by moving the hierarchy of methods into one object.

What is the Sequence of PLC event when the page has Master Page -->Page-->user Control-->Child user Control?

First

_________________________________________________________

1. PreInit
2. Init
3. InitComplete

Second

_________________________________________________________

1. PreLoad
2. Load
3. Controlevents
4. LoadComplete

Third

 __________________________________________________

1. Prerender
2. PrerenderComnplete
3. SavestateComplete
4. Render

Fourth

__________________________________________________

 UnLoad

A little bit about  Init:

Init Raised after all controls have been initialized and any skin settings have been applied. The Init event of individual controls occurs before the Init event of the page.(MSDN)

And  we can see the sequence of events of a page consisting of “master page àpageàuser controlàchild user controls” as below

---------------------------------------------------------------------------

1.PreInit – Page

     Init :ChildUserContr     

     Init : UserControl     

     Init : MasterPage

2.Init : Page

3.InitComplete :Page

------------------------------------------------------------------------------

LoadPageStateFromPersistenceMedium :Page 

ProcessPostData (1st Try) - Page

-----------------------------------------------------------------------------------------------------------------------------------------------

4.PreLoad – Page  

5.   Load :Page            Load: MasterPage     

       Load : UserControl        

       Load :ChildUserControl

       ProcessPostData  : Page        

       RaiseChangedEvents : Page        

       RaisePostBackEvent :Page

6.  Controlevents      

       DataBinding : Page       

       DataBinding : MasterPage       

       DataBinding :UserControl      

       DataBinding:ChildUserControl

7.LoadComplete : Page

----------------------------------------------------------------------------------------------------------------------

8. PreRender - Page    

     PreRender : MasterPage    

     PreRender : UserControl    

     PreRender : ChildUserControl

9.PreRenderComplete – Page      

---------------------------------------------------------------------------------------------------------------------------------------------------

SaveViewState : Page    

SavePageStateToPersistenceMedium: Page  

----------------------------------------------------------------------------------------------------------------------------------------------------

10.    SaveStateComplete :Page

      Unload - ChildUserControl    

      Unload - UserControl    

      Unload - MasterPage

11.Unload - Page