anycpu and versions file

Author: JoeStech

content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md

@@ -0,0 +1,51 @@
+---
+title: Run a .NET OrchardCore application on Arm and x86
+weight: 4
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+# Run a .NET OrchardCore application on Arm and x86
+
+In this section, you will learn how to configure and run your OrchardCore application on both Arm and x86 architectures using the .NET AnyCPU configuration. This approach allows your application to be architecture agnostic, providing flexibility and ease of deployment across different hardware platforms.
+
+## Configure the project for AnyCPU
+
+To make your OrchardCore application architecture agnostic, you need to configure it to use the AnyCPU platform target. This allows the .NET runtime to choose the appropriate architecture at runtime.
+
+1. Open your OrchardCore project in your preferred IDE.
+2. Locate the `.csproj` file for your project.
+3. Modify the `<PlatformTarget>` element to `AnyCPU`:
+
+   ```xml
+   <PropertyGroup>
+     <PlatformTarget>AnyCPU</PlatformTarget>
+   </PropertyGroup>
+   ```
+
+4. Save the changes to the `.csproj` file.
+
+## Build once, run anywhere
+
+   ```bash
+   dotnet build -c Release
+   ```
+
+4. Run the application:
+
+   ```bash
+   dotnet run
+   ```
+
+Your application should now be runnable on any architecture.
+
+## Benefits of architecture agnostic applications
+
+By configuring your application to be architecture agnostic, you gain several benefits:
+
+- **Flexibility**: Deploy your application on a wide range of devices without modification.
+- **Efficiency**: Reduce the need for maintaining separate builds for different architectures.
+- **Scalability**: Easily scale your application across different hardware platforms.
+
+This approach ensures that your OrchardCore application can run seamlessly on both Arm and x86 architectures, as well as 64 bit or 32 bit processors.

content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md

@@ -0,0 +1,69 @@
+---
+title: Evaluate .NET versions for performance on Arm
+weight: 5
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+# Evaluate .NET versions for performance on Arm
+
+In this section, we will explore the performance characteristics of different .NET versions on Arm architecture. Understanding which versions perform best and the features they offer can help you make informed decisions when developing applications for Arm-based systems.
+
+## .NET versions overview
+
+.NET has evolved significantly over the years, with each version introducing new features and performance improvements. Here, we will focus on the key versions that have notable performance implications for Arm architecture.
+
+## .NET Core 3.1 (end-of-life 2022)
+
+.NET Core 3.1 was a significant release that introduced better support for Arm64, making it a viable option for developing applications on Arm-based systems. Key features include:
+
+- Improved JIT (Just-In-Time) compilation for Arm64.
+- Enhanced garbage collection performance.
+- Support for hardware intrinsics, allowing for optimized low-level operations.
+
+## .NET 5 (end-of-life 2022)
+
+.NET 5 marked the unification of the .NET platform, bringing together .NET Core, .NET Framework, and Xamarin. It continued to build on the performance improvements of .NET Core 3.1, with additional enhancements:
+
+- Improved cross-platform performance, including Arm64.
+- Introduction of single-file applications, reducing deployment complexity.
+- Enhanced support for containerized applications, which is beneficial for cloud deployments on Arm servers.
+
+## .NET 6 (end-of-life 2024)
+
+.NET 6 is a Long-Term Support (LTS) release that further optimizes performance for Arm architecture. It includes:
+
+- TieredPGO (Profile Guided Optimization). TieredPGO is a feature in .NET that allows the runtime to optimize code execution based on the actual usage patterns observed during the application's execution. It combines the benefits of both Tiered Compilation and Profile Guided Optimization to improve performance.
+- Improved support for high core counts, making it ideal for modern Arm servers with many cores.
+
+## .NET 7
+
+.NET 7 continues the trend of performance enhancements, with a focus on:
+
+- Native AOT (Ahead-Of-Time) compilation, which can significantly improve startup times and reduce memory usage.
+- Enhanced support for cloud-native applications, which are increasingly deployed on Arm-based infrastructure.
+- Continued optimizations for high-performance computing scenarios.
+
+## .NET 8 (current LTS)
+
+.NET 8, as the current Long-Term Support (LTS) version, builds upon the advancements of its predecessors with a focus on stability and performance. Key features include:
+
+- Further improvements in Native AOT, enhancing startup times and reducing resource consumption.
+- Optimized performance for cloud-native and microservices architectures on Arm.
+- Enhanced developer productivity features, making it easier to build and deploy applications on Arm-based systems.
+
+## .NET 9
+
+.NET 9 introduces experimental features and performance enhancements aimed at future-proofing applications. While not an LTS release, it offers:
+
+- Cutting-edge performance optimizations for Arm architecture.
+- New language features and runtime improvements.
+- Enhanced support for emerging technologies and platforms.
+
+## .NET 10 (preview)
+
+
+## Hands-on performance comparison
+
+Let's do a comparison between OrchardCore running on .NET 8 and the earliest compatible version of .NET