a) PRE JIT : It Compiles complete source code to native caode In a single Compilation.

b) ECONO JIT : It compiles only those methods that are called at Runtime.

c) NORMAL JIT : It compiles only those methods that are called at Runtime and are stored in cache.

A private constructor is a special instance constructor. It is commonly used in classes that contain static members only. If a class has one or more private constructors and no public constructors, then other classes (except nested classes) are not allowed to create instances of this class.

Multithreading also comes with disadvantages. The biggest is that it can lead to vastly more complex programs. Having multiple threads does not in itself create complexity; it's the interaction between the threads that creates complexity. This applies whether or not the interaction is intentional, and can result long development cycles, as well as an ongoing susceptibility to intermittent and non-reproducable bugs. For this reason, it pays to keep such interaction in a multi-threaded design simple – or not use multithreading at all – unless you have a peculiar penchant for re-writing and debugging!

Multithreading also comes with a resource and CPU cost in allocating and switching threads if used excessively. In particular, when heavy disk I/O is involved, it can be faster to have just one or two workers thread performing tasks in sequence, rather than having a multitude of threads each executing a task at the same time. Later we describe how to implement a Producer/Consumer queue, which provides just this functionality.

All threads within a single application are logically contained within a process – the operating system unit in which an application runs.

Threads have certain similarities to processes – for instance, processes are typically time-sliced with other processes running on the computer in much the same way as threads within a single C# application. The key difference is that processes are fully isolated from each other; threads share (heap) memory with other threads running in the same application. This is what makes threads useful: one thread can be fetching data in the background, while another thread is
displaying the data as it arrives.

Multithreading is managed internally by a thread scheduler, a function the CLR typically delegates to the operating system. A thread scheduler ensures all active threads are allocated appropriate execution time, and that threads that are waiting or blocked – for instance – on an exclusive lock, or on user input – do not consume CPU time.

On a single-processor computer, a thread scheduler performs time-slicing – rapidly switching execution between each of the active threads.

On a multi-processor computer, multithreading is implemented with a mixture of time-slicing and genuine concurrency – where different threads run code simultaneously on different CPUs. It's almost certain there will still be some time-slicing, because of the operating system's need to service its own threads – as well as those of other applications.

A thread is said to be preempted when its execution is interrupted due to an external factor such as time-slicing. In most situations, a thread has no control over when and where it's preempted.

In an interface class, all methods are abstract - there is no implementation. 

In an abstract class some methods can be concrete.  In an interface class, no accessibility modifiers are allowed. 

An abstract class may have accessibility modifiers. 
 

Yes.  .NET does support multiple interfaces. 

They all must be public, and are therefore public by default. 

Interfaces, like classes, define a set of properties, methods, and events. But unlike classes, interfaces do not provide implementation. They are implemented by classes, and defined as separate entities from classes. 

A class that cannot be instantiated.  An abstract class is a class that must be inherited and have the methods overridden.  An abstract class is essentially a blueprint for a class  with or without implementation. 

Yes.  Just leave the class public and make the method sealed.  

Yes.  The keyword “sealed” will prevent the class from being inherited. 

The data value may not be changed.  Note: The variable value may be changed, but the original immutable data value was discarded and a new data value was created in memory. 

System.String is immutable.  System.StringBuilder was designed with the purpose of having a mutable string where a variety of operations can be performed. 

It is available to classes that are within the same assembly and derived from the specified base class. 

Yes, but they are not accessible.  Although they are not visible or accessible via the class interface, they are inherited. 

No

The Clone() method returns a new array (a shallow copy) object containing all the elements in the original array.  The CopyTo() method copies the elements into another existing array.  Both perform a shallow copy.  A shallow copy means the contents (each array element) contains references to the same object as the elements in the original array.  A deep copy (which neither of these methods performs) would create a new instance of each element's object, resulting in a different, yet identacle object.

Channels represent the objects that transfer the other serialized objects from one application domain to another and from one computer to another, as well as one process to another on the same box. A channel must exist before an object can be transferred. 

A formatter is an object that is responsible for encoding and serializing data into messages on one end, and deserializing and decoding messages into data on the other end. 

