Wieloliniowy ciąg literału w C #

Czy istnieje prosty sposób na utworzenie literału ciągu wielowierszowego w języku C #?

Oto co mam teraz:

string query = "SELECT foo, bar"
+ " FROM table"
+ " WHERE id = 42";

Wiem, że PHP ma

<<<BLOCK

BLOCK;

Czy C # ma coś podobnego?

Możesz użyć @symbolu przed a, stringaby utworzyć dosłowny ciąg literału :

string query = @"SELECT foo, bar
FROM table
WHERE id = 42";

Nie musisz także uciekać przed znakami specjalnymi , korzystając z tej metody, z wyjątkiem podwójnych cudzysłowów, jak pokazano w odpowiedzi Jona Skeeta.

W języku C # nazywa się to dosłowne dosłowne ciągi literalne , a kwestią jest umieszczenie @ przed literałem. Pozwala to nie tylko na wiele linii, ale także wyłącza ucieczkę. Na przykład możesz wykonać:

string query = @"SELECT foo, bar
FROM table
WHERE name = 'a\b'";

Obejmuje to jednak podział wiersza (przy użyciu dowolnego podziału wiersza, jaki ma je źródło) w ciągu. W przypadku SQL jest to nie tylko nieszkodliwe, ale prawdopodobnie poprawia czytelność w dowolnym miejscu łańcucha - ale w innych miejscach może nie być wymagane, w takim przypadku albo nie musisz używać dosłownego ciągu literowego o wielu wierszach, lub usuń je z powstałego ciągu.

Jedyną różnicą jest to, że jeśli chcesz podwójnego cudzysłowu, musisz dodać dodatkowy symbol podwójnego cudzysłowu:

string quote = @"Jon said, ""This will work,"" - and it did!";

Problem z używaniem literału ciągów, który znajduję, polega na tym, że może sprawić, że twój kod będzie wyglądał „ dziwnie ”, ponieważ aby nie uzyskać spacji w samym ciągu, należy go całkowicie wyrównać:

    var someString = @"The
quick
brown
fox...";

Fuj

Tak więc rozwiązaniem, które lubię używać, dzięki czemu wszystko ładnie dopasowuje się do reszty kodu:

var someString = String.Join(
    Environment.NewLine,
    "The",
    "quick",
    "brown",
    "fox...");

I oczywiście, jeśli chcesz po prostu logicznie podzielone wiersze instrukcji SQL jak jesteś i w rzeczywistości nie potrzebują nowej linii, zawsze można po prostu zastąpić Environment.NewLineza " ".

Inną sprawą, na którą trzeba uważać, jest użycie literałów łańcuchowych w łańcuchu znaków. W takim przypadku musisz uciec nawiasom klamrowym / nawiasom klamrowym „{” i „}”.

// this would give a format exception
string.Format(@"<script> function test(x) 
      { return x * {0} } </script>", aMagicValue)
// this contrived example would work
string.Format(@"<script> function test(x) 
      {{ return x * {0} }} </script>", aMagicValue)

Na marginesie, w C # 6.0 możesz teraz łączyć interpolowane ciągi z dosłownym dosłownym ciągiem:

string camlCondition = $@"
<Where>
    <Contains>
        <FieldRef Name='Resource'/>
        <Value Type='Text'>{(string)parameter}</Value>
    </Contains>
</Where>";

Dlaczego ludzie mylą ciągi z literałami ciągu? Przyjęta odpowiedź jest świetną odpowiedzią na inne pytanie; nie do tego.

Wiem, że to stary temat, ale przyszedłem tutaj z prawdopodobnie tym samym pytaniem co OP, i frustrujące jest obserwowanie, jak ludzie wciąż go błędnie interpretują. A może źle to rozumiem, nie wiem.

Z grubsza mówiąc, ciąg znaków to obszar pamięci komputera, który podczas wykonywania programu zawiera sekwencję bajtów, które można odwzorować na znaki tekstowe. Z drugiej strony, literał ciągu znaków jest fragmentem kodu źródłowego, który nie został jeszcze skompilowany i reprezentuje wartość użytą do zainicjowania ciągu znaków później podczas wykonywania programu, w którym się pojawia.

W języku C # instrukcja ...

 string query = "SELECT foo, bar"
 + " FROM table"
 + " WHERE id = 42";

... nie produkuje trzywierszowego sznurka, ale jedną wkładkę; konkatenacja trzech łańcuchów (każdy zainicjowany z innego literału), z których żaden nie zawiera modyfikatora nowej linii.

To, o co OP wydaje się pytać - a przynajmniej to, o co pytałbym tymi słowami - nie polega na tym, jak wprowadzić w skompilowanym ciągu znaków podział wierszy naśladujący te znajdujące się w kodzie źródłowym, ale na jak długo rozdzielić dla zachowania przejrzystości , pojedynczy wiersz tekstu w kodzie źródłowym bez wprowadzania przerw w skompilowanym ciągu. I nie wymagając dłuższego czasu wykonywania, spędziłem dołączając do wielu podciągów pochodzących z kodu źródłowego. Podobnie jak końcowe ukośniki odwrotne w literale ciągu wielowierszowego w javascript lub C ++.

Sugerowanie użycia dosłownych ciągów, nieistotnych StringBuilders, s, String.Joina nawet funkcji zagnieżdżonych z odwracaniem ciągów, a co nie, sprawia, że ​​myślę, że ludzie tak naprawdę nie rozumieją pytania. A może nie rozumiem tego.

O ile mi wiadomo, C # nie ma (przynajmniej w wersji paleolitycznej, której wciąż używam, z poprzedniej dekady) funkcji czystego generowania wieloliniowych literałów łańcuchowych, które można rozwiązać podczas kompilacji, a nie wykonywania.

Być może obecne wersje to obsługują, ale pomyślałem, że podzielę różnicę, którą dostrzegam między łańcuchami i literałami łańcucha.

AKTUALIZACJA:

(Od komentarza MeowCat2012) Możesz. Podejście „+” OP jest najlepsze. Zgodnie ze specyfikacją gwarantowana jest optymalizacja: http://stackoverflow.com/a/288802/9399618

Nie widziałem tego, więc opublikuję go tutaj (jeśli chcesz przekazać ciąg znaków, możesz to zrobić). Pomysł polega na tym, że możesz podzielić ciąg na wiele wierszy i dodać własną treść (również na wielu liniach) w dowolny sposób. Tutaj „tableName” można przekazać do ciągu.

    private string createTableQuery = "";

    void createTable(string tableName)
    {

         createTableQuery = @"CREATE TABLE IF NOT EXISTS
                ["+ tableName  + @"] (
               [ID] INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, 
               [Key] NVARCHAR(2048)  NULL, 
               [Value] VARCHAR(2048)  NULL
                                )";
    }

Możesz użyć @ i „” .

        string sourse = @"{
        ""items"":[
        {
            ""itemId"":0,
            ""name"":""item0""
        },
        {
            ""itemId"":1,
            ""name"":""item1""
        }
        ]
    }";

Tak, możesz podzielić ciąg na wiele wierszy bez wprowadzania nowych wierszy do rzeczywistego ciągu, ale nie jest ładny:

string s = $@"This string{
string.Empty} contains no newlines{
string.Empty} even though it is spread onto{
string.Empty} multiple lines.";

