Najbardziej efektywny sposób łączenia łańcuchów?

Jaki jest najskuteczniejszy sposób łączenia łańcuchów?

Ta StringBuilder.Append()metoda jest znacznie lepsza niż korzystanie z +operatora. Ale odkryłem, że wykonanie 1000 konkatenacji lub mniej String.Join()jest jeszcze bardziej wydajne niż StringBuilder.

StringBuilder sb = new StringBuilder();
sb.Append(someString);

Jedynym problemem String.Joinjest to, że musisz połączyć łańcuchy ze wspólnym separatorem.

Edycja: jak wskazał @ryanversaw , możesz ustawić separator string.Empty.

string key = String.Join("_", new String[] 
{ "Customers_Contacts", customerID, database, SessionID });

Rico Mariani , guru ds. Wydajności .NET, napisał artykuł na ten temat. To nie jest tak proste, jak można się spodziewać. Podstawowa rada jest następująca:

Jeśli Twój wzór wygląda następująco:

x = f1(...) + f2(...) + f3(...) + f4(...)

to jeden konkat i jest spakowany, StringBuilder prawdopodobnie nie pomoże.

Jeśli Twój wzór wygląda następująco:

if (...) x += f1(...)
if (...) x += f2(...)
if (...) x += f3(...)
if (...) x += f4(...)

wtedy prawdopodobnie chcesz StringBuilder.

Kolejny artykuł na poparcie tego twierdzenia pochodzi od Erica Lipperta, w którym szczegółowo opisuje optymalizacje przeprowadzone na +konkatenacjach jednej linii .

Istnieje 6 rodzajów konkatenacji łańcuchów:

1. Korzystanie z +symbolu plus ( ).
2. Korzystanie string.Concat().
3. Korzystanie string.Join().
4. Korzystanie string.Format().
5. Korzystanie string.Append().
6. Korzystanie StringBuilder.

W eksperymencie udowodniono, że string.Concat()jest to najlepszy sposób podejścia, jeśli słowa są mniejsze niż 1000 (w przybliżeniu) i jeśli słowa są większe niż 1000, StringBuildernależy ich użyć.

Aby uzyskać więcej informacji, sprawdź tę stronę .

string.Join () vs string.Concat ()

Metoda string.Concat tutaj jest równoważna wywołaniu metody string.Join z pustym separatorem. Dołączanie pustego ciągu jest szybkie, ale nie robi tego nawet szybciej, więc metoda string.Concat byłaby tutaj lepsza.

Od Chinh Do - StringBuilder nie zawsze jest szybszy :

Reguły kciuka

• Podczas konkatenacji trzech wartości dynamicznych ciągów lub mniej, użyj tradycyjnej konkatenacji ciągów.

• Podczas łączenia więcej niż trzech dynamicznych wartości ciągu użyj StringBuilder.

• Budując duży ciąg z kilku literałów łańcuchowych, użyj @literału łańcuchowego lub operatora inline +.

Większość czasu StringBuilderjest najlepszym wyborem, ale są przypadki pokazane w tym poście, że powinieneś przynajmniej pomyśleć o każdej sytuacji.

Jeśli pracujesz w pętli, StringBuilderprawdopodobnie jest to właściwa droga; oszczędza ci to nakładów związanych z regularnym tworzeniem nowych ciągów. W kodzie, który uruchomi się tylko raz, String.Concatprawdopodobnie jest w porządku.

Jednak Rico Mariani (guru optymalizacji .NET) przygotował quiz, w którym stwierdził na końcu, że w większości przypadków zaleca String.Format.

Oto najszybsza metoda, którą opracowałem przez dekadę dla mojej aplikacji NLP na dużą skalę. Mam wariacje IEnumerable<T>i inne typy danych wejściowych, z separatorami różnych typów i bez nich ( Char, String), ale tutaj pokazuję prosty przypadek połączenia wszystkich łańcuchów w tablicy w pojedynczy łańcuch bez separatora. Najnowsza wersja tutaj została opracowana i przetestowana na C # 7 i .NET 4.7 .

