Использование LINQ для конкатенации строк

Каков наиболее эффективный способ написания старой школы:

StringBuilder sb = new StringBuilder();
if (strings.Count > 0)
{
    foreach (string s in strings)
    {
        sb.Append(s + ", ");
    }
    sb.Remove(sb.Length - 2, 2);
}
return sb.ToString();

... в LINQ?

298
20 окт. '08 в 11:46
источник поделиться
17 ответов

Этот ответ показывает использование LINQ (Aggregate) в соответствии с запросом в вопросе и не предназначен для повседневного использования. Поскольку это не использует StringBuilder него будет ужасная производительность для очень длинных последовательностей. Для обычного кода используйте String.Join как показано в другом ответе

Используйте агрегированные запросы следующим образом:

string[] words = { "one", "two", "three" };
var res = words.Aggregate(
   "", // start with empty string to handle empty list case.
   (current, next) => current + ", " + next);
Console.WriteLine(res);

Эти результаты:

one, two, three

Агрегат - это функция, которая берет набор значений и возвращает скалярное значение. Примеры из T-SQL включают min, max и sum. Оба VB и С# поддерживают агрегаты. Оба VB и С# поддерживают агрегаты как методы расширения. Используя точечную нотацию, вы просто вызываете метод на объект IEnumerable.

Помните, что агрегированные запросы выполняются немедленно.

Дополнительная информация - MSDN: сводные запросы


Если вы действительно хотите использовать вариант использования Aggregate с помощью StringBuilder предложенный в комментарии CodeMonkeyKing, который будет примерно того же кода, что и обычный String.Join включая хорошую производительность для большого количества объектов:

 var res = words.Aggregate(
     new StringBuilder(), 
     (current, next) => current.Append(current.Length == 0? "" : ", ").Append(next))
     .ToString();
477
20 окт. '08 в 11:53
источник

Связанные вопросы


Похожие вопросы

return string.Join(", ", strings.ToArray());

В.Net 4 появилась новая перегрузка для string.Join которая принимает IEnumerable<string>. Тогда код будет выглядеть так:

return string.Join(", ", strings);
293
20 окт. '08 в 16:28
источник

Зачем использовать Linq?

string[] s = {"foo", "bar", "baz"};
Console.WriteLine(String.Join(", ", s));

Это работает отлично и принимает любой IEnumerable<string>, насколько я помню. Нет необходимости Aggregate что-нибудь здесь, что намного медленнее.

117
23 сент. '08 в 21:18
источник

Вы просмотрели метод расширения Aggregate?

var sa = (new[] { "yabba", "dabba", "doo" }).Aggregate((a,b) => a + "," + b);
74
23 сент. '08 в 21:09
источник

Реальный пример из моего кода:

return selected.Select(query => query.Name).Aggregate((a, b) => a + ", " + b);

Запрос - это объект, у которого есть свойство Name, которое является строкой, и мне нужны имена всех запросов в выбранном списке, разделенные запятыми.

56
20 окт. '08 в 11:52
источник

Вы можете использовать StringBuilder в Aggregate:

  List<string> strings = new List<string>() { "one", "two", "three" };

  StringBuilder sb = strings
    .Select(s => s)
    .Aggregate(new StringBuilder(), (ag, n) => ag.Append(n).Append(", "));

  if (sb.Length > 0) { sb.Remove(sb.Length - 2, 2); }

  Console.WriteLine(sb.ToString());

(Select находится там, чтобы показать, что вы можете делать больше материалов LINQ.)

27
19 мая '10 в 23:42
источник

Вот комбинированный подход Join/Linq, на котором я остановился, рассмотрев другие ответы и проблемы, рассмотренные в аналогичном вопросе (а именно, что Aggregate и Concatenate с 0 элементами).

string Result = String.Join(",", split.Select(s => s.Name));

или (если s не является строкой)

