flowchart LR
    subgraph Input
        T[Token Sequence]
    end

    subgraph "Tokenizer"
        T --> ID[Integer IDs]
    end

    subgraph "Embeddings"
        ID --> E[Token Embeddings]
    end

    subgraph "Transformer"
        subgraph Encoder
            E --> A1[Attention]
            A1 --> FF1[Feed-Forward]
        end
        subgraph Decoder
            FF1 --> A2[Attention]
            A2 --> FF2[Feed-Forward]
        end
    end

    subgraph "Output"
        FF2 --> C[Contextual Representations]
        C --> P[Next Token Prediction]
    end

    subgraph "Context Window"
        CW["Max tokens (input + output + reasoning)<br />Exceeded → truncate/drop"]
    end

    E -.-> CW

flowchart LR
    I["Input<br/>Prompt / Messages"] --> M["LLM Model"]
    M --> O["Output<br/>Completion / Response"]

flowchart LR
    U[User Question] --> QE[Query Embedding]
    QE --> VS[(Vector Store)]
    KB[Knowledge Base Documents] --> CH[Chunk + Embed]
    CH --> VS
    VS --> RC[Retrieve Top-K Chunks]
    RC --> AP[Augmented Prompt]
    U --> AP
    AP --> LLM[LLM]
    LLM --> A[Grounded Answer]

sequenceDiagram
    actor User
    participant App as Application
    participant LLM as Model
    participant Tool as Weather Tool

    User->>App: Ask question
    App->>LLM: Messages + tool definitions
    LLM-->>App: tool_calls(get_current_weather)
    App->>Tool: Execute function call
    Tool-->>App: Return tool result
    App->>LLM: Append tool message
    LLM-->>App: Final answer
    App-->>User: Response

flowchart LR
    U[User Goal] --> T[Thought<br/>Reason and plan]
    T --> A[Action<br/>Tool call]
    A --> O[Observation<br/>Tool result]
    O --> D{Solved?}
    D -- No --> T
    D -- Yes --> F[Final Answer]

flowchart LR
    U[User Message] --> ST[Short-term Memory<br/>Session History]
    ST --> P[Prompt Assembly]
    P --> LLM[LLM]
    LLM --> R[Response]
    R --> ST

    LT[(Long-term Memory<br/>Vector Store / DB)]
    ST -->|Summaries / facts| LT
    LT -->|Relevant retrieval| P

flowchart LR
    subgraph Host["MCP Host (IDE / CLI / App)"]
        User[User]
        Agent[LLM Agent]
        Client[MCP Client]
        User --> Agent
        Agent <--> Client
    end

    Client <--> Server[MCP Server]

    subgraph External["External Systems"]
        Tool["Tools (actions)"]
        Resource["Resources (data)"]
        Prompt["Prompts (templates)"]
    end

    Server --> Tool
    Server --> Resource
    Server --> Prompt

.agents/
└── skills/
    └── my-skill/
        ├── SKILL.md        # Required: instructions + metadata
        ├── scripts/        # Optional: executable code
        ├── references/     # Optional: documentation
        └── assets/         # Optional: templates, resources

---
name: [skill-id]
description: [Short summary for discovery]
---

# [Skill Name]

## When to use
- Use when [Trigger Scenario A] or [Trigger Scenario B] occurs.

## Instructions
1. **Analyze:** Identify [Key Input].
2. **Execute:** Perform [Action] using bundled resources.
3. **Output:** Return [Result Format].

my-plugin/
├── plugin.json (1)
├── skills/ (2)
│   └── summarize/
│       ├── SKILL.md
│       ├── scripts/
│       └── references/
├── mcp.json (3)
└── com.example.client/ (4)
    └── hooks/

graph TD
    User([User Intent]) --> LeadAgent[Lead Agent]

    subgraph "Recursive Stateful Graph"
        LeadAgent -->|Perceive| Env[Environment]
        Env -->|Data| Brain{LLM Brain}
        Brain -->|Decompose| Tasks[Specialized Tasks]

        subgraph "Agent Swarm"
            Tasks --> AgentA[Agent A: Specialist]
            Tasks --> AgentB[Agent B: Specialist]
            Tasks --> AgentC[Recursive Lead]
            AgentC -->|Sub-Tasks| SubAgent1[Sub-Agent 1]
        end

        AgentA & AgentB & SubAgent1 -->|Actions| Orchestrator[Orchestration Framework]
        Orchestrator -->|State Update| Env
        Orchestrator -.->|Loop/Self-Correct| Brain
    end

    Orchestrator --> Result([Structured Workflow Output])

    classDef lead fill:#f96,stroke:#333,stroke-width:2px;
    classDef swarm fill:#dcf,stroke:#333;
    class LeadAgent,AgentC lead;
    class AgentA,AgentB,SubAgent1 swarm;