Istnieją dwa klucze do wyższej wydajności; pierwszy polega na wstępnym obliczeniu wymaganego całkowitego rozmiaru. Ten krok jest trywialny, gdy dane wejściowe są tablicą, jak pokazano tutaj. Do obsługi IEnumerable<T>zamiast tego warto najpierw zebrać ciągi do tymczasowej tablicy do obliczenia tej sumy (tablica jest wymagana, aby uniknąć wywoływania ToString()więcej niż raz na element, ponieważ technicznie, biorąc pod uwagę możliwość wystąpienia efektów ubocznych, może to zmienić oczekiwaną semantykę operacji „łączenia ciągu”).

Następnie, biorąc pod uwagę całkowitą wielkość alokacji końcowego łańcucha, największy wzrost wydajności uzyskuje się poprzez zbudowanie łańcucha wynikowego w miejscu . Wykonanie tego wymaga (być może kontrowersyjnej) techniki tymczasowego zawieszenia niezmienności nowego, Stringktóry początkowo ma przypisane zera. Pomijając wszelkie takie kontrowersje ...

... zauważ, że jest to jedyne rozwiązanie konkatenacji zbiorczej na tej stronie, które całkowicie eliminuje dodatkową rundę alokacji i kopiowania przez Stringkonstruktora.

Pełny kod:

/// <summary>
/// Concatenate the strings in 'rg', none of which may be null, into a single String.
/// </summary>
public static unsafe String StringJoin(this String[] rg)
{
    int i;
    if (rg == null || (i = rg.Length) == 0)
        return String.Empty;

    if (i == 1)
        return rg[0];

    String s, t;
    int cch = 0;
    do
        cch += rg[--i].Length;
    while (i > 0);
    if (cch == 0)
        return String.Empty;

    i = rg.Length;
    fixed (Char* _p = (s = new String(default(Char), cch)))
    {
        Char* pDst = _p + cch;
        do
            if ((t = rg[--i]).Length > 0)
                fixed (Char* pSrc = t)
                    memcpy(pDst -= t.Length, pSrc, (UIntPtr)(t.Length << 1));
        while (pDst > _p);
    }
    return s;
}

[DllImport("MSVCR120_CLR0400", CallingConvention = CallingConvention.Cdecl)]
static extern unsafe void* memcpy(void* dest, void* src, UIntPtr cb);

Powinienem wspomnieć, że ten kod ma niewielką modyfikację w stosunku do tego, z czego sam korzystam. W oryginale, ja wywołać cpblk IL dyspozycję z C # zrobić rzeczywiste kopiowanie. Dla uproszczenia i przenośności w kodzie tutaj zastąpiłem to P / Invoke memcpy, jak widać. Aby uzyskać najwyższą wydajność na x64 ( ale może nie x86 ), możesz zamiast tego użyć metody cpblk .

Z tego artykułu MSDN :

Z tworzeniem obiektu StringBuilder wiąże się pewne obciążenie, zarówno czasowe, jak i pamięciowe. Na komputerze z szybką pamięcią StringBuilder staje się opłacalny, jeśli wykonujesz około pięciu operacji. Zasadniczo powiedziałbym, że 10 lub więcej operacji na łańcuchach jest uzasadnieniem narzutu na dowolnej maszynie, nawet wolniejszej.

Jeśli więc ufasz MSDN, skorzystaj z StringBuilder, jeśli musisz wykonać więcej niż 10 operacji / konkatenacji łańcuchów - w przeciwnym razie proste połączenie łańcuchów z '+' jest w porządku.

Ważne jest również, aby podkreślić, że powinieneś używać +operatora, jeśli łączysz literały łańcuchowe .

Podczas łączenia literałów lub stałych ciągów za pomocą operatora + kompilator tworzy pojedynczy ciąg. Nie występuje łączenie w czasie wykonywania.

