הידור AOT מתקדם ב־C#: מדריך לימודי עם דוגמאות

המקור באנגלית פורסם ב־2026-05-16T18:58:25.751+03:00. המאמר המקורי באנגלית

מהדורה לימודית מתוקנת. תאריך הבדיקה הטכנית מול מקורות ראשוניים: 2026-10-28. דוגמאות הקוד לא הודרו ולא נבדקו בזמן ריצה. תאריך הפרסום המקורי באנגלית נשמר; המהדורה בעברית משתמשת בתאריך הפרסום שלה בפועל, ולא בתאריך המקור באנגלית.

🛡️ מגבלות דורשות בדיקה

מדריך עם דוגמאות והדרכות

1. קוד מקור C#

   קובצי ‎.cs

   Program.cs

   Roslyn

2. IL / MSIL

   קוד ביניים

   .dll/.exe

   AOT

3. קובץ בינארי מקומי

   ללא אתחול JIT

   צריכה תלויה בעומס

   ביצועים תלויי יישום

מאפייני AOT

• ⚡ אתחול עשוי להשתפר
• 🔒 זיכרון תלוי בעומס
• 📦 עצמאי
• 🐳 מותאם לענן
• ☁️ Serverless
• 🛡️ אבטחה

.NET · C# · AOT · NativeAOT · ביצועים · ענן

התרשים בעיצוב המקורי (אופציונלי; גלילה אופקית בגודל מלא)

התרשים המקורי באנגלית

⚡ הידור מראש, AOT, לעומת הידור בזמן ריצה, JIT

🐚

JIT (‎.NET המסורתי)

• ✓ יצירת קוד דינמית
• ✓ תמיכה מלאה בהשתקפות
• ✓ ספריית בסיס רחבה, BCL
• זמן האתחול תלוי ביישום; JIT עשוי להוסיף עלות חימום ^מקור
• צריכת הזיכרון תלויה בעומס ובאופן הפריסה
• ✗ תקורת חימום של JIT

🚀

AOT (Native AOT)

• האתחול עשוי להשתפר; יש למדוד את היישום שלכם ^מקור
• צריכת הזיכרון עשויה להשתפר; יש למדוד ^מקור
• פריסה מקומית עצמאית; תלויות מערכת ההפעלה נותרות ^מקור
• ✓ ללא תלות ב־JIT
• ✗ ללא יצירת קוד בזמן הריצה
• ✗ תמיכה מוגבלת בהשתקפות

מהו הידור AOT ב־.NET?

הידור מראש, Ahead-of-Time או AOT, ב־.NET ממיר את קוד ה־C# לקוד מכונה מקומי לפני הפריסה, במקום להשתמש בהידור JIT בזמן הביצוע. הפלט הוא יישום מקומי ועצמאי למערכת הפעלה ולארכיטקטורה מסוימות. אין צורך בהתקנת סביבת ריצה נפרדת של .NET, אך עדיין חלות תלויות מערכת מקומיות ודרישות לפלטפורמה ולשרשרת כלים נתמכות. יש למדוד את השיפור באתחול ובזיכרון ביישום בפועל. ^מקור

ל־.NET יש כמה טכניקות פריסה עם הידור מראש; שתי הטכניקות הללו משרתות מטרות שונות:

• Native AOT מהדר IL של היישום לקוד מקומי בזמן הפרסום ואינו משתמש ב־JIT בזמן הביצוע. דוגמת .NET 10 שלהלן ממחישה גרסה נתמכת נכון ל־2026-10-28, ולא מבטיחה תאימות לכל תלות או פלטפורמה. ^{מקור1 מקור2}
• ReadyToRun (R2R) מהדר חלק מהקוד מראש אך משאיר IL ועדיין יכול להשתמש ב־JIT; בדרך כלל הוא מגדיל את נפח הפרסום ואינו Native AOT. יש לבחון בנפרד את הפשרות בין אתחול, גודל ותאימות. ^מקור

מדריך 1: יישום Native AOT ראשון

# Create a new console app
dotnet new console -n AotDemo
cd AotDemo

ערכו את הקובץ AotDemo.csproj:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <PublishAot>true</PublishAot>
    <OptimizationPreference>Speed</OptimizationPreference>
  </PropertyGroup>
</Project>

כתבו קוד תואם AOT בקובץ Program.cs:

using System.Text.Json;
using System.Text.Json.Serialization;

// Native AOT requires source-generated JSON serialization
[JsonSerializable(typeof(User))]
[JsonSerializable(typeof(List<User>))]
internal partial class AppJsonContext : JsonSerializerContext { }

