Ligne continuent de caractères en C#

Nous avons un test unitaire avec la variable qui contient une très longue chaîne.

Question est de savoir comment écrire dans le code, sans avoir de problèmes avec les sauts de ligne ou que le code est difficile à lire.

En VB il y a une ligne de continuer personnage, est-il un équivalent en C#?

  • Créer un tableau, puis se joindre à elle.
  • Double Possible de Multiligne Littéral de Chaîne en C#
  • Mettre la chaîne dans un fichier de ressources.
  • ne pas faire ceci: alors, vous êtes effectivement la création de plusieurs chaînes (à l'exécution) qui doivent être concaténées (à l'exécution). Plusieurs chaînes de caractères séparées par un signe plus seront concaténés par le compilateur.
InformationsquelleAutor Shiraz Bhaiji | 2010-11-03
  1. 60

    C# vous permettra d'avoir une chaîne répartie sur plusieurs lignes, le terme est appelé verbatim literal:

    string myString = @"this is a
                    test
                   to see how long my string
                   can be



                    and it can be quite long";

    Si vous cherchez une alternative à & _ à partir de visual basic, utilisez le + à se joindre à vos lignes.

    • myString va être farcies avec des espaces. Ne pas le faire.
    • Il vaut la peine de faire cela si vous êtes l'incorporation d'une chaîne SQL dans votre code. L'analyseur SQL ne se soucie pas de l'espace blanc, et c'est beaucoup plus facile lors du transfert de ces déclarations entre un programme et un client SQL.
    • mais que penser de l'octet de déchets!
    • Notez également que cela inclut toutes les \r\n les retours à la ligne dans la chaîne finale.
    • Concernant l'octet de déchets: comment un petit pensez-vous de nos disques durs sont ces jours-ci? pas comme nous avons besoin d'enregistrer plusieurs punchcards...
    • Assez sûr que le commentaire a été la langue dans la joue.

    InformationsquelleAutor Neil Knight
  2. 51

    Constantes De Chaîne

    Suffit d'utiliser la + de l'opérateur et de briser la chaîne lisible lignes. Le compilateur va chercher jusqu'à ce que les cordes sont constants et de les enchaîner au moment de la compilation. Consultez le site web MSDN Guide de Programmation C#ici.

    par exemple

    const string myVeryLongString = 
    "This is the opening paragraph of my long string. " +
    "Which is split over multiple lines to improve code readability, " +
    "but is in fact, just one long string.";

    IL_0003: ldstr "This is the opening paragraph of my long string. Which is split over multiple lines to improve code readability, but is in fact, just one long string."

    Variables De Chaîne

    Noter que lors de l'utilisation chaîne d'interpolation de valeurs de substitution dans votre chaîne, que le $ personnage doit précéder chaque ligne où une substitution doit être faite:

    var interpolatedString = 
    "This line has no substitutions. " +
    $" This line uses {count} widgets, and " +
    $" {CountFoos()} foos were found.";

    Cependant, ce qui a le rendement négatif conséquence de multiples appels à string.Format et de l'éventuelle concaténation des chaînes de caractères (marqué avec ***)

    IL_002E:  ldstr       "This line has no substitutions. "
