1. What is .NET Framework?

.NET Framework is a complete environment that allows developers to develop, run, and deploy the
following applications:

Console applications
Windows Forms applications

Windows Presentation Foundation (WPF) applications

Web applications (ASP.NET applications)

Web services

Windows services

Service-oriented applications using Windows Communication Foundation (WCF)

Workflow-enabled applications using Windows Workflow Foundation (WF)

.NET Framework also enables a developer to create sharable components to be used in distributed
computing architecture. NET Framework supports the object-oriented programming model for multiple
languages, such as Visual Basic, Visual C#, and Visual C++. .NET Framework supports multiple
programming languages in a manner that allows language interoperability. This implies that each
language can use the code written in some other language.
2. What are the main components of .NET Framework?
.NET Framework provides enormous advantages to software developers in comparison to the
advantages provided by other platforms. Microsoft has united various modern as well as existing
technologies of software development in .NET Framework. These technologies are used by developers
to develop highly efficient applications for modern as well as future business needs. The following are
the key components of .NET Framework:

.NET Framework Class Library

Common Language Runtime

Dynamic Language Runtimes (DLR)

Application Domains

Runtime Host

Common Type System

Metadata and Self-Describing Components

Cross-Language Interoperability

.NET Framework Security

Profiling

Side-by-Side Execution

3. List the new features added in .NET Framework 4.0.

The following are the new features of .NET Framework 4.0:

Improved Application Compatibility and Deployment Support

Dynamic Language Runtime

Managed Extensibility Framework

Parallel Programming framework

Improved Security Model

Networking Improvements

Improved Core ASP.NET Services

Improvements in WPF 4

Improved Entity Framework (EF)

Integration between WCF and WF

4. What is an IL?
Intermediate Language is also known as MSIL (Microsoft Intermediate Language) or CIL (Common
Intermediate Language). All .NET source code is compiled to IL. IL is then converted to machine code
at the point where the software is installed, or at run-time by a Just-In-Time (JIT) compiler.
5. What is Manifest?
Assembly metadata is stored in Manifest. Manifest contains all the metadata needed to do the
following things

Version of assembly.
Security identity.

Scope of the assembly.

Resolve references to resources and classes.

