Wrapping a static unmanaged library in an instance class

Question

I'm using an unmanaged library (written in C++) in my code (C#). All the methods provided by the library are static. I use P/Invoke to communicate with the library. Here's the way the library works:

1. There's an initialization method that you need to call before calling all the other methods (this takes one parameter and that parameter can only be set during initialization).
2. There's a settings method to change different settings for the library, you need to run this if you need to change the way the library works (more like fine-tuning the library). Settings can be changed any time.
3. There is a method that takes an array of numbers, and returns another array. Let's call this the intermediate operation. This operation takes a while, so I'd like to cache it and prevent calculating it every time.
4. The array returned by the previous method (intermediate operation) is an input to the last method that creates the result. Let's call this the main operation

I'd normally like to have different instances of the library, one with settings A and the other one with settings B. As the library is static, I can't.

How can I wrap this library in an instance class? Probably, every instance of my class will need to load a new instance of the library in memory (as every instance of the library itself is static, and you can't have two different setting in one instance of the library).

Is there a workaround for this, other than re-writing the library (as I don't have any control on how it's written)?

And I'd really like to be able to handle parallel calls to operation methods.

Answer 1

Here's an example implementation of what's been said in the comments to the question:

public class Library
{
    private static class Native
    {
        [DllImport("foobar.dll")]
        public static extern void Initialize();

        [DllImport("foobar.dll")]
        public static extern void Settings(int param1, string param2);

        [DllImport("foobar.dll")]
        public static extern float[] Intermediate(float[] input);

        [DllImport("foobar.dll")]
        public static extern void MainMethod(float[] main);
    }

    private static readonly object sync = new object();

    private int param1;
    private string param2;

    static Library()
    {
        Native.Initialize();
    }


    public void Settings(int param1, string param2)
    {
        this.param1 = param1;
        this.param2 = param2;
    }

    public float[] Intermediate(float[] input)
    {
        lock (sync)
        {
            Native.Settings(param1, param2);
            return Native.Intermediate(input);
        }
    }

    public void MainMethod(float[] input)
    {
        lock (sync)
        {
            Native.Settings(param1, param2);
            Native.MainMethod(input);
        }
    }
}

The most important things

• Settings does not call the "real" settings immediately, but stores the values
• When Intermediate and MainMethod are called they apply the settings store previously
• Both calls are synchronized on a static object to avoid that calls to different instances of Library running on different threads interfere.

Answer 2

As I suggested in my comment, if palatalization is required, the only workaround I can think of is to go with a multi-process approach: wrapping each "settings" in an independent process. Of course that will make communication and data-traffic between processes the new candidate for a bottle-neck (whether you will be using WCF named pipes, Remoting, WM_COPYDATA or sockets).