.NET is a software development framework created by Microsoft to build and run applications on Windows, macOS, and Linux. It provides a unified environment for developing a wide range of applications, including desktop software, web applications, mobile apps, and cloud-based services. .NET enables developers to write code in multiple programming languages like C#, F#, and Visual Basic, and then run that code on different platforms.
.NET consists of several key components that make it a powerful and flexible framework for developers:
Common Language Runtime (CLR):
The CLR is the heart of the .NET framework. It’s responsible for managing the execution of code, including things like memory management, garbage collection (automatic cleanup of unused memory), and exception handling. It provides services that ensure the execution of applications is efficient and secure.
.NET Class Library:
The .NET Class Library is a collection of reusable code that provides a vast set of functionalities for developers. It includes APIs (Application Programming Interfaces) that simplify tasks such as file I/O, database access, networking, security, and more. Essentially, it’s a huge toolbox of pre-built components that developers can use to speed up development.
ASP.NET:
ASP.NET is a web development framework built on top of .NET. It allows developers to create dynamic web applications, websites, and web APIs. ASP.NET provides a set of tools and libraries that make it easy to build scalable and secure web-based solutions.
Entity Framework (EF):
Entity Framework is an Object-Relational Mapping (ORM) framework for data access. It allows developers to interact with databases using object-oriented programming instead of writing raw SQL queries. EF makes database operations like querying and updating data simpler and more intuitive.
Windows Forms and WPF (Windows Presentation Foundation):
These are frameworks for building desktop applications on Windows. Windows Forms is the older technology, while WPF offers more advanced features for creating rich, visually appealing user interfaces.
Xamarin:
Xamarin is a cross-platform mobile development framework that allows developers to create mobile applications for iOS, Android, and Windows using C#. It’s built on top of .NET and allows developers to write shared code for different mobile platforms.
.NET Core and .NET 5+:
.NET Core is an open-source, cross-platform version of .NET that runs on Windows, macOS, and Linux. In 2020, Microsoft introduced .NET 5 as the successor to .NET Core, combining the best features of .NET Framework and .NET Core into one unified platform. As of 2021, .NET 6 and beyond are the latest versions, continuing to improve cross-platform support and performance.
The architecture of .NET is designed to provide a modular and flexible environment for building applications. Here are the key layers in .NET architecture:
Application Layer:
This is where developers write their application code. The application layer is built using languages like C#, F#, and Visual Basic. It contains the business logic, data access logic, and other components that make up the application.
Base Class Library (BCL):
The BCL is a core part of the .NET framework that provides basic building blocks for developing applications, such as classes for handling input/output, networking, collections, threading, etc. It is included as part of the runtime and is tightly integrated with the CLR.
Common Language Runtime (CLR):
The CLR is responsible for executing the code. It manages things like memory, threading, garbage collection, and security. It provides a common execution environment for code written in different languages within the .NET framework.
Intermediate Language (IL):
When you compile a .NET program, the source code is first compiled into Intermediate Language (IL) code. This IL code is platform-independent and is stored in assemblies (DLLs or EXE files). When the program runs, the CLR's Just-In-Time (JIT) compiler translates the IL into machine code that can be executed on the host machine.
Assemblies:
Assemblies are the output of compiling .NET code, and they contain the compiled Intermediate Language (IL) code, metadata, and resources (like images or strings). Assemblies are the building blocks of .NET applications, and they are what the CLR loads and executes.
Garbage Collector (GC):
The .NET garbage collector automatically manages memory by reclaiming unused objects. It tracks which objects are no longer in use and frees up memory without needing the developer to manually deallocate memory. This helps avoid memory leaks and simplifies memory management for developers.
Common Type System (CTS):
The CTS defines how types are declared, used, and managed in .NET, ensuring that code written in different languages can work together seamlessly. It standardizes types like integers, strings, and arrays, making them compatible across different languages.
Common Language Specification (CLS):
The CLS defines a set of rules and guidelines for writing .NET code that can be shared across different languages. It ensures that types and components developed in different languages, such as C# and Visual Basic, can be used together without issues.
.NET is a powerful framework that enables developers to build a wide range of applications across different platforms, including web, desktop, and mobile. It provides a common runtime environment (CLR), a vast library of pre-built functions, and tools for developing scalable, secure, and efficient software. With its cross-platform capabilities (especially with .NET Core and .NET 5+), .NET continues to evolve and play a central role in modern enterprise application development.
Open this section to load past papers