Instrukcje: łączenie wielu ciągów (Podręcznik programowania w języku C #)

Dodając do innych odpowiedzi, należy pamiętać, że StringBuilder może otrzymać początkową ilość pamięci do przydzielenia .

Pojemność parametr określa maksymalną liczbę znaków, które mogą być przechowywane w pamięci przydzielonej do bieżącej instancji. Jego wartość jest przypisana do właściwości Pojemność . Jeśli liczba znaków, które mają być przechowywane w bieżącej instancji, przekracza tę wartość pojemności , obiekt StringBuilder przydziela dodatkową pamięć do ich przechowywania.

Jeśli pojemność wynosi zero, używana jest domyślna pojemność specyficzna dla implementacji.

Wielokrotne dołączanie do StringBuilder, który nie został wstępnie przydzielony, może powodować wiele niepotrzebnych przydziałów, podobnie jak powtarzające się regularne łączenie ciągów.

Jeśli wiesz, jak długi będzie końcowy ciąg, możesz go trywialnie obliczyć lub zgadnij, co to jest typowy przypadek (przydzielanie zbyt dużej liczby niekoniecznie jest złą rzeczą), powinieneś przekazać te informacje konstruktorowi lub Właściwość pojemności . Zwłaszcza podczas uruchamiania testów wydajności w celu porównania StringBuilder z innymi metodami, takimi jak String.Concat, które robią to samo wewnętrznie. Każdy test widziany online, który nie uwzględnia wstępnej alokacji StringBuilder w swoich porównaniach, jest nieprawidłowy.

Jeśli nie możesz zgadnąć, jaki jest rozmiar, prawdopodobnie piszesz funkcję narzędziową, która powinna mieć własny opcjonalny argument do kontroli wstępnej alokacji.

Poniżej może być jeszcze jedno alternatywne rozwiązanie do łączenia wielu ciągów.

String str1 = "sometext";
string str2 = "some other text";

string afterConcate = $"{str1}{str2}";

interpolacja ciągów

Najbardziej wydajne jest użycie StringBuilder, takie jak:

StringBuilder sb = new StringBuilder();
sb.Append("string1");
sb.Append("string2");
...etc...
String strResult = sb.ToString();

@jonezy: String.Concat jest w porządku, jeśli masz kilka małych rzeczy. Ale jeśli łączysz megabajty danych, Twój program prawdopodobnie się zapełni.

Wypróbuj 2 fragmenty kodu, a znajdziesz rozwiązanie.

 static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 10000000; i++)
        {
            s.Append( i.ToString());
        }
        Console.Write("End");
        Console.Read();
    }

Vs

static void Main(string[] args)
    {
        string s = "";
        for (int i = 0; i < 10000000; i++)
        {
            s += i.ToString();
        }
        Console.Write("End");
        Console.Read();
    }

Przekonasz się, że 1. kod skończy się naprawdę szybko, a pamięć będzie w sporej ilości.

Drugi kod może pamięć będzie w porządku, ale zajmie to dłużej ... znacznie dłużej. Więc jeśli masz aplikację dla wielu użytkowników i potrzebujesz prędkości, użyj 1.. Jeśli masz aplikację na krótki czas dla jednej aplikacji użytkownika, być może możesz użyć obu aplikacji lub druga będzie bardziej „naturalna” dla programistów.

Twoje zdrowie.

W przypadku tylko dwóch ciągów zdecydowanie nie chcesz używać StringBuilder. Istnieje pewien próg, powyżej którego obciążenie StringBuilder jest mniejsze niż obciążenie przydzielania wielu ciągów.

Tak więc, dla więcej niż 2-3 łańcuchów, użyj kodu DannySmurf . W przeciwnym razie wystarczy użyć operatora +.

System.String jest niezmienny. Kiedy modyfikujemy wartość zmiennej łańcuchowej, nowa pamięć jest przydzielana do nowej wartości i poprzedni przydział pamięci jest zwalniany. System.StringBuilder został zaprojektowany w taki sposób, aby miał pojęcie zmiennego ciągu, w którym można wykonywać różne operacje bez przydzielania osobnej lokalizacji pamięci dla zmodyfikowanego ciągu.

Inne rozwiązanie:

wewnątrz pętli użyj List zamiast łańcucha.

List<string> lst= new List<string>();

for(int i=0; i<100000; i++){
    ...........
    lst.Add(...);
}
return String.Join("", lst.ToArray());;

to jest bardzo, bardzo szybkie.

To naprawdę zależy od wzorca użytkowania. Szczegółowy test porównawczy między string.Join, string, Concat i string.Format można znaleźć tutaj: String.Format nie nadaje się do intensywnego rejestrowania

(To jest właściwie ta sama odpowiedź, którą dałem na to pytanie)

To zależy od kodu. StringBuilder jest ogólnie bardziej wydajny, ale jeśli łączysz tylko kilka łańcuchów i robisz to wszystko w jednym wierszu, optymalizacje kodu zapewnią to za Ciebie. Ważne jest, aby pomyśleć również o tym, jak wygląda kod: w przypadku większych zestawów StringBuilder ułatwi czytanie, w przypadku małych StringBuilder po prostu doda niepotrzebnego bałaganu.