<!-- To run this benchmark: -->
<!-- 1. Add NuGet package BenchmarkDotNet to your project. -->
<!-- 2. Ensure your project is compiled in 'Release' mode. -->
<!-- 3. Run the executable from the command line. -->
<!-- This provides concrete data on performance differences between Span<T> and Substring. -->

using System;
using System.Text;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace DotNet10Performance
{
    public class PerformanceExample
    {
        private const string Data = "This is a long string that we will process efficiently using Span<T> without allocations.";

        public static void Main(string[] args)
        {
            // Execute benchmarks to compare approaches. This will print detailed performance results.
            var summary = BenchmarkRunner.Run<PerformanceExample>();
        }

        [Benchmark]
        public ReadOnlySpan<char> ProcessStringWithSpan()
        {
            // Create a Span from the string (no memory allocation for the Span itself, just a view).
            ReadOnlySpan<char> span = Data.AsSpan();

            // Simulate extracting a part of the string (e.g., "long string")
            // This operation creates a new Span, not a new string object, avoiding heap allocation.
            ReadOnlySpan<char> targetSpan = span.Slice(10, 11); // Extracts "long string"

            // Simulate further processing on the span, e.g., checking content.
            if (targetSpan.StartsWith("long".AsSpan()))
            {
                // Perform operations directly on the span.
            }

            return targetSpan; // Returns a Span, still no new string allocation.
        }

        [Benchmark]
        public string ProcessStringWithSubstring()
        {
            // Traditional Substring approach (creates a new string allocation on the heap).
            string targetString = Data.Substring(10, 11); // Allocates a new string object.

            // Simulate further processing.
            if (targetString.StartsWith("long"))
            {
                // Perform operations on the newly allocated string.
            }

            return targetString; // Returns the newly allocated string.
        }

        // Best Practice: Utilize Span<T> for high-performance, low-allocation string and memory operations.
        // Common Error: Overlooking `Span<T>` and relying solely on `string.Substring` in performance-critical loops.
    }
}

// Example: Advanced Pattern Matching in C# (Illustrative of future possibilities in C# 13+)
// C# 13 might expand pattern matching to simplify complex data extraction and validation,
// combining property patterns, collection patterns, and relational patterns for concise logic.

using System;
using System.Collections.Generic;
using System.Linq;

namespace DotNet10LanguageFeatures
{
    // Define records for immutable data, enhancing clarity and reducing boilerplate.
    public record Order(int Id, List<OrderItem> Items, decimal TotalAmount, string Status);
    public record OrderItem(string ProductId, int Quantity, decimal Price);

    public class OrderProcessor
    {
        public static void Main(string[] args)
        {
            var order1 = new Order(101,
                new List<OrderItem> { new("SKU001", 2, 50m), new("SKU002", 1, 100m) },
                200m, "Pending");

            var order2 = new Order(102,
                new List<OrderItem> { new("SKU003", 5, 10m) },
                50m, "Completed");

            var order3 = new Order(103,
                new List<OrderItem>(),
                0m, "Cancelled");

            ProcessOrder(order1); // Expected: "Processing a large pending order."
            ProcessOrder(order2); // Expected: "Processing a completed small order."
            ProcessOrder(order3); // Expected: "Order cancelled or empty."
            ProcessOrder(new Order(104, new List<OrderItem> { new("SKU004", 1, 75m) }, 75m, "Pending")); // Expected: "Processing generic order 104."
        }

        public static void ProcessOrder(Order order)
        {
            string message = order switch
            {
                // Match a pending order with multiple items and a total amount > 150
                // This pattern combines property patterns (`Status`, `TotalAmount`) with a collection count pattern (`Items.Count`).
                { Status: "Pending", Items.Count: > 1, TotalAmount: > 150m } => "Processing a large pending order.",

                // Match a completed order with a single item (any quantity > 0) and a total amount < 100
                // This pattern uses a list pattern to check for a single item, and a property pattern within that item.
                { Status: "Completed", Items: [{ Quantity: > 0 }], TotalAmount: < 100m } => "Processing a completed small order.",

                // Match any order that is cancelled or has no items
                // This combines an 'or' pattern for Status with a collection count pattern for empty items.
                { Status: "Cancelled" or "Pending", Items.Count: 0 } => "Order cancelled or empty.",

                // Default case for any other order not explicitly matched by the above patterns.
                _ => $"Processing generic order {order.Id}."
            };

            Console.WriteLine(message);
        }

        // Best Practice: Employ pattern matching to simplify complex conditional logic and data extraction.
        // Common Error: Writing verbose `if/else if` chains when pattern matching offers a more concise and readable alternative.
    }
}

// Example: Conceptual Dapr Integration for Cloud-Native Microservices (Illustrative)
// .NET 10 is expected to deepen integration with tools like Dapr,
// simplifying distributed systems challenges for C# developers by providing building blocks.

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using Dapr.Client; // Requires Dapr.Client NuGet package

namespace DotNet10CloudNative
{
    // Records for simplified data transfer objects (DTOs).
    public record OrderData(string Item, int Quantity, decimal Price);
    public record MessageData(string Text);

    public class DaprMicroserviceExample
    {
        // Default Dapr sidecar HTTP port. Ensure Dapr is running.
        private const string DAPR_HTTP_PORT = "3500"; 
        // Example Dapr state store component name (e.g., 'statestore' configured via Dapr components YAML).
        private const string STORE_NAME = "statestore"; 
        // Example Dapr pub/sub component name (e.g., 'pubsub' configured via Dapr components YAML).
        private const string PUBSUB_NAME = "pubsub"; 
        // Example topic name for publishing/subscribing messages.
        private const string TOPIC_NAME = "orders"; 

