The history of the .NET ecosystem goes back many years (about 25 years as of the date of this article). Considering the last 25 years, many additions have been made to the .NET ecosystem to implement/pioneer the development of areas such as desktop, web, mobile, games, cloud, IoT, AI and the technological developments required by these. As such, whether you are in the .NET ecosystem or not, there may be confusion about various frameworks and naming. In the timeline below, you can see these developments chronologically and distinctively as they are marked with different tags.
The content of the graph is taken from TimeGraphs
. It may not be viewable because it is added and maintained by third party sources.
In the heyday of Windows application development, the .NET Framework emerged as a game-changer, simplifying the development process. However, as time progressed, developers encountered limitations, leading to a cascade of patches and workarounds. The .NET Framework's tightly integrated nature with Windows posed challenges for cross-platform compatibility, and its monolithic structure hindered the adoption of more modular architectures. Additionally, the framework struggled to adapt to the evolving internet landscape. Recognizing these issues, the .NET ecosystem underwent a transformative journey, giving birth to .NET Core(Unified ".NET" anymore).
In this article, I will try to explain the evolution of .NET as much as possible. When you read this article, you will see that you can find answers to the following questions and if you have any confusion about them, they will be cleared:
- How has the evolution of .NET progressed?
- What are
.NET Framework
,.NET Core
,.NET Standard
? - What are the purposes of emergence?
- What are their differences from each other?
- When to use which one?
In order not to make the article boring and to make it easy to skim through in a short time, I will give the main idea in the article and give the details in the collapsible panels. If you want to get more detailed information, do not forget to examine the collapsible panels π
The Birth of .NET Frameworkβ
The story begins in the early 2000s when Microsoft introduced the .NET Framework. This revolutionary platform aimed to simplify software development by providing a unified framework for building Windows applications. With its Common Language Runtime (CLR) and a comprehensive class library, .NET Framework empowered developers to create robust, scalable applications.
.NET Framework addressed key challenges developers faced, such as language interoperability and versioning issues. It marked a significant departure from traditional Windows development models, offering a modern, object-oriented programming paradigm.
What is .NET Framework?
Key Components of .NET Framework
Common Language Runtime (CLR)
![net-clr](/assets/images/net-common-language-runtime-a2de85228e8a366fcdd84c0a634b5def.png)
Framework Class Library (FCL)
![net-clr](/assets/images/net-fcl-226b8538cbc874b7a86173d7926e1f4a.png)
Common Intermediate Language (CIL)
Common Type System (CTS)
Common Language Specification (CLS)
The Need for .NET Coreβ
As technology advanced, so did the demands of the software development landscape. With the rise of cross-platform development, microservices architecture, and cloud computing, .NET Framework faced limitations. Enter .NET Core, a leaner, modular, and cross-platform successor.
Recognizing these challenges, the .NET ecosystem underwent a transformative journey, leading to the introduction of .NET Core. This evolution was a strategic response to the limitations of the traditional .NET Framework. .NET Core addressed these challenges by embracing cross-platform support, introducing a modular architecture, and adopting an open-source approach.
The cross-platform nature of .NET Core was a pivotal response to the growing demand for applications running on diverse environments. Its modular architecture allowed developers to choose and include only the components they needed, fostering a more efficient and lightweight runtime. Moreover, the decision to release .NET Core as an open-source project under the MIT License promoted community involvement and collaboration, enabling developers to actively contribute to the framework's growth.
Performance improvements were a key focus of .NET Core, with the introduction of features like the CoreCLR and various optimizations. This commitment to efficiency positioned .NET Core as a high-performance framework suited for modern development practices. Embracing containerization and microservices architecture, .NET Core became well-adapted to the rise of Docker and the trend towards building and running applications in containers.
Developers now had the freedom to choose their development environment, deploy applications in containers, and embrace modern development practices. .NET Core was not just an upgrade; it was a strategic move towards a more versatile and adaptable framework.
What is .NET Core?
Key Features of .NET Core
Fast, Lightweight, and Modular
Cross-Platform Compatibility
Cross-Platform Development in the Cloud
Open Source Framework
ASP.NET Core Integration
Package Management with NuGet
Microservices Architecture
Containerization with Docker
Cloud-Native Development
Core Components of .NET Core
![net-clr](/assets/images/net-core-components-92923df36d1c85d5bd4c85209559c506.png)
coreclr
corefx
cli (Command-Line Interface)
roslyn
The Unification Process and The Naming Issueβ
Microsoft has recognized the confusion caused by multiple frameworks and versions and has taken steps to streamline and simplify the ecosystem. The move towards a unified .NET platform aims to provide a more cohesive and consistent experience for developers across different application types and platforms.
During the Microsoft Build 2019 conference in May, the introduction of .NET 5 marked a significant milestone for developers across various platforms, including desktop, web, mobile, cloud, and devices. This platform update represented a rare convergence, unifying disparate frameworks, streamlining code complexity, and advancing cross-platform capabilities.
Microsoft's ambitious goal was to merge the source code streams of key frameworks, namely .NET Framework, .NET Core, and Xamarin/Mono. This endeavour aimed to bridge historical gaps that had emerged and provide developers with a single target framework for their projects.
According to the .NET Reunify Plan
that Microsoft has planned and created the roadmap for, you can see that the unification process will be completed in the yellow area in the image below:
![net-clr](/assets/images/net-5-unified-platform-7285bd2831191113fb741cab4f78c62f.png)
The transition from .NET Core 3.1 to .NET 5 is a pivotal moment. Microsoft's decision to skip version 4.x and adopt .NET 5 is due to the following reasons:
Avoiding Version Confusion:β
The leap from .NET Core 3.1 to .NET 5 is more than a numerical jump; it's a deliberate move to sidestep confusion with the existing .NET Framework 4.x. Microsoft's decision to skip version numbers 4.x communicates that this release is not just an incremental update but a substantial advancement. This strategic versioning ensures that developers recognize the magnitude of the changes and innovations introduced in .NET 5.
Dropping the "Core" for Emphasis:β
The removal of "Core" from the framework's name is more than a cosmetic change. It signifies a shift in focus, emphasizing that .NET 5 is the principal implementation of the framework going forward. This move is a declaration of maturity and completeness, indicating that .NET is no longer confined to a subset. It is a comprehensive and inclusive framework that supports a diverse range of applications and platforms.
![net-clr](/assets/images/net-7-4b8cec9e213ea02e0eaa9b041adf1b7a.png)
ASP.NET Core 5.0 and Entity Framework Core 5.0:β
While the overarching framework adopted the streamlined moniker, certain components retained the "Core" in their names for practical reasons. ASP.NET Core 5.0 and Entity Framework Core 5.0 maintained their identifiers to ensure a smooth transition for developers familiar with the previous versionsβASP.NET MVC 5 and Entity Framework 5/6, respectively. This decision reflects Microsoft's commitment to clarity and compatibility in the evolving landscape.
Bridging the Divide with .NET Standardβ
While .NET Core was a step in the right direction, a new challenge emerged β the fragmentation of APIs across various .NET implementations. This prompted the creation of .NET Standard, a specification that defined a set of APIs to be implemented by all .NET platforms.
.NET Standard acted as a bridge between .NET Framework and .NET Core, ensuring compatibility and facilitating the transition to the new paradigm. Developers could now create libraries targeting .NET Standard, guaranteeing compatibility with any platform implementing the standard, be it .NET Framework, .NET Core, or future versions.
![net-clr](/assets/images/net-standard-architecture-64d90ffd2f10f1f9b82debc321a63906.png)
What is .NET Standard?
.NET Standard is a specification, and different .NET implementations must declare their compliance with a specific version of .NET Standard. This ensures that applications and libraries can be confident about the availability of certain APIs across different platforms.
For example, if you developed a library targeting .NET Standard 2.0, it could be used in applications targeting .NET Core 2.0, .NET Framework 4.6.1, Xamarin.iOS 10.0, and more, as long as those platforms implemented .NET Standard 2.0.
![net-clr](/assets/images/net-standard-774fa7dbe1c8cb1ced71fe431ea75cd0.png)
Key Components of .NET Standard
API Definition
Versioning
Cross-Platform Compatibility
NuGet Packages
Portability Analyzer
It's important to note that .NET Standard served its purpose in reducing fragmentation, but with the release of .NET 5 and later versions, Microsoft shifted towards a unified platform called ".NET" that includes various workloads (e.g., ASP.NET, WinForms, Console, etc.). As a result, .NET Standard is no longer actively maintained or updated, and developers are encouraged to target specific platforms directly using the unified APIs provided by the latest versions of .NET.
.NET Framework vs .NET Coreβ
.NET Framework and .NET Core are two different .NET implementations, each catering to distinct development scenarios. In this comprehensive comparison, we delve into the technical intricacies of both .NET and .NET Core across various aspects, application models, installation processes, microservices support, cross-platform capabilities, APIs, performance, security, and much more. The following table encapsulates the nuanced differences between these two frameworks.
Feature / Aspect | .NET Framework | .NET Core |
---|---|---|
API | Windows-centric APIs provide seamless integration with Windows-specific functionalities, making it an excellent choice for applications deeply tied to the Windows ecosystem. Developers can leverage a rich set of libraries and tools tailored for Windows development. | Takes a standardized and platform-agnostic approach with its APIs, allowing developers to write code that is not bound to a specific operating system. This facilitates cross-platform compatibility, enabling the creation of applications for Windows, Linux, and macOS. |
Application Models | Excels in building Windows-centric applications, offering a comprehensive framework for the development of desktop and server applications on the Windows platform. | Introduces a more modular and lightweight approach, expanding its capabilities to support cross-platform development. It enables developers to build applications that run seamlessly on Windows, Linux, and macOS, fostering versatility in application deployment. |
CI/CD Integration | Applications may require additional configurations for smooth integration with Continuous Integration/Continuous Deployment (CI/CD) pipelines, potentially leading to more complex build and deployment processes. | Simplifies CI/CD integration with built-in support for popular tools like Jenkins, Azure DevOps, and GitHub Actions. This streamlined integration enhances the development workflow, making it easier for developers to implement efficient CI/CD practices. |
CLI Tools | Relies on Visual Studio and may have limited support for command-line interfaces. | Emphasizes command-line interfaces, providing a rich set of CLI tools for development, testing, and deployment. This CLI-centric approach enhances automation and facilitates efficient development practices. |
CLR Tools | Relies on the Common Language Runtime (CLR), a Windows-centric runtime environment that executes and manages applications written in languages like C# and VB.NET. | Features a modular CLR designed for cross-platform execution. This modularity enhances flexibility, enabling applications to run on various platforms without being tied to the traditional Windows-specific runtime environment. |
Community and Community Support | Boasts an established community with strong Windows-centric support. Developers benefit from a wealth of resources and expertise in Windows application development. | It's open-source nature has fostered a diverse and vibrant community that extends beyond Windows. This cross-platform support in the community provides a rich pool of knowledge and solutions for developers working on different operating systems. |
Community-Driven Extensions and Tooling | Relies on Microsoft-provided tools and extensions, often following a more centralized development model. | Encourages a community-driven approach to extensions and tooling. The open-source ecosystem facilitates the creation of diverse tools and extensions, empowering developers with a broader set of options beyond the official offerings. |
Cross-Platform Support | Has limited cross-platform capabilities, primarily catering to Windows environments. | Takes a significant leap in cross-platform development, supporting Windows, Linux, and macOS. This enables developers to create applications that seamlessly run on various operating systems, providing flexibility in deployment. |
Deployment Model | Applications may involve complex setups and dependencies, potentially leading to challenges in managing dependencies and versioning issues. | Simplifies the deployment process with a self-contained deployment model. This model bundles necessary dependencies with the application, streamlining deployment and reducing the overall footprint on the target system. |
Ecosystem and Library Compatibility | Boasts a mature ecosystem with a vast array of libraries and third-party tools. However, compatibility with the latest framework versions may pose challenges for some libraries. | Benefits from a growing ecosystem, leveraging NuGet packages and supporting modern libraries. Its modular architecture promotes better library compatibility, encouraging the development of cross-platform libraries. |
Installation | The installation process of the full .NET Framework can be extensive, requiring a complete runtime installation on the target system. | .NET Core introduces a more streamlined installation process with smaller runtime packages. This reduces the installation footprint and makes the process quicker and more straightforward. |
Innovation and Future Development | May see slower adoption of new features due to its established nature and release cycles. | Embraces faster innovation cycles, regularly introducing updates and embracing emerging technologies swiftly. This agile development approach positions .NET Core at the forefront of modern application development. |
Microservices Support | Conducive to monolithic applications, and while microservices can be implemented, it may require additional effort. | Designed with microservices in mind, offering features like lightweight containers, improved performance, and better modularity for building scalable and distributed systems. |
Modern Development Practices | Being established earlier, may have limitations in adopting some modern development practices, such as containerization and serverless architectures. | Aligns with contemporary development trends, offering native support for containerization through Docker and enabling developers to build serverless applications using technologies like Azure Functions. |
Packaging and Shipping | Applications may have dependencies on the installed runtime, potentially leading to version conflicts. | Applications can be packaged as standalone executables or as platform-specific packages, reducing deployment complexities and minimizing potential version conflicts. |
Performance and Scalability | While .NET Framework provides robust performance, it may be considered heavier compared to .NET Core. | .NET Core is renowned for its high performance, faster startup times, and efficient resource utilization. Its modular architecture facilitates scalability, making it well-suited for microservices-based architectures. |
Portability and Framework Versioning | Applications may face challenges when it comes to portability due to platform-specific dependencies. | Excels in portability, allowing developers to create applications that can run seamlessly across different platforms. Improved versioning strategies minimize compatibility issues, facilitating the adoption of the latest features. |
Security | Security model is robust but may be influenced by the underlying Windows security infrastructure. | Focuses on enhancing security, with features like improved cryptography libraries and support for modern security practices. Its security enhancements make it well-suited for applications requiring strong security measures. |
When to Use Eachβ
The evolution of the .NET ecosystem has led to the coexistence of two major frameworks: .NET Framework and .NET Core. Both frameworks offer powerful tools and libraries for building robust and scalable applications, but understanding when to use each is crucial for making informed development decisions.
When to Use .NET Frameworkβ
Integrated with Windows:
- .NET Framework comes bundled with Windows, making it the default choice for building Windows desktop applications and large-scale enterprise solutions. If your application aligns with Windows-centric technologies, .NET Framework is a natural fit.
Third-Party Libraries and NuGet Packages:
- If your project relies on third-party libraries or NuGet packages that are not yet compatible with .NET Core, sticking with .NET Framework is a pragmatic choice. Ensure that the necessary libraries are available for your chosen framework.
Technologies Not Yet Available in .NET Core:
- .NET Core may not support all the technologies available in .NET Framework. For instance, if your project involves ASP.NET Web Forms, ASP.NET SignalR, or Windows Presentation Foundation (WPF), .NET Framework remains the more suitable option.
Already in Use:
- If your existing application is built on .NET Framework and you're not planning a migration, it may be more practical to extend the application within the current framework. New components or services can be developed using the latest technologies like ASP.NET Core.
Legacy Technologies:
- If your project involves technologies that are not yet available in .NET Core, such as workflow-related services, WCF services, or specific aspects of ASP.NET, sticking with .NET Framework is the pragmatic choice.
When to Use .NET Coreβ
Cross-Platform Needs:
- .NET Core is the go-to choice when your application demands cross-platform compatibility. It supports Windows, Linux, and macOS, making it an excellent choice for developers working in diverse environments.
- Compatible development tools like Visual Studio and Visual Studio Code are available on multiple platforms, facilitating seamless development.
Microservices Architecture:
- If your project involves microservices architecture, .NET Core shines. Its lightweight nature, scalability, and support for various technologies make it an ideal framework for building modular business services.
- The ability to deploy independent microservices facilitates easier maintenance and updates, enhancing overall system agility.
Docker Containerization:
- .NET Core is well-suited for containerized environments, especially when working with Docker containers. Its modular structure allows for efficient deployment and management of applications within containers.
- Compared to .NET Framework, .NET Core offers a smaller image size, making it more suitable for containerized deployments.
High-Performance and Scalability:
- For applications with high-performance and scalability requirements, Microsoft recommends using .NET Core in conjunction with ASP.NET Core. This combination ensures optimal performance.
- The efficiency gained translates to a better user experience and cost savings, making .NET Core a compelling choice for performance-critical applications.
Multiple .NET Versions Side-by-Side:
- When running multiple .NET versions side-by-side on the same server, .NET Core is the preferred choice. It allows developers to install applications with dependencies on different versions of frameworks, ensuring compatibility and flexibility.
Command Line Interface (CLI) Control:
- Developers who prefer lightweight editors and command line control will find .NET Core appealing. It provides a CLI for all supported platforms, requiring minimal installation on production machines.
- The flexibility to switch to a full-fledged IDE, such as Visual Studio, adds versatility to the development workflow.
Choosing between .NET Framework and .NET Core depends on various factors such as platform requirements, performance needs, application types, and the state of the existing codebase. While .NET Core is the future of the .NET ecosystem and offers numerous advantages, there are situations where .NET Framework remains a valid and practical choice.
Evaluate your project's specific needs and constraints, and you can make an informed decision based on the factors outlined in this guide.
.NET Core's Performance Secretβ
.NET Core exhibits superior performance compared to the traditional .NET Framework due to several architectural and design decisions aimed at optimizing resource usage and enhancing execution speed. Here are key factors contributing to the performance gains of .NET Core:
Cross-Platform and Modular Design:β
Designed with cross-platform compatibility in mind, .NET Core follows a modular architecture. Developers can include only the necessary components for their applications, reducing the overall footprint. This modular design allows for more efficient resource utilization, making .NET Core more lightweight and performant.
Optimized Just-In-Time (JIT) Compilation:β
Implements an improved version of the JIT compiler, known as
RyuJIT
. RyuJIT introduces better optimizations, resulting in faster code execution. It generates highly optimized machine code, leading to enhanced performance across various workloads.Runtime Enhancements:β
Introduces improvements to the runtime components, such as the CoreCLR. These enhancements include better garbage collection strategies, more efficient memory management, and optimized thread handling, all of which contribute to overall performance gains.
Image Source: Stackify Support for Asynchronous Programming:β
Places a strong emphasis on asynchronous programming patterns. The framework is designed to efficiently handle asynchronous operations, making it well-suited for scalable and responsive applications. Asynchronous programming can lead to better utilization of system resources and improved application responsiveness. While the .NET Framework also supports asynchronous programming, .NET Core's emphasis on this aspect, combined with other optimizations, contributes to better performance in scenarios where parallel and asynchronous execution is crucial.
Microservices and Containerization:β
With the rise of microservices architectures and containerization, .NET Core has been engineered to excel in these environments. Its modular design and lightweight nature make it well-suited for building and deploying microservices. Containerization support allows for efficient resource utilization and rapid scaling, enhancing performance in cloud-native applications.
Performance Tuning Tools:β
.NET Core provides better tools and diagnostics for performance monitoring and optimization. This allows developers to identify and address performance bottlenecks more effectively. Developers can use tools like PerfView, dotTrace, and others to identify and address performance issues.
JIT and AOTβ
In the context of .NET, AOT (Ahead-of-Time Compilation) and JIT (Just-In-Time Compilation) refer to different compilation strategies used to convert high-level code into machine code that can be executed by the computer's hardware. These strategies have varying impacts on the performance of applications developed using .NET Core and .NET Framework.
JIT (Just-In-Time) Compilation:β
When a .NET application is compiled, the source code is translated into an intermediate language called Common Intermediate Language (CIL) or simply Intermediate Language (IL). IL is a low-level, platform-agnostic representation of the code that can be executed by the Common Language Runtime (CLR). Rather than compiling the entire application to native machine code during the build process, .NET applications are distributed with their IL code. When the application is run, the CLR (Common Language Runtime) dynamically compiles the IL code into native machine code that is specific to the host system's architecture. This dynamic compilation occurs "just-in-time" before the code is executed.
JIT | .NET Core | .NET Framework |
---|---|---|
Compilation | NET Core predominantly uses JIT compilation. The Just-In-Time compiler translates Intermediate Language (IL) code into native machine code at runtime, just before the application executes. This allows for platform-specific optimizations and adaptability to the underlying hardware. | Like .NET Core, the traditional .NET Framework also relies on JIT compilation. The process occurs dynamically during program execution. |
Performance Benefits | JIT compilation can result in optimized code tailored to the specific environment where the application is running. This can lead to improved performance as the compiler can take advantage of the target machine's architecture and capabilities. | JIT compilation in .NET Framework allows for adaptability, but it may introduce some startup latency as the compilation occurs at runtime. In scenarios where startup time is critical, this can be a consideration. |
AOT (Ahead-Of-Time) Compilation:β
AOT refers to the compilation strategy where the code is translated from a high-level language (such as C# in the case of .NET) directly into native machine code during the build process, ahead of the application's execution.
AOT | .NET Core | .NET Framework |
---|---|---|
Compilation | While .NET Core primarily uses JIT compilation, there are scenarios where Ahead-of-Time compilation is employed. For example, .NET Core applications can be compiled ahead of time into native machine code using tools like .NET Native. This AOT compilation can be beneficial for reducing startup times and improving performance in certain scenarios. | .NET Framework has limited support for AOT compilation. The use of NGEN (Native Image Generator) allows developers to create native images ahead of time for some assemblies. However, it doesn't cover the entire application, and the benefits are not as extensive as in .NET Core. |
Performance Benefits | AOT compilation can eliminate the need for JIT compilation at runtime, leading to faster startup times. This can be crucial in scenarios where rapid application launch is essential, such as in mobile or serverless environments. | While NGEN can help in reducing startup time for specific assemblies, the overall impact on performance may be less pronounced compared to .NET Core's AOT capabilities. |
Alright, let's break it down. When you're working with .NET, deciding between JIT and AOT compilation is a big deal. So, here's the deal: JIT compiles your code on the go, as it runs, in both .NET Core and .NET Framework. It's adaptable to your hardware, which is cool. On the flip side, AOT compilation precompiles your code into machine language, scoring points for faster startup times. Now, here's where things get interesting. There are some considerations you should keep in mind when making this decision. We're talking about how fast your app starts up, whether it plays nice with your hardware, how much memory it chews up, and more. Let's get into those considerations:
Considerations | JIT Compilation | AOT Compilation |
---|---|---|
Startup Time | - Introduces startup latency as code is compiled at runtime.- Fast startup times crucial for scenarios like serverless computing or containerized environments. | - Significantly reduces startup time by precompiling code into native machine code. |
Adaptability and Optimization | - Offers adaptability to the underlying hardware.- Potential for runtime optimizations. | - Provides extensive optimization during compilation phase.- May lack adaptability to runtime changes. |
Memory Usage | - Can lead to higher memory usage as both IL code and native code coexist in memory. | - May result in more efficient memory usage as the native code is generated ahead of time. |
Runtime Performance | - Allows for platform-specific optimizations, potentially leading to better runtime performance. | - Offers optimized performance due to extensive precompilation. |
Binary Size | - Generates machine code tailored to the specific platform at runtime, resulting in potentially smaller binaries.- Binary size depends on the platform. | - May result in larger binaries due to precompiled machine code.- Binary size is generally larger and may depend on the specific AOT tool used and its configuration. |
Development Workflow | - Simplifies development workflow by allowing late binding and dynamic loading of assemblies. | - Requires additional considerations during development due to the need for precompilation. |
The Current Support Policyβ
![net-clr](/assets/images/net-release-schedule-c81b2be8783a97ae43343eff0e22d1e3.png)
.NET, Microsoft's toolkit, has a life cycle, starting from when it's born to when it retires. There are two types of versions: Long-Term Support (LTS) for stability (3 years of support) and Standard Term Support (STS) for the latest features (18 months of support).
Imagine a family album with versions like .NET 8 and .NET 7, showing when they were born and when they retire. Some, like .NET 5, have retired.
There are also preview releases (not for regular use) and Go-Live releases (for production). Every November, there's a big release β even-numbered ones for stability, odd-numbered for excitement.
Joining the LTS or STS club means keeping your software up-to-date. Patch updates are like vitamins, bundled up every month on "Patch Tuesday."
Updates are active for a while, improving functionality. The last 6 months focus on security β the retirement plan for software.
End of Life (EOL) is when Microsoft stops helping. It's like saying bye to an old friend for a newer version.
.NET's support policy includes ASP.NET Core 2.1 on .NET Framework, following ASP.NET Support rules. It works on various operating systems, and Windows users get automatic patching.
Understanding the support policy helps your .NET projects stay healthy.
Conclusionβ
The evolution of .NET βfrom Framework to Coreβ reflects a commitment to adaptability and innovation. .NET Framework laid the foundation for Windows development, .NET Core expanded the horizons with cross-platform capabilities, and .NET Standard served as the glue to unite the ecosystem. As we move forward, Microsoft has further streamlined the .NET landscape with the introduction of .NET 5 and beyond, unifying the best of .NET Framework and .NET Core into a single, versatile platform. The journey of .NET continues, promising a future of powerful, cross-platform development for the global developer community.
Thank you for reading. If you were confused before reading this article, I hope this article was useful to you and cleared up your confusion. I am open to all your criticisms and thoughts, if you think there is a missing/wrong/improvable part, do not forget to comment :)