The assembly manifest can be stored in a PE file either (an .exe or) .dll with Microsoft
intermediate language (MSIL code with Microsoft intermediate language (MSIL) code or in a
stand-alone PE file, that contains only assembly manifest information.
6. What are code contracts?

Code contracts help you to express the code assumptions and statements stating the behavior of your
code in a language-neutral way. The contracts are included in the form of pre-conditions, postconditions and object-invariants. The contracts help you to improve-testing by enabling run-time
checking, static contract verification, and documentation generation.
The System.Diagnostics.Contracts namespace contains static classes that are used to express
contracts in your code.
7. Name the classes that are introduced in the System.Numerics namespace.
The following two new classes are introduced in the System.Numerics namespace:

BigInteger - Refers to a non-primitive integral type, which is used to hold a value of any
size. It has no lower and upper limit, making it possible for you to perform arithmetic
calculations with very large numbers, even with the numbers which cannot hold by double or
long.
Complex - Represents complex numbers and enables different arithmetic operations with
complex numbers. A number represented in the form a + bi, where a is the real part,
and b is the imaginary part, is a complex number.

8. What is managed extensibility framework?

Managed extensibility framework (MEF) is a new library that is introduced as a part of .NET 4.0 and
Silverlight 4. It helps in extending your application by providing greater reuse of applications and
components. MEF provides a way for host application to consume external extensions without any
configuration requirement.
9. Explain memory-mapped files.
Memory-mapped files (MMFs) allow you map the content of a file to the logical address of an
application. These files enable the multiple processes running on the same machine to share data with
each Other. TheMemoryMappedFile.CreateFromFile() method is used to obtain
a MemoryMappedFile object that represents a persisted memory-mapped file from a file on disk.
These files are included in the System.IO.MemoryMappedFiles namespace. This namespace
contains four classes and three enumerations to help you access and secure your file mappings.
10. What is Common Type System (CTS)?
CTS is the component of CLR through which .NET Framework provides support for multiple languages
because it contains a type system that is common across all the languages. Two CTS-compliant
languages do not require type conversion when calling the code written in one language from within
the code written in another language. CTS provide a base set of data types for all the languages
supported by.NET Framework. This means that the size of integer and long variables is same across all
.NET-compliant programming languages. However, each language uses aliases for the base data types
provided by CTS. For example, CTS uses the data type system. int32 to represent a 4 byte integer
value; however, Visual Basic uses the alias integer for the same; whereas, C# uses the alias int. This
is done for the sake of clarity and simplicity.

11. Give a brief introduction on side-by-side execution. Can two applications, one using
private assembly and the other using the shared assembly be stated as side-by-side
executables?
Side-by-side execution enables you to run multiple versions of an application or component and CLR
on the same computer at the same time. As versioning is applicable only to shared assemblies and not
to private assemblies, two applications, one using a private assembly and other using a shared
assembly, cannot be stated as side-by-side executables.
12. Which method do you use to enforce garbage collection in .NET?
The System.GC.Collect() method.
13. State the differences between the Dispose() and Finalize().
CLR uses the Dispose and Finalize methods to perform garbage collection of run-time objects of .NET
applications.
The Finalize method is called automatically by the runtime. CLR has a garbage collector (GC),
which periodically checks for objects in heap that are no longer referenced by any object or program.
It calls the Finalize method to free the memory used by such objects. The Dispose method is called
by the programmer.Dispose is another method to release the memory used by an object. The
Dispose method needs to be explicitly called in code to dereference an object from the heap.
The Dispose method can be invoked only by the classes that implement the IDisposable interface.
14. What is code access security (CAS)?
Code access security (CAS) is part of the .NET security model that prevents unauthorized access of
resources and operations, and restricts the code to perform particular tasks.
15. Differentiate between managed and unmanaged code?
Managed code is the code that is executed directly by the CLR instead of the operating system. The
code compiler first compiles the managed code to intermediate language (IL) code, also called as MSIL
code. This code doesn't depend on machine configurations and can be executed on different machines.
Unmanaged code is the code that is executed directly by the operating system outside the CLR
environment. It is directly compiled to native machine code which depends on the machine
configuration.
In the managed code, since the execution of the code is governed by CLR, the runtime provides
different services, such as garbage collection, type checking, exception handling, and security support.
These services help provide uniformity in platform and language-independent behavior of managed
code applications. In the unmanaged code, the allocation of memory, type safety, and security is
required to be taken care of by the developer. If the unmanaged code is not properly handled, it may
result in memory leak. Examples of unmanaged code are ActiveX components and Win32 APIs that
execute beyond the scope of native CLR.
16. What are tuples?

Tuple is a fixed-size collection that can have elements of either same or different data types. Similar to
arrays, a user must have to specify the size of a tuple at the time of declaration. Tuples are allowed to
hold up from 1 to 8 elements and if there are more than 8 elements, then the 8th element can be
defined as another tuple. Tuples can be specified as parameter or return type of a method.
17. How can you turn-on and turn-off CAS?
YOU can use the Code Access Security Tool (Caspol.exe) to turn security on and off.
To turn off security, type the following command at the command prompt:

caspol -security off

To turn on security, type the following command at the command prompt:

caspol -security on
In the .NET Framework 4.0, for using Caspol.exe, you first need to set
the <LegacyCasPolicy> element totrue.
18. What is garbage collection? Explain the difference between garbage collections in .NET
4.0 and earlier versions.
Garbage collection prevents memory leaks during execution of programs. Garbage collector is a lowpriority process that manages the allocation and deallocation of memory for your application. It checks
for the unreferenced variables and objects. If GC finds any object that is no longer used by the
application, it frees up the memory from that object.
GC has changed a bit with the introduction of .NET 4.0. In .NET 4.0, the GC.Collect() method
contains the following overloaded methods:

GC.Collect(int)
GC.Collect(int,GCCollectionMode)
Another new feature introduced in .NET is to notify you when the GC.Collect() method is invoked
and completed successfully by using different methods. The .NET 4.0 supports a new background
garbage collection that replaces the concurrent garbage collection used in earlier versions. This
concurrent GC allocates memory while running and uses current segment (which is 16 MB on a
workstation) for that. After that, all threads are suspended. In case of background GC, a separate
ephemeral GC - gen0 and gen1 can be started, while the full GC - gen0, 1, and 2 - is already running.

19. How does CAS works?

There are two key concepts of CAS security policy- code groups and permissions. A code group
contains assemblies in it in a manner that each .NET assembly is related to a particular code group
and some permissions are granted to each code group. For example, using the default security policy,
a control downloaded from a Web site belongs to the Zone, Internet code group, which adheres to the
permissions defined by the named permission set. (Normally, the named permission set represents a
very restrictive range of permissions.)

Assembly execution involves the following steps:

1.
2.

Evidences are gathered about assembly.

Depending on the gathered evidences, the assembly is assigned to a code group.

3.

Security rights are allocated to the assembly, depending on the code group.

4.

Assembly runs as per the rights assigned to it.

20. What is Difference between NameSpace and Assembly?

Following are the differences between namespace and assembly:

Assembly is physical grouping of logical units, Namespace, logically groups classes.

Namespace can span multiple assembly.

21. Mention the execution process for managed code.

A piece of managed code is executed as follows:

Choosing a language compiler

Compiling the code to MSIL

Compiling MSIL to native code

Executing the code.

22. Is there a way to suppress the finalize process inside the garbage collector forcibly in
.NET?
Use the GC.SuppressFinalize() method to suppress the finalize process inside the garbage
collector forcibly in .NET.
23. How can you instantiate a tuple?
The following are two ways to instantiate a tuple:

Using the new operator. For example,

Tuple<String,int>t=newTuple<String,int>("Hellow",2);

Using the Create factory method available in the Tuple class. For example,

Tuple<int,int,int>t=Tuple.Create<int,int,int>(2,4,5);
24. Which is the root namespace for fundamental types in .NET Framework?

System.Object is the root namespace for fundamental types in .NET Framework.

25. What are the improvements made in CAS in .NET 4.0?
The CAS mechanism in .NET is used to control and configure the ability of managed code. Earlier, as
this policy was applicable for only native applications, the security guarantee was limited. Therefore,
developers used to look for alternating solutions, such as operating system-level solutions. This
problem was solved in .NET Framework 4 by turning off the machine-wide security. The shared and
hosted Web applications can now run more securely. The security policy in .NET Framework 4 has
been simplified using the transparency model. This model allows you to run the Web applications
without concerning about the CAS policies.
As a result of security policy changes in .NET Framework 4.0, you may encounter compilation
warnings and runtime exceptions, if your try to use the obsolete CAS policy types and members either
implicitly or explicitly. However, you can avoid the warnings and errors by using
the <NetFx40_LegacySecurityPolicy>configuration element in the runtime settings schema to
opt into the obsolete CAS policy behavior.
26. What is Microsoft Intermediate Language (MSIL)?
The .NET Framework is shipped with compilers of all .NET programming languages to develop
programs. There are separate compilers for the Visual Basic, C#, and Visual C++ programming
languages in .NET Framework. Each .NET compiler produces an intermediate code after compiling the
source code. The intermediate code is common for all languages and is understandable only to .NET
environment. This intermediate code is known as MSIL.
27. What is lazy initialization?
Lazy initialization is a process by which an object is not initialized until it is first called in your code.
The .NET 4.0 introduces a new wrapper class, System.Lazy<T>, for executing the lazy initialization
in your application. Lazy initialization helps you to reduce the wastage of resources and memory
requirements to improve performance. It also supports thread-safety.
28. How many types of generations are there in a garbage collector?
Memory management in the CLR is divided into three generations that are build up by grouping
memory segments. Generations enhance the garbage collection performance. The following are the
three types of generations found in a garbage collector:

Generation 0 - When an object is initialized, it is said to be in generation 0.

Generation 1 - The objects that are under garbage collection process are considered to be in
generation 1.

Generation 2 - Whenever new objects are created and added to the memory, they are added
to generation 0 and the old objects in generation 1 are considered to be in generation 2.

29. Explain covariance and contra-variance in .NET Framework 4.0. Give an example for
each.

In .NET 4.0, the CLR supports covariance and contravariance of types in generic interfaces and
delegates. Covariance enables you to cast a generic type to its base types, that is, you can assign a
instance of typeIEnumerable<Tl> to a variable of type IEnumerable<T2> where, T1 derives
from T2. For example,

IEnumerable<string>str1=newList<string>();
IEnumerable<object>str2=str1;
Contravariance allows you to assign a variable of Action<base> to a variable of
type Action<derived>. For example,

IComparer<object>obj1=GetComparer()
IComparer<string>obj2=obj1;
.NET framework 4.0 uses some language keywords (out and in) to annotate covariance and contravariance. Out is used for covariance, while in is used for contra-variance.
Variance can be applied only to reference types, generic interfaces, and generic delegates. These
cannot be applied to value types and generic types.
30. How do you instantiate a complex number?
The following are the different ways to assign a value to a complex number:
By passing two Double values to its constructor. The first value represents the real, and the second
value represents imaginary part of a complex number.
For example,

Complexc1=newComplex(5,8);/*Itrepresents(5,8)*/
By assigning a Byte, SByte, Intl6, UIntl6, Int32, UInt32, Int64, UInt64, Single,
or Double value to aComplex object. The assigned value represents the real part of the complex
number, and its imaginary part becomes 0. For example,

Complexc2=15.3;/*Itrepresents(15.3,0)*/
By casting a Decimal or BigInteger value to a Complex object.
For example,

Complexc3=(Complex)14.7;/*Itrepresents(14.7,0)*/
Assigning the value returned by an operator to a Complex variable.
For example,

Complexc4=c1+c2;/*Itrepresents(20.3,8)*/

31. What is Common Language Specification (CLS)?

CLS is a set of basic rules, which must be followed by each .NET language to be a .NET- compliant
language. It enables interoperability between two .NET-compliant languages. CLS is a subset of CTS;
therefore, the languages supported by CLS can use each other's class libraries similar to their own.
Application programming interfaces (APIs), which are designed by following the rules defined in CLS
can be used by all .NET-compliant languages.
32. What is the role of the JIT compiler in .NET Framework?
The JIT compiler is an important element of CLR, which loads MSIL on target machines for execution.
The MSIL is stored in .NET assemblies after the developer has compiled the code written in any .NETcompliant programming language, such as Visual Basic and C#.
JIT compiler translates the MSIL code of an assembly and uses the CPU architecture of the target
machine to execute a .NET application. It also stores the resulting native code so that it is accessible
for subsequent calls. If a code executing on a target machine calls a non-native method, the JIT
compiler converts the MSIL of that method into native code. JIT compiler also enforces type-safety in
runtime environment of .NET Framework. It checks for the values that are passed to parameters of
any method.
For example, the JIT compiler detects any event, if a user tries to assign a 32-bit value to a parameter
that can only accept 8-bit value.
33. What is difference between System.String and System.StringBuilder classes?

String and StringBuilder classes are used to store string values but the difference in them is that
String is immutable (read only) by nature, because a value once assigned to a String object cannot be
changed after its creation. When the value in the String object is modified, a new object is created, in
memory, with a new value assigned to the String object. On the other hand,
the StringBuilder class is mutable, as it occupies the same space even if you change the value.
The StringBuilder class is more efficient where you have to perform a large amount of string
manipulation.
34. Describe the roles of CLR in .NET Framework.
CLR provides an environment to execute .NET applications on target machines. CLR is also a common
runtime environment for all .NET code irrespective of their programming language, as the compilers of
respective language in .NET Framework convert every source code into a common language known as
MSIL or IL (Intermediate Language).
CLR also provides various services to execute processes, such as memory management service and
security services. CLR performs various tasks to manage the execution process of .NET applications.
The responsibilities of CLR are listed as follows:

Automatic memory management

Garbage Collection

Code Access Security

Code verification

JIT compilation of .NET code

35. What is the difference between int and int32.

There is no difference between int and int32. System.Int32 is a .NET Class and int is an alias
name forSystem.Int32.
What is a IL or What is MSIL or CIL , What is JIT?
(IL)Intermediate Language is also known as MSIL (Microsoft Intermediate Language) or CIL
(Common Intermediate Language). All .NET source code is compiled to IL. This IL is then
converted to machine code at the point where the software is installed, or at run-time by a
Just-In- Time (JIT) compiler.
What is a CLR?
Full form of CLR is Common Language Runtime and it forms the heart of the .NET
framework. All Languages have runtime and its the responsibility of the runtime to take care
of the code execution of the program. For example VC++ has MSCRT40.DLL,VB6 has
MSVBVM60.DLL, Java has Java Virtual Machine etc. Similarly .NET has CLR. Following are the
responsibilities of CLR:1. Garbage Collection - CLR automatically manages memory thus eliminating memory leaks.
When objects are not referred GC automatically releases those memories thus providing
efficient memory management.
2. Code Access Security - CAS grants rights to program depending on the security
configuration of the machine. Example the program has rights to edit or create a new file but
the security configuration of machine does not allow the program to delete a file. CAS will
take care that the code runs under the environment of machines security configuration.
3. Code Verification - This ensures proper code execution and type safety while the code
runs. It prevents the source code to perform illegal operation such as accessing invalid
memory locations etc.
IL( Intermediate language )-to-native translators and optimizers - CLR uses JIT and compiles
the IL code to machine code and then executes. CLR also determines depending on platform
what is optimized way of running the IL code.
What is a CTS?
In order that two language communicate smoothly CLR has CTS (Common Type System).
Example in VB you have "Integer" and in C++ you have "long" these datatypes are not
compatible so the interfacing between them is very complicated. In order to able that two
different languages can communicate Microsoft introduced Common Type System. So
"Integer" datatype in VB6 and "int" datatype in C++ will convert it to System.int32 which is
datatype of CTS. CLS which is covered in the coming question is subset of CTS. Note: If you
have undergone COM programming period interfacing VB6 application with VC++ application
was a real pain as the datatype of both languages did not have a common ground where they
can come and interface, by having CTS interfacing is smooth.
What is a CLS(Common Language Specification)?
This is a subset of the CTS which all .NET languages are expected to support. It was always a
dream of Microsoft to unite all different languages in to one umbrella and CLS is one step
towards that. Microsoft has defined CLS which are nothing but guidelines that language to
follow so that it can communicate with other .NET languages in a seamless manner.
What is a Managed Code?
Managed code runs inside the environment of CLR i.e. .NET runtime. In short all IL are
managed code. But if you are using some third party software example VB6 or VC++
component they are unmanaged code as .NET runtime (CLR) does not have control over the
source code execution of the language.
What is a Assembly?
1. Assembly is unit of deployment like EXE or a DLL.
2. An assembly consists of one or more files (dlls, exes, html files etc.), and represents a
group of resources, type definitions, and implementations of those types. An assembly may
also contain references to other assemblies. These resources, types and references are
described in a block of data called a manifest. The manifest is part of the assembly, thus

making the assembly self-describing.

3. An assembly is completely self-describing.An assembly contains metadata information,
which is used by the CLR for everything from type checking and security to actually invoking
the components methods. As all information is in the assembly itself, it is independent of
registry. This is the basic advantage as compared to COM where the version was stored in
registry.
4. Multiple versions can be deployed side by side in different folders. These different
versions can execute at the same time without interfering with each other. Assemblies can be
private or shared. For private assembly deployment, the assembly is copied to the same
directory as the client program that references it. No registration is needed, and no fancy
installation program is required. When the component is removed, no registry cleanup is
needed, and no uninstall program is required. Just delete it from the hard drive.
5. In shared assembly deployment, an assembly is installed in the Global Assembly Cache (or
GAC). The GAC contains shared assemblies that are globally accessible to all .NET
applications on the machine.
What are the different types of Assembly?
There are two types of assembly Private and Public assembly. A private assembly is normally
used by a single application, and is stored in the application's directory, or a sub-directory
beneath. A shared assembly is normally stored in the global assembly cache, which is a
repository of assemblies maintained by the .NET runtime. Shared assemblies are usually
libraries of code which many applications will find useful, e.g. Crystal report classes which will
be used by all application for Reports.
What is NameSpace?
Namespace has two basic functionality :1. NameSpace Logically group types, example System.Web.UI logically groups our UI related
features.
2. In Object Oriented world many times its possible that programmers will use the same
class name.By qualifying NameSpace with classname this collision is able to be removed.
What is Difference between NameSpace and Assembly?
Following are the differences between namespace and assembly :1. Assembly is physical grouping of logical units. Namespace logically groups classes.
2. Namespace can span multiple assembly.
What is Manifest?
Assembly metadata is stored in Manifest. Manifest contains all the metadata needed to do
the following things:1. Version of assembly.
2. Security identity.
3. Scope of the assembly.
4. Resolve references to resources and classes.
5. The assembly manifest can be stored in either a PE file (an .exe or .dll) with Microsoft
intermediate language (MSIL) code or in a stand-alone PE file that contains only assembly
manifest information.
Where is version information stored of an assembly?
Version information is stored in assembly in manifest.
Is versioning applicable to private assemblies?
Versioning concept is only applicable to global assembly cache (GAC) as private assembly lie
in their individual folders.
What is GAC?
GAC (Global Assembly Cache) is used where shared .NET assembly reside. GAC is used in the
following situations :1. If the application has to be shared among several application.
2. If the assembly has some special security requirements like only administrators can
remove the assembly. If the assembly is private then a simple delete of assembly the
assembly file will remove the assembly.
What is the concept of strong names?
Strong name is similar to GUID(It is supposed to be unique in space and time) in COM
components.Strong Name is only needed when we need to deploy assembly in GAC. Strong
Names helps GAC to differentiate between two versions. Strong names use public key
cryptography (PKC) to ensure that no one can spoof it.PKC use public key and private key
concept.
How to add and remove an assembly from GAC?

There are two ways to install .NET assembly in GAC:1. Using Microsoft Installer Package. You can get download of installer
from http://www.microsoft.com.
2. Using Gacutil. Goto "Visual Studio Command Prompt" and type "gacutil i
(assembly_name)", where (assembly_name) is the DLL name of the project.
What is garbage collection?
Garbage collection is a CLR feature which automatically manages memory. Programmers
forget to release the objects while coding.(Remember in VB6 where one of the good practices
is to set object to nothing). CLR automatically releases objects when they are no longer in
use and refernced. CLR runs on non-deterministic to see the unused objects and cleans
them. One side effect of this non-deterministic feature is that we cannot assume an object is
destroyed when it goes out of the scope of a function. Therefore, we should not put code into
a class destructor to release resources.
Can we force garbage collector to run?
System.GC.Collect() forces garbage collector to run. This is not recommended but can be
used if situations arises.
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.
What are Value types and Reference types?
Value types directly contain their data which are either allocated on the stack or allocated inline in a structure. Reference types store a reference to the value's memory address, and are
allocated on the heap. Reference types can be self-describing types, pointer types, or
interface types. Variables that are value types each have their own copy of the data, and
therefore operations on one variable do not affect other variables. Variables that are
reference types can refer to the same object; therefore, operations on one variable can affect
the same object referred to by another variable. All types derive from the System.Object
base type.
What is concept of Boxing and Unboxing?
Boxing permits any value type to be implicitly converted to type object or to any interface
type implemented by value type. Boxing is a process in which object instances are created
and copy values in to that instance. Unboxing is vice versa of boxing operation where the
value is copied from the instance in to appropriate storage location. Below is sample code of
boxing and unboxing where integer data type is converted in to object and then vice versa.
Dim x As Integer
Dim y As Object
x =10
y = x boxing process
x = y unboxing process
What is the difference between VB.NET and C#?
Well this is the most debatable issue in .NET community and people treat there languages
like religion. Its a subjective matter which language is best. Some like VB.NETs natural style
and some like professional and terse C# syntaxes. Both use the same framework and speed
is also very much equivalents. But still lets list down some major differences between
them :- Advantages VB.NET :1. Has support for optional parameters which makes COM interoperability much easy.
2. With Option Strict off late binding is supported.Legacy VB functionalities can be used by
using Microsoft.VisualBasic namespace.
3. Has the WITH construct which is not in C#.
4. The VB.NET part of Visual Studio .NET compiles your code in the background. While this is
considered an advantage for small projects, people creating very large projects have found
that the IDE slows down considerably as the project gets larger.
Advantages of C#
1. XML documentation is generated from source code but this is now been incorporated in
Whidbey.
2. Operator overloading which is not in current VB.NET.
3. Use of this statement makes unmanaged resource disposal simple.
4. Access to Unsafe code. This allows pointer arithmetic etc, and can improve performance in
some situations. However, it is not to be used lightly, as a lot of the normal safety of C# is
lost (as the name implies).This is the major difference that you can access unmanaged code

in C# and not in VB.NET.

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..
How to prevent my .NET DLL to be decompiled?
By design .NET embeds rich Meta data inside the executable code using MSIL. Any one can
easily decompile your DLL back using tools like ILDASM (owned by Microsoft) or Reflector
for .NET which is a third party. Secondly there are many third party tools which make this
decompiling process a click away. So any one can easily look in to your assemblies and
reverse engineer them back in to actual source code and understand some real good logic
which can make it easy to crack your application. The process by which you can stop this
reverse engineering is using "obfuscation". Its a technique which will foil the decompilers.
There are many third parties (XenoCode, Demeanor for .NET) which provide .NET obfuscation
solution. Microsoft includes one that is Dotfuscator Community Edition with Visual
Studio.NET.
What is the difference between Convert.toString and .toString() method?
Just to give an understanding of what the above question means seethe below code.
int i =0;
MessageBox.Show(i.ToString());
MessageBox.Show(Convert.ToString(i));
We can convert the integer "i" using "i.ToString()" or "Convert.ToString" so whats the
difference. The basic difference between them is "Convert" function handles NULLS while
"i.ToString()" does not it will throw a NULL reference exception error. So as good coding
practice using "convert" is always safe.
What is Native Image Generator (Ngen.exe)?
The Native Image Generator utility (Ngen.exe) allows you to run the JIT compiler on your
assembly's MSIL and generate native machine code which is cached to disk. After the image
is created .NET runtime will use the image to run the code rather than from the hard disk.
Running Ngen.exe on an assembly potentially allows the assembly to load and execute faster,
because it restores code and data structures from the native image cache rather than
generating them dynamically. Below are some points to be remembered for Native Image
Generator:1. Native images load faster than MSIL because JIT compilation and type-safety verification
is eliminated.
2. If you are sharing code between process Ngen.exe improves the performance significantly.
As Native image generated Windows PE file so a single DLL file can be shared across
applications. By contrast JIT produced code are private to an assembly and can not be
shared.
3. Native images enable code sharing between processes.
4. Native images require more storage space and more time to generate.
5. Startup time performance improves lot. We can get considerable gains when applications
share component assemblies because after the first application has been started the shared
components are already loaded for subsequent applications. If assemblies in an application
must be loaded from the hard disk, does not benefit as much from native images because
the hard disk access time shadows everything.
1. Assemblies in GAC do not benefit from Native image generator as the loader performs
extra validation on the strong named assemblies thus shadowing the benefits of Native
Image Generator.
2. If any of the assemblies change then Native image should also be updated.
3. You should have administrative privilege for running Ngen.exe.
4. While this can fasten your application startup times as the code is statically compiled but it
can be somewhat slower than the code generated dynamically by the JIT compiler. So you
need to compare how the whole application performance with Ngen.exe and with out it. To
run Ngen.exe, use the following command line.
ngen.exe install <assemblyname>
This will synchronously precompile the specified assembly and all of its dependencies. The
generated native images are stored in the native image cache. In .NET Framework 2.0 there
is a service (.NET Runtime Optimization Service) which can precompile managed assemblies
in the background. You can schedule your assemblies to be precompiled asynchronously by

queueing them up with the NGEN Service. Use the following command line.
ngen.exe install <assemblyname> /queue:<priority>
Assemblies which are critical to your application's start up time should either be precompiled
synchronously or asynchronously with priority 1. Priority 1 and 2 assemblies are precompiled
aggressively while Priority 3 assemblies are only precompiled during machine idle-time.
Synchronously precompiling your critical assemblies guarantees that the native images will
be available prior to the first time your end user launches the application but increases the
time taken to run your application's set up program. You can uninstall an assembly and its
dependencies (if no other assemblies are dependent on them) from the native image cache
by running the following command. ngen.exe uninstall <assemblyname>. Native images
created using Ngen.exe cannot be deployed; instead they need to be created on the end
user's machine. These commands therefore need to be issued as part of the application's
setup program. Visual Studio .NET can be used to implement this behavior by defining
custom actions in a Microsoft Installer (MSI) package.
What is .NET Framework?
The .NET Framework is such a comprehensive platform that it can be used to develop
websites, webapplications, web services and much more.
What is portable executable (PE)?
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.
Which is the base class for .net Class library?
System.object.
What is Application Domain?
Application domains provide a unit of isolation for the common language runtime. They are
created and run inside a process. Application domains are usually created by a runtime host,
which is an application responsible for loading the runtime into a process and executing user
code within an application domain. The runtime host creates a process and a default
application domain, and runs managed code inside it. Runtime hosts include ASP.NET,
Microsoft Internet Explorer, and the Windows shell.
What is serialization in .NET?
Serialization can be defined as the process of storing the state of an object to a storage
medium. During this process, the public and private fields of the object and the name of the
class, including the assembly containing the class, are converted to a stream of bytes, which
is then written to a data stream. When the object is subsequently deserialized, an exact
clone of the original object is created.
1. Binary serialization preserves type fidelity, which is useful for preserving the state of an
object between different invocations of an application. For example, you can share an object
between different applications by serializing it to the clipboard. You can serialize an object to
a stream, disk, memory, over the network, and so forth. Remoting uses serialization to pass
objects "by value" from one computer or application domain to another.
2. XML serialization serializes only public properties and fields and does not preserve type
fidelity. This is useful when you want to provide or consume data without restricting the
application that uses the data. Because XML is an open standard, it is an attractive choice for
sharing data across the Web. SOAP is an open standard, which makes it an attractive choice.
What is an Assembly?
Assemblies are the building blocks of .NET Framework applications; they form the
fundamental unit of deployment, version control, reuse, activation scoping, and security
permissions. An assembly is a collection of types and resources that are built to work
together and form a logical unit of functionality. An assembly provides the common language
runtime withthe information it needs to be aware of type implementations. To the runtime, a
type does not exist outside the context of an assembly. Assemblies are a fundamental part of
programming withthe .NET Framework. An assembly performs the following functions:1. It contains code that the common language runtime executes. Microsoft intermediate
language (MSIL) code in a portable executable (PE) file will not be executed if it does not
have an associated assembly manifest. Note that each assembly can have only one entry
point (that is,DllMain,WinMain, orMain).
2. It forms a security boundary. An assembly is the unit at which permissions are requested

and granted.
3. It forms a type boundary. Every types identity includes the name of the assembly in which
it resides. A type called MyType loaded in the scope of one assembly is not the same as a
type called MyType loaded in the scope of another assembly.
4. It forms areference scope boundary. The assemblys manifest contains assembly metadata
that is used for resolving types and satisfying resource requests. It specifies the types and
resources that are exposed outside the assembly. The manifest also enumerates other
assemblies on which it depends.
5. It forms aversion boundary. The assembly is the smallest versionable unit in the common
language runtime; all types and resources in the same assembly are versioned as a unit. The
assemblys manifest describes the version dependencies you specify for any dependent
assemblies.
6. It forms a deployment unit. When an application starts, only the assemblies that the
application initially calls must be present. Other assemblies, such as localization resources or
assemblies containing utility classes, can be retrieved on demand. This allows applications to
be kept simple and thin when first downloaded.
7. It is the unit at which side-by-side execution is supported. Assemblies can be static or
dynamic. Static assemblies can include .NET Framework types (interfaces and classes), as
well as resources for the assembly (bitmaps, JPEG files, resource files, and so on). Static
assemblies are stored on disk in PE files. You can also use the .NET Framework to create
dynamic assemblies, which are run directly from memory and are not saved to disk before
execution. You can save dynamic assemblies to disk after they have executed. There are
several ways to create assemblies. You can use development tools, such as Visual Studio
.NET, that you have used in the past to create .dll or .exe files. You can use tools provided in
the .NET Framework SDK to create assemblies withmodules created in other development
environments. You can also use common language runtime APIs, such as Reflection.Emit, to
create dynamic assemblies.
What are Satellite Assemblies?
Satellite assemblies are often used to deploy language-specific resources for an application.
These language-specific assemblies work in side-by-side execution because the application
has a separate product ID for each language and installs satellite assemblies in a languagespecific subdirectory for each language. When uninstalling, the application removes only the
satellite assemblies associated witha given language and .NET Framework version. No
core .NET Framework files are removed unless the last language for that .NET Framework
version is being removed.
What is Assembly manifest?
Every assembly, whether static or dynamic, contains a collection of data that describes how
the elements in the assembly relate to each other. The assembly manifest contains this
assembly metadata. An assembly manifest contains all the metadata needed to specify the
assemblys version requirements and security identity, and all metadata needed to define the
scope of the assembly and resolve references to resources and classes. The assembly
manifest can be stored in either a PE file (an .exe or .dll) withMicrosoft intermediate
language (MSIL) code or in a standalone PE file that contains only assembly manifest
information. It contains Assembly name, Version number, Culture, Strong name information,
List of all files in the assembly, Type reference information, Information on referenced
assemblies.
What are the contents of assembly?
In general, a static assembly can consist of four elements:1. The assembly manifest, which contains assembly metadata.
2. Type metadata.
3. Microsoft intermediate language (MSIL) code that implements the types.
4. A set of resources.
Difference between assembly manifest & metadata assembly manifest?
An integral part of every assembly that renders the assembly self-describing. The assembly
manifest contains the assemblys metadata. The manifest establishes the assembly identity,
specifies the files that make up the assembly implementation, specifies the types and
resources that make up the assembly, itemizes the compile-time dependencies on other
assemblies, and specifies the set of permissions required for the assembly to run properly.
This information is used at run time to resolve references, enforce version binding policy, and
validate the integrity of loaded assemblies. The self-describing nature of assemblies also
helps makes zero-impact install and XCOPY deployment feasible. metadata -Information that

describes every element managed by the common language runtime: an assembly, loadable
file, type, method, and so on. This can include information required for debugging and
garbage collection, as well as security attributes, marshaling data, extended class and
member definitions, version binding, and other information required by the runtime.
What is Global Assembly Cache (GAC) and what is the significance of it?
Each computer where the common language runtime is installed has a machine-wide code
cache called the global assembly cache. The global assembly cache 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.
What is the difference between Readonly and Constant?
Aconstfield can only be initialized at the declaration of the field. Areadonlyfield can be
initialized either at the declaration or in a constructor. Therefore,readonlyfields can have
different values depending on the constructor used. Also, while aconstfield is a compile-time
constant, thereadonlyfield can be used for runtime constants, as in the following example:
public static readonly uint l1 = (uint) DateTime.Now.Ticks;
What is the managed and unmanaged code in .net?
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 runtimes functionality and
enable you to write code that benefits from this managed execution environment. Code that
you develop witha language compiler that targets the runtime is calledmanaged code;
itbenefits from features such as cross-language integration, cross-language exception
handling, enhanced security, versioning and deployment support, a simplified model for
component interaction, and debugging and profiling services.
PAGE NO. 1 2
How to implement cloning in .NET ? What is shallow copy and deep copy ?
Cloning is achieved by using ICloneable of the System namespace. It has a "Clone" method
which actually returns the reference of the same copy. Clone method allows a Shallow copy
and not a deep copy. In Shallow copy if you make changes to the cloned object it actually
changes on the main object itself. So how is deep copy achieved, by using "ISerializable"
interface? So what you do is first serialize the object then deserialize back to a complete new
copy. Now any changes to this new copy do not reflect on the original copy of the object, this
is called as Deep copy.
How can I write IL programs directly?
Assembly MyAssembly {}
.class MyApp {
.method static void Main() {
.entrypoint
ldstr "Hello, IL!"
call void System.Console::WriteLine(class System.Object)
ret
}
}.
Which name space is the base class for .net Class library?
language should comply with the Common Language Runtime standard to become a.NET
language. In .NET, code is compiled to Microsoft Intermediate Language (MSIL for short).
This is called as Managed Code. This Managed code is run in .NET environment. So after
compilation to this IL the language is not a barrier. A code can call or use a function written
in another language.

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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
What is an assembly?

An assembly is a collection of one or more .exe or dlls. 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.
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.
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.
What is a dynamic assembly?
A dynamic assembly is created dynamically at run time when an application requires the
types within these assemblies.
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.
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
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.
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.
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.
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.
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.
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.

Dotnet Assembly interview questions and answers

Define .Net Assembly.

What does an assembly contain?
Define a private assembly and a shared assembly.

What are Satellite Assemblies?

What do you understand by side-by-site execution of assembly?
How do you create a resource-only assembly?
Explain how to retrieve resources using ResourceManager class.
Define Strong Name. How do you apply a strong name to assembly?
How do you install assembly to the Global Assembly Cache?
What is AL.EXE and RESGEN.EXE?
Explain the concepts and capabilities of Assembly in .NET
What is Manifest in .NET?
What is GAC in .NET?
.Net Framework
This includes introduction of .Net framework, .Net framework architecture, role of assembly and GAC.

1) What are the advantages of .Net?

1) Good Design
2) Object-Oriented Programming Using C# and .NET which are based on object-oriented
Concepts.
3) Language Independence All the languages which are supported by .Net ( VB.NET, C#,
J#, and managed C++ ) are compiled in to common Intermediate Language (IL) . So IL make
sure that languages are interoperable.
4) Efficient Data Access ADO.NET provide fast and efficient way to access RDBMS, file
system etc
5) Code Sharing .To share code between applications, a new concept called assembly is
introduced. Assemblies supports versioning.
6) Improved Security
7) Support Dynamic Web Pages Using ASP.NET.

8) Support for Web Services

2) What is .Net Framework ?

The .NET framework is a programming framework from Microsoft. Developers can use .Net
Framework to develop applications,install and run the application on Windows operating
systems.

3) What is MS-IL (Microsoft Intermediate Language) ?

When a program is complied in .Net , the source code will be converted into an intermediate
language called Microsoft Intermediate Language (MS-IL) . This is done by Just-In time
Compiler (JIT). .Net framework is built in such a way that , Code is Just-In time complied,
that is it get complied when it is called rather compiling entire code at the start up. A portion
of the code will get complied only once and it will exists till the application exit. This will have
a significant improvement in performance since entire section of the code wont get executed
in most cases.

4) What is Common Language Runtime (CLR) ?