string Result = String.Join(",", split.Select(s => s.ToString()));

  • просто
  • легко читать и понимать
  • работает для генерических элементов
  • позволяет использовать объекты или свойства объекта
  • обрабатывает случай с 0-образными элементами
  • может использоваться с дополнительной фильтрацией Linq
  • (по крайней мере, по моему опыту)
  • не требует (вручную) создания дополнительного объекта (например, StringBuilder) для реализации

И, конечно же, Join заботится о досадной финальной запятой, которая иногда пробирается в другие подходы (for, foreach), поэтому я искал решение Linq в первую очередь.

27
04 окт. '12 в 22:02
источник

данные быстрой производительности для случая StringBuilder и Select & Aggregate более 3000 элементов:

Единичный тест - Длительность (в секундах)
LINQ_StringBuilder - 0.0036644
LINQ_Select.Aggregate - 1.8012535

    [TestMethod()]
    public void LINQ_StringBuilder()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000;i++ )
        {
            ints.Add(i);
        }
        StringBuilder idString = new StringBuilder();
        foreach (int id in ints)
        {
            idString.Append(id + ", ");
        }
    }
    [TestMethod()]
    public void LINQ_SELECT()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000; i++)
        {
            ints.Add(i);
        }
        string ids = ints.Select(query => query.ToString())
                         .Aggregate((a, b) => a + ", " + b);
    }
22
11 мая '10 в 1:46
источник

Я всегда использую метод расширения:

public static string JoinAsString<T>(this IEnumerable<T> input, string seperator)
{
    var ar = input.Select(i => i.ToString()).ToArray();
    return string.Join(seperator, ar);
}
15
08 мая '09 в 20:02
источник

Посредством "супер-крутого метода LINQ" вы можете говорить о том, как LINQ делает функциональное программирование намного более приятным с использованием методов расширения. Я имею в виду, синтаксический сахар, который позволяет функциям быть цепями визуально линейным способом (один за другим) вместо гнездования (один внутри другого). Например:

int totalEven = Enumerable.Sum(Enumerable.Where(myInts, i => i % 2 == 0));

можно записать следующим образом:

int totalEven = myInts.Where(i => i % 2 == 0).Sum();

Вы можете видеть, как второй пример легче читать. Вы также можете увидеть, как можно добавить больше функций с меньшими проблемами с отступом или закрывающимися парсерами Lispy, появляющимися в конце выражения.

Многие другие ответы говорят о том, что String.Join - это путь, потому что он является самым быстрым или простейшим для чтения. Но если вы примете мою интерпретацию "супер-крутого пути LINQ", тогда ответ будет состоять в использовании String.Join, но он будет завершен в метод расширения стиля LINQ, который позволит вам целенаправленно связывать ваши функции. Поэтому, если вы хотите написать sa.Concatenate(", "), вам просто нужно создать что-то вроде этого:

public static class EnumerableStringExtensions
{
   public static string Concatenate(this IEnumerable<string> strings, string separator)
   {
      return String.Join(separator, strings);
   }
}

Это обеспечит код, который так же эффективен, как и прямой вызов (по крайней мере, с точки зрения сложности алгоритма), и в некоторых случаях может сделать код более читаемым (в зависимости от контекста), особенно если другой код в блоке использует цепочки функций.

12
16 мая '12 в 15:37
источник

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

5
20 окт. '08 в 12:14
источник

Здесь используется чистый LINQ как одно выражение:

static string StringJoin(string sep, IEnumerable<string> strings) {
  return strings
    .Skip(1)
    .Aggregate(
       new StringBuilder().Append(strings.FirstOrDefault() ?? ""), 
       (sb, x) => sb.Append(sep).Append(x));
}

И его довольно чертовски быстро!

5
03 сент. '12 в 7:34
источник

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

Итак, вы можете выделить одну строку:

List<string> strings = new List<string>() { "one", "two", "three" };

string concat = strings        
    .Aggregate(new StringBuilder("\a"), 
                    (current, next) => current.Append(", ").Append(next))
    .ToString()
    .Replace("\a, ",string.Empty); 

