1.

Describe the Framework Class Library (FCL) and its

significance in .NET.
The Framework Class Library (FCL) is a core component of the .NET
Framework and provides the building blocks for .NET applications.
✅ Key Points:
1. Comprehensive Collection of Reusable Types
o FCL contains thousands of reusable classes, interfaces,
structures, and enumerations.
o These types are logically organized into namespaces like
System, [Link], [Link], etc.
2. Provides Core Functionality
o FCL supports essential operations such as file reading/writing,
database access ([Link]), collections, threading, networking,
XML processing, and GUI design (Windows Forms, WPF).
3. Standardized and Extensible
o Ensures consistency across applications, promoting
standardized development practices.
o Developers can also extend FCL by creating custom class
libraries.
4. Language Interoperability
o FCL is language-independent, so any .NET language like C#,
[Link], or F# can utilize the same class library, ensuring
maximum code reuse.
5. Tightly Integrated with CLR
o FCL works hand-in-hand with the Common Language Runtime
(CLR) to provide a robust and secure environment.
o CLR manages execution while FCL provides the functional API.

2. What is framework versioning? Discuss the significance of

versioning in .NET.
Framework versioning refers to the management of changes and updates
across different releases of the .NET Framework.
✅ Key Points:
 1. Definition and Purpose
o Framework versioning handles the evolution of the .NET
Framework while maintaining backward compatibility with
existing applications.
2. Types of Versioning in .NET
o Runtime Versioning: Ensures that applications target a
specific CLR version.
o Assembly Versioning: Controls updates and compatibility of
shared assemblies via strong names and version numbers.
o API Versioning: Manages changes to the public API of
libraries.
3. Side-by-Side Execution
o Allows multiple versions of the .NET Framework to coexist on
the same system.
o Prevents the “DLL Hell” problem where older applications break
due to incompatible newer libraries.
4. Backward Compatibility
o Microsoft designs updates to retain support for older
applications, ensuring minimal breakage during upgrades.
5. Granular Control with Binding Redirects
o Developers can configure [Link] or [Link] files with
binding redirects to specify which versions of assemblies to use.

3. Discuss the purpose of the Just-In-Time (JIT) compiler and its

role in .NET execution.
The JIT compiler translates Intermediate Language (IL) code into
native machine code at runtime.
✅ Key Points:
1. Core Role in Execution
o When a .NET application runs, the CLR invokes the JIT compiler
to convert IL to native code specific to the machine's
architecture.
2. Types of JIT Compilation
 o Pre-JIT ([Link]): Compiles entire code before execution.
o Econo-JIT: Compiles only required methods and removes them
when not needed (used in mobile scenarios).
o Normal JIT: Compiles methods on demand and stores
compiled code in memory.
3. Improved Performance
o JIT optimizes execution by compiling only the code that is
actually executed, reducing overhead.
4. Security and Verification
o Before JIT compilation, CLR performs verification of IL to ensure
it is type-safe and secure.
5. Platform-Specific Optimization
o Native code generated is optimized for the target CPU and OS,
enhancing performance and compatibility.

4. Utilize the Reflection API to retrieve metadata from a .NET

application. Write a sample C# code snippet to demonstrate.
Reflection in .NET allows inspection of assemblies, types, and members at
runtime.
✅ Key Points:
1. Purpose
o Reflection is used for examining metadata, accessing methods,
properties, and invoking members dynamically.
2. Assembly Inspection
o Developers can load an assembly and extract information such
as namespaces, classes, and methods.
3. Use Cases
o Plugin systems, object serialization, dependency injection, and
custom attribute inspection.
✅ Sample Code:
csharp
CopyEdit
using System;
using [Link];

class Demo
{
public void Display() => [Link]("Hello Reflection");
}

class Program
{
static void Main()
{
Type type = typeof(Demo);
[Link]("Class Name: " + [Link]);

MethodInfo[] methods = [Link]();

[Link]("Methods:");
foreach (MethodInfo method in methods)
{
[Link]([Link]);
}
}
}

5. Explain the key steps to develop a simple .NET console-based

application in Visual [Link].
✅ Key Steps:
1. Create a New Project
 o Open Visual Studio → Click “Create a new project” → Select
“Console App (.NET Core or .NET Framework)” → Name the
project.
2. Write the Application Logic
o The [Link] file contains the Main() method.
o Add your business logic within Main() or call other functions.
3. Build the Project
o Use Ctrl + Shift + B or go to Build → Build Solution to compile
the code and check for syntax errors.
4. Run the Application
o Press Ctrl + F5 to execute the application without debugging.
5. Debug and Test
o Use breakpoints, F10/F11, and watch windows to step through
code and verify the flow and outputs.
6. Demonstrate how assemblies are added and referred across
different projects during .NET application deployment.
Assemblies are essential building blocks in .NET, representing compiled
code libraries used by applications.
✅ Key Points:
1. Adding Assembly Reference in Visual Studio
o Right-click on the target project → Click Add > Project
Reference.
o Select the source project (which produces the assembly) from
the solution.
o This establishes a dependency between the two projects.
2. Types of Assemblies Used
o Private Assemblies: Stored in the same folder as the
application.
o Shared Assemblies: Installed in the Global Assembly Cache
(GAC) and shared across applications.
o Project-to-Project References: Common in large solutions.
3. Build and Deployment
 o During build, referenced assemblies are copied to the output
directory.
o When deploying, make sure all dependent DLLs are included
(for private) or installed in GAC (for shared).
4. Using NuGet Packages as Assemblies
o Assemblies can also be added via NuGet Package Manager,
which automatically resolves dependencies and versioning.
5. Managing Version Conflicts
o Binding redirects in [Link] or [Link] ensure the correct
version of an assembly is loaded at runtime.

