如何跳过二维数组的某些初始化程序？

Question

I have the following definition

static readonly String[,] allItems = {
    { "Alpha", null },
    { "Beta", "Magic" },
    { "Gamma", null },
    // more items follow
}

In the first column all items must be initialized to some string literals. In the second column only a small fraction of items must be initialized to string literals and all others are null.

I now need to add the third column and it will mostly contain null s and I'd be happy to omit typing all of them.

Is there a way to somehow omit those null values?

Answer 1

I'm not sure if this is the answer you are looking for but have you considered using an object instead. You can then give default values and only supply ones that are different.

for example

public class YourObject{    
    public string Name {get;set;}
    public string Value {get;set;}
    public string SomethingElse {get;set;}

    public YourObject()
    {
        //provide defaults here
        SomethingElse = "";
    }

}

Then to create objects you can create like so

static readonly List<YourObject> allItems = new List<YourObject>{
    new YourObject{ Name = "Alpha" },
    new YourObject{ Name = "Beta", Value = "Magic" },
    new YourObject{ Name = "Gamma", SomethingElse = "Hello" }
    // more items follow
}

Sriram Sakthivel suggested this whilst i was typing ;)

Answer 2

Try out list. that would allow you to add only required elements. You can add further elements later on

List allList=new List; allList.Add()

Answer 3

You can create a class and then use a collection:

class MyClass
{
   public string Prop1 {get;set;}
   public string Prop2 {get;set;}   
   public MyClass(string prop1, string prop2 = null)
   {
       this.Prop1 = prop1;
       this.Prop2 = prop2   
   }
}

Now, you can use a List<T>

var list = new List<MyClass>()
{
    new MyClass("Alpha"),
    new MyClass("Beta" , "Magic"),
    new MyClass("Gamme")    
}

Answer 4

If you are not sure about number of columns and you want to define just like table then I recommend you using DataTable. Thus you can define column type and enforce any constraint. This way you can even use Linq to manipulate values.

Here is the sample code:

DataTable table = new DataTable();
table.Columns.Add("Dosage", typeof(int));
table.Columns.Add("Drug", typeof(string));
table.Columns.Add("Patient", typeof(string));
table.Columns.Add("Date", typeof(DateTime));

//
// Here we add five DataRows.
//
table.Rows.Add(25, "Indocin", "David", DateTime.Now);
table.Rows.Add(50, "Enebrel", "Sam", DateTime.Now);
table.Rows.Add(10, "Hydralazine", "Christoff", DateTime.Now);
table.Rows.Add(21, "Combivent", "Janet", DateTime.Now);
table.Rows.Add(100, "Dilantin", "Melanie", DateTime.Now);
return table;

Answer 5

You can write a class modelling a jagged two dimensional array that can be initialized using a collection initializer. The class has to implement IEnumerable and should have an appropriate Add method:

class Table<T> : IEnumerable<IEnumerable<T>> {

  readonly List<T[]> rows = new List<T[]>();

  public void Add(params T[] row) {
    rows.Add(row);
  }

  public IEnumerator<IEnumerable<T>> GetEnumerator() {
    return rows.GetEnumerator();
  }

  IEnumerator IEnumerable.GetEnumerator() {
    return GetEnumerator();
  }

}

You can then use this class directly by say implementing an indexer ( public T this[Int32 rowIndex, Int32 columnIndex] { get { ... } } ) but a better solution is probably to create a method that converts the table to an array:

public T[,] ToArray() {
  var columnCount = rows.Max(row => row.Length);
  var array = new T[rows.Count, columnCount];
  for (var rowIndex = 0; rowIndex < rows.Count; rowIndex += 1)
    for (var columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
      var row = rows[rowIndex];
      array[rowIndex, columnIndex] = columnIndex < row.Length
        ? row[columnIndex] : default(T);
    }
  return array;
}

You can then initialize the two dimensional array using this code:

static readonly String[,] allItems = new Table<String> {
  { "Alpha" },
  { "Beta", "Magic" },
  { "Gamma" },
}.ToArray();