Native AOT + unmanaged static lib interop: DLL required while development phase?

[thewavelength]

In my final deployment, I want to link against an unmanaged static lib as written in the Native code interop article. As far as I understand, static lib linking is not possible while being in "development phase", as it's a feature of the "publish" self-contained executable step. I want to normally debug my application while developing it.

1. Is it really the "correct" way to link dynamically in development phase and link statically at publish time?
2. Does this mean I have to have my libraries available both as static and dynamic versions to have a proper development phase?
3. Are there ideas for future ways to improve that experience?

[AustinWise]

1. Yes, I think it makes sense to use CoreCLR dynamically linking against your library during development. The compile times are much faster than doing native AOT. Beyond that, you can use features like hot reload to further speed up the development inner loop. ilc.exe itself (the NativeAOT compiler) is developed this way in this repo.
2. Yes, this means you will need dynamically libraries when running on CoreCLR and need static libraries when publishing for NativeAOT.
3. I have some thoughts on the C# side that makes it relatively painless, but you still to compile your native libraries twice. I'm not aware of a way to make the fundamental difference between static and dynamic linking easier.

I have a sample that illustrates a way to build an application that can both work with dynamic libraries when running on CoreCLR and static libraries when publishing with NativeAOT:

https://github.com/AustinWise/DotNetHostingAndNativeAot

Note that the way this project is set up, every possible build configuration is supported. You can build for CoreCLR for release and debug. You can publish for NativeAOT for release and debug.

The key point is when compiling for CoreCLR, the shared libraries is copied to the output directory with a Copy MSBuild item. When publishing for NativeAOT, the static library is referenced with a NativeLibrary MSBuild item and the P/Invokes are forced to statically link with a DirectPInvoke item. This way the C# code is the same whether you are using a dynamic library on CoreCLR or statically linking when publishing with NativeAOT.