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

346

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

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?

tags2k
источник
1
Вы открыли для себя какие-нибудь другие классные способы LINQ?
Роберт С.
3
Хорошо выбранный ответ и все другие параметры не работают в Linq to Entities.
Биной ​​Антоний
3
@Binoj Антоний, не заставляй свою базу данных выполнять конкатенацию строк.
Эми Б
6
@ Pr0fess0rX: Потому что не может и потому что не должен. Я не знаю о других базах данных, но в SQL Server вы можете использовать только concat (n) varcahr, который ограничивает вас (n) varchar (max). Этого не должно быть, потому что бизнес-логика не должна реализовываться на уровне данных.
the_drow
любое окончательное решение с полным исходным кодом и высокой производительностью?
Kiquenet

Ответы:

529

Этот ответ показывает использование 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);

Это выводит:

, раз два три

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

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

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


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

 var res = words.Aggregate(
     new StringBuilder(), 
     (current, next) => current.Append(current.Length == 0? "" : ", ").Append(next))
     .ToString();
Хорхе Феррейра
источник
4
Первый пример не выводит «один, два, три», он выводит «один, два, три» (обратите внимание на начальную запятую).
Морт
В первом примере, так как вы ""начинаете с первого значения, используется currentпустая строка. Таким образом, для 1 или более элементов, вы всегда получите , в начале строки.
Майкл Янни
@ Я исправил это
sergtk
358
return string.Join(", ", strings.ToArray());

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

return string.Join(", ", strings);
Эми Б
источник
2
Итак, решение не использует Linq, но мне кажется, что оно работает очень хорошо
Мэт Робертс
33
ToArray is linq :)
Эми Б
18
Это самый правильный ответ. Это быстрее, чем как вопрос, так и принятый ответ, и гораздо яснее, чем Агрегированный, который требует пояснения длиной в параграф каждый раз, когда он используется.
PRMan
@realPro Совершенно неверно. github.com/microsoft/referencesource/blob/master/mscorlib/… строка 161
Эми Б
125

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

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

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

Армин Ронахер
источник
19
Изучение LINQ может быть классным, и LINQ может быть хорошим средством для достижения цели, но использование LINQ для фактического получения конечного результата было бы, по меньшей мере, плохо, если не откровенно глупо
Джейсон Бантинг
9
.NET 4.0 имеет перегрузку IEnumerable <string> и IEnumrable <T>, что значительно облегчит его использование
Cine
3
Как указывает Cine, в .NET 4.0 есть перегрузка. Предыдущие версии этого не делают. Вы все еще можете String.Join(",", s.ToArray())в старых версиях, хотя.
Мартейн
1
К вашему сведению: объединено со stackoverflow.com/questions/122670/…
Shog9
@ Shog9 Объединение делает ответы здесь похожими на дублированные усилия, а временные метки не помогают вообще. Все еще путь.
Nawfal
77

Вы смотрели на метод совокупного расширения?

var sa = (new[] { "yabba", "dabba", "doo" }).Aggregate((a,b) => a + "," + b);
Роберт С.
источник
23
Это, вероятно, медленнее, чем String.Join (), и труднее читать в коде. Отвечает ли на вопрос «LINQ way», хотя :-)
Крис Уэнам,
5
Да, я не хотел портить ответ своим мнением. : P
Роберт С.
2
Это, безусловно, немного медленнее, на самом деле. Даже использование Aggregate с StringBuilder вместо конкатенации медленнее, чем String.Join.
Джоэл Мюллер
4
Выполнен тест с 10 000 000 итераций, агрегат занял 4,3 с, а string.join - 2,3 с. Так что я бы сказал, что разница в производительности не важна для 99% случаев общего использования. Так что, если вы уже делаете много linq для обработки ваших данных, обычно нет необходимости нарушать этот красивый синтаксис и использовать string.join imo. gist.github.com/joeriks/5791981
joeriks
1
К вашему сведению: объединено со stackoverflow.com/questions/122670/…
Shog9
56

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

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

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

