Comment échapper les accolades (accolades) dans une chaîne de format dans .NET

Comment échapper les crochets en utilisant string.Format.

Par exemple:

String val = "1,2,3"
String.Format(" foo {{0}}", val); 

Cet exemple ne lève pas d'exception, mais génère la chaîne foo {0}.

Existe-t-il un moyen d'échapper aux crochets?

Pour que vous puissiez sortir, foo {1, 2, 3}vous devez faire quelque chose comme:

string t = "1, 2, 3";
string v = String.Format(" foo {{{0}}}", t);

Pour sortir un que {vous utilisez {{et pour sortir un que }vous utilisez }}.

ou Maintenant, vous pouvez également utiliser l'interpolation de chaîne c # comme ceci (fonctionnalité disponible dans C # 6.0)

Échappement des parenthèses: interpolation de chaîne $ ("") . c'est une nouvelle fonctionnalité en C # 6.0

var inVal = "1, 2, 3";
var outVal = $" foo {{{inVal}}}";
//Output will be:  foo {1, 2, 3}

Oui à la sortie {en string.Formatvous devez échapper comme ça{{

Donc ça

String val = "1,2,3";
String.Format(" foo {{{0}}}", val);

sortira "foo {1,2,3}".

MAIS vous devez connaître un bogue de conception en C # qui est qu'en suivant la logique ci-dessus, vous supposeriez que le code ci-dessous s'imprime {24.00}

int i = 24;
string str = String.Format("{{{0:N}}}", i); //gives '{N}' instead of {24.00}

Mais cela imprime {N}. En effet, la façon dont C # analyse les séquences d'échappement et formate les caractères. Pour obtenir la valeur souhaitée dans le cas ci-dessus, vous devez l'utiliser à la place.

String.Format("{0}{1:N}{2}", "{", i, "}") //evaluates to {24.00}

Articles de référence String.Format gottach et FAQ sur la mise en forme des chaînes

Presque là! La séquence d'échappement pour une attelle est {{ou }}si votre exemple , vous utilisez:

string t = "1, 2, 3";
string v = String.Format(" foo {{{0}}}", t);

Vous pouvez utiliser des crochets ouverts doubles et des crochets fermants doubles qui n'afficheront qu'un seul crochet sur votre page.

Échapper les accolades et utiliser l' interpolation de chaîne en fait un défi intéressant. Vous devez utiliser des crochets quadruples pour échapper à l' analyse d' interpolation de chaîne et à l' string.formatanalyse.

Échappement des parenthèses: interpolation de chaîne $ ("") et String.Format

string localVar = "dynamic";
string templateString = $@"<h2>{0}</h2><div>this is my {localVar} template using a {{{{custom tag}}}}</div>";
string result = string.Format(templateString, "String Interpolation");

// OUTPUT: <h2>String Interpolation</h2><div>this is my dynamic template using a {custom tag}</div>

Entré ici à la recherche de la façon de construire des chaînes json ad-hoc (sans sérialiser une classe / un objet) en C #. En d'autres termes, comment échapper les accolades et les guillemets lors de l'utilisation de chaînes interpolées en C # et de " littéraux de chaînes verbatim " (chaînes entre guillemets doubles avec préfixe '@'), comme ...

var json = $@"{{""name"":""{name}""}}";

[TestMethod]
public void BraceEscapingTest()
{
    var result = String.Format("Foo {{0}}", "1,2,3");  //"1,2,3" is not parsed
    Assert.AreEqual("Foo {0}", result);

    result = String.Format("Foo {{{0}}}", "1,2,3");
    Assert.AreEqual("Foo {1,2,3}", result);

    result = String.Format("Foo {0} {{bar}}", "1,2,3");
    Assert.AreEqual("Foo 1,2,3 {bar}", result);

    result = String.Format("{{{0:N}}}", 24); //24 is not parsed, see @Guru Kara answer
    Assert.AreEqual("{N}", result);

    result = String.Format("{0}{1:N}{2}", "{", 24, "}");
    Assert.AreEqual("{24.00}", result);

    result = String.Format("{{{0}}}", 24.ToString("N"));
    Assert.AreEqual("{24.00}", result);
}

ou vous pouvez utiliser l'interpolation de chaîne c # comme ceci (fonctionnalité disponible dans C # 6.0)

var value = "1, 2, 3";
var output = $" foo {{{value}}}";

Échappement des parenthèses: Interpolation de chaîne $ (""):

Maintenant, vous pouvez également utiliser l'interpolation de chaînes c # comme celle-ci (fonctionnalité disponible dans C # 6.0)

var inVal= "1, 2, 3";
var outVal= $" foo {{{inVal}}}";
//Output will be:  foo {1, 2, 3}

Mon objectif:

J'avais besoin d'attribuer la valeur "{CR}{LF}"à une stringvariable delimiter.

Code c #:

string delimiter= "{{CR}}{{LF}}";

Remarque: Pour échapper aux caractères spéciaux, vous devez normalement les utiliser. Pour ouvrir la parenthèse bouclée {, utilisez-en une supplémentaire comme {{. Pour fermer le crochet,}, utilisez un extra}}.