Dans .NET, je peux fournir les deux \r
ou des \n
chaînes littérales, mais il existe un moyen d'insérer quelque chose comme un caractère spécial "nouvelle ligne" comme Environment.NewLine
une propriété statique?
Dans .NET, je peux fournir les deux \r
ou des \n
chaînes littérales, mais il existe un moyen d'insérer quelque chose comme un caractère spécial "nouvelle ligne" comme Environment.NewLine
une propriété statique?
Réponses:
Eh bien, les options simples sont:
string.Format
:
string x = string.Format("first line{0}second line", Environment.NewLine);
Concaténation de chaînes:
string x = "first line" + Environment.NewLine + "second line";
Interpolation de chaîne (en C # 6 et supérieur):
string x = $"first line{Environment.NewLine}second line";
Vous pouvez également utiliser \ n partout et remplacer:
string x = "first line\nsecond line\nthird line".Replace("\n",
Environment.NewLine);
Notez que vous ne pouvez pas en faire une constante de chaîne , car la valeur de Environment.NewLine
ne sera disponible qu'au moment de l'exécution.
Environment.NewLine
? Bien au contraire, c'est une bonne pratique de l'utiliser
Si vous voulez une chaîne const qui contient Environment.NewLine, vous pouvez faire quelque chose comme ceci:
const string stringWithNewLine =
@"first line
second line
third line";
Puisque c'est dans une chaîne de const, cela est fait au moment de la compilation, c'est donc l'interprétation du compilateur d'une nouvelle ligne. Je n'arrive pas à trouver une référence expliquant ce comportement, mais je peux prouver que cela fonctionne comme prévu. J'ai compilé ce code à la fois sur Windows et Ubuntu (avec Mono) puis démonté et voici les résultats:
Comme vous pouvez le voir, dans Windows, les nouvelles lignes sont interprétées comme \ r \ n et sur Ubuntu comme \ n
var sb = new StringBuilder();
sb.Append(first);
sb.AppendLine(); // which is equal to Append(Environment.NewLine);
sb.Append(second);
return sb.ToString();
first + Environment.NewLine + second
ce qui est plus efficace et (IMO) plus facile à lire?
String.Format
cela produirait 1 chaîne à la fois (mais c'est en interne un peu lent à cause des concaténations spécifiques à la culture, etc.), tandis que la concaténation de chaînes - 1 résultant + 1 temporaire, non?
String.Concatenate
, qui construit directement une seule chaîne de sortie (IIRC, si les chaînes sont littérales, la concaténation est effectuée dans le compilateur.
"a"+b+"c"+d
, etc.) par performance sont égales à une seule? Ou simplement converti en String.Concatenate(a,b,c,d,etc)
, non?
string.Format
dans le commentaire. La concaténation de chaînes ne produira aucune chaîne temporaire, car le compilateur appellera string.Concat(first, Environment.NewLine, second)
.
Un autre moyen de placement pratique de Environment.NewLine dans une chaîne de format. L'idée est de créer une méthode d'extension de chaîne qui formate la chaîne comme d'habitude, mais remplace également {nl} dans le texte par Environment.NewLine
Usage
" X={0} {nl} Y={1}{nl} X+Y={2}".FormatIt(1, 2, 1+2);
gives:
X=1
Y=2
X+Y=3
Code
///<summary>
/// Use "string".FormatIt(...) instead of string.Format("string, ...)
/// Use {nl} in text to insert Environment.NewLine
///</summary>
///<exception cref="ArgumentNullException">If format is null</exception>
[StringFormatMethod("format")]
public static string FormatIt(this string format, params object[] args)
{
if (format == null) throw new ArgumentNullException("format");
return string.Format(format.Replace("{nl}", Environment.NewLine), args);
}
Remarque
Si vous souhaitez que ReSharper met en évidence vos paramètres, ajoutez un attribut à la méthode ci-dessus
[StringFormatMethod ("format")]
Cette implémentation est évidemment moins efficace que simplement String.
Peut-être que l'un d'entre eux, intéressé par cette question, serait également intéressé par la question suivante: mise en forme de chaîne nommée en C #
string myText =
@"<div class=""firstLine""></div>
<div class=""secondLine""></div>
<div class=""thirdLine""></div>";
ce n'est pas ça:
string myText =
@"<div class=\"firstLine\"></div>
<div class=\"secondLine\"></div>
<div class=\"thirdLine\"></div>";
static class MyClass
{
public const string NewLine="\n";
}
string x = "first line" + MyClass.NewLine + "second line"
Environment.NewLine
- voir les autres réponses.
const string
les nouvelles versions .net vous permettent d'utiliser $ devant le littéral, ce qui vous permet d'utiliser des variables à l'intérieur comme suit:
var x = $"Line 1{Environment.NewLine}Line 2{Environment.NewLine}Line 3";
Si vous voulez vraiment que la chaîne New Line soit une constante, vous pouvez le faire:
public readonly string myVar = Environment.NewLine;
L'utilisateur du mot clé readonly en C # signifie que cette variable ne peut être affectée qu'une seule fois. Vous pouvez trouver la documentation à ce sujet ici . Il permet la déclaration d'une variable constante dont la valeur n'est connue qu'au moment de l'exécution.
Si vous travaillez avec une application Web, vous pouvez essayer ceci.
StringBuilder sb = new StringBuilder();
sb.AppendLine("Some text with line one");
sb.AppendLine("Some mpre text with line two");
MyLabel.Text = sb.ToString().Replace(Environment.NewLine, "<br />")
Si je comprends la question: couple "\r\n"
pour obtenir cette nouvelle ligne ci-dessous dans un textbox
. Mon exemple a fonctionné -
string s1 = comboBox1.Text; // s1 is the variable assigned to box 1, etc.
string s2 = comboBox2.Text;
string both = s1 + "\r\n" + s2;
textBox1.Text = both;
Une réponse typique pourrait être s1
s2
dans le text box
style de type défini.