flowchart LR
    A[Agent proposes plan or action] --> G{High risk or ambiguity?}
    G -- No --> E[Execute automatically]
    G -- Yes --> H[Human review]
    H -->|Approve| E
    H -->|Reject / Edit| C[Provide correction or context]
    C --> A
    E --> O[Outcome]
    O --> L[Log feedback for future runs]

GET /data/2.5/weather?q=London,uk&appid=*** HTTP/1.1
Host: samples.openweathermap.org
Authorization: ***
User-Agent: dotnet-docs

HTTP/1.1 200 OK
Server: openresty/1.9.7.1
Content-Type: application/json; charset=utf-8
Transfer-Encoding: chunked

{"coord":{"lon":-0.13,"lat":51.51},"weather":[...]...}

builder.Services.AddHttpClient("SecureClient")
    .AddHttpRawMessageLogging(options =>
    {
        options.RedactRequestHeaders = new[] {
            "Authorization",
            "X-Api-Key",
            "Cookie"
        };
        options.IgnoreRequestContent = true;  // No request body logging
        options.IgnoreResponseContent = false; // Response body OK to log
    });

builder.Services.ConfigureHttpClientDefaults(builder =>
{
    builder.AddHttpRawMessageLogging(options =>
    {
        options.Level = LogLevel.Information;
        options.IgnoreRequestContent = false;
        options.IgnoreResponseContent = false;
    });
});

builder.Services
    .AddHttpClient<IWeatherService, WeatherService>(client =>
    {
        client.BaseAddress = new Uri("https://api.openweathermap.org");
    })
    .AddHttpRawMessageLogging(options =>
    {
        options.CategoryName = "WeatherApi";
        options.Level = LogLevel.Debug;
    });

dotnet add package Alyio.Extensions.Http.Logging

builder.Services.AddHttpClient<IApiService, ApiService>()
    .AddHttpRawMessageLogging();

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning",
      "System.Net.Http.HttpClient": "Information"
    }
  }
}

builder.Services.AddHttpClient("MyApi")
    .AddHttpRawMessageLogging(options =>
    {
        // Custom logger category for filtering
        options.CategoryName = "MyApi.HttpLogs";

        // Log level
        options.Level = LogLevel.Debug;

        // Include message bodies
        options.IgnoreRequestContent = false;
        options.IgnoreResponseContent = false;

        // Exclude noisy headers
        options.IgnoreRequestHeaders = new[] { "User-Agent", "Accept-Encoding" };

        // Redact sensitive headers
        options.RedactRequestHeaders = new[] {
            "Authorization",
            "X-Api-Key"
        };
    });

info: MyApi.HttpLogs[0]
      Request-Queue: 1
info: MyApi.HttpLogs[0]
      Request-Message:

      POST /api/users HTTP/1.1
      Host: api.example.com
      Content-Type: application/json
      Authorization: ***
      X-Api-Key: ***

      {"name":"John Doe","email":"john@example.com"}

info: MyApi.HttpLogs[0]
      Response-Message: 234ms

      HTTP/1.1 201 Created
      Content-Type: application/json
      Location: /api/users/12345

      {"id":12345,"name":"John Doe","email":"john@example.com"}

POST /api/orders HTTP/1.1
Host: partner-api.example.com
Content-Type: application/json
Authorization: Bearer ***

{
  "order_date": "2025-12-18T17:02:12+08:00",
  "items": [...]
}

[Fact]
public async Task Should_Send_Correct_Headers()
{
    // Arrange - logging is enabled in test setup
    var client = _factory.CreateClient();

    // Act
    var response = await client.GetAsync("/api/users");

    // Assert - check console output for raw HTTP messages
    response.Should().BeSuccessful();
}

info: HttpClient.MyApi[0]
      Request-Queue: 3

protected override Task<HttpResponseMessage> SendAsync(
    HttpRequestMessage request,
    CancellationToken cancellationToken)
{
    if (_logger.IsEnabled(_loggingOptions.Level))
    {
        return SendCoreAsync(request, cancellationToken);
    }
    else
    {
        return base.SendAsync(request, cancellationToken);
    }
}

