Как отформатировать сложные цепочки операторов Linq для удобства чтения?

Question

У меня есть такой код:

var effects = xElement.Elements ( "Effects" ).Elements ( "Effect" ).Select (
    e => new Effect (
        ( EffectType ) Enum.Parse ( typeof ( EffectType ), ( string ) e.Elements ( "Type" ).FirstOrDefault ( ) ),
        e.Elements ( "Options" ).Any ( )
            ? e.Elements ( "Options" ).Select ( o => ( object ) o.Elements ( "Option" ).Select ( n => n.Value ).First ( ) )
            : null ) )
            .ToList ( );

Но в настоящее время это не выглядит читабельным, и я не уверен, куда мне добавить новую строку и / или отступ для читабельности.

Какие-нибудь предложения, которые я мог бы использовать для создания согласованных, читаемых блоков linq?

Answer 1

Я предпочитаю небольшие функции с понятными именами. Примерно так:

    public void Parse()
    {
        //XElement xElement = blah...

        var elements = xElement.Elements("Effects").Elements("Effect");
        var converted = elements.Select(ConvertToEffect);
    }

    private static Effect ConvertToEffect(XElement e)
    {
        var value = ConvertEnum((string) e.Elements("Type").FirstOrDefault());
        var option = GetOption(e.Elements("Options"));

        return new Effect(value, option);
    }

    private static EffectType ConvertEnum(string value)
    {
        return (EffectType)Enum.Parse(typeof(EffectType), value);
    }

    private static IEnumerable<object> GetOption(IEnumerable<XElement> e)
    {
        var any = e.Elements("Options").Any();
        if (any)
        {
            return e.Elements("Options").Select(o => (object) o.Elements("Option").Select(n => n.Value).First());
        }

        return null;
    }

Answer 2

Абсолютно субъективный вопрос, даже не знаю, почему я отвечаю на него, но вот что мне кажется более читабельным :

var effects = xElement
    .Elements("Effects")
    .Elements("Effect")
    .Select(e => 
        new Effect(
            (EffectType)Enum.Parse(
                typeof(EffectType), 
                (string)e.Elements("Type").FirstOrDefault()
            ),
            e.Elements("Options").Any() 
                ? e.Elements("Options").Select(
                    o => o.Elements("Option").Select(n => n.Value).First()
                )
                : null
        ) 
    )
    .ToList();

или если вы предпочитаете синтаксис запроса:

var effects = 
    from e in xElement.Elements("Effects").Elements("Effect")
    let effectType = 
        (EffectType)Enum.Parse(
            typeof(EffectType), 
            (string)e.Elements("Type").FirstOrDefault()
        )
    let options = 
        e.Elements("Options").Any() 
            ? e.Elements("Options").Select(
                  o => o.Elements("Option").Select(n => n.Value).First()
            )
            : null
    select new Effect(effectType, options);

Answer 3

Я думаю, что я отформатировал бы это примерно так:

var effects =
  xElement.Elements("Effects").Elements("Effect")
  .Select (
    e => new Effect(
      (EffectType)Enum.Parse(
        typeof(EffectType),
        (string)e.Elements("Type").FirstOrDefault()
      ),
      e.Elements("Options").Any() ?
        e.Elements("Options")
        .Select(o => (object)o.Elements("Option")
        .Select(n => n.Value).First())
        : null
    )
  )
  .ToList ();

Answer 4

Используйте вместо этого выражение запроса. Я думаю, что это будет более читабельным.