Common Language Runtime or CLR is the run-time execution environment of .Net
Framework. Converting MS-IL into platform or OS specific code is done by CLR. Currently
.Net programs will run only in windows.

5) What is Common Type System (CTS) ?

.Net uses Common Type System (CTS) for Language Interoperability. CTS defines the
predefined data types that are available in IL, so that all languages that target the .NET
framework will produce compiled code that is ultimately based on these types. So that a data
type defined in a VB.net will be understood by C#. For example, VB.Net uses Integer to
define data type Integer. C# uses int to define data type Integer. When VB.Net code is
complied , it will convert Integer to Int32 and since C# refers Int to Int32 VB.Net code will be
understood by C#.

6) What is Common Language Specification (CLS) ?

Common Language Specification (CLS) is also used for Language Interoperability in tandem
with CTS to ensure Language Interoperability. CLS defines a set of minimum standards that
all compilers targeting .NET must support. For example VB.Net is not case sensitive. So
attribute EmployeeName and employeename is considered same. But C# is case

sensitive. So for language interoperability , C# doesn't allow two variable which differs only in
Case.

7) What is Garbage Collector ?

Garbage Collector is used in .Net Framework for memory management. While running an
application, application request for memory for its internal use. Framework allocates memory
from the heap. Once the process is completed , allocated need to be reclaimed for future
use. The process of reclaiming unused memory is taken care by Garbage Collector.