IL_0033:  ldstr       " This line uses {0} widgets, and "
IL_0038:  ldloc.0     //count
IL_0039:  box         System.Int32
IL_003E:  call        System.String.Format ***
IL_0043:  ldstr       " {0} foos were found."
IL_0048:  ldloc.1     //CountFoos
IL_0049:  callvirt    System.Func<System.Int32>.Invoke
IL_004E:  box         System.Int32
IL_0053:  call        System.String.Format ***
IL_0058:  call        System.String.Concat ***

    Bien que vous pouvez soit utiliser $@ de fournir une chaîne unique et éviter les problèmes de performances, à moins que l'espace est placé à l'intérieur de {} (ce qui semble étrange, de l'OMI), ce qui a le même problème que Neil Chevalier de la réponse, car il inclut tous les espaces dans la ligne de pannes:

    var interpolatedString = $@"When breaking up strings with `@` it introduces
    <- [newLine and whitespace here!] each time I break the string.
    <- [More whitespace] {CountFoos()} foos were found.";

    La injecté espace est facile à repérer:

    IL_002E:  ldstr       "When breaking up strings with `@` it introduces
    <- [newLine and whitespace here!] each time I break the string.
    <- [More whitespace] {0} foos were found."

    Une alternative est de revenir à string.Format. Ici, la chaîne de formatage est une constante unique de par mon début de réponse:

    const string longFormatString = 
    "This is the opening paragraph of my long string with {0} chars. " +
    "Which is split over multiple lines to improve code readability, " +
    "but is in fact, just one long string with {1} widgets.";

    Et ensuite évaluée en tant que telle:

    string.Format(longFormatString, longFormatString.Length, CountWidgets());

    Cependant, il peut toujours être difficile de maintenir compte tenu de la séparation de potentiel entre la chaîne de mise en forme et la substitution des jetons.

    • En fait, Resharper fera essayer de le faire automatiquement à chaque fois que vous appuyez sur la touche entrée sur un non littéral de chaîne.
    • C'est ainsi que nous faisons de notre longue chaîne de caractères littéraux de trop. Particulièrement utile pour les messages d'erreur tout le monde devrait s'efforcer de faire!
    InformationsquelleAutor StuartLC
  3. 6
    @"string here
that is long you mean"

    Mais être prudent, car

    @"string here
           and space before this text
     means the space is also a part of the string"

    Il échappe aussi des choses dans la chaîne

    @"c:\\folder" //c:\\folder
@"c:\folder" //c:\folder
"c:\\folder" //c:\folder

    Liées

    InformationsquelleAutor BrunoLM
  4. 5

    Vous pouvez utiliser verbatim les littéraux:

    const string test = @"Test
123
456
";

    Mais l'indentation de la 1ère ligne est délicat/laid.

    InformationsquelleAutor Henk Holterman
  5. 0

    Vous devez utiliser l'une des manières suivantes:

        string s = @"loooooooooooooooooooooooong loooooong
                  long long long";

string s = "loooooooooong loooong" +
           " long long" ;
    • Il en résulte tout à fait différentes chaînes. Qui est, l'ancien est un caractère de saut de ligne.
    InformationsquelleAutor Liviu M.
  6. 0

    Dans son excellente réponse, StuartLC cites une réponse à une question connexe, et mentionne que les plaçant des sauts de ligne à l'intérieur de la {expression} d'une interpolation de chaîne "qui semble étrange." La plupart serait d'accord, mais la désagréable code source de l'effet peut être atténué quelque peu--et sans runtime conséquences--en utilisant dédié {expression} blocs qui résoudre à default(String), qui est, null (et en particulier la pas String.Empty).

    (Même s'ils sont mineurs) ne s'agit pas de gâchis ou de polluer votre expression réelle de contenu, en utilisant à la place un dédié jeton pour ce but. Donc, si vous déclarez une constante, par exemple:

    const String more = null;

    ...puis une ligne qui peut être trop long à regarder dans le code source, comme...

    var s1 = $"one: {99 + 1} two: {99 + 2} three: {99 + 3} four: {99 + 4} five: {99 + 5} six: {99 + 6}";

    ...peut être écrit comme ceci.

    var s2 = $@"{more
    }one: {99 + 1} {more
    }two: {99 + 2} {more
    }three: {99 + 3} {more
    }four: {99 + 4} {more
    }five: {99 + 5} {more
    }six: {99 + 6}";

    Ou peut-être vous préférez un autre type de "bizarre" approche à la même chose:

    //elsewhere:
public const String Ξ = null;  //Unicode '\u039E', Greek 'Capital Letter Xi'

//anywhere:
var s3 = $@"{
           Ξ}one: {99 + 1} {
           Ξ}two: {99 + 2} {
           Ξ}three: {99 + 3} {
           Ξ}four: {99 + 4} {
           Ξ}five: {99 + 5} {
           Ξ}six: {99 + 6}";

    Tous trois exemples de produire la même string au moment de l'exécution, qui dans ce cas est tous sur une seule ligne:

    one: 100 two: 101 three: 102 four: 103 five: 104 six: 105

    Stuart suggéré, IL la performance est conservé dans ces deux exemples, en n'utilisant pas + pour concaténer des chaînes. Bien que la chaîne de format dans mon nouvel exemple est en effet stocké dans l'ILLINOIS, et donc votre exécutable, null espaces réservés références ne sont pas initialisés, et il n'y a aucun excès des enchaînements ou des appels de fonction au moment de l'exécution. Pour comparaison, voici la IL pour les deux exemples ci-dessus.

    IL pour premier exemple

    ldstr "one: {0} two: {1} three: {2} four: {3} five: {4} six: {5}"
ldc.i4.6
newarr object
dup
ldc.i4.0
ldc.i4.s 100
box int32
stelem.ref
dup
ldc.i4.1
ldc.i4.s 101
box int32
stelem.ref
dup
ldc.i4.2
ldc.i4.s 102
box int32
stelem.ref
dup
ldc.i4.3
ldc.i4.s 103
box int32
stelem.ref
dup
ldc.i4.4
ldc.i4.s 104
box int32
stelem.ref
dup
ldc.i4.5
ldc.i4.s 105
box int32
stelem.ref
call string string::Format(string, object[])

    IL pour le deuxième exemple

    ldstr "{0}one: {1} {2}two: {3} {4}three: {5} {6}four: {7} {8}five: {9} {10}six: {11}"
ldc.i4.s 12
newarr object
dup
ldc.i4.1
ldc.i4.s 100
box int32
stelem.ref
dup
ldc.i4.3
ldc.i4.s 101
box int32
stelem.ref
dup
ldc.i4.5
ldc.i4.s 102
box int32
stelem.ref
dup
ldc.i4.7
ldc.i4.s 103
box int32
stelem.ref
dup
ldc.i4.s 9
ldc.i4.s 104
box int32
stelem.ref
dup
ldc.i4.s 11
ldc.i4.s 105
box int32
stelem.ref
call string string::Format(string, object[])
    InformationsquelleAutor Glenn Slayden
  7. -1

    Si vous avez déclaré des variables différentes, alors la suite de la méthode simple:

    Int salary=2000;

String abc="I Love Pakistan";

Double pi=3.14;

Console.Writeline=salary+"/n"+abc+"/n"+pi;
Console.readkey();
    InformationsquelleAutor Wahab Khan