Использование LINQ для объединения строк
-
03-07-2019 - |
Вопрос
Каков наиболее эффективный способ написания олдскульного:
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?
Решение
В этом ответе показано использование 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, и C # поддерживают агрегаты. И VB, и C # поддерживают агрегаты в качестве методов расширения. Используя точечную запись, можно просто вызвать метод в IEnumerable объект.
Помните, что агрегатные запросы выполняются немедленно.
Дополнительная информация - MSDN: агрегат Запросы
<Ч>Если вы действительно хотите использовать <=> вариант с использованием <=>, предложенный в комментарии CodeMonkeyKing , который будет Примерно такой же код, что и у обычного <=>, включая хорошую производительность для большого количества объектов:
var res = words.Aggregate(
new StringBuilder(),
(current, next) => current.Append(current.Length == 0? "" : ", ").Append(next))
.ToString();
Другие советы
return string.Join(", ", strings.ToArray());
<Ч>
В .Net 4 существует новая перегрузка для <кода > string.Join , который принимает IEnumerable < string >
. Код будет выглядеть следующим образом:
return string.Join(", ", strings);
Зачем использовать Linq?
string[] s = {"foo", "bar", "baz"};
Console.WriteLine(String.Join(", ", s));
Это прекрасно работает и принимает любые IEnumerable < string >
, насколько я помню. Нет необходимости Aggregate
здесь что-то намного медленнее.
Рассматривали ли вы метод агрегирования расширений?
var sa = (new[] { "yabba", "dabba", "doo" }).Aggregate((a,b) => a + "," + b);
Реальный пример из моего кода:
return selected.Select(query => query.Name).Aggregate((a, b) => a + ", " + b);
Запрос - это объект, у которого есть свойство Name, представляющее собой строку, и я хочу, чтобы имена всех запросов в выбранном списке были разделены запятыми.
Вы можете использовать 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.)
Вот комбинированный подход Join / Linq, на котором я остановился после рассмотрения других ответов и рассмотренных проблем в аналогичном вопросе (а именно, что агрегировать и конкатенировать не удается с 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.
быстрые данные о производительности для StringBuilder vs Select & amp; Совокупный случай более 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);
}
Я всегда использую метод расширения:
public static string JoinAsString<T>(this IEnumerable<T> input, string seperator)
{
var ar = input.Select(i => i.ToString()).ToArray();
return string.Join(seperator, ar);
}
Под « супер-классным способом 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);
}
}
Это обеспечит код, который является таким же производительным, как и прямой вызов (по крайней мере, с точки зрения сложности алгоритма), и в некоторых случаях может сделать код более читабельным (в зависимости от контекста), особенно если другой код в блоке использует стиль цепочки функций.
На этот есть различные альтернативные ответы. предыдущий вопрос - который, по общему признанию, был нацелен на целочисленный массив в качестве источника, но получил обобщенные ответы.
Здесь используется чистый 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));
}
И это чертовски быстро!
Я собираюсь немного обмануть и выкинуть новый ответ на этот вопрос, который, кажется, суммирует лучшее из всего, что здесь есть, вместо того, чтобы вставлять его в комментарий. Р>
Таким образом, вы можете написать одну строку:
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, вы потеряете свои разделители ... Я считаю это маловероятным. Если это так, у вас есть другие необычные символы на выбор.
Вы можете эффективно комбинировать LINQ и string.join ()
. Здесь я удаляю элемент из строки. Есть и лучшие способы сделать это, но вот оно:
filterset = String.Join(",",
filterset.Split(',')
.Where(f => mycomplicatedMatch(f,paramToMatch))
);
Здесь много вариантов. Вы можете использовать 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();
Я быстро и грязно выполнил следующие действия при синтаксическом анализе файла журнала 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("/cstring[] 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()
;
quot;) &&
!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 ():
<*>Некоторое время назад я писал об этом в блоге, чтобы сделать именно то, что вы ищете:
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(", ");