8) How to invoke garbage collector programmatically ?

To call garbage collector programmatically, use code GC.Collect();
9) What is a Managed Code ?
Managed code is code that cane be executed and managed by .NET Framework Common
Language Runtime. All code based on Intermediate language executes as managed code.

10) What is an Assembly ?

Assemblies are self-describing logical unit, consisting of one or more files targeted at .Net. An
assembly can be stored across single file such as a single DLL or EXE that includes meta data, or it
can be stored in multiple files, for example, resource files, meta data, DLL's, and an EXE.
Assemblies support versioning.

11) What is Assembly Manifest ?

Part of assembly which contains assembly meta data that describes the assembly itself is known as
manifest. Assembly manifest contain Assembly Name ,Version Number,Culture, Strong name, List
of files inside the assembly and Reference information

12) What are different types of Assembly ?

The two types of Assemblies are Shared and Private.

13) What is Private Assembly ?

Private Assemblies are intended to be used by the program for which its made for. This is because
application will only load private assemblies that are located in the same folder or in a sub folder that
the main executable is loaded.

14) What is Shared Assembly ?

Shared Assemblies contain Common Libraries which are intended to be used by multiple
applications. While making shared assemblies, Name Collisions and Overwriting existing Assemblies
need to be taken care. Name Collisions can be taken care by strong name. And global assembly
cache can be used to avoid assembly overwriting.

15) How to view a Assembly information ?

By using Ildasm.exe which is an MSIL Disassembler one can view attributes, references to other
modules and assemblies

16) Where is the assembly version information stored ?

In the Manifest.
17) What is NameSpace ?
Namespace is a logical grouping of related classes and types. Every class should have a
NameSpace.
18) What is the Difference between NameSpace and Assembly ?
Namespace:
1) Form the logical boundary for a Group of classes.
2) It is a Collection of names wherein each name is Unique.
3) Namespace must be specified in Project-Properties.
Assembly:
1) Assemblies are Self-Describing
2) It is an Output Unit. It is a unit of Deployment & a unit of versioning. Assemblies contain MSIL
code.

19) What is Global Assembly Cache (GAC) ?

While using shared assemblies, to avoid Assembly being overwritten by a different version of the
same assembly , shared assemblies are placed in a special directory subtree in the file system,
known as the global assembly cache (GAC). Placing shared assemblies can be done by special .Net
Utilities Only.

20) What is concept of strong names ?

While using shared assemblies, in order to avoid name collisions strong names are used. Strong
Names are based on private key cryptography , ie private assemblies are simply given the same
name as their main file name.

21) How to add and remove a assembly from GAC?

To install assembly in Cache use Gacutil. Goto "Visual Studio Command Prompt" and type "gacutil
-i
<assembly_name>", where (assembly_name) is the DLL name of the project. To uninstall assembly,
type gacutil u <assembly name> in Visual Studio Command Prompt.

22) What is Reflection?

Reflection is used to dynamically load a class , create object and invoke methods at runtime. It can
also be used read its own meta data to find assemblies, modules and type information at runtime.

23) What is Delay signing ?

To create a strong named assembly and want this assembly to be used by someone else, we
partially build this assembly by provide a Public Key. We write this Public Key in the AssemblyInfo.vb
OR .cs file. We also add an attribute by the named <Assembly:AssemblyDelaySignAttribute(true)> to
the assembly info file. This makes it sure that when we build the assembly, It would be containing the
information only about the public key before we deliver it to our client. This is a partial strong named
assembly that we have created, and hence it is called Delayed Assembly.

24) What are different type of JIT ?

Different Types of JIT are
1) Pre-JIT - Complies complete source code into native code at the time of deployment
2) Econo-JIT - Complies methods that are called at runtime.

3) Normal-JIT - Complies methods that are called at runtime and get stored in cache. Next time
when the same method is called, it will be taken from cache.
25) What are Value types and Reference types ?
There are two types of data types in .Net, Value types and Reference types.Value types are stored
in stack part of the memory. Reference type are stored in managed heap. Let have a look at the
example for better understanding.
Int iCount = 0; \\ Value Type
int NewiCount = iCount; \\ Reference Type

26) What is concept of Boxing and Unboxing ?

