Stringa multilinea letterale in C #

C'è un modo semplice per creare una stringa multilinea letterale in C #?

Ecco quello che ho ora:

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

So che ha PHP

<<<BLOCK

BLOCK;

C # ha qualcosa di simile?

Puoi usare il @simbolo davanti a a stringper formare una stringa letterale letterale :

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

Inoltre , non è necessario sfuggire a caratteri speciali quando si utilizza questo metodo, ad eccezione delle doppie virgolette, come mostrato nella risposta di Jon Skeet.

Si chiama letteralmente una stringa letterale in C #, ed è solo una questione di mettere @ prima del letterale. Questo non solo consente più linee, ma disattiva anche la fuga. Quindi ad esempio puoi fare:

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

Ciò include le interruzioni di riga (utilizzando qualsiasi interruzione di riga utilizzata dal sorgente) nella stringa, tuttavia. Per SQL, questo non è solo innocuo, ma probabilmente migliora la leggibilità ovunque tu veda la stringa, ma in altri luoghi potrebbe non essere necessario, nel qual caso dovresti non utilizzare una stringa letterale multilinea per iniziare, o rimuoverli dalla stringa risultante.

L'unico bit di escape è che se si desidera una virgoletta doppia, è necessario aggiungere un ulteriore simbolo di virgoletta doppia:

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

Il problema con l'uso della stringa letterale che trovo è che può rendere il tuo codice un po '" strano " perché per non ottenere spazi nella stringa stessa, deve essere completamente allineato a sinistra:

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

Che schifo.

Quindi la soluzione che mi piace usare, che mantiene tutto ben allineato con il resto del codice è:

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

E, naturalmente, se si desidera solo per dividere logicamente le linee di un'istruzione SQL, come sei e in realtà non c'è bisogno di una nuova linea, si può sempre e solo sostituire Environment.NewLineper " ".

Un altro aspetto da tenere d'occhio è l'uso dei letterali stringa in string.Format. In tal caso è necessario sfuggire alle parentesi graffe / parentesi graffe "{" e "}".

// 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)

Come nota a margine, con C # 6.0 ora puoi combinare stringhe interpolate con la stringa letterale letterale:

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

Perché le persone continuano a confondere le stringhe con i letterali delle stringhe? La risposta accettata è un'ottima risposta a una domanda diversa; non a questo.

So che questo è un vecchio argomento, ma sono venuto qui con forse la stessa domanda del PO, ed è frustrante vedere come le persone continuano a fraintenderlo. O forse sto leggendo male, non lo so.

In parole povere, una stringa è una regione di memoria del computer che, durante l'esecuzione di un programma, contiene una sequenza di byte che possono essere associati a caratteri di testo. Una stringa letterale, d'altra parte, è un pezzo di codice sorgente, non ancora compilato, che rappresenta il valore utilizzato per inizializzare una stringa in seguito, durante l'esecuzione del programma in cui appare.

In C #, la dichiarazione ...

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

... non produce una stringa di tre righe ma una riga; la concatenazione di tre stringhe (ciascuna inizializzata da un letterale diverso) nessuna delle quali contiene un modificatore di nuova riga.

Ciò che l'OP sembra chiedere - almeno quello che vorrei chiedere con quelle parole - non è come introdurre, nella stringa compilata, le interruzioni di riga che imitano quelle trovate nel codice sorgente, ma come spezzare per chiarezza a lungo , singola riga di testo nel codice sorgente senza introdurre interruzioni nella stringa compilata. E senza richiedere un tempo di esecuzione prolungato, impiegato per unire le molteplici sottostringhe provenienti dal codice sorgente. Come le barre rovesciate finali all'interno di una stringa multilinea letterale in javascript o C ++.

Suggerire l'uso di stringhe testuali, nevermind StringBuilders, String.Joinse addirittura funzioni annidate con inversioni di stringa e quant'altro, mi fa pensare che le persone non stiano davvero capendo la domanda. O forse non lo capisco.

Per quanto ne so, C # non (almeno nella versione paleolitica che sto ancora utilizzando, rispetto al decennio precedente) ha una funzione per produrre in modo chiaro valori letterali su più righe che possono essere risolti durante la compilazione piuttosto che nell'esecuzione.

Forse le versioni attuali lo supportano, ma ho pensato di condividere la differenza che percepisco tra stringhe e letterali di stringa.

AGGIORNARE:

(Dal commento di MeowCat2012) Puoi farlo. L'approccio "+" di OP è il migliore. Secondo le specifiche, l'ottimizzazione è garantita: http://stackoverflow.com/a/288802/9399618

Non l'ho visto, quindi lo posterò qui (se sei interessato a passare una stringa puoi farlo anche tu.) L'idea è che puoi spezzare la stringa su più righe e aggiungere il tuo contenuto (anche su più righe) nel modo desiderato. Qui "tableName" può essere passato nella stringa.

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

Puoi usare @ e "" .

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

Sì, puoi dividere una stringa su più righe senza introdurre nuove righe nella stringa effettiva, ma non è abbastanza:

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

Il trucco consiste nell'introdurre il codice che viene valutato come vuoto e tale codice può contenere newline senza influire sull'output. Ho adattato questo approccio da questa risposta a una domanda simile.

Apparentemente c'è un po 'di confusione su quale sia la domanda, ma ci sono due suggerimenti che quello che vogliamo qui è una stringa letterale che non contiene caratteri di nuova riga, la cui definizione si estende su più righe. (nei commenti lo dice, ed "ecco quello che ho" mostra il codice che non crea una stringa con al suo interno delle righe)

Questo test unitario mostra l'intento:

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

Modificare la definizione sopra di query in modo che sia un valore letterale di stringa, anziché la concatenazione di due valori letterali di stringa che possono essere o meno ottimizzati in uno dal compilatore.

L'approccio C ++ sarebbe quello di terminare ogni riga con una barra rovesciata, facendo in modo che il carattere newline fosse evitato e non apparisse nell'output. Sfortunatamente, c'è ancora il problema che ogni riga dopo la prima deve essere allineata a sinistra per non aggiungere spazi bianchi al risultato.

Esiste solo un'opzione che non si basa su ottimizzazioni del compilatore che potrebbero non verificarsi, che consiste nel mettere la definizione su una riga. Se vuoi fare affidamento sulle ottimizzazioni del compilatore, il + che hai già è ottimo; non è necessario allineare a sinistra la stringa, non si ottengono nuove righe nel risultato ed è solo un'operazione, nessuna chiamata di funzione, su cui aspettarsi l'ottimizzazione.

Aggiungi più righe: usa @

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

Aggiungi valori stringa al centro: usa $

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

Stringa di più righe Aggiungi valori al centro: usa $ @

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

Se non vuoi spazi / newline, l'aggiunta di stringhe sembra funzionare:

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.

Se lo desideri, puoi eseguire quanto sopra qui .

So di essere un po 'in ritardo alla festa, ma desidero raccomandare https://www.buildmystring.com/ per i futuri lettori di questa discussione. È possibile convertire qualsiasi codice in letterale stringa C # utilizzando questo sito.

Puoi usare questi due metodi:

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

In SplitLineToMultiline (), è necessario definire la stringa che si desidera utilizzare e la lunghezza della riga, è molto semplice. Grazie .