Сделать более читаемо - .NET

Есть такая портянка, есть иысли как её можно сделать поприличнее?

            var table2CacheFields = new Dictionary<string, List<string[]>>()
            {
                {
                    "Table1", new List<string[]>()
                        {
                            new string[]{"Field1"},
                            new string[]{"Field2"},
                        }
                },
                {
                    "Table2", new List<string[]>()
                        {
                            new string[]{"Field1"},
                            new string[]{"Field3", "Field4"},
                        }
                }
            };

Спасибо

Здравствуйте, Tom, Вы писали:

Tom>Есть такая портянка, есть иысли как её можно сделать поприличнее?

Скобки можно убрать:

var table2CacheFields = new Dictionary<string, List<string[]>>
{
    {
        "Table1", new List<string[]>
            {
                new string[] {"Field1"},
                new string[] {"Field2"},
            }
    },
    {
        "Table2", new List<string[]>
            {
                new string[] {"Field1"},
                new string[] {"Field3", "Field4"},
            }
    },
};

если c#3.0,
то вместо new string[] использовать просто new[], ну и убрать скобки

            var table2CacheFields = new Dictionary<string, List<string[]>>
                                        {
                                            {
                                                "Table1", new List<string[]>
                                                              {
                                                                  new[] {"Field1"},
                                                                  new[] {"Field2"},
                                                              }
                                                },
                                            {
                                                "Table2", new List<string[]>
                                                              {
                                                                  new[] {"Field1"},
                                                                  new[] {"Field3", "Field4"},
                                                              }
                                                },
                                        };

Здравствуйте, moxnatiy, Вы писали:

M>если c#3.0,
M>то вместо new string[] использовать просто new[], ну и убрать скобки

M>

M>            var table2CacheFields = new Dictionary<string, List<string[]>>
M>                                        {
M>                                            {
M>                                                "Table1", new List<string[]>
M>                                                              {
M>                                                                  new[] {"Field1"},
M>                                                                  new[] {"Field2"},
M>                                                              }
M>                                                },
M>                                            {
M>                                                "Table2", new List<string[]>
M>                                                              {
M>                                                                  new[] {"Field1"},
M>                                                                  new[] {"Field3", "Field4"},
M>                                                              }
M>                                                },
M>                                        };
M>

Оно лучше конечно но всё равно как то криво. Ещё бы от new List<string[]> избавиться как нибудь

Здравствуйте, moxnatiy, Вы писали:

M>если c#3.0,
M>то вместо new string[] использовать просто new[], ну и убрать скобки

А если List не принципиален (например, не будет меняться) то можно и вовсе

var table2CacheFields = new Dictionary<string, IList<string[]>>
{
  { "Table1", new [] { new [] {"Field1"}, new [] {"Field2"}, } },
  { "Table2", new [] { new [] {"Field1"}, new [] {"Field3", "Field4"}, } },
};

Здравствуйте, Tom, Вы писали:

Я бы тайп-алиасы добавил. Так вот выглядит несколько чище:

var table2CacheFields = new TABLE
{
    {
        "Table1", new ROW
            {
                new[]{"Field1"},
                new[]{"Field2"},
            }
    },
    {
        "Table2", new ROW
            {
                new[]{"Field1"},
                new[]{"Field3", "Field4"},
            }
    }
};

Здравствуйте, Воронков Василий, Вы писали:

ВВ>Здравствуйте, Tom, Вы писали:

ВВ>Я бы тайп-алиасы добавил. Так вот выглядит несколько чище:

ВВ>

ВВ>var table2CacheFields = new TABLE
ВВ>{
ВВ>    {
ВВ>        "Table1", new ROW
ВВ>            {
ВВ>                new[]{"Field1"},
ВВ>                new[]{"Field2"},
ВВ>            }
ВВ>    },
ВВ>    {
ВВ>        "Table2", new ROW
ВВ>            {
ВВ>                new[]{"Field1"},
ВВ>                new[]{"Field3", "Field4"},
ВВ>            }
ВВ>    }
ВВ>};
ВВ>

По-моему жесть.

Два вопроса:
1. Как это скомпилить? (студия 08-я)
2. Почему МСДНовский сайт ни рыла не знает о type alias? Если я, конечно, правильно все это на чухонский перевел...

Здравствуйте, Smarty, Вы писали:

S>По-моему жесть.

Два вопроса:
S>1. Как это скомпилить? (студия 08-я)
S>2. Почему МСДНовский сайт ни рыла не знает о type alias? Если я, конечно, правильно все это на чухонский перевел...

Странно, что не знает. Type alias еще с самой первой версии в шарпе. Объявляется с помощью директивы using:

using TABLE = System.Collections.Generic.Dictionary<striung,System.Collections.Generic.List<string[]>>;

Но названия типов надо указывать полностью и видно только в пределах одного файла.

Здравствуйте, Воронков Василий, Вы писали:

ВВ>Объявляется с помощью директивы using:

Ах это...

Ну так, ясно, работает. Просто МСДНу эта "фишка" известна как

an alias for a namespace or a type

вот и не ищется по простому alias type, а сам я в виду редкости применения на практике второй реинкарнации директивы using все время о ней забываю... Спасибо за напоминание!

Здравствуйте, Воронков Василий, Вы писали:

ВВ>using TABLE = System.Collections.Generic.Dictionary<striung,System.Collections.Generic.List<string[]>>;

ВВ>Но названия типов надо указывать полностью…

Не обязательно:

using System.Collections.Generic;

namespace Aaaa
{
  using Table = Dictionary<string, List<string[]>>;

  // …
}

Здравствуйте, Tom, Вы писали:

Tom>Есть такая портянка, есть иысли как её можно сделать поприличнее?
На F# вот так, например:

open System.Linq

let table2CacheFields =
    [
      "Table1",
        [["Field1"];
         ["Field2"]];
      "Table2",
        [["Field1"];
         ["Field3"; "Field4"]]
    ].ToDictionary(fst, snd)

Здравствуйте, Tom, Вы писали:

Tom>Есть такая портянка, есть иысли как её можно сделать поприличнее?

Есть отличная мысль, как сделать понеприличнее:
Для начала сохраняешь данные в xml:

<?xml version="1.0" encoding="utf-8" ?>
<data>
    <table name="Table1">
        <row>
            <field>Field1</field>
        </row>
        <row>
            <field>Field2</field>
        </row>
    </table>
    <table name="Table2">
        <row>
            <field>Field1</field>
        </row>
        <row>
            <field>Field3</field>
            <field>Field4</field>
        </row>
    </table>
</data>

Потом одним махом их вычитываешь:

var dict = (from table in XDocument.Load("Data.xml").Descendants("table")
            let rows = from row in table.Elements("row")
                       let fields = from field in row.Elements("field")
                                    select field.Value
                       select fields.ToArray()
            select new {
                name = table.Attribute("name"),
                rows = rows.ToList()
            }).ToDictionary(_ => _.name, _ => _.rows);

Ляпота.

Здравствуйте, Lloyd, Вы писали:

Tom>>Есть такая портянка, есть иысли как её можно сделать поприличнее?
L>Есть отличная мысль, как сделать понеприличнее:
L>Для начала сохраняешь данные в xml:
…

Ещё неприличнее будет compile-time-генерация проблемного кода по этому xml

L>Ляпота.

я тоже вначале думал или XML или типизированный датасет, но в итоге решил что это усложнение для конкретной задачи.

Здравствуйте, Аноним, Вы писали:

Tom>>Есть такая портянка, есть иысли как её можно сделать поприличнее?
А>На F# вот так, например:
А>

А>open System.Linq

А>let table2CacheFields =
А>    [
А>      "Table1",
А>        [["Field1"];
А>         ["Field2"]];
А>      "Table2",
А>        [["Field1"];
А>         ["Field3"; "Field4"]]
А>    ].ToDictionary(fst, snd)
А>

Меряем у кого короче?

Тогда вот Nemerle-овый вариант:

    def table2CacheFields = Nemerle.Collections.Hashtable([
      ("Table1", [["Field1"], ["Field2"]]), 
      ("Table2", [["Field1"], ["Field3", "Field4"]])
      ]);

хотя конечно можно и так же:

using System.Linq;

def table2CacheFields = [
  ("Table1", [["Field1"], ["Field2"]]), 
  ("Table2", [["Field1"], ["Field3", "Field4"]])
  ].ToDictionary(x => x[0], x => x[1]);

Здравствуйте, VladD2, Вы писали:

F#

    let table2CacheFields = Map.of_list([
      "Table1", [["Field1"], ["Field2"]]; 
      "Table2", [["Field1"], ["Field3", "Field4"]]
      ]);

Здравствуйте, Tom, Вы писали:

Tom>Есть такая портянка, есть иысли как её можно сделать поприличнее?
Если это принципиально, то я бы сделал в функциональном стиле а ля StringBuilder

var table2CacheFields = new CacheTableFields()
       .AddFields("table1", "field1", "field2")
       .AddFields("table2", "field1", "field2")
       .AddFields("table3", "field1", "field2").ToDictionary();

Все таки имена методов и имя объектов дают больше информации о предназначении чем абстрактный List.

Здравствуйте, GlebZ, Вы писали:

GZ>Если это принципиально, то я бы сделал в функциональном стиле а ля StringBuilder
GZ>

GZ>var table2CacheFields = new CacheTableFields()
GZ>       .AddFields("table1", "field1", "field2")
GZ>       .AddFields("table2", "field1", "field2")
GZ>       .AddFields("table3", "field1", "field2").ToDictionary();
GZ>

А что тут функционального?

Здравствуйте, Tom, Вы писали:

L>>Ляпота.

Tom>я тоже вначале думал или XML или типизированный датасет, но в итоге решил что это усложнение для конкретной задачи.
еще есть время передумать.

Здравствуйте, desco, Вы писали:

D>F#
D>

D>    let table2CacheFields = Map.of_list([
D>      "Table1", [["Field1"], ["Field2"]]; 
D>      "Table2", [["Field1"], ["Field3", "Field4"]]
D>      ]);
D>

Ага, только в результате имеем другую структуру данных. Не ту что в задаче.

От:	Tom	http://www.RSDN.ru
Дата:	18.06.09 13:07
Оценка:

От:	Qbit86	https://twitter.com/qbit86
Дата:	18.06.09 13:11
Оценка:

	От:	moxnatiy
	Дата:	18.06.09 13:43
	Оценка:

От:	Tom	http://www.RSDN.ru
Дата:	18.06.09 13:52
Оценка:

От:	Qbit86	https://twitter.com/qbit86
Дата:	18.06.09 13:53
Оценка:	14 (1)

	От:	Воронков Василий
	Дата:	18.06.09 13:58
	Оценка:	9 (1)

От:	_FRED_	@ViIvanov
Дата:	18.06.09 17:40
Оценка:	13 (2) +2

	От:	Аноним
	Дата:	18.06.09 18:19
	Оценка:	1 (1)

От:	VladD2	www.nemerle.org
Дата:	19.06.09 17:24
Оценка:

От:	desco	http://v2matveev.blogspot.com
Дата:	20.06.09 13:48
Оценка:

	От:	Draqon
	Дата:	21.06.09 20:53
	Оценка:

	От:	Igor Sukhov
	Дата:	22.06.09 05:31
	Оценка: