1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
# ORT C# Managed Library
The solution files here are used to produce nuget packages for the C# bindings.
Note that the project naming is currently confusing and needs updating.
- The Microsoft.ML.OnnxRuntime project produces the Microsoft.ML.OnnxRuntime.**Managed** nuget package.
- The Microsoft.ML.OnnxRuntime nuget package contains the native (i.e. C++) code for various platforms.
## Solution files
The main solution file is OnnxRuntime.CSharp.sln. This includes desktop and Xamarin mobile projects.
OnnxRuntime.DesktopOnly.CSharp.sln is a copy of that with all the mobile projects removed. This is
due to there being no way to selectively exclude a csproj from the sln if Xamarin isn't available.
If changes are required, either update the main solution first and copy the relevant changes across,
or copy the entire file and remove the mobile projects (anything with iOS, Android or Droid in the name).
## Development setup:
### Requirements:
#### Windows
NOTE: The usage of this solution is primarily for ORT developers creating the managed Microsoft.ML.OnnxRuntime.Managed
nuget package. Due to that, the requirements are quite specific.
Visual Studio 2022 v17.2.4 or later, with Xamarin workloads
- v17.2.4 installs dotnet sdk 6.0.301
- in theory you could use an earlier VS version and download dotnet SDK 6.0.300+ from https://dotnet.microsoft.com/en-us/download/dotnet/6.0
- untested
There's no good way to use Visual Studio 2022 17.3 Preview in a CI, so we currently have to build pre-.net6 targets
using VS, and .net6 targets using dotnet. We can't build them all using dotnet as the xamarin targets require msbuild.
We can't package them using dotnet as that also requires msbuild.
Once the official VS 2022 release supports .net6 and is available in the CI we can revert to the original simple
setup of building everything using msbuild.
To test packaging locally you will also need nuget.exe.
Download from https://www.nuget.org/downloads.
Put in a folder (e.g. C:\Program Files (x86)\NuGet).
Add that folder to your PATH.
#### Linux
1. Install [.Net SDK](https://dotnet.microsoft.com/download).
2. Install Mono.
```bash
wget http://download.mono-project.com/repo/xamarin.gpg && sudo apt-key add xamarin.gpg && rm xamarin.gpg
echo "deb https://download.mono-project.com/repo/ubuntu stable-bionic main" | sudo tee /etc/apt/sources.list.d/mono-official-stable.list
sudo apt update -y && apt install -y mono-devel
```
3. Install `nupkg.exe`
```bash
wget https://dist.nuget.org/win-x86-commandline/latest/nuget.exe && sudo mv nuget.exe /usr/local/bin/nuget.exe
echo 'mono /usr/local/bin/nuget.exe $@' | sudo tee /usr/local/bin/nuget
chmod a+x /usr/local/bin/nuget
```
### Magic incantations to build the nuget managed package locally:
#### Windows
If we're starting with VS 2022 17.2.4 we should have dotnet sdk 6.0.301
The IncludeMobileTargets property determines whether the MAUI targets are included. This is set to 'true' for the
real package build.
Make sure all the required workloads are installed if the MAUI targets are included.
`dotnet workload install maui android ios maccatalyst`
- original example from [here](https://github.com/Sweekriti91/maui-samples/blob/swsat/devops/6.0/Apps/WeatherTwentyOne/devops/AzureDevOps/azdo_windows.yml):
Restore and build the managed package.
`msbuild -t:restore .\src\Microsoft.ML.OnnxRuntime\Microsoft.ML.OnnxRuntime.csproj -p:IncludeMobileTargets=true`
`msbuild -t:build .\src\Microsoft.ML.OnnxRuntime\Microsoft.ML.OnnxRuntime.csproj -p:IncludeMobileTargets=true`
Need to run msbuild twice - once to restore which creates some json configs that are needed like
Microsoft.ML.OnnxRuntime\obj\project.assets.json, and once to build using those configs.
Create nuget package
`msbuild .\OnnxRuntime.CSharp.proj -t:CreatePackage -p:OrtPackageId=Microsoft.ML.OnnxRuntime -p:Configuration=Debug -p:Platform="Any CPU"`
#### Linux
For example, to build a CUDA GPU package, just run:
```bash
./build.sh \
--config="Release" \
--cmake_generator Ninja \
--use_cuda \
--cuda_home=/usr/local/cuda \
--cudnn_home=/usr \
--build_nuget \
--msbuild_extra_options \
/p:SelectedTargets=Net6 \
/p:Net6Targets=net6.0 \
/p:TargetFrameworks=netstandard2.0 \
/p:IsLinuxBuild=true
```
**Note**: to build a pure CPU development package, you need to add `/p:OrtPackageId="Microsoft.ML.OnnxRuntime"`
to `--msbuild_extra_options`. Otherwise, it will try to create Xamarin mobile targets which may not be properly configured on your devbox.
A `.nupkg` file will be produced at you build root, say, `build/Release`.
To consume the package, in your .net project,
```bash
nuget add <path/to/packages.nuget> -Source ./packages/
dotnet add package microsoft.ml.onnxruntime.managed -s ./packages --prerelease
dotnet add package microsoft.ml.onnxruntime.gpu -s ./packages --prerelease
```
|
