Лучший способ конвертировать IEnumerable <char> в строку?

Ответ 1

Предполагая, что вы ищете преимущественно для производительности, тогда что-то вроде этого должно быть значительно быстрее, чем любой из ваших примеров:

string x = "asdf1234";
string y = x.LeadingLettersOnly();

// ...

public static class StringExtensions
{
    public static string LeadingLettersOnly(this string source)
    {
        if (source == null)
            throw new ArgumentNullException("source");

        if (source.Length == 0)
            return source;

        char[] buffer = new char[source.Length];
        int bufferIndex = 0;

        for (int sourceIndex = 0; sourceIndex < source.Length; sourceIndex++)
        {
            char c = source[sourceIndex];

            if (!char.IsLetter(c))
                break;

            buffer[bufferIndex++] = c;
        }
        return new string(buffer, 0, bufferIndex);
    }
}

Ответ 2

Как об этом конвертировать IEnumerable<char> в string:

string.Concat(x.TakeWhile(char.IsLetter));

Ответ 3

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

Я провел несколько тестов производительности трех простых методов преобразования IEnumerable<char> в string, эти методы

новая строка

return new string(charSequence.ToArray());

Concat

return string.Concat(charSequence)

StringBuilder

var sb = new StringBuilder();
foreach (var c in charSequence)
{
    sb.Append(c);
}

return sb.ToString();

В моем тестировании, подробно описанном в связанном вопросе, для 1000000 итераций "Some reasonably small test data" я получаю такие результаты,

1000000 итераций "Конкат" заняло 1597 мс.

1000000 итераций "новой строки" заняло 869 мс.

1000000 итераций "StringBuilder" заняло 748 мс.

Это говорит мне, что нет веских оснований для использования string.Concat для этой задачи. Если вы хотите простоту использовать подход новая строка, и если хотите, чтобы производительность использовала StringBuilder.

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

Ответ 4

Почему нельзя использовать свободный язык в строке?

Это возможно. Вы сделали это в самом вопросе:

var y = new string(x.TakeWhile(char.IsLetter).ToArray());

Нет ли лучшего способа преобразования IEnumerable<char> в строку?

(Мое предположение:)

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

Единственное решение для этого - сначала нажать на массив поддержки или StringBuilder и перераспределить по мере увеличения ввода. Для чего-то низкого уровня как строки, это, вероятно, следует считать слишком скрытым механизмом. Это также поставило бы проблемы с перфорацией в класс строк, поощряя людей использовать механизм, который не может быть как можно быстрее.

Эти проблемы решаются легко, требуя от пользователя использования метода расширения ToArray.

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

Ответ 5

Вы можете очень часто работать лучше. Но что это вы покупаете? Если это действительно не бутылочная горловина для вашего приложения, и вы измерили ее, я бы придерживался версии Linq TakeWhile(): это наиболее читаемое и поддерживаемое решение, и это то, что важно для большинства приложений.

Если вы действительно ищете сырую производительность, вы можете сделать преобразование вручную - в моих тестах было больше фактора 4+ (в зависимости от длины входной строки) быстрее, чем TakeWhile(), но я бы не использовал его лично если это не критично:

int j = 0;
for (; j < input.Length; j++)
{
    if (!char.IsLetter(input[j]))
        break;
}
string output = input.Substring(0, j);

Ответ 6

возвращает новую строку (foo.Select(x = > x).ToArray());