Sztuką jest wprowadzenie kodu, który ewaluuje do pustego, a kod ten może zawierać znaki nowej linii bez wpływu na wynik. Dostosowałem to podejście z tej odpowiedzi do podobnego pytania.

Wygląda na to, że istnieje pewne zamieszanie co do pytania, ale istnieją dwie wskazówki, że chcemy tutaj dosłowny ciąg znaków nie zawierający żadnych znaków nowego wiersza, którego definicja obejmuje wiele wierszy. (w komentarzach tak mówi, a „oto co mam” pokazuje kod, który nie tworzy łańcucha z nowymi liniami)

Ten test jednostkowy pokazuje zamiar:

    [TestMethod]
    public void StringLiteralDoesNotContainSpaces()
    {
        string query = "hi"
                     + "there";
        Assert.AreEqual("hithere", query);
    }

Zmień powyższą definicję zapytania, tak aby był to jeden literał łańcuchowy, zamiast łączenia dwóch literałów łańcuchowych, które kompilator może zoptymalizować w kompilatorze.

Podejście C ++ polega na kończeniu każdego wiersza odwrotnym ukośnikiem, co powoduje, że znak nowej linii jest zastępowany i nie pojawia się na wyjściu. Niestety nadal istnieje problem polegający na tym, że każda linia po pierwszej musi być wyrównana, aby nie dodawać dodatkowych białych znaków do wyniku.

Jest tylko jedna opcja, która nie polega na optymalizacjach kompilatora, które mogą się nie zdarzyć, czyli umieszczenie definicji w jednym wierszu. Jeśli chcesz polegać na optymalizacjach kompilatora, + już masz świetny; nie musisz wyrównywać łańcucha w lewo, w wyniku nie otrzymujesz nowego wiersza, a to tylko jedna operacja, brak wywołań funkcji, aby oczekiwać optymalizacji.

Dodaj wiele wierszy: użyj @

string query = @"SELECT foo, bar
FROM table
WHERE id = 42";

Dodaj wartości ciągu do środka: użyj $

string text ="beer";
string query = $"SELECT foo {text} bar ";

Ciąg wielu linii Dodaj wartości do środka: użyj $ @

string text ="Customer";
string query = $@"SELECT foo, bar
FROM {text}Table
WHERE id = 42";

Jeśli nie chcesz spacji / znaków nowej linii, wydaje się, że dodawanie ciągów działa:

var myString = String.Format(
  "hello " + 
  "world" +
  " i am {0}" +
  " and I like {1}.",
  animalType,
  animalPreferenceType
);
// hello world i am a pony and I like other ponies.

Możesz uruchomić powyższe , jeśli chcesz.

Wiem, że jestem trochę spóźniony na imprezę, ale chcę polecić https://www.buildmystring.com/ przyszłym czytelnikom tego wątku. Za pomocą tej strony możesz przekonwertować dowolny kod na literał ciąg C #.

Możesz użyć tych dwóch metod:

    private static String ReverseString(String str)
    {
        int word_length = 0;
        String result = "";
        for (int i = 0; i < str.Length; i++)
        {
            if (str[i] == ' ')
            {
                result = " " + result;
                word_length = 0;
            }
            else
            {
                result = result.Insert(word_length, str[i].ToString());
                word_length++;
            }
        }
        return result;
    }
//NASSIM LOUCHANI
    public static string SplitLineToMultiline(string input, int rowLength)
    {
        StringBuilder result = new StringBuilder();
        StringBuilder line = new StringBuilder();

        Stack<string> stack = new Stack<string>(ReverseString(input).Split(' '));

        while (stack.Count > 0)
        {
            var word = stack.Pop();
            if (word.Length > rowLength)
            {
                string head = word.Substring(0, rowLength);
                string tail = word.Substring(rowLength);

                word = head;
                stack.Push(tail);
            }

            if (line.Length + word.Length > rowLength)
            {
                result.AppendLine(line.ToString());
                line.Clear();
            }

            line.Append(word + " ");
        }

        result.Append(line);
        return result.ToString();
    }

W SplitLineToMultiline () musisz zdefiniować ciąg, którego chcesz użyć, a długość wiersza jest bardzo prosta. Dziękuję Ci .