Converting a value type to reference type is called Boxing. Converting a reference type to value type
is called Unboxing.

27) Whats difference between System exceptions and Application exceptions?

System exceptions are common exceptions thrown by the CLR of .Net Framework. Application
exceptions can be user defined exceptions thrown by the application.

28) What is CODE Access security?

CODE Access security is a security model that lets us grant or deny execution permissions to an
assembly according to its "properties," called evidence, such as its strong name or publisher

29) What is a satellite assembly?

A satellite assembly are used when multilingual (UI) application are created. Satellite assembly is a
compiled library that contains localized resources which provides us with the capability of designing
and deploying solutions to multiple cultures, rather than hard coding texts, bitmaps etc
30) How to prevent my .NET DLL to be decompiled ?
We can prevent .NET DLL to be decompiled up to an extent by Obfuscate Source code, asymmetric
encryption and encrypted w32 wrapper application.

31) What is Native Image Generator (Ngen.exe) ?

Ngen.exe creates compiled processor-specific machine code called native images, which are files
and installs them into the native image cache on the local computer. The runtime will use native
images from the cache rather than using the JIT compiler to compile the original assembly.

32) What is Code Document Object Model (CodeDom) ?

Code Document Object Model are code generators which are used to minimize repetitive coding
tasks, and to minimize the number of human-generated source code lines.