record User(string Name, int Age, string Email);

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("AOT App Started!");

        var users = new List<User>
        {
            new("Alice", 30, "alice@example.com"),
            new("Bob", 25, "bob@example.com")
        };

        // Source-generated serialization - no reflection!
        var json = JsonSerializer.Serialize(users, AppJsonContext.Default.ListUser);
        Console.WriteLine(json);

        var loaded = JsonSerializer.Deserialize(json, AppJsonContext.Default.ListUser);
        foreach (var user in loaded!)
            Console.WriteLine($"Name: {user.Name}, Age: {user.Age}");
    }
}

// Publish commands:
// dotnet publish -r linux-x64 -c Release
// dotnet publish -r win-x64 -c Release

מדריך 2: Minimal API התואם ל־AOT

ASP.NET Core תומכת ב־Native AOT עבור דפוסי יישום נתמכים, ובהם Minimal APIs. השתמשו ב־Web SDK ובתבנית או בתצורת AOT המתאימה, ובדקו את התכונות והתלויות הנתמכות. הדוגמה אינה מדידת ביצועים של מיקרו־שירות. ^מקור

// Separate ASP.NET Core project using Microsoft.NET.Sdk.Web and net10.0.
// Project settings: <PublishAot>true</PublishAot>
// Runtime-untested illustration; not a persistent product service.
using System.Text.Json.Serialization;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateSlimBuilder(args);
builder.Services.ConfigureHttpJsonOptions(options =>
    options.SerializerOptions.TypeInfoResolverChain.Insert(0, ApiJsonContext.Default));
var app = builder.Build();
app.MapGet("/", () => "Hello from Native AOT API!");
app.MapGet("/products", () => new[]
{
    new Product(1, "Laptop", 999.99m),
    new Product(2, "Mouse", 29.99m)
});
app.MapPost("/products", (CreateProductRequest req) =>
{
    // Demonstrates a response shape only: no persistence or unique-ID guarantee.
    var product = new Product(100, req.Name, req.Price);
    return TypedResults.Created($"/products/{product.Id}", product);
});
app.Run();

record Product(int Id, string Name, decimal Price);
record CreateProductRequest(string Name, decimal Price);
[JsonSerializable(typeof(Product))]
[JsonSerializable(typeof(Product[]))]
[JsonSerializable(typeof(CreateProductRequest))]
internal partial class ApiJsonContext : JsonSerializerContext { }

מדריך 3: הזרקת תלויות ב־AOT

השתמשו בדפוסי הזרקת תלויות שה־trimmer ומנתח AOT יכולים להבין, עם רישום מפורש כשמעשי. הזרקה דרך הבנאי לבדה אינה מבטיחה תאימות ל־AOT. דוגמת Microsoft DI שלהלן יוצרת scope לפני פתרון שירות scoped ומציבה פקודות ברמה העליונה לפני הכרזות טיפוסים. ^מקור

// Separate console example, with a compatible Microsoft.Extensions.DependencyInjection package.
// Runtime-untested. Top-level statements precede all type declarations.
using System;
using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();
services.AddSingleton<IDataService, DataService>();
services.AddScoped<IReportService, ReportService>();
using var provider = services.BuildServiceProvider(validateScopes: true);
using var scope = provider.CreateScope();
var reporter = scope.ServiceProvider.GetRequiredService<IReportService>();
Console.WriteLine(reporter.GenerateReport());

interface IDataService { string[] GetData(); }
interface IReportService { string GenerateReport(); }
class DataService : IDataService
{
    public string[] GetData() => new[] { "Item1", "Item2", "Item3" };
}
class ReportService : IReportService
{
    private readonly IDataService _data;
    public ReportService(IDataService data) => _data = data;
    public string GenerateReport() => $"Report: {string.Join(", ", _data.GetData())}";
}

מדריך 4: מחוללי קוד מקור ל־JSON ב־AOT

המפתח לסריאליזציה של JSON ב־AOT הוא מחולל קוד המקור [JsonSerializable]. הנה דוגמה מקיפה למודל תחום של REST API:

// Separate console example. Runtime-untested.
using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;

var order = new Order(1, "CUST-001",
    new List<OrderItem> { new(42, "Widget", 3, 9.99m) }, 29.97m, "Pending");
var json = JsonSerializer.Serialize(order, OrderJsonContext.Default.Order);
var parsed = JsonSerializer.Deserialize(json, OrderJsonContext.Default.Order);
Console.WriteLine(json);

public record OrderItem(int ProductId, string Name, int Quantity, decimal UnitPrice);
public record Order(int Id, string CustomerId, List<OrderItem> Items, decimal Total, string Status);
public record CreateOrderRequest(string CustomerId, List<OrderItem> Items);
[JsonSerializable(typeof(Order))]
[JsonSerializable(typeof(Order[]))]
[JsonSerializable(typeof(List<Order>))]
[JsonSerializable(typeof(OrderItem))]
[JsonSerializable(typeof(CreateOrderRequest))]
[JsonSourceGenerationOptions(
    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
    WriteIndented = false,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
public partial class OrderJsonContext : JsonSerializerContext { }

📊 ביצועי AOT: מה צריך למדוד

מדד	JIT	Native AOT	שיטת השוואה
אתחול קר	מדדו את בניית היעד	מדדו את אותו עומס	אותו מארח והרצות חוזרות
נפח היישום שפורסם	ציינו את מצב הפריסה	כללו תוצרים נדרשים	השוו תכולות שקולות
זיכרון במנוחה ובעומס	מדדו RSS באופן עקבי	מדדו שלבים מקבילים	דווחו על שונות ותצורה

מאפייני Trimmer: שמירה על התאמה ל־AOT

// Type-declaration example, not top-level statements. Runtime-untested.
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

public static class FactoryExamples
{
    // A hazard declaration, NOT a fix for trimming or Native AOT compatibility.
    [RequiresUnreferencedCode("Type names and constructors may be removed by trimming.")]
    [RequiresDynamicCode("Arbitrary runtime types may require unavailable native code.")]
    public static object CreateFromTypeName(string typeName)
    {
        var type = Type.GetType(typeName, throwOnError: true)!;
        return Activator.CreateInstance(type)
            ?? throw new InvalidOperationException("Constructor returned no object.");
    }

    // Prefer explicit, statically visible factories for a closed set of types.
    private static readonly Dictionary<string, Func<object>> Factories = new()
    {
        ["user"] = () => new User("", 0, ""),
        ["product"] = () => new Product(0, "", 0)
    };
    public static object CreateFromName(string name) =>
        Factories.TryGetValue(name, out var factory) ? factory()
            : throw new ArgumentException($"Unknown type: {name}");

    // This annotation describes required members; callers must satisfy the requirement.
    public static void PrintProperties<
        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T obj)
    {
        foreach (var prop in typeof(T).GetProperties())
        {
            if (prop.GetIndexParameters().Length == 0 && prop.GetMethod is not null)
                Console.WriteLine($"{prop.Name}: {prop.GetValue(obj)}");
        }
    }
    private record User(string Name, int Age, string Email);
    private record Product(int Id, string Name, decimal Price);
}

סיכום

Native AOT עשוי להתאים ל־APIs מסוימים, לכלי CLI, לפונקציות serverless ולמיקרו־שירותים, אך ההתאמה תלויה בתכונות נתמכות, בתלויות ובהתנהגות שנמדדה. החליפו מסלולים עתירי השתקפות ביצירת קוד מקור או ברישום מפורש, פתרו אזהרות trimming ו־AOT ובדקו את הקובץ שפורסם בכל יעד. אין להתייחס ל־RequiresUnreferencedCode כתיקון בטיחות: הוא מצהיר על סיכון ואינו משמר טיפוסים חסרים. לא הוכחו כאן תוצאת benchmark או חיסכון בעלויות ענן. ^{מקור1 מקור2}

כל הדוגמאות לא נבדקו בזמן ריצה; לא הופעלו מהדר, פרסום או benchmark. פרויקט .NET 10 המתוקן משתמש ב־OptimizationPreference=Speed במקום המאפיין המקורי OptimizeSpeed. המאפיין InvariantGlobalization הוסר מפני שהוא משנה התנהגות תלוית תרבות, לרבות התנהגות רלוונטית לעברית; הפעילו אותו רק לאחר בדיקת דרישות מכוונת. השתמשו בשרשרת ההידור המקומית הנדרשת לפלטפורמת היעד; פקודות הפרסום ל־Windows ול־Linux הן חלופות, ולא הבטחה להידור בין מערכות הפעלה. כל מדריך הוא דוגמה נפרדת, ולא קובץ מקור אחד מחובר.

מקורות לתיקונים

• https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/
• https://learn.microsoft.com/en-us/lifecycle/products/microsoft-net-and-net-core
• https://learn.microsoft.com/en-us/dotnet/core/deploying/ready-to-run
• https://learn.microsoft.com/en-us/aspnet/core/fundamentals/native-aot?view=aspnetcore-10.0
• https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection-guidelines
• https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/fixing-warnings
• https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/optimizing
• https://learn.microsoft.com/en-us/dotnet/core/runtime-config/globalization