Дэниел Уорвикер
источник
2
Учитывая комментарии по производительности, я должен добавить, что пример взят из кода, который запускается один раз, когда диалог закрывается, и в списке вряд ли когда-либо будет более десяти строк!
Даниэль Уорвикер
Любой ключ, как сделать эту же задачу в Linq to Entities?
Биной ​​Антоний
1
Отличный пример. Спасибо, что поместили это в сценарий реального мира. У меня была точно такая же ситуация со свойством объекта, который требовал конкатенации.
Джесси Хоул
1
Голосовали за то, что помогли мне понять, что первая часть выбора строкового свойства моего Списка <T>
Nikki9696,
1
Пожалуйста, напишите о производительности этого подхода с большим массивом.
Джулио Качинь
31

Вот комбинированный подход 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 в первую очередь.

brichins
источник
1
пропущенная скобка.
Ctrl-Alt-Delor
1
К вашему сведению: объединено со stackoverflow.com/questions/122670/…
Shog9
3
Мне нравится этот ответ, потому .Select()что такое использование обеспечивает удобное место для изменения каждого элемента во время этой операции. Например, упаковка каждого элемента в какой - то персонаж , как такstring Result = String.Join(",", split.Select(s => "'" + s + "'"));
Сэм Стори
29

Вы можете использовать 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.)

jonathan.s
источник
2
+1 приятно. Тем не менее, IMO лучше избегать добавления дополнительных «,», чем стереть их потом. Нечто подобноеnew[] {"one", "two", "three"}.Aggregate(new StringBuilder(), (sb, s) =>{if (sb.Length > 0) sb.Append(", ");sb.Append(s);return sb;}).ToString();
dss539
5
Вы бы сэкономили драгоценные такты, не проверяя if (length > 0)в linq и убирая его.
Биной ​​Антони
1
Я согласен с dss539. Моя версия соответствуетnew[] {"", "one", "two", "three"}.Aggregate(new StringBuilder(), (sb, s) => (String.IsNullOrEmpty(sb.ToString())) ? sb.Append(s) : sb.Append(", ").Append(s)).ToString();
ProfNimrod
22

быстрые данные о производительности для случая 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);
    }
user337754
источник
Полезно при принятии решения пойти не по маршруту LINQ для этого
crabCRUSHERclamCOLLECTOR
4
Разница во времени, вероятно, StringBuilder против String Concatination с использованием +. Ничего общего с LINQ или Aggregate. Поместите StringBuilder в LINQ Aggregate (множество примеров для SO), и все должно быть так же быстро.
пульт управления
16

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

public static string JoinAsString<T>(this IEnumerable<T> input, string seperator)
{
    var ar = input.Select(i => i.ToString());
    return string.Join(seperator, ar);
}
Киран Бентон
источник
5
string.Joinв .net 4 уже можно взять IEnumerable<T>любой произвольный T.
рекурсивный
1
К вашему сведению: объединено со stackoverflow.com/questions/122670/…
Shog9
12

Под « супер-классным способом 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);
   }
}

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

TPower
источник
1
Количество опечаток в этой теме сумасшедшее: seperator => separator, Concatinate => Concatenate
SilverSideDown
1
К вашему сведению: объединено со stackoverflow.com/questions/122670/…
Shog9
5

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

Джон Скит
источник
5

Здесь он использует чистый 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));
}

И это чертовски быстро!

cdiggins
источник
3

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

Таким образом, вы можете в одну строку это:

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, вы потеряете свои разделители ... Я считаю это маловероятным. Если это так, у вас есть другие необычные персонажи на выбор.

Крис Марисик
источник
2

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

filterset = String.Join(",",
                        filterset.Split(',')
                                 .Where(f => mycomplicatedMatch(f,paramToMatch))
                       );
Andiih
источник
1
К вашему сведению: объединено со stackoverflow.com/questions/122670/…
Shog9
1

Много вариантов здесь. Вы можете использовать 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();
Келли
источник
Было бы быстрее не проверять builder.Length > 0в ForEach и удалив первую запятую после ForEach
Binoj Antony
1

Я быстро и грязно сделал следующее при разборе файла журнала 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
К вашему сведению: объединено со stackoverflow.com/questions/122670/…
Shog9
0

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

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(", ");
Патрик Хагне
источник
1
К вашему сведению: объединено со stackoverflow.com/questions/122670/…
Shog9
Можете ли вы объединить код здесь, чтобы ответ был легче понять?
Джулио Качинь