Dollnet核心的DllImport返回当前DLL的DLLNotFoundException

Question

Over the past few days I have been trying to interface with a C library (built for an ARM platform) on linux, in dotnet core. All I am trying to do is call a simple function which (essentially) returns a string.

However, I have no experience of using DLLImport or interop on the whole in C# and I am struggling.

The C code looks like (with substitute names as I am using a work platform):

int version(int argc, char *argv[])
{
    return READ_DATA(0,
            version, //callbackfunction
            "version: 0x%04x\n"); //formatting string
}

    public class Board
    {
        private Interop_Commands _commands = new Interop_Commands();

        public string GetVersion()
        {
            return _commands.GetVersion();
        }
    }
    internal class Interop_Commands
    {
        public const string LIBRARYPATH = "libname";
        [DllImport(LIBRARYPATH,CharSet=CharSet.Unicode, CallingConvention =CallingConvention.Cdecl)]
        public static extern int version(int argc, StringBuilder argv);

        public string GetVersion()
        {
            var sb = new StringBuilder();
            Console.WriteLine($"Calling {nameof(version)}");
            version(0, sb);
            Console.WriteLine($"Called {nameof(version)}, got: {sb.ToString()}");
            return sb.ToString();
        }
    }

with the calling class (main for this very simple proof of concept/trial code):

    static void Main(string[] args)
    {
        Console.WriteLine("Getting Version from board..");

        var board = new Board();
        Console.WriteLine(board.GetVersion());

        Console.WriteLine("done");
        Console.ReadLine();
    }

The folder structure is (simplified):

folder
|--> Dll/runtime
|--> libname (note no .so here, just libname)

Any help would be appreciated, I am finding examples of C imports/usages limited, and also finding examples limited for how to use custom libraries in dotnet core.

EDIT 1:

Following help from @Sohaib Jundi, I have added the extern so the signature is now: (it wouldnt compile with extern "C")

extern int version(int argc, char *argv[])

I am unsure what to try next.

but dotnet core wont publish with x86 and target runtime set to linux-arm , just throws an unknown exception, with the log file not being very helpful.. If i use the compiled library with the previous code ( AnyCPU + linux-arm ), then the DllNotFoundException is still thrown

* EDIT 2: *

As it turns out, the original no extension file i was using appears to be an executable referencing a static library (which ends up compiled into the executable). rebuilding I have managed to get the static library separate, but still get the same DllNotFoundException . Does anyone know what the search procedure is for the DllImport on dotnet core?

The interop/import code now looks like:

[DllImport("libname", 
           CallingConvention =CallingConvention.Cdecl,
           EntryPoint= "version")]
public static extern int version(ref uint val);

where the static lib code looks like:

extern int version(uint32_t *);

Answer 1

After some playing around, I managed to get an example to work.
Follow these steps:
1. export your function from the dll, ie: add extern "C" __declspec(dllexport) to the function signature
2. Make sure that both the dll and your dotnet core application have the same architecture. don't keep the dotnet core as "Any CPU", force it to the same architecture as the dll. (project properties -> build -> platform target = x86 or x64)

Answer 2

I have found the solution.. the library was being compiled as a .la (statically linked library) rather than a .so (shared object) library. The DllImport doesnt work with statically linked libraries so.. a recompilation of the library into a shared object library has meant it will now find the dll (I also exported LD_LIBRARY_PATH as pwd to make sure it was in the search path..).

Once this was in, the rest of the code fell into place. The matching dll import declaration for the version above was correct (from *EDIT 2 * ) - using ref uint . So now I have to extend the methods supported in my interop class to fully support the library.

Thanks for your help @Sohaib Jundi