Inicjalizacja listy dwuwymiarowej

Mam klasę Foo, następnie robię dwie listy: colData1,colData2

    class Foo
    {
        public string Name;
        public string Width;
    }

        List<Foo> colData1 = new List<Foo>
        {
            new Foo{ Name = "Str1",	Width = "1" },
            new Foo{ Name = "Str2", Width = "2" },
            new Foo{ Name = "Str3", Width = "1" },
        };

        List<Foo> colData2 = new List<Foo>
        {
            new Foo{ Name = "Str4",	Width = "2" },
            new Foo{ Name = "Str1", Width = "4" },
        };

Następnie potrzebuję zrobić listę dwuwymiarową, robię to tak:

      List<List<Foo>> myList = new List<List<Foo>>();
      myList.Add(colData1);
      myList.Add(colData2);

No i wszystko jest OK, tylko chciałbym do zrobienia tej listy dwuwymiarowej użyć inicjalizatorów (żeby kod wyglądał tak jak w przypadku list colData1i colData2) i nie wiem jak to wszystko poskładać żeby zadziałało.

krócej niż:

var myList = new List<List<Foo>> {
    new()
    {
        new(){ Name = "Str1",	Width = "1" },
        new(){ Name = "Str2", Width = "2" },
        new(){ Name = "Str3", Width = "1" },
    },
    new()
    {
        new(){ Name = "Str4",	Width = "2" },
        new(){ Name = "Str1", Width = "4" },
    }
};

chyba się nie da w aktualnej wersji C#, gdyby była to tablica dwuwymiarowa to możnaby było napisać:

Foo[,] myArray = {
      {
          new() { Name = "Str1",	Width = "1" },
          new() { Name = "Str2", Width = "2" },
          new() { Name = "Str3", Width = "1" }
      },
      {
          new() { Name = "Str4",	Width = "2" },
          new() { Name = "Str1", Width = "4" },
          new() { Name = "Str3", Width = "1" }
      }
  };

z tym że tutaj drugi rozmiar musi być stały (nie może być więcej lub mniej elementów w każdym "wierszu"). Jeśli chcesz poszarpaną tablicę (jagged) to znów trzeba wrócić do konstrukcji z new:

Foo[][] myArray = {
	new[] {
		new() { Name = "Str1",	Width = "1" },
    	new() { Name = "Str2", Width = "2" },
        new() { Name = "Str3", Width = "1" }
	},
	new[] {
		new() { Name = "Str4",	Width = "2" },
        new() { Name = "Str1", Width = "4" }
	}
};

Jak wyżej lub jeżeli chcesz dynamicznie to:

            List<List<Foo>> myList = new List<List<Foo>>();
            myList.Add(new List<Foo>());
            myList.Add(new List<Foo>());
            myList[0].Add(new Foo() { Name = "r1c1", Width = "1.1" });
            myList[0].Add(new Foo() { Name = "r1c2", Width = "1.2" });
            myList[1].Add(new Foo() { Name = "r2c1", Width = "2.1" });
            myList[1].Add(new Foo() { Name = "r3c2", Width = "2.2" });

Warto może dodać że aby tak używać inicjalizatorów jak pokazał obscurity należy ustawić w projekcie wersję C# na minimum 9.0.

Powinno działać nawet na archaicznych wersjach:

	var myList = new List<List<Foo>> {
		new List<Foo> {
	            new Foo{ Name = "Str1", Width = "1" },
	            new Foo{ Name = "Str2", Width = "2" },
	            new Foo{ Name = "Str3", Width = "1" }
		},
		new List<Foo> {
			new Foo{ Name = "Str4",	Width = "2" },
			new Foo{ Name = "Str1", Width = "4" },
		}
	};

ja czuje subiektywną niechęć do wewnętrznej listy jako takiej. i MI po analizie zawsze wychodzi, że to wewnętrzne coś, nie jest stricte listą, ile NAZWANYM obiektem zawierającym listę.
To strasznie rzadka sytuacja, że mamy nienazwaną zbiorowość, "kolekcję", NxM, mamy oczywiście macierz w sensie matematycznym

public class FooContainer {
  /* public */ List<Foo> date = new List<Foo>();
   public FooContainer (....) {} 
   string comething ;
}

List<FooContainer>

Wg mnie tu specjalnie podany przykład w którym pierwszy wiersz ma 3 kolumny zaś drugi tylko 2, aby nie mylić z NxM — _13th_Dragon 2 minuty temu

Oczywiście, lista list nie ma charakteru matematycznej macierzy, już samo to że jest zapisana jako lista. NxM to skrócony zapis dwóch wymiarów - nie nazwanych co do charakteru i głownie to chciałem podkreslić.

Wiesz co ... myślę z kawą w ręce ... powiedziałbym paradoksalnie, że na gruncie INFORMATYKI (gdyby matematyka nie istniała) tablica t[a,b] jest zbędna - jedynie oczywisty wpływ matematyki to uzwasadnia (zresztą, bardzo dobrze uzasadnia).
Potrafię sobie wyobrazić język, który nie ma natywnych tablic o wymiarze wiekszym niż 1 - ale sa w module Math