Najlepszy sposób na powtórzenie znaku w C #

Jaki jest najlepszy sposób na wygenerowanie ciągu \tw C #

Uczę się języka C # i eksperymentuję z różnymi sposobami mówienia tego samego.

Tabs(uint t)Jest to funkcja, która zwraca stringz tilością \t„S

Na przykład Tabs(3)zwraca"\t\t\t"

Który z tych trzech sposobów wdrożenia Tabs(uint numTabs)jest najlepszy?

Oczywiście zależy to od tego, co oznacza „najlepszy”.

1. Wersja LINQ to tylko dwie linie, co jest miłe. Ale czy wezwania do powtarzania i agregowania niepotrzebnie pochłaniają czas / zasoby?

2. StringBuilderWersja jest bardzo jasne, ale to StringBuilderklasa jakoś wolniej?

3. stringWersja podstawowa, co oznacza, że jest łatwe do zrozumienia.

4. Czy to w ogóle nie ma znaczenia? Czy wszystkie są równe?

To są wszystkie pytania, które pomogą mi lepiej poznać 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; 
}

A co z tym:

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

Gdzie njest liczba powtórzeń ciągu znaków.

Albo lepiej:

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

string.Concat(Enumerable.Repeat("ab", 2));

Zwroty

„abab”

I

string.Concat(Enumerable.Repeat("a", 2));

Zwroty

„aa”

od...

Czy jest wbudowana funkcja powtarzania łańcucha lub znaku w .net?

We wszystkich wersjach .NET możesz powtórzyć ciąg w ten sposób:

public static string Repeat(string value, int count)
{
    return new StringBuilder(value.Length * count).Insert(0, value, count).ToString();
}

Powtarzanie postaci new String('\t', count)jest najlepszym wyborem. Zobacz odpowiedź @CMS .

Najlepszą wersją jest z pewnością użycie wbudowanego sposobu:

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

Spośród innych rozwiązań preferuj najłatwiejsze; tylko jeśli okaże się to zbyt wolne, staraj się znaleźć bardziej wydajne rozwiązanie.

Jeśli użyjesz StringBuilderi znasz z góry jego wynikową długość, użyj również odpowiedniego konstruktora, jest to o wiele bardziej wydajne, ponieważ oznacza, że ​​ma miejsce tylko jeden czasochłonny przydział i nie ma potrzeby niepotrzebnego kopiowania danych. Bzdury: oczywiście powyższy kod jest bardziej wydajny.

Metody rozszerzenia:

public static string Repeat(this string s, int n)
{
    return new String(Enumerable.Range(0, n).SelectMany(x => s).ToArray());
}

public static string Repeat(this char c, int n)
{
    return new String(c, n);
}

Co z użyciem metody rozszerzenia?

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();
   }
}

Możesz wtedy napisać:

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

Zauważ, że test wydajności użycia wersji programu budującego ciąg dla prostych znaków zamiast ciągów daje dużą karę za wydajność: na moim komputerze różnica mierzonej wydajności wynosi 1:20 pomiędzy: Debug.WriteLine ('-'. Powtórz (1000000)) // wersja char i
Debug.WriteLine („-”. Powtórz (1000000)) // wersja string

Co powiesz na to:

//Repeats a character specified number of times
public static string Repeat(char character,int numberOfIterations)
{
    return "".PadLeft(numberOfIterations, character);
}

//Call the Repeat method
Console.WriteLine(Repeat('\t',40));

Wiem, że to pytanie ma już pięć lat, ale istnieje prosty sposób na powtórzenie ciągu znaków, który działa nawet w .Net 2.0.

Aby powtórzyć ciąg:

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

Zwroty

"Witam Witam Witam, "

Aby powtórzyć ciąg jako tablicę:

// 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(',');

Zwroty

{"Witam Witam Witam", ""}

Nie komplikuj.

Powiedzmy, że chcesz powtórzyć „\ t” n razy, możesz użyć;

String.Empty.PadRight(n,'\t')

Twój pierwszy przykład, który wykorzystuje Enumerable.Repeat:

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

można napisać bardziej kompaktowo za pomocą String.Concat:

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

Korzystanie String.Concati Enumerable.Repeatktóre będzie tańsze niż korzystanieString.Join

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

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

Odpowiedź naprawdę zależy od wymaganej złożoności. Na przykład chcę obrysować wszystkie moje wcięcia pionowym paskiem, więc mój ciąg wcięcia jest określany w następujący sposób:

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

I jeszcze jedna metoda

new System.Text.StringBuilder().Append('\t', 100).ToString()

Dla mnie jest w porządku:

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);
    }
}

Możesz utworzyć metodę rozszerzenia

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

Następnie możesz użyć tego w ten sposób

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

Bez wątpienia przyjęta odpowiedź jest najlepszym i najszybszym sposobem na powtórzenie jednego znaku.

Odpowiedź Binoj Anthony'ego to prosty i dość skuteczny sposób na powtórzenie łańcucha.

Jeśli jednak nie przeszkadza ci trochę więcej kodu, możesz użyć mojej techniki wypełniania tablic, aby efektywnie tworzyć te ciągi jeszcze szybciej. W moich testach porównawczych poniższy kod został wykonany w około 35% czasu kodu 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);
}

Aby uzyskać więcej informacji na temat tej techniki wypełniania tablicy, zobacz Najszybszy sposób wypełnienia tablicy jedną wartością

Spróbuj tego:

1. Dodaj odwołanie Microsoft.VisualBasic
2. Użyj: Ciąg wynik = Microsoft.VisualBasic.Strings.StrDup (5, „cześć”);
3. Daj mi znać, czy to działa dla Ciebie.

Chociaż bardzo podobna do poprzedniej sugestii, lubię ją upraszczać i stosować następujące zasady:

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

Standardowo .Net naprawdę,