public static async Task<string> ReadRawMessageAsync(
    this HttpRequestMessage request,
    bool ignoreContent,
    string[] ignoreHeaders,
    string[] redactHeaders,
    CancellationToken cancellationToken)
{
    // Stream processing implementation
}

if (redactHeaders.Contains(header.Key, StringComparer.OrdinalIgnoreCase))
{
    sb.Append("***");
}

<TargetFrameworks>net6.0;net8.0;net9.0;net10.0</TargetFrameworks>

$ curl -Ii https://blog.codefarm.me
HTTP/2 200
server: GitHub.com
content-type: text/html; charset=utf-8
last-modified: Fri, 25 Jul 2025 13:29:44 GMT
access-control-allow-origin: *
etag: "688386c8-7454"
expires: Mon, 28 Jul 2025 01:21:36 GMT
cache-control: max-age=600
x-proxy-cache: MISS
x-github-request-id: FC47:08F9:889ED7:8AE375:6886CE46
accept-ranges: bytes
date: Mon, 28 Jul 2025 01:11:43 GMT
via: 1.1 varnish
age: 7
x-served-by: cache-nrt-rjtf7700026-NRT
x-cache: HIT
x-cache-hits: 1
x-timer: S1753665103.429076,VS0,VE1
vary: Accept-Encoding
x-fastly-request-id: 817c69f5770b7da31b4d999125b6c8aba907a859
content-length: 29780

from datetime import datetime
from zoneinfo import ZoneInfo

# Define the time zone
tz = ZoneInfo("America/New_York")

# 1. A user schedules an event for Nov 5th at 9:00 AM (during Standard Time)
event_time_local = datetime(2025, 11, 5, 9, 0, 0, tzinfo=tz)
# This correctly converts to 14:00 UTC
event_time_utc = event_time_local.astimezone(ZoneInfo("UTC"))
print(f"Event in November (local): {event_time_local}") # ... 09:00:00-05:00
print(f"Event in November (UTC):   {event_time_utc}")   # ... 14:00:00+00:00

# 2. Now, let's use that stored UTC time to see what time the event
#    would appear to be on a day in May (during Daylight Time).
utc_time_in_may = datetime(2025, 5, 5, 14, 0, 0, tzinfo=ZoneInfo("UTC"))
local_time_in_may = utc_time_in_may.astimezone(tz)

# The meeting has unexpectedly moved to 10:00 AM!
print(f"Event in May (local):      {local_time_in_may}") # ... 10:00:00-04:00

namespace Learning.Dapper.Entities;

public class Category
{
    public int Id { get; set; }

    public required string Name { get; set; }
}

namespace Learning.Dapper.Entities;

public class Product
{
    public int Id { get; set; }

    public string? Name { get; set; }

    public string? Description { get; set; }

    public decimal Price { get; set; }

    public int Stock { get; set; }

    public int CategoryId { get; set; }

    public ProductStatus Status { get; set; }

    public ProductCondition Condition { get; set; }
}

public enum ProductStatus
{
    Available,
    OutOfStock,
    Discontinued
}

public enum ProductCondition
{
    New,
    Used,
    Refurbished
}

using Dapper;
using Microsoft.Data.Sqlite;
using StackExchange.Profiling;
using StackExchange.Profiling.Data;

// Initialize MiniProfiler.
var profiler = MiniProfiler.StartNew("Learn Dapper");  // MiniProfiler.Current is the profiler now.

// Use in-memory SQLite database.
using var sqliteConnection = new SqliteConnection("Data Source=:memory:");

// Wrap connection with ProfiledDbConnection for Dapper (i.e., ADO.NET) profiling.
using var conn = new ProfiledDbConnection(sqliteConnection, profiler);

conn.Open();

