учета - экранирование символов c#




Лучший способ повторить символ в C# (13)

Что это лучший способ создать строку из \t 's в C #

Я изучаю C # и экспериментирую с разными способами говорить то же самое.

Tabs(uint t) - это функция, которая возвращает string с t количеством \t 's

Например, Tabs(3) возвращают "\t\t\t"

Какой из этих трех способов реализации Tabs(uint numTabs) лучше всего?

Конечно, это зависит от того, что означает «лучший».

  1. Версия LINQ - это только две строки, что приятно. Но являются ли призывы к повторению и объединению излишним потреблением времени / ресурсов?

  2. Версия StringBuilder очень понятна, но класс StringBuilder как-то медленнее?

  3. string версия является базовой, что означает, что ее легко понять.

  4. Разве это не имеет значения? Все ли они равны?

Это все вопросы, которые помогут мне лучше понять C #.

private string Tabs(uint numTabs)
{
    IEnumerable<string> tabs = Enumerable.Repeat("\t", (int) numTabs);
    return (numTabs > 0) ? tabs.Aggregate((sum, next) => sum + next) : ""; 
}  

private string Tabs(uint numTabs)
{
    StringBuilder sb = new StringBuilder();
    for (uint i = 0; i < numTabs; i++)
        sb.Append("\t");

    return sb.ToString();
}  

private string Tabs(uint numTabs)
{
    string output = "";
    for (uint i = 0; i < numTabs; i++)
    {
        output += '\t';
    }
    return output; 
}

Без сомнения, принятый ответ - лучший и быстрый способ повторить один символ.

Ответ Биноя Энтони - простой и довольно эффективный способ повторить строку.

Однако, если вы не возражаете немного больше кода, вы можете использовать мою технику заполнения массива, чтобы эффективно создавать эти строки еще быстрее. В моих сравнительных тестах приведенный ниже код выполняется примерно в 35% времени кода StringBuilder.Insert.

public static string Repeat(this string value, int count)
{
    var values = new char[count * value.Length];
    values.Fill(value.ToCharArray());
    return new string(values);
}

public static void Fill<T>(this T[] destinationArray, params T[] value)
{
    if (destinationArray == null)
    {
        throw new ArgumentNullException("destinationArray");
    }

    if (value.Length > destinationArray.Length)
    {
        throw new ArgumentException("Length of value array must not be more than length of destination");
    }

    // set the initial array value
    Array.Copy(value, destinationArray, value.Length);

    int copyLength, nextCopyLength;

    for (copyLength = value.Length; (nextCopyLength = copyLength << 1) < destinationArray.Length; copyLength = nextCopyLength)
    {
        Array.Copy(destinationArray, 0, destinationArray, copyLength, copyLength);
    }

    Array.Copy(destinationArray, 0, destinationArray, copyLength, destinationArray.Length - copyLength);
}

Дополнительные сведения об этой технике заполнения массива см. В разделе Самый быстрый способ заполнения массива одним значением


Ваш первый пример, который использует Enumerable.Repeat :

private string Tabs(uint numTabs)
{
    IEnumerable<string> tabs = Enumerable.Repeat(
                                 "\t", (int) numTabs);
    return (numTabs > 0) ? 
            tabs.Aggregate((sum, next) => sum + next) : ""; 
} 

может быть переписана более компактно с помощью String.Concat :

private string Tabs(uint numTabs)
{       
    return String.Concat(Enumerable.Repeat("\t", (int) numTabs));
}

Вы можете создать метод расширения

static class MyExtensions
{
    internal static string Repeat(this char c, int n)
    {
        return new string(c, n);
    }
}

Тогда вы можете использовать его так

Console.WriteLine('\t'.Repeat(10));

Для меня все хорошо:

public static class Utils
{
    public static string LeftZerosFormatter(int zeros, int val)
    {
        string valstr = val.ToString();

        valstr = new string('0', zeros) + valstr;

        return valstr.Substring(valstr.Length - zeros, zeros);
    }
}

Использование String.Concat и Enumerable.Repeat которое будет менее дорогостоящим, чем использование String.Join

public static Repeat(this String pattern, int count)
{
    return String.Concat(Enumerable.Repeat(pattern, count));
}

Как насчет использования метода расширения?

public static class StringExtensions
{
   public static string Repeat(this char chatToRepeat, int repeat) {

       return new string(chatToRepeat,repeat);
   }
   public  static string Repeat(this string stringToRepeat,int repeat)
   {
       var builder = new StringBuilder(repeat*stringToRepeat.Length);
       for (int i = 0; i < repeat; i++) {
           builder.Append(stringToRepeat);
       }
       return builder.ToString();
   }
}

Тогда вы могли бы написать:

Debug.WriteLine('-'.Repeat(100)); // For Chars  
Debug.WriteLine("Hello".Repeat(100)); // For Strings

Обратите внимание, что тест производительности использования версии строковой версии для простых символов вместо строк дает вам серьезную предваряющую предвзятость: на моем компьютере разница в измеренной производительности составляет 1:20 между: Debug.WriteLine ('-'. Repeat (1000000)) // char и
Debug.WriteLine ("-". Repeat (1000000)) // строковая версия


Как насчет этого:

string tabs = new String('\t', n);

Где n - количество повторений строки.

Или лучше:

static string Tabs(int n)
{
    return new String('\t', n);
}

Лучшая версия, безусловно, должна использовать встроенный способ:

string Tabs(int len) { return new string('\t', len); }

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

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


Ответ действительно зависит от сложности, которую вы хотите. Например, я хочу выделить все свои отступы с вертикальной полосой, поэтому моя строка отступа определяется следующим образом:

return new string(Enumerable.Range(0, indentSize*indent).Select(
  n => n%4 == 0 ? '|' : ' ').ToArray());

Попробуй это:

  1. Добавить ссылку Microsoft.VisualBasic
  2. Использование: Результат строки = Microsoft.VisualBasic.Strings.StrDup (5, «привет»);
  3. Дайте мне знать, если это сработает для вас.

Хотя это очень похоже на предыдущее предложение, мне нравится держать его простым и применять следующее:

string MyFancyString = "*";
int strLength = 50;
System.Console.WriteLine(MyFancyString.PadRight(strLength, "*");

Стандарт .Net действительно,


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

Чтобы повторить строку:

string repeated = new String('+', 3).Replace("+", "Hello, ");

Возвращает

"Привет привет привет, "

Повторить строку как массив:

// Two line version.
string repeated = new String('+', 3).Replace("+", "Hello,");
string[] repeatedArray = repeated.Split(',');

// One line version.
string[] repeatedArray = new String('+', 3).Replace("+", "Hello,").Split(',');

Возвращает

{"Привет привет привет", ""}

Будь проще.


var str = new string(Enumerable.Repeat('\t', numTabs).ToArray());






string