Dela via


ASP.NET Core Blazor WebAssembly inhemska beroenden

Observera

Det här är inte den senaste versionen av den här artikeln. För den aktuella versionen, se .NET 9-versionen av den här artikeln .

Varning

Den här versionen av ASP.NET Core stöds inte längre. Mer information finns i .NET och .NET Core Support Policy. För den aktuella utgåvan, se .NET 9-versionen av den här artikeln.

Viktig

Den här informationen gäller en förhandsversionsprodukt som kan ändras avsevärt innan den släpps kommersiellt. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, med avseende på den information som tillhandahålls här.

Den aktuella versionen finns i .NET 9-versionen av den här artikeln.

Blazor WebAssembly appar kan använda inbyggda beroenden som skapats för att köras på WebAssembly. Du kan statiskt länka inbyggda beroenden till .NET WebAssembly-körningen med hjälp av .NET WebAssembly-kompileringsverktyg, samma verktyg som används för att i förväg (AOT) kompilera en Blazor app till WebAssembly och för att länka om körningen för att ta bort oanvända funktioner.

Den här artikeln gäller endast för Blazor WebAssembly.

Byggverktyg för .NET WebAssembly

Byggverktygen för .NET WebAssembly baseras på Emscripten, en kompilatorverktygskedja för webbplattformen. Mer information om byggverktygen, inklusive installation, finns i ASP.NET Core Blazor WebAssembly byggverktyg och kompilering i förväg (AOT).

Lägg till interna beroenden i en Blazor WebAssembly app genom att lägga till NativeFileReference objekt i appens projektfil. När projektet byggs skickas varje NativeFileReference till Emscripten av .NET WebAssembly-byggverktygen så att de kompileras och länkas till körtidsmiljön. Därefter p/invoke in i den ursprungliga koden från appens .NET-kod.

I allmänhet kan all flyttbar native kod användas som ett inbyggt beroende med Blazor WebAssembly. Du kan lägga till interna beroenden i C/C++-kod eller kod som tidigare kompilerats med Emscripten:

  • Objektfiler (.o)
  • Arkivera filer (.a)
  • Bitkod (.bc)
  • Fristående WebAssembly-moduler (.wasm)

Fördefinierade beroenden måste vanligtvis skapas med samma version av Emscripten som används för att skapa .NET WebAssembly-körningen.

Not

För egenskaper och mål för Mono/WebAssembly MSBuild, se WasmApp.targets (dotnet/runtime GitHub-lagringsplats). Officiell dokumentation för vanliga MSBuild-egenskaper planeras enligt dokumentet Blazor MSBuild-konfigurationsalternativ (dotnet/docs #27395).

Använda intern kod

Lägg till en enkel inbyggd C-funktion i en Blazor WebAssembly app:

  1. Skapa ett nytt Blazor WebAssembly projekt.

  2. Lägg till en Test.c fil i projektet.

  3. Lägg till en C-funktion för beräkningsfaktorer.

    Test.c:

    int fact(int n)
    {
        if (n == 0) return 1;
        return n * fact(n - 1);
    }
    
  4. Lägg till en NativeFileReference för Test.c i appens projektfil:

    <ItemGroup>
      <NativeFileReference Include="Test.c" />
    </ItemGroup>
    
  5. I en Razor komponent lägger du till en DllImportAttribute för funktionen fact i det genererade Test-biblioteket och anropar metoden fact från .NET-koden i komponenten.

    Pages/NativeCTest.razor:

    @page "/native-c-test"
    @using System.Runtime.InteropServices
    
    <PageTitle>Native C</PageTitle>
    
    <h1>Native C Test</h1>
    
    <p>
        @@fact(3) result: @fact(3)
    </p>
    
    @code {
        [DllImport("Test")]
        static extern int fact(int n);
    }
    

När du skapar appen med .NET WebAssembly-byggverktygen installerade kompileras den interna C-koden och länkas till .NET WebAssembly-körningen (dotnet.wasm). När appen har skapats kör du appen för att se det renderade faktorvärdet.

Återanrop för metoder hanterade i C++

Etiketthanterade metoder som skickas till C++ med attributet [UnmanagedCallersOnly].

Metoden som är markerad med attributet [UnmanagedCallersOnly] måste vara static. Om du vill anropa en instansmetod i en Razor komponent skickar du en GCHandle för instansen till C++ och skickar sedan tillbaka den till den inbyggda. Du kan också använda någon annan metod för att identifiera komponentens instans.

Metoden som är markerad med [DllImport] måste använda en C# 9.0-funktionspekare i stället för en delegate-typ för callback-argumentet.

Not

För C#-funktionspekartyper i [DllImport] metoder använder du IntPtr i metodsignaturen på den hanterade sidan i stället för delegate *unmanaged<int, void>. Mer information finns i [WASM] återanrop från den ursprungliga koden till .NET: Tolkning av funktionspekartyper i signaturer stöds inte (dotnet/runtime #56145).

Paketera interna beroenden i ett NuGet-paket

NuGet-paket kan innehålla inbyggda beroenden för användning på WebAssembly. Dessa bibliotek och deras interna funktioner är sedan tillgängliga för alla Blazor WebAssembly appar. Filerna för de inbyggda beroendena ska skapas för WebAssembly och paketeras i den browser-wasmarkitekturspecifika mappen. WebAssembly-specifika beroenden refereras inte automatiskt och måste refereras manuellt som NativeFileReferences. Paketförfattare kan välja att lägga till de inbyggda referenserna genom att inkludera en .props fil i paketet med referenserna.

SkiaSharp-exempelbiblioteksanvändning

SkiaSharp är ett plattformsoberoende 2D-grafikbibliotek för .NET baserat på det inbyggda Skia-grafikbiblioteket med stöd för Blazor WebAssembly.

Så här använder du SkiaSharp i en Blazor WebAssembly app:

  1. Lägg till en paketreferens till SkiaSharp.Views.Blazor-paketet i ett Blazor WebAssembly projekt. Använd Visual Studio-processen för att lägga till paket i en app (Hantera NuGet-paket med Inkludera förhandsversion markerat) eller kör kommandot dotnet add package i ett kommandogränssnitt:

    dotnet add package –-prerelease SkiaSharp.Views.Blazor
    

    Notis

    Mer information om hur du lägger till paket i .NET-appar finns i artiklarna under Installera och hantera paketArbetsflöde för paketförbrukning (NuGet-dokumentation). Bekräfta rätt paketversioner på NuGet.org.

  2. Lägg till en SKCanvasView komponent i appen med följande:

    • SkiaSharp och SkiaSharp.Views.Blazor namnområden.
    • Logik för att rita på komponenten SkiaSharp Canvas View (SKCanvasView).

    Pages/NativeDependencyExample.razor:

    @page "/native-dependency-example"
    @using SkiaSharp
    @using SkiaSharp.Views.Blazor
    
    <PageTitle>Native dependency</PageTitle>
    
    <h1>Native dependency example with SkiaSharp</h1>
    
    <SKCanvasView OnPaintSurface="OnPaintSurface" />
    
    @code {
        private void OnPaintSurface(SKPaintSurfaceEventArgs e)
        {
            var canvas = e.Surface.Canvas;
    
            canvas.Clear(SKColors.White);
    
            using var paint = new SKPaint
            {
                Color = SKColors.Black,
                IsAntialias = true,
                TextSize = 24
            };
    
            canvas.DrawText("SkiaSharp", 0, 24, paint);
        }
    }
    
  3. Skapa appen, vilket kan ta flera minuter. Kör appen och gå till komponenten NativeDependencyExample/native-dependency-example.

Ytterligare resurser

.NET WebAssembly-byggverktyg