/// Recursively prints the timing information collected by MiniProfiler,
/// including custom SQL timings for each step.
static async void PrintTimings(IEnumerable<Timing> timings, string indent = "")
{
    foreach (var timing in timings)
    {
        // Display the name and duration of the current timing step.
        Console.WriteLine($"{indent}{timing.Name} - {timing.DurationMilliseconds} ms");

        // If custom timings (e.g., SQL queries) exist for this step, print them.
        if (timing.CustomTimings != null)
        {
            foreach (KeyValuePair<string, List<CustomTiming>> pair in timing.CustomTimings)
            {
                foreach (CustomTiming customTiming in pair.Value)
                {
                    if (customTiming.CommandString is not null)
                    {
                        string heading = $"{indent}  [SQL]:";
                        Console.WriteLine(heading);
                        string prefix = string.Join("", Enumerable.Repeat(" ", heading.Length));
                        using var reader = new StringReader(customTiming.CommandString);
                        string? line = await reader.ReadLineAsync();
                        while (line != null)
                        {
                            Console.WriteLine($"{prefix} {line}");
                            line = await reader.ReadLineAsync();
                        }
                    }
                }
            }
        }

        // Recursively print child timings to maintain the hierarchy.
        if (timing.Children != null && timing.Children.Count > 0)
        {
            PrintTimings(timing.Children, indent + "  ");
        }
    }
}

using (profiler.Step("INIT SCHEMA"))
{
    var schemaSql = await File.ReadAllTextAsync(@"sql/schema.sql");
    await conn.ExecuteAsync(schemaSql);
}

using (profiler.Step("SEED DATA"))
{
    var seedSql = await File.ReadAllTextAsync(@"sql/seed.sql");
    await conn.ExecuteAsync(seedSql);
}

// Stop MiniProfiler session.
await profiler!.StopAsync();

// Print profiling timings.
PrintTimings([profiler.Root]);

CREATE TABLE IF NOT EXISTS Categories (
    Id INTEGER PRIMARY KEY AUTOINCREMENT,
    Name TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS Products (
    Id INTEGER PRIMARY KEY AUTOINCREMENT,
    Name TEXT,
    Description TEXT,
    Price REAL NOT NULL,
    Stock INTEGER NOT NULL,
    CategoryId INTEGER NOT NULL,
    Status INTEGER NOT NULL, -- Mapped from ProductStatus enum
    Condition INTEGER NOT NULL, -- Mapped from ProductCondition enum
    FOREIGN KEY (CategoryId) REFERENCES Categories(Id)
);

INSERT INTO Categories (Name) VALUES ('Electronics');
INSERT INTO Categories (Name) VALUES ('Books');
INSERT INTO Categories (Name) VALUES ('Home & Kitchen');
INSERT INTO Categories (Name) VALUES ('Sports & Outdoors');

INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Laptop', 'Powerful laptop for work and gaming', 1200.00, 50, 1, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Smartphone', 'Latest model smartphone with advanced features', 800.00, 150, 1, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Headphones', 'Noise-cancelling over-ear headphones', 150.00, 100, 1, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Smart TV', '4K UHD Smart TV with HDR', 750.00, 30, 1, 0, 0);

INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('The Hitchhiker''s Guide to the Galaxy', 'A comedic science fiction series', 15.50, 200, 2, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('1984', 'Dystopian social science fiction novel', 12.00, 180, 2, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('To Kill a Mockingbird', 'Classic American novel', 10.00, 250, 2, 0, 0);

INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Coffee Maker', 'Automatic drip coffee maker', 45.00, 70, 3, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Blender', 'High-speed professional blender', 90.00, 60, 3, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Toaster', '2-slice stainless steel toaster', 30.00, 90, 3, 0, 0);

INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Yoga Mat', 'Non-slip yoga mat for all types of yoga', 25.00, 120, 4, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Dumbbell Set', 'Adjustable dumbbell set (5-25 lbs)', 100.00, 40, 4, 0, 0);
INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Camping Tent', 'Lightweight 2-person camping tent', 120.00, 25, 4, 0, 0);

Learn Dapper - 189.45 ms
  [SQL]:
         Connection Open()
  INIT SCHEMA - 103.35 ms
    [SQL]:
           CREATE TABLE IF NOT EXISTS Categories (
               Id INTEGER PRIMARY KEY AUTOINCREMENT,
               Name TEXT NOT NULL
           );

           CREATE TABLE IF NOT EXISTS Products (
               Id INTEGER PRIMARY KEY AUTOINCREMENT,
               Name TEXT NOT NULL,
               Description TEXT NULL,
               Price REAL NOT NULL,
               Stock INTEGER NOT NULL,
               CategoryId INTEGER NOT NULL,
               Status INTEGER NOT NULL,
               CONDITION TEXT NOT NULL,
               FOREIGN KEY (CategoryId) REFERENCES Categories (Id)
           );
  SEED DATA - 2.97 ms
    [SQL]:
           INSERT INTO Categories (Name) VALUES ('Electronics');
           INSERT INTO Categories (Name) VALUES ('Books');
           INSERT INTO Categories (Name) VALUES ('Home & Kitchen');
           INSERT INTO Categories (Name) VALUES ('Sports & Outdoors');

           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Laptop', 'Powerful laptop for work and gaming', 1200.00, 50, 1, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Smartphone', 'Latest model smartphone with advanced features', 800.00, 150, 1, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Headphones', 'Noise-cancelling over-ear headphones', 150.00, 100, 1, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Smart TV', '4K UHD Smart TV with HDR', 750.00, 30, 1, 0, 'New');

           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('The Hitchhiker''s Guide to the Galaxy', 'A comedic science fiction series', 15.50, 200, 2, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('1984', 'Dystopian social science fiction novel', 12.00, 180, 2, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('To Kill a Mockingbird', 'Classic American novel', 10.00, 250, 2, 0, 'New');

           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Coffee Maker', 'Automatic drip coffee maker', 45.00, 70, 3, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Blender', 'High-speed professional blender', 90.00, 60, 3, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Toaster', '2-slice stainless steel toaster', 30.00, 90, 3, 0, 'New');

           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Yoga Mat', 'Non-slip yoga mat for all types of yoga', 25.00, 120, 4, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Dumbbell Set', 'Adjustable dumbbell set (5-25 lbs)', 100.00, 40, 4, 0, 'New');
           INSERT INTO Products (Name, Description, Price, Stock, CategoryId, Status, Condition) VALUES ('Camping Tent', 'Lightweight 2-person camping tent', 120.00, 25, 4, 0, 'New');

using (profiler.Step("Dapper Query Single Row"))
{
    // Query a product by Id using QueryFirstOrDefaultAsync
    var product1 = await conn.QueryFirstOrDefaultAsync<Product>("SELECT * FROM Products WHERE Id = @Id", new { Id = 1 });
    Console.WriteLine($"Product 1 (QueryFirstOrDefault): {product1?.Name ?? "Not Found"}");

    // Query a non-existent product using QueryFirstOrDefaultAsync
    var product999 = await conn.QueryFirstOrDefaultAsync<Product>("SELECT * FROM Products WHERE Id = @Id", new { Id = 999 });
    Console.WriteLine($"Product 999 (QueryFirstOrDefault): {product999?.Name ?? "Not Found"}");

    // Query a product by Id using QuerySingleOrDefaultAsync (expecting 0 or 1 result)
    var product2 = await conn.QuerySingleOrDefaultAsync<Product>("SELECT * FROM Products WHERE Id = @Id", new { Id = 2 });
    Console.WriteLine($"Product 2 (QuerySingleOrDefault): {product2?.Name ?? "Not Found"}");

    // Example of QuerySingleAsync (expecting exactly one result)
    // This will throw an exception if the query returns zero or more than one result.
    try
    {
        var product3 = await conn.QuerySingleAsync<Product>("SELECT * FROM Products WHERE Id = @Id", new { Id = 3 });
        Console.WriteLine($"Product 3 (QuerySingle): {product3.Name}");
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"Error QuerySingle (Product 3): {ex.Message}");
    }

    // Demonstrate QuerySingleOrDefaultAsync throwing an exception for multiple results
    try
    {
        // This query will return multiple products, causing QuerySingleOrDefaultAsync to throw
        var multipleProducts = await conn.QuerySingleOrDefaultAsync<Product>("SELECT * FROM Products WHERE CategoryId = @CategoryId", new { CategoryId = 1 });
        Console.WriteLine($"Multiple Products (QuerySingleOrDefault): {multipleProducts?.Name ?? "Not Found"}");
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"Error QuerySingleOrDefault (Multiple Products): {ex.Message}");
    }
}