Изменить:. Вы либо захотите сначала проверить пустое перечисление, либо добавить .Replace("\a",string.Empty); в конец выражения. Угадай, что я, возможно, пытался немного сообразить.

Ответ от @a.friend может быть немного более результативным, я не уверен, что Replace делает под капотом по сравнению с Remove. Единственное другое предостережение, если по какой-то причине вы хотели конкатрировать строки, которые закончились в \a, вы потеряете разделители... Я нахожу это маловероятным. Если это так, у вас есть другие причудливые символы на выбор.

3
01 сент. '11 в 20:42
источник

Вы можете эффективно комбинировать LINQ и string.join(). Здесь я удаляю элемент из строки. Есть и лучшие способы сделать это, но вот оно:

filterset = String.Join(",",
                        filterset.Split(',')
                                 .Where(f => mycomplicatedMatch(f,paramToMatch))
                       );
2
02 февр. '11 в 12:00
источник

Я делал следующее быстро и грязно при анализе файла журнала IIS с использованием linq, он работал на 1 миллион строк довольно хорошо (15 секунд), хотя и получил ошибку из памяти при попытке 2 миллиона строк.

    static void Main(string[] args)
    {

        Debug.WriteLine(DateTime.Now.ToString() + " entering main");

        // USED THIS DOS COMMAND TO GET ALL THE DAILY FILES INTO A SINGLE FILE: copy *.log target.log 
        string[] lines = File.ReadAllLines(@"C:\Log File Analysis\12-8 E5.log");

        Debug.WriteLine(lines.Count().ToString());

        string[] a = lines.Where(x => !x.StartsWith("#Software:") &&
                                      !x.StartsWith("#Version:") &&
                                      !x.StartsWith("#Date:") &&
                                      !x.StartsWith("#Fields:") &&
                                      !x.Contains("_vti_") &&
                                      !x.Contains("/c$") &&
                                      !x.Contains("/favicon.ico") &&
                                      !x.Contains("/ - 80")
                                 ).ToArray();

        Debug.WriteLine(a.Count().ToString());

        string[] b = a
                    .Select(l => l.Split(' '))
                    .Select(words => string.Join(",", words))
                    .ToArray()
                    ;

        System.IO.File.WriteAllLines(@"C:\Log File Analysis\12-8 E5.csv", b);

        Debug.WriteLine(DateTime.Now.ToString() + " leaving main");

    }

Настоящая причина, по которой я использовал linq, была для Distinct(), которая мне раньше понадобилась:

string[] b = a
    .Select(l => l.Split(' '))
    .Where(l => l.Length > 11)
    .Select(words => string.Format("{0},{1}",
        words[6].ToUpper(), // virtual dir / service
        words[10]) // client ip
    ).Distinct().ToArray()
    ;
1
14 дек. '11 в 21:41
источник

Здесь много вариантов. Вы можете использовать LINQ и StringBuilder, чтобы вы тоже получили производительность:

StringBuilder builder = new StringBuilder();
List<string> MyList = new List<string>() {"one","two","three"};

MyList.ForEach(w => builder.Append(builder.Length > 0 ? ", " + w : w));
return builder.ToString();
1
21 апр. '10 в 23:02
источник

Я писал об этом некоторое время назад, что я сделал, чтобы быть именно тем, что вы ищете:

http://ondevelopment.blogspot.com/2009/02/string-concatenation-made-easy.html

В сообщении в блоге описывается, как реализовать методы расширения, которые работают на IEnumerable и называются Concatenate, это позволит вам писать такие вещи, как:

var sequence = new string[] { "foo", "bar" };
string result = sequence.Concatenate();

Или более сложные вещи вроде:

var methodNames = typeof(IFoo).GetMethods().Select(x => x.Name);
string result = methodNames.Concatenate(", ");
0
15 нояб. '09 в 14:50
источник

Посмотрите другие вопросы по меткам или Задайте вопрос