Merge pull request #221 from jsturtevant/update-csharp-docs

Update docs to use latest componentize-dotnet

Author: kate-goldenring

component-model/src/language-support/csharp.md

@@ -13,56 +13,19 @@ componentize-dotnet serves as a one-stop shop for .NET developers, wrapping seve
 - [wit-bindgen](https://github.com/bytecodealliance/wit-bindgen) (WIT imports and exports)
 - [wasm-tools](https://github.com/bytecodealliance/wasm-tools) (component conversion)
 - [WASI SDK](https://github.com/WebAssembly/wasi-sdk) (SDK used by NativeAOT-LLVM)
+- [Wac](https://github.com/bytecodealliance/wac) (used to compose components)
 
-First, install the .NET SDK. For this walkthrough, we’ll use the [.NET 9 SDK RC
-1](https://dotnet.microsoft.com/en-us/download/dotnet/9.0). You should also have
-[wasmtime](https://wasmtime.dev/) installed so you can run the binary that you produce.
+First, install the .NET SDK. For this walkthrough, we’ll use the [.NET 10 SDK preview](https://dotnet.microsoft.com/en-us/download/dotnet/10.0). 
+You should also have [wasmtime](https://wasmtime.dev/) installed so you can run the binary that you produce.
 
 Once you have the .NET SDK installed, create a new project:
 
 ```sh
-dotnet new classlib -o adder
+dotnet new install BytecodeAlliance.Componentize.DotNet.Templates
+dotnet new componentize.wasi.cli -o adder
 cd adder
 ```
 
-The `componentize-dotnet` package depends on the `NativeAOT-LLVM` package, which resides at the
-dotnet-experimental package source, so you will need to make sure that NuGet is configured to refer
-to experimental packages. You can create a project-scoped NuGet configuration by running:
-
-```sh
-dotnet new nugetconfig
-```
-
-Edit your nuget.config file to look like this:
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
- <packageSources>
-    <!--To inherit the global NuGet package sources remove the <clear/> line below -->
-    <clear />
-    <add key="dotnet-experimental" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental/nuget/v3/index.json" />
-    <add key="nuget" value="https://api.nuget.org/v3/index.json" />
- </packageSources>
-</configuration>
-```
-
-Now back in the console we’ll add the `BytecodeAlliance.Componentize.DotNet.Wasm.SDK` package:
-
-```sh
-dotnet add package BytecodeAlliance.Componentize.DotNet.Wasm.SDK --prerelease
-```
-
-In the .csproj project file, add the following to the `<PropertyGroup>`:
-
-```xml
-<RuntimeIdentifier>wasi-wasm</RuntimeIdentifier>
-<UseAppHost>false</UseAppHost>
-<PublishTrimmed>true</PublishTrimmed>
-<InvariantGlobalization>true</InvariantGlobalization>
-<SelfContained>true</SelfContained>
-```
-
 Next, create or download the WIT world you would like to target. For this example we will use an
 [`example`
 world](https://github.com/bytecodealliance/component-docs/tree/main/component-model/examples/example-host/add.wit)
@@ -76,23 +39,36 @@ world example {
 }
 ```
 
-In the .csproj project file, add a new `<ItemGroup>`:
+In the `adder.csproj` project file, add a new `<ItemGroup>`:
 
 ```xml
 <ItemGroup>
     <Wit Update="add.wit" World="example" />
 </ItemGroup>
 ```
 
-If you try to build the project with `dotnet build`, you'll get an error like "The name
+Since this component will only export a function dotnet considers this a library project. Let's update
+the  `<OutputType>` to be a library in the `adder.csproj`:
+
+```xml
+<OutputType>Library</OutputType>
+```
+
+And remove the `Program.cs` file:
+
+```bash
+rm Program.cs
+```
+
+At this point, if you try to build the project with `dotnet build`, you'll get an error like "The name
 'ExampleWorldImpl' does not exist in the current context". This is because you've said you'll
 provide an implementation, but haven't yet done so. To fix this, add the following code to your
-project:
+project in a file called `adder.cs`:
 
 ```csharp
 namespace ExampleWorld;
 
-public class ExampleWorldImpl : IOperations
+public class ExampleWorldImpl : IExampleWorld
 {
     public static uint Add(uint x, uint y)
     {
@@ -107,7 +83,7 @@ If we build it:
 dotnet build
 ```
 
-The component will be available at `bin/Debug/net9.0/wasi-wasm/native/adder.wasm`.
+The component will be available at `bin/Debug/net10.0/wasi-wasm/native/adder.wasm`.
 
 ## Building a component that exports an interface
 
@@ -137,7 +113,7 @@ world hostapp {
 
 If you peek at the bindings, you'll notice that we now implement a class for the `add` interface
 rather than for the `example` world. This is a consistent pattern. As you export more interfaces
-from your world, you implement more classes. Our add example gets the slight update of:
+from your world, you implement more classes. Our `adder.cs` example gets the slight update of:
 
 ```csharp
 namespace ExampleWorld.wit.exports.example.component;
@@ -157,12 +133,12 @@ Once again, compile an application to a Wasm component using `dotnet build`:
 $ dotnet build
 Restore complete (0.4s)
 You are using a preview version of .NET. See: https://aka.ms/dotnet-support-policy
-  adder succeeded (1.1s) → bin/Debug/net9.0/wasi-wasm/adder.dll
+  adder succeeded (1.1s) → bin/Debug/net10.0/wasi-wasm/adder.dll
 
 Build succeeded in 2.5s
 ```
 
-The component will be available at `bin/Debug/net9.0/wasi-wasm/native/adder.wasm`.
+The component will be available at `bin/Debug/net10.0/wasi-wasm/native/adder.wasm`.
 
 ## Building a component that imports an interface
 
@@ -172,51 +148,15 @@ our `adder` component and call the `add` function. We will later compose this co
 the `adder` library component we just built.
 
 Now we will be taking the `adder` component and executing it from another WebAssembly component.
-`dotnet new console` creates a new project that creates an executable.
+`dotnet new componentize.wasi.cli` creates a new project that creates an executable.  
+Back out of the current project and create a new one:
 
 ```sh
-dotnet new console -o host-app
+cd ..
+dotnet new componentize.wasi.cli -o host-app
 cd host-app
 ```
 
-The `componentize-dotnet` package depends on the `NativeAOT-LLVM` package, which resides at the
-dotnet-experimental package source, so you will need to make sure that NuGet is configured to refer
-to experimental packages. You can create a project-scoped NuGet configuration by running:
-
-```sh
-dotnet new nugetconfig
-```
-
-Edit your nuget.config file to look like this:
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
- <packageSources>
-    <!--To inherit the global NuGet package sources remove the <clear/> line below -->
-    <clear />
-    <add key="dotnet-experimental" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental/nuget/v3/index.json" />
-    <add key="nuget" value="https://api.nuget.org/v3/index.json" />
- </packageSources>
-</configuration>
-```
-
-Now back in the console we’ll add the `BytecodeAlliance.Componentize.DotNet.Wasm.SDK` package:
-
-```sh
-dotnet add package BytecodeAlliance.Componentize.DotNet.Wasm.SDK --prerelease
-```
-
-In the .csproj project file, add the following to the `<PropertyGroup>`:
-
-```xml
-<RuntimeIdentifier>wasi-wasm</RuntimeIdentifier>
-<UseAppHost>false</UseAppHost>
-<PublishTrimmed>true</PublishTrimmed>
-<InvariantGlobalization>true</InvariantGlobalization>
-<SelfContained>true</SelfContained>
-```
-
 Copy the same WIT file as before into your project:
 
 ```wit
@@ -236,7 +176,7 @@ world hostapp {
 }
 ```
 
-Add it to your .csproj project file as a new `ItemGroup`:
+Add it to your `host-app.csproj` project file as a new `ItemGroup`:
 
 ```xml
 <ItemGroup>
@@ -255,8 +195,8 @@ Modify `Program.cs` to look like this:
 // example.component refers to the package name defined in the WIT file.
 using HostappWorld.wit.imports.example.component;
 
-var left = 1;
-var right = 2;
+uint left = 1;
+uint right = 2;
 var result = AddInterop.Add(left, right);
 Console.WriteLine($"{left} + {right} = {result}");
 ```
@@ -282,12 +222,30 @@ world, it needs to be composed the first component. You can compose your `host-a
 your `adder` component by running [`wac plug`](https://github.com/bytecodealliance/wac):
 
 ```sh
-wac plug bin/Debug/net9.0/wasi-wasm/native/host-app.wasm --plug ../adder/bin/Debug/net9.0/wasi-wasm/native/adder.wasm -o main.wasm
+wac plug bin/Debug/net10.0/wasi-wasm/native/host-app.wasm --plug ../adder/bin/Debug/net10.0/wasi-wasm/native/adder.wasm -o main.wasm
 ```
 
+You can also automate the process by adding the following to your `host-app.csproj`:
+
+```xml
+<Target Name="ComposeWasmComponent" AfterTargets="Publish">
+    <PropertyGroup>
+        <EntrypointComponent>bin/$(Configuration)/$(TargetFramework)/wasi-wasm/native/host-app.wasm</EntrypointComponent>
+        <DependencyComponent>../adder/bin/$(Configuration)/$(TargetFramework)/wasi-wasm/native/adder.wasm</DependencyComponent>
+    </PropertyGroup>
+    
+    <MakeDir Directories="dist" />
+    <Exec Command="$(WacExe) plug $(EntrypointComponent) --plug $(DependencyComponent) -o dist/main.wasm" />
+</Target>
+```
+
+Run `dotnet build` again you will have a composed component in `./dist/main.wasm`
+
 Then you can run the composed component:
 
 ```sh
-wasmtime run main.wasm
+wasmtime run ./dist/main.wasm
 1 + 2 = 3
 ```
+
+Checkout the [componentize-dotnet docs](https://github.com/bytecodealliance/componentize-dotnet) for more configurations options.