.NET හි හැඩතලයකින් වරහන් (කැරලි වරහන්) වලින් බේරෙන්නේ කෙසේද

කොහොමද වරහන් භාවිතා පලා ගත හැක string.Format.

උදාහරණයක් වශයෙන්:

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

මෙම උදාහරණය ව්‍යතිරේකයක් නොදක්වයි, නමුත් නූල ප්‍රතිදානය කරයි foo {0}.

වරහන් වලින් බේරීමට ක්‍රමයක් තිබේද?

ඔබට ප්‍රතිදානය සඳහා foo {1, 2, 3} ඔබට මෙවැනි දෙයක් කළ යුතුය:

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

ප්රතිදානය වෙත {ඔබ භාවිතා {{ප්රතිදානය වෙත} ඔබ භාවිතා }}.

හෝ දැන්, ඔබට මේ ආකාරයට c # string interpolation ද භාවිතා කළ හැකිය (C # 6.0 හි ඇති විශේෂාංගය)

ගැලවීමේ වරහන්: නූල් අන්තර් මැදිහත්වීම $ ("") . එය C # 6.0 හි නව අංගයකි

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

ඔව් {, string.Formatඔබ තුළ ප්‍රතිදානය කිරීමට මේ ආකාරයෙන් පැන යා යුතුය{{

ඉතින් මේක

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

ප්‍රතිදානය "foo {1,2,3}"කරයි.

නමුත් C # හි සැලසුම් දෝෂයක් ගැන ඔබ දැන සිටිය යුතුය, එනම් ඉහත තර්කනය අනුගමනය කිරීමෙන් මෙම කේතය {24.00 print මුද්‍රණය කරනු ඇතැයි ඔබ සිතනු ඇත.

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

නමුත් මෙය මුද්‍රණය කරන්නේ {N}. එයට හේතුව C # විග්‍රහ කරන අනුපිළිවෙලවල් සහ අක්ෂර හැඩතල ගැන්වීමයි. ඉහත නඩුවේ අපේක්ෂිත අගය ලබා ගැනීම සඳහා ඔබ ඒ වෙනුවට භාවිතා කළ යුතුය.

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

යොමු ලිපි නූල්. ෆෝමැට් ගොටාච් සහ ස්ට්‍රිං ෆෝමැටින් FAQ

පාහේ එහි! වරහනක් සඳහා ගැලවීමේ අනුක්‍රමය ඔබේ උදාහරණය සඳහා {{හෝ }}එසේ වේ:

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

ඔබට ද්විත්ව විවෘත වරහන් සහ ද්විත්ව වසා දැමීමේ වරහන් භාවිතා කළ හැකි අතර එමඟින් ඔබේ පිටුවේ එක් වරහනක් පමණක් පෙන්වනු ඇත.

කැරලි වරහන් වලින් ගැලවීම සහ නූල් අන්තර් මැදිහත්වීම භාවිතා කිරීම සිත්ගන්නා සුළු අභියෝගයක් වේ. නූල් අන්තර් මැදිහත්වීම විග්‍රහ කිරීමෙන් හා විග්‍රහ කිරීමෙන් ගැලවීමට ඔබට හතරැස් වරහන් භාවිතා කළ යුතුය .string.format

ගැලවීමේ වරහන්: නූල් අන්තර් මැදිහත්වීම $ ("") සහ 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>

සී # හි json නූල් තාවකාලිකව (පන්තියක් / වස්තුවක් අනුක්‍රමික නොකර) සාදා ගන්නේ කෙසේදැයි සෙවීමට මෙහි පැමිණියේය. වෙනත් වචන වලින් කිවහොත්, C # සහ " වාචික වචන වචන " ('pre' උපසර්ගය සහිත ද්විත්ව උපුටා ගත් නූල්) භාවිතා කරන අතරතුර වරහන් සහ උපුටා දැක්වීම් වලින් බේරෙන්නේ කෙසේද , වැනි ...

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

හෝ ඔබට මේ ආකාරයට c # string interpolation භාවිතා කළ හැකිය (C # 6.0 හි ඇති විශේෂාංගය)

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

ගැලවීමේ වරහන්: නූල් අන්තර් මැදිහත්වීම $ (""):

දැන්, ඔබට මේ ආකාරයට c # string interpolation ද භාවිතා කළ හැකිය (C # 6.0 හි ඇති විශේෂාංගය)

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

මගේ පරමාර්ථය:

මම අගය අනුයුක්ත කිරීමට අවශ්ය "{CR}{LF}"වෙත stringවිචල්යdelimiter .

කේතය #:

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

සටහන: විශේෂ අක්ෂර වලින් ගැලවීමට සාමාන්‍යයෙන් ඔබ භාවිතා කළ යුතුය. කැරලි වරහන {විවෘත කිරීම සඳහා extra {වැනි අමතර එකක් භාවිතා කරන්න. වක්‍ර වරහන වසා දැමීම සඳහා one එක් අමතර use use භාවිතා කරන්න.