using (profiler.Step("Dapper Query Multiple Rows"))
{
    // Query all products
    var allProducts = await conn.QueryAsync<Product>("SELECT * FROM Products");
    Console.WriteLine("\n--- All Products ---");
    foreach (var product in allProducts)
    {
        Console.WriteLine($"- {product.Name} (Price: {product.Price:C}, Stock: {product.Stock})");
    }

    // Query products by CategoryId
    var electronicsProducts = await conn.QueryAsync<Product>("SELECT * FROM Products WHERE CategoryId = @CategoryId", new { CategoryId = 1 });
    Console.WriteLine("\n--- Electronics Products ---");
    foreach (var product in electronicsProducts)
    {
        Console.WriteLine($"- {product.Name}");
    }

    // Query products with a price greater than a certain value
    var expensiveProducts = await conn.QueryAsync<Product>("SELECT * FROM Products WHERE Price > @MinPrice", new { MinPrice = 100.00m });
    Console.WriteLine("\n--- Expensive Products (> $100) ---");
    foreach (var product in expensiveProducts)
    {
        Console.WriteLine($"- {product.Name} (Price: {product.Price:C})");
    }
}

using (profiler.Step("Dapper Query Multiple Results"))
{
    using (var multi = await conn.QueryMultipleAsync("SELECT Id, Name, Description, Price, Stock, CategoryId, Status, Condition FROM Products; SELECT Id, Name FROM Categories;"))
    {
        // Read the first result set (Products)
        var products = await multi.ReadAsync<Product>();

        // Read the second result set (Categories)
        var categories = await multi.ReadAsync<Category>();

        Console.WriteLine("\n--- All Products (from multi-query) ---");
        foreach (var product in products)
        {
            Console.WriteLine($"- {product.Name} (Price: {product.Price:C}, CategoryId: {product.CategoryId})");
        }

        Console.WriteLine("\n--- All Categories (from multi-query) ---");
        foreach (var category in categories)
        {
            Console.WriteLine($"- {category.Name} (Id: {category.Id})");
        }
    }
}

using (profiler.Step("Dapper Anonymous Parameters"))
{
    // Single parameter
    var product = await conn.QueryFirstOrDefaultAsync<Product>("SELECT * FROM Products WHERE Id = @ProductId", new { ProductId = 1 });
    Console.WriteLine($"Product (Anonymous Parameter): {product?.Name ?? "Not Found"}");

    // Multiple parameters
    var products = await conn.QueryAsync<Product>("SELECT * FROM Products WHERE CategoryId = @CategoryId AND Stock > @MinStock", new { CategoryId = 1, MinStock = 10 });
    Console.WriteLine("\n--- Products with Anonymous Parameters (CategoryId = 1, Stock > 10) ---");
    foreach (var p in products)
    {
        Console.WriteLine($"- {p.Name}");
    }

    // Parameter with a different name than the property (Dapper matches by name)
    var category = await conn.QueryFirstOrDefaultAsync<Category>("SELECT * FROM Categories WHERE Name = @CategoryName", new { CategoryName = "Books" });
    Console.WriteLine($"Category (Anonymous Parameter): {category?.Name ?? "Not Found"}");
}

using (profiler.Step("Dapper Dynamic Parameters"))
{
    // Single parameter
    // 1.
    //   var parameters = new DynamicParameters({ ProductId = 1 });
    // 2.
    //   var dictionary = new Dictionary<string, object>
    //   {
    //       { "@ProductId", 1 }
    //   };
    //   var parameters = new DynamicParameters(dictionary);
    // 3.
    //   var template = new Product { ProductId = 1 };
    //   var parameters = new DynamicParameters(template);
    // 4.
    //   var singleParam = new DynamicParameters();
    //   singleParam.Add("ProductId", 1);
    var singleParam = new DynamicParameters();
    singleParam.Add("@ProductId", 1);
    var product = await conn.QueryFirstOrDefaultAsync<Product>("SELECT * FROM Products WHERE Id = @ProductId", singleParam);
    Console.WriteLine($"Product (Dynamic Parameter): {product?.Name ?? "Not Found"}");

    // Multiple parameters
    var multipleParams = new DynamicParameters();
    multipleParams.Add("CategoryId", 1);
    multipleParams.Add("MinStock", 10);
    multipleParams.Add("Status", ProductStatus.Available); // Dapper handles enum to underlying type (int) conversion automatically
    multipleParams.Add("Condition", ProductCondition.New.ToString()); // Convert enum to string for database if column is TEXT
    var products = await conn.QueryAsync<Product>("SELECT * FROM Products WHERE CategoryId = @CategoryId AND Stock > @MinStock AND Status = @Status AND Condition = @Condition", multipleParams);
    Console.WriteLine("\n--- Products with Dynamic Parameters (CategoryId = 1, Stock > 10) ---");
    foreach (var p in products)
    {
        Console.WriteLine($"- {p.Name}");
    }
}