C#, how to handle constant tables

Question

It seems strange that the language apparently includes no suitable functionality.

I find myself with data that would best be expressed as a multi-dimensional array but it's utterly constant, there is no way anyone could want to change it without also changing the associated code. Faced with such stuff in Delphi the answer is obvious--a constant whose value is the table. However, C# doesn't seem to support anything like this.

Google shows many people griping about this, no good answers.

How do people handle this sort of situation?

(And don't say that constants don't belong in code--the last one I bumped into was all possible permutations of 4 items. Unless the very nature of spacetime changes this is set in stone.)

What happened?? There was an answer that came pretty close, I was asking about a detail and it vanished! Simply declaring an array sort of does the job--the only problem is that the array allocation is going to run every time. The one in front of me contains 96 values--how do I get it to initialize only once? Do I just have to accept scoping it far wider than it should be? (As it stands it's in one 3-line routine that's inside what amounts to an O(n^3) routine.)

Answer 1

Enumerations, surely.

Answer 2

ReadOnlyCollection

Answer 3

Well, I've taken the approach of the following, it's a little nasty to read but easy to edit.

 public struct Something
 {
  public readonly int Number;
  public readonly string Name;
  public Something(int num, string name) { this.Number = num; this.Name = name; }
 }

 public readonly Something[] GlobalCollection = new Something[] 
 {
  new Something(1, "One"),
  new Something(2, "Two"),
 };

Answer 4

There's a page in in the C# FAQ about this specific thing.

They suggest using a static readonly array:

static readonly int[,] constIntArray = new int[,] { { 1, 2, 3 }, { 4, 5, 6 }};

However, be aware that this is only sort of constant - you can still reassign individual elements within the array. Also, this has to be specified on the class level since it's a static, but it will work fairly well.

Answer 5

You could use a readonly Hashtable. The only downside is that readonly does not prevent you from changing the value of a particular item in the Hashtable. So it is not truly const.

readonly Hashtable table = new Hashtable(){{1,"One"},{2,"Two"}};

Or an array

public readonly string[,] arry = new string[,]{{"1","2"},{"2","4"}};

Yes, you will need to declare the variable in the appropriate scope so it does not get initialized more than once.

Answer 6

Like they say, just add another layer of indirection. C# doesn't need to provide a specialized data structure as a language primitive, although one does, at times, wish there was a way to make any class immutable, but that's another discussion.

Now you didn't mention if you need to store different things in there. In fact you didn't mention anything other than multi-dimensional and no ability to change the values or the arrays. I don't even know if the access pattern (a single int,int,int indexer) is appropriate.

But in general, for a 3-dimensional jagged array, the following works (but it isn't pretty).

One caveat is the type you construct it with also needs to be immutable, but that's your problem. You can just create your own read-only wrapper.

public static readonly ReadOnlyThreeDimensions<int> MyGlobalThree 
    = new ReadOnlyThreeDimensions<int>(IntInitializer);

public class ReadOnlyThreeDimensions<T> 
{
    private T[][][] _arrayOfT;

    public ReadOnlyThreeDimensions(Func<T[][][]> initializer)
    {
        _arrayOfT = initializer();
    }

    public ReadOnlyThreeDimensions(T[][][] arrayOfT)
    {
        _arrayOfT = arrayOfT;
    }

    public T this [int x, int y, int z]
    {
        get 
        {
            return _arrayOfT[x][y][z];
        } 
    }
}

And then you just need to provide some initializer method, or assign it in a static constructor.

public static int[][][] IntInitializer()
{
    return xyz // something that constructs a [][][]  
}