It’s a fake copy of the server object that resides on the client side and behaves as if it was the server. It handles the communication between real server object and the client object. This process is also known as marshaling. 

Remoting is a more efficient communication exchange when you can control both ends of the application involved in the communication process.  Web Services provide an open-protocol-based exchange of informaion. 

Web Services are best when you need to communicate with an external organization or another (non-.NET) technology.

It’s an application that’s running and had been allocated memory.

A process is an instance of a running application. An application is an executable on the hard drive or network. There can be numerous processes launched of the same application (5 copies of Word running), but 1 process can run just 1 application. 

An assembly is the logical unit that contains compiled code targeted at the .NET Framework.

An assembly is completely self-describing, and is a logical rather than a physical unit, which means that it can be stored across more than one file (indeed dynamic assemblies are stored in memory, not on file at all). If an assembly is stored in more than one file, then there will be one main file that contains the entry point and describes the other files in the assembly.

Note that the same assembly structure is used for both executable code and library code. The only real difference is that an executable assembly contains a main program entry point, whereas a library assembly doesn’t.

Assemblies come in two types: shared and private assemblies.

Private Assembly :
------------------
Private assemblies are the simplest type. They normally ship with software and are intended to be used only with that software.

The system guarantees that private assemblies will not be used by other software, because an application may only load private assemblies that are located in the same folder that the main executable is loaded in, or in a subfolder of it.

Shared Assembly :
-----------------
Shared assemblies are intended to be common libraries that any other application can use. Because any other software can access a shared assembly, more precautions need to be taken against the following risks:

•  Name collisions, where another company’s shared assembly implements types that have the same names as those in your shared assembly. Because client code can theoretically have access to both assemblies simultaneously, this could be a serious problem.
  
• The risk of an assembly being overwritten by a different version of the same assembly—the new version being incompatible with some existing client code.

STA (Single Threaded Apartment) is basically the concept that only one thread will interact with your code at a time. Calls into your apartment are marshaled via windows messages (using a non-visible) window. This allows calls to be queued and wait for operations to complete.

MTA (Multi Threaded Apartment) is where many threads can all operate at the same time and the onus is on you as the developer to handle the thread security.

The .NET Framework uses role-based security and code-based security mechanisms for protecting resources and code from unauthorized use. Click each security mechanism to learn more:

Role Based Security
--------------------
A role-based security model uses authenticated identity information about the user to determine which computing resources the user is authorized to use. The authenticated identity information typically consists of the user’s logon and the roles that are associated with the user. Role-based security in the .NET Framework also allows developers to use Microsoft Windows® user and group information, or to perform custom authentication and authorization by using generic principals and identities.

A role defines a group of related users of an application. For example, a banking application may impose limits on the withdrawal amounts that can be transacted, based on role. In this scenario, tellers may be authorized to process withdrawals that are less than a specified amount, whereas managers may be allowed to process withdrawals above the amount specified. Role-based security in the .NET Framework extensively uses two concepts: identities and principals.

An identity encapsulates the user’s logon name.
A principal encapsulates the membership information of the user’s role.
The runtime provides functionality to perform authorization checks by using identity and principal-related objects directly, or by using imperative or declarative permission checks. .NET Framework role-based security supports authorization by making information about the user, which is constructed from an associated identity, available to the current thread. The identity can be based on a Windows account, or it can be a custom identity unrelated to a Windows account.

Code based Security
-------------------
Code access security is a mechanism provided by the CLR to examine and enforce permissions granted by security policy. To prevent unintended code paths from exposing a security vulnerability, all callers on the call stack must be granted the necessary permissions.

Every application that targets the CLR must interact with its security system. When an application runs, it is automatically evaluated and given a set of permissions by the CLR. Depending on the permissions that the application receives, it either runs properly or generates a security exception. The local security settings on a particular computer ultimately decide which permissions the code receives.

A shallow copy creates a new instance of the same type as the original object, and then copies the non-static fields of the original object. If the field is a value type, a bit-by-bit copy of the field is performed. If the field is a reference type, the reference is copied but the referred object is not; therefore, the reference in the original object and the reference in the clone point to the same object.

A deep copy of an object duplicates everything directly or indirectly referenced by the fields in the object

It define a set of feature that all .net compatible languages should support.