        public static async Task Main(string[] args)
        {
            Console.WriteLine("Starting Dapr microservice example...");
            await SaveAndRetrieveState();
            await PublishAndSubscribeMessage();
            Console.WriteLine("Dapr example completed.");
        }

        // Simulates saving and retrieving application state using Dapr's state management building block.
        public static async Task SaveAndRetrieveState()
        {
            Console.WriteLine("\n--- State Management Example ---");
            // DaprClient provides a convenient way to interact with Dapr building blocks.
            using var daprClient = new DaprClientBuilder().Build();

            string orderId = "order_abc_123";
            var orderData = new OrderData("Laptop", 1, 1200.00m);

            try
            {
                // Save state to the configured Dapr state store.
                await daprClient.SaveStateAsync(STORE_NAME, orderId, orderData);
                Console.WriteLine($"State for order '{orderId}' saved successfully: {JsonSerializer.Serialize(orderData)}.");

                // Retrieve state from the Dapr state store.
                var retrievedOrder = await daprClient.GetStateAsync<OrderData>(STORE_NAME, orderId);
                Console.WriteLine($"Retrieved state for order '{orderId}': {JsonSerializer.Serialize(retrievedOrder)}.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error during Dapr state management: {ex.Message}. Is Dapr sidecar running and state store configured?");
            }
        }

        // Simulates publishing and subscribing to messages using Dapr's Pub/Sub building block.
        public static async Task PublishAndSubscribeMessage()
        {
            Console.WriteLine("\n--- Pub/Sub Example ---");
            using var daprClient = new DaprClientBuilder().Build();

            var messageData = new MessageData("New order received for processing!");

            try
            {
                // Publish a message to the configured Dapr pub/sub component and topic.
                await daprClient.PublishEventAsync(PUBSUB_NAME, TOPIC_NAME, messageData);
                Console.WriteLine($"Message published to topic '{TOPIC_NAME}': {JsonSerializer.Serialize(messageData)}.");

                // In a real microservices scenario, another service (with its own Dapr sidecar)
                // would subscribe to this topic (e.g., via a Dapr HTTP endpoint like app.MapPost("/dapr-pubsub/{pubsubname}/{topicname}", ...))
                Console.WriteLine("A subscriber (another microservice) would now process this message.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error during Dapr pub/sub: {ex.Message}. Is Dapr sidecar running and pub/sub component configured?");
            }
        }

        // To run this code:
        // 1. Ensure Dapr CLI is installed: `dapr init`
        // 2. Ensure Dapr components are configured (e.g., default `statestore` and `pubsub` components).
        // 3. Run your .NET application with a Dapr sidecar: 
        //    `dapr run --app-id myapp --dapr-http-port 3500 --app-port [YOUR_APP_PORT] dotnet run`
        //    Replace `[YOUR_APP_PORT]` with the actual port your console app might expose if it were a web API.

        // Common error: Forgetting to run Dapr sidecar, or misconfiguring state store/pub/sub components.
        // Best practice: Clearly define Dapr component YAMLs and ensure they are applied to your Dapr environment.
    }
}

<!-- Example: Project Configuration for .NET 10 (Illustrative) -->
<!-- .NET 10 will likely introduce new Target Framework Monikers (TFMs) -->
<!-- and enable new language features via LangVersion. -->
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <!-- Target the forthcoming .NET 10 framework -->
    <TargetFramework>net10.0</TargetFramework>

    <!-- Explicitly activate C# 13 language features (or later) -->
    <!-- Use 'preview' for future versions to leverage all new language constructs as they arrive. -->
    <LangVersion>preview</LangVersion> 

    <!-- Enable Native AOT for specific project types (e.g., console apps, some web apps) -->
    <!-- This property helps optimize for smaller, faster executables and reduced startup times. -->
    <PublishAot>true</PublishAot>

    <!-- Enable Hot Reload for faster development iterations, allowing code changes without restart. -->
    <HotReloadEnabled>true</HotReloadEnabled>

    <!-- Potentially new tooling flags for enhanced diagnostics or specific build behaviors -->
    <!-- For example, stricter nullable analysis or specific code analysis rules to improve code quality. -->
    <AnalysisMode>AllEnabledByDefault</AnalysisMode>
    <EnableNETAnalyzers>true</EnableNETAnalyzers>

    <!-- Expect new project-level settings to optimize for specific deployment targets or environments. -->
    <!-- <EnableCloudNativeOptimizations>true</EnableCloudNativeOptimizations> -->
  </PropertyGroup>

  <ItemGroup>
    <!-- Include new NuGet packages or SDKs anticipated for .NET 10 -->
    <!-- E.g., next-gen ML.NET components, advanced Dapr clients, or MAUI enhancements. -->
    <!-- <PackageReference Include="Microsoft.ML.NextGen" Version="1.0.0" /> -->
    <!-- <PackageReference Include="Dapr.Client.Advanced" Version="1.0.0" /> -->
    <!-- <PackageReference Include="Microsoft.Maui.Core" Version="10.0.0" /> -->
  </ItemGroup>

  <!-- Best Practice: Regularly audit project files to ensure you are targeting the latest frameworks
       and language versions to maximize performance and leverage new features. -->
  <!-- Common Error: Forgetting to update LangVersion can prevent access to new C# syntax and compiler optimizations. -->

</Project>