7. Explain the architecture of the .NET Framework and describe

its layers.
The .NET Framework is a layered architecture designed to support
multiple languages, provide a runtime environment, and manage
application execution.
✅ Key Layers:
1. Common Language Runtime (CLR)
o The execution engine for .NET applications.
o Manages memory, security, garbage collection, exception
handling, and code execution.
2. Base Class Library (FCL/BCL)
o Provides built-in functionality like collections, file I/O, database
access, etc.
o Examples: [Link], [Link], [Link].
3. Application Models
o Frameworks built on top of the BCL for building applications:
 WinForms, WPF (Windows)
 [Link], Web API (Web)
 [Link] (Data access)
4. Languages and Compilers
o .NET supports multiple languages: C#, [Link], F#.
 o Compilers translate source code to IL (Intermediate Language).
5. Tools and Runtime Services
o Tools like MSBuild, Visual Studio IDE, and deployment services
help compile, debug, and run applications.

8. Explain the concepts of Common Type System (CTS) and

Common Language Specification (CLS) in the .NET Framework.
These are core concepts that support multi-language development
in .NET.
✅ Common Type System (CTS):
1. Definition:
o Defines a standard set of data types that all .NET languages
must use.
2. Type Safety:
o Ensures that types declared in one language can be understood
and used by other .NET languages.
3. Categories:
o Value Types (e.g., int, float) and Reference Types (e.g.,
string, objects).
4. Supports Inheritance and Polymorphism:
o CTS supports object-oriented features such as class hierarchies
and interfaces.
✅ Common Language Specification (CLS):
1. Definition:
o A subset of CTS that defines a set of rules for language
interoperability.
2. CLS Compliance:
o Ensures that code written in one language can be used by
another CLS-compliant language.
3. Example Rule:
o All member names must be case-insensitive to ensure
compatibility with languages like [Link].
9. Illustrate the role of CLR in the .NET application life cycle.
The Common Language Runtime (CLR) is the heart of the .NET
Framework that manages program execution.
✅ Key Roles:
1. Code Execution
o Converts IL to native code using the JIT compiler.
o Executes managed code under a controlled environment.
2. Memory Management
o Allocates and deallocates memory automatically using
Garbage Collection, eliminating memory leaks.
3. Security Enforcement
o Provides Code Access Security (CAS) and Role-based
Security (RBS).
o Ensures only trusted code is executed.
4. Exception Handling
o CLR standardizes exception handling across all .NET languages
using try-catch-finally.
5. Thread and Process Management
o Manages threads, concurrency, and synchronization for
scalable application execution.

10. Assess the debugging tools available in Visual [Link] for

debugging a .NET application.
Visual Studio offers advanced debugging capabilities to help developers
find and fix errors efficiently.
✅ Key Debugging Tools:
1. Breakpoints
o Used to pause code execution at specific lines to inspect
program state.
o Can be conditional, hit-count based, or location-based.
 2. Watch Windows & QuickWatch
o Lets you monitor variable values and expressions during
runtime.
o Helps inspect objects and collections in-depth.
3. Immediate and Output Windows
o Immediate Window: Evaluate expressions and execute code
during debugging.
o Output Window: Shows build, run-time, and debug messages.
4. Step Into (F11), Step Over (F10), Step Out (Shift + F11)
o Control code execution line by line, entering or skipping over
method calls.
5. Exception Settings and Diagnostic Tools
o Customize how exceptions are handled.
o View CPU usage, memory allocation, and I/O operations in real-
time using Diagnostic Tools.
11. Apply the concept of assemblies for deploying a .NET
application. Explain different types of assemblies.
An assembly is the compiled output of .NET code (EXE or DLL), and it is
the basic unit of deployment.
✅ Key Points:
1. Definition and Structure
o Contains IL code, metadata, and manifest.
o Can be executed or referenced by other assemblies.
2. Types of Assemblies:
o Private Assembly: Used by a single application, stored in the
application folder.
o Shared Assembly: Stored in the Global Assembly Cache (GAC)
and used by multiple apps.
o Satellite Assembly: Contains resources (e.g., localization
strings) for different cultures.
o Dynamic Assembly: Created at runtime using [Link].
 3. Deployment Methods
o XCOPY deployment (copy-paste).
o MSI installer.
o ClickOnce for simplified web deployment.
4. Strong Naming
o Shared assemblies require a strong name (includes name,
version, culture, public key token).
o Ensures version control and integrity.
5. Manifest Role
o Each assembly has a manifest containing metadata about the
version, culture, and referenced assemblies.

12. Demonstrate how to inspect metadata using the Reflection

API in a .NET application.
Reflection provides a powerful way to read metadata and dynamically
interact with code.
✅ Key Points:
1. Load Assembly
o Use [Link]() or [Link]() to
get the current assembly.
2. Inspect Types and Members
o Use GetTypes(), GetMethods(), GetProperties() to explore
structure.
3. Read Attributes
o Use GetCustomAttributes() to read data annotations or custom
metadata.
✅ Sample Code:
csharp
CopyEdit
using System;
using [Link];
class Person
{
public string Name { get; set; }
public void Greet() => [Link]("Hi from Greet!");
}

class Program
{
static void Main()
{
Assembly asm = [Link]();
Type[] types = [Link]();

foreach (Type t in types)

{
[Link]("Type: " + [Link]);
foreach (MethodInfo m in [Link]([Link] |
[Link] | [Link]))
{
[Link](" - Method: " + [Link]);
}
}
}
}