Multiple static variable scopes within same application?

Question

What is the best way to set up multiple static scopes within the same application? I have structs that serve as wrappers over accessing an array.

Here's an example:

class FooClass{
   static int[] BarArray;
}

struct FooStruct{
    public int BarArrayIndex;

    public int BarArrayValue { 
      get { return FooClass.BarArray[BarArrayIndex]; } 
      set { FooClass.BarArray[BarArrayIndex] = value; }
    }
}

For performance reasons, I don't want to store a reference to BarArray in every instance of FooStruct, hence I declared the array static. However, it's possible that in the future I'll have to work with multiple different BarArrays at the same time (where different instances of the struct should point into different arrays). Is there a way to achieve that without having to store an additional reference in every instance of the structs and not using a static variable neither? If not, what's the best way to use multiple static instances while making the whole application feel as "one application" for the end-user?

Answer 1

You seem to think that holding a reference to an array means copying the array .. ie that each instance of your struct would contain a copy of the array? This is not the case. All the struct would contain is a reference to the array ... a pointer. There would only exist one instance of the array in memory. I'm not sure this is gaining you any performance points.

Answer 2

You can't. The point of static is to have one instance over the whole application.

Have a look at Dependency Injection instead. It should fulfill your usecase perfectly fine and is the prefered way of handling such a problem.

Answer 3

It's not only memory. Every time I create a new instance or copy it (pass it to a method etc.) it'll add some cpu time overhead as well. That's the main thing I'd like to minimize

Then make them class objects. Then you only have to pass a reference around and you can add a ref to the array without penalty. (And No, using 1M small objects on the heap is not a perfromance issue).

But I seriously doubt that copying small structs was singled out by a profiler. It sounds like you're guessing where the bottleneck is.

Answer 4

static class FooClass{
    private static int[][] barArrays;

    public static int[] getBarArray(int instanceIndex)
    {
        return barArrays[instanceIndex];
    }
}

struct FooStruct{
    private int instanceIndex;
    public int BarArrayIndex;

    public int BarArrayValue { 
        get { return FooClass.getBarArray[instanceIndex][BarArrayIndex]; } 
        set { FooClass.getBarArray[instanceIndex][BarArrayIndex] = value; }
    }
}

This is a generalization of the Singleton pattern.

By the way, the performance penalty for each instance of FooStruct to hold on to a common instance of FooClass is absolutely trivial.

Answer 5

The best you could do at this moment is to add a factory method to the FooClass, responsible for returning an instance of the BarArray.

class FooClass {
   int[] GetBarArray() {
   }
}

For now, implement this method to return a static object. If somewhere in future you decide to change the policy of creating the array, you just reimplement the factory method.

Answer 6

If you just want to have multiple static Variables use a new AppDomain for every Context.
But i'm not sure if this is the right soultion for your Problem (See other Answers).

EDIT: Tutorials and Helpful
http://msdn.microsoft.com/en-us/library/system.appdomain.aspx
http://www.beansoftware.com/NET-Tutorials/Application-Domain.aspx
I don't understand Application Domains