සී # හි බහු වචන නූල් වචනාර්ථයෙන්

C # හි බහු වචන මාලාවක් නිර්මාණය කිරීමට පහසු ක්‍රමයක් තිබේද?

මෙන්න මට දැන් ඇති දේ:

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

මම දන්නවා PHP තියෙනවා

<<<BLOCK

BLOCK;

C # ට සමාන දෙයක් තිබේද?

ඔබට @ඉදිරියෙන් ඇති සංකේතය භාවිතා stringකර වාචික වචන මාලාවක් සෑදිය හැකිය :

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

ඔබ ද විශේෂ අක්ෂර පැන නැත ජෝන් Skeet පිළිතුරේ පෙන්වා ඇති පරිදි, උද්ධෘත පාඨ හැර, ඔබ හට මෙම ක්රමය භාවිතා කරන විට.

එය C # හි වචනාර්ථමය වචන මාලාවක් ලෙස හැඳින්වෙන අතර එය වචනානුසාරයෙන් ඉදිරියෙන් තැබීම පමණි. මෙය බහුවිධ රේඛාවලට ඉඩ දෙනවා පමණක් නොව, එයින් ගැලවීමද වළක්වයි. උදාහරණයක් ලෙස ඔබට මෙය කළ හැකිය:

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

කෙසේ වෙතත්, රේඛා බිඳීම් (ඔබේ මූලාශ්‍රය ඇති ඕනෑම රේඛා බිඳීමක් භාවිතා කරමින්) නූලට ඇතුළත් වේ. SQL සඳහා, එය හානිකර නොවනවා පමණක් නොව, ඔබ නූල දකින ඕනෑම තැනක කියවීමේ හැකියාව වැඩි දියුණු කරයි - නමුත් වෙනත් ස්ථානවල එය අවශ්‍ය නොවනු ඇත, එවැනි අවස්ථාවකදී ඔබට ආරම්භ කිරීමට බහු-රේඛීය වාචික වචන භාවිතා නොකිරීමට අවශ්‍ය වනු ඇත, හෝ එහි ප්‍රති ing ලයක් ලෙස ඇති නූලෙන් ඒවා ඉවත් කරන්න.

පැන යාමේ එකම දෙය නම් ඔබට ද්විත්ව උපුටා දැක්වීමක් අවශ්‍ය නම් අමතර ද්විත්ව උපුටා දැක්වීමේ සංකේතයක් එක් කළ යුතුය:

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

වචනාර්ථයෙන් වචනාර්ථයෙන් භාවිතා කිරීමේ ගැටළුව නම්, එය ඔබේ කේතය මඳක් " අමුතු " පෙනුමක් ඇති කළ හැකි බැවිනි.

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

යක්.

එබැවින් මම භාවිතා කිරීමට කැමති විසඳුම, ඔබේ කේතයේ අනෙක් සියල්ල සමඟ හොඳින් ගැලපෙන පරිදි තබා ගන්නා:

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

ඇත්ත වශයෙන්ම, ඔබ වැනි SQL ප්‍රකාශයක රේඛා තර්කානුකූලව බෙදීමට ඔබට අවශ්‍ය නම් සහ ඇත්ත වශයෙන්ම නව පේළියක් අවශ්‍ය නොවන්නේ නම්, ඔබට සැමවිටම ආදේශ Environment.NewLineකළ " "හැකිය.

පැති සටහනක් ලෙස, සී # 6.0 සමඟ ඔබට දැන් අන්තර් වචන නූල් වාචික වචන සමඟ වචනාර්ථයෙන් ඒකාබද්ධ කළ හැකිය:

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

නැරඹිය යුතු තවත් එක් කරුණක් වන්නේ නූල් වල වචන වචන භාවිතා කිරීමයි. එවැනි අවස්ථාවක ඔබ කැරලි වරහන් / වරහන් '{' සහ '}' වලින් ගැලවිය යුතුය.

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

මිනිසුන් නූල් වචනාර්ථයෙන් පටලවා ගන්නේ ඇයි? පිළිගත් පිළිතුර වෙනස් ප්‍රශ්නයකට හොඳ පිළිතුරකි; මේකට නෙවෙයි.

මෙය පැරණි මාතෘකාවක් බව මම දනිමි, නමුත් මම මෙහි පැමිණියේ OP හා සමාන ප්‍රශ්නයක් සමඟ විය හැකි අතර මිනිසුන් එය වැරදි ලෙස කියවන ආකාරය දැකීම කලකිරීමට කරුණකි. නැත්නම් මම එය වැරදියට කියවනවා, මම දන්නේ නැහැ.

දළ වශයෙන් කිවහොත්, නූලක් යනු පරිගණක මතකයේ කලාපයක් වන අතර, එය වැඩසටහනක් ක්‍රියාත්මක කිරීමේදී, පෙළ අක්ෂරවලට අනුරූපණය කළ හැකි බයිට් අනුක්‍රමයක් අඩංගු වේ. අනෙක් අතට, වචන මාලාවක් යනු තවමත් සම්පාදනය කර නොමැති ප්‍රභව කේත කැබැල්ලකි, එය දර්ශනය වන වැඩසටහන ක්‍රියාත්මක කිරීමේදී පසුකාලීනව නූලක් ආරම්භ කිරීමට භාවිතා කළ අගය නියෝජනය කරයි.

සී # හි, ප්රකාශය ...

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

... පේළි තුනකින් යුත් නූලක් නිපදවන්නේ නැත, නමුත් එක් ලයිනර්; නූල් තුනක සංක්ෂිප්තකරණය (සෑම එකක්ම වෙනත් වචනාර්ථයෙන් ආරම්භ කරන ලදි) ඒ කිසිවක් නව රේඛා විකරණකාරකයක් අඩංගු නොවේ.

OP අසන බවක් පෙනේ - අවම වශයෙන් මම එම වචන වලින් අසන්නේ කුමක් ද යන්න - සම්පාදනය කරන ලද නූලෙන්, ප්‍රභව කේතයේ ඇති ඒවා අනුකරණය කරන රේඛා බිඳීම් හඳුන්වා දෙන්නේ කෙසේද යන්න නොව, පැහැදිලිකම සඳහා දීර් break වන්නේ කෙසේද? , සම්පාදනය කරන ලද නූලෙහි බිඳීම් හඳුන්වා නොදී ප්‍රභව කේතයේ තනි පෙළක්. දීර් exec ක්‍රියාත්මක කිරීමේ කාලයක් අවශ්‍ය නොවී, ප්‍රභව කේතයෙන් එන බහු උපස්ථර වලට සම්බන්ධ වීමට වියදම් කළේය. ජාවාස්ක්‍රිප්ට් හෝ සී ++ හි වචනාර්ථයෙන් බහු රේඛා පේළියක් තුළ ඇති පසුපස බැක් මෙන්.

වාචික නූල් භාවිතා කිරීම, කිසිසේත්ම නොසලකා හරින්න StringBuilder, String.Joinනැතිනම් කුමක් කළ යුතුද යන්න යෝජනා කිරීම, මිනිසුන් සිතන්නේ ප්‍රශ්නය සැබවින්ම වටහා නොගන්නා බවයි. නැත්නම් සමහර විට මට එය තේරෙන්නේ නැත.

මා දන්නා පරිදි, සී # (අවම වශයෙන් පෙර දශකයේ සිට මම තවමත් භාවිතා කරන පැලියොලිතික් අනුවාදයේ) ක්‍රියාත්මක කිරීමට වඩා සම්පාදනය කිරීමේදී විසඳිය හැකි බහු රේඛා වචනාර්ථයෙන් පිරිසිදු ලෙස නිෂ්පාදනය කිරීමේ අංගයක් නොමැත .

සමහර විට වර්තමාන අනුවාදයන් එයට සහය දක්වනු ඇත, නමුත් මම සිතුවේ නූල් සහ නූල් වචනාර්ථය අතර මා දකින වෙනස බෙදා ගනීවි කියාය.

යාවත්කාලීන කිරීම:

(MeowCat2012 හි අදහස් දැක්වීමෙන්) ඔබට පුළුවන්. OP හි "+" ප්රවේශය හොඳම වේ. පිරිවිතරයන්ට අනුව ප්‍රශස්තිකරණය සහතික කර ඇත: http://stackoverflow.com/a/288802/9399618

මම මෙය දැක නැත, එබැවින් මම එය මෙහි පළ කරමි (ඔබ නූලක් සම්මත කිරීමට කැමති නම් ඔබටත් මෙය කළ හැකිය.) අදහස නම් ඔබට පේළිය පේළි කිහිපයකින් කැඩී ඔබේම අන්තර්ගතයක් එක් කළ හැකිය (එසේම ඔබට අවශ්‍ය ඕනෑම ආකාරයකින්. මෙහිදී "tableName" නූලට යැවිය හැකිය.

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

ඔබට @ සහ "" භාවිතා කළ හැකිය .

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

පේළි කිහිපයක් එක් කරන්න: use භාවිතා කරන්න

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

මැදට නූල් අගයන් එක් කරන්න: use භාවිතා කරන්න

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

බහු පේළි නූල් මැදට අගයන් එක් කරන්න: use use භාවිතා කරන්න

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

ඔව්, සත්‍ය රේඛාවට නව රේඛා හඳුන්වා නොදී ඔබට පේළි කිහිපයක් පේළි කිහිපයකට බෙදිය හැකිය, නමුත් එය ලස්සනයි:

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

උපක්‍රමය නම් හිස් ලෙස තක්සේරු කරන කේත හඳුන්වා දීමයි, එම කේතයේ ප්‍රතිදානයට බලපෑමක් නොකර නව රේඛා අඩංගු විය හැකිය. මම මෙම පිළිතුර මෙම පිළිතුරේ සිට සමාන ප්‍රශ්නයකට අනුවර්තනය කළෙමි .

ප්‍රශ්නය කුමක්ද යන්න පිළිබඳව යම් ව්‍යාකූලත්වයක් ඇති බවක් පෙනෙන්නට තිබේ, නමුත් අපට මෙහි අවශ්‍ය වන්නේ වචනාර්ථයෙන් කිසිදු නව රේඛා අක්ෂර අඩංගු නොවන වචන මාලාවක් වන අතර එහි අර්ථ දැක්වීම බහු රේඛා දක්වා විහිදේ. (අදහස් දැක්වීමේදී ඔහු එසේ පවසයි, සහ "මෙන්න මා සතුව ඇත්තේ" එහි නව රේඛා සමඟ නූලක් නිර්මාණය නොකරන කේතය පෙන්වයි)

මෙම ඒකක පරීක්ෂණය අභිප්‍රාය පෙන්වයි:

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

විමසුමේ ඉහත අර්ථ දැක්වීම වෙනස් කරන්න, එය සම්පාදකයා විසින් එකකට ප්‍රශස්තිකරණය කළ හැකි හෝ නොවිය හැකි නූල් වචනාර්ථ දෙකක සංක්ෂිප්ත කිරීම වෙනුවට එක් වචන මාලාවක් වේ.

C ++ ප්‍රවේශය වනුයේ සෑම පේළියක්ම බැක්ස්ලෑෂ් එකකින් අවසන් කිරීමයි, එමඟින් නව රේඛා අක්‍ෂරය ගැලවී යන අතර ප්‍රතිදානයේ නොපෙන්වයි. අවාසනාවකට මෙන්, ප්‍රති .ලයට අමතර සුදු අවකාශයක් එක් නොකිරීම සඳහා පළමු පේළියට පසුව ඇති සෑම පේළියක්ම පෙළ ගැස්විය යුතුය යන ගැටළුව තවමත් පවතී.

සිදුවිය නොහැකි සම්පාදක ප්‍රශස්තිකරණයන් මත රඳා නොපවතින එකම විකල්පයක් ඇත, එනම් ඔබේ අර්ථ දැක්වීම එක් පේළියකට දැමීමයි. ඔබට සම්පාදක ප්‍රශස්තිකරණය මත විශ්වාසය තැබීමට අවශ්‍ය නම්, ඔබට දැනටමත් ඇති + විශිෂ්ටයි; ඔබට නූල් වම්-පෙළගැස්විය යුතු නැත, ප්‍රති result ලයෙන් ඔබට නව රේඛා ලැබෙන්නේ නැත, එය ප්‍රශස්තිකරණය අපේක්ෂා කිරීම සඳහා එක් මෙහෙයුමක් පමණි, ක්‍රියාකාරී ඇමතුම් නොමැත.

ඔබට අවකාශ / නව රේඛා අවශ්‍ය නැතිනම්, නූල් එකතු කිරීම ක්‍රියා කරන බව පෙනේ:

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.

ඔබ කැමති නම් ඉහත සඳහන් දේ මෙහි ධාවනය කළ හැකිය .

මම සාදයට ටිකක් ප්‍රමාද වී ඇති බව මම දනිමි, නමුත් මෙම ත්‍රෙඩ් එකේ අනාගත පා readers කයන් සඳහා https://www.buildmystring.com/ නිර්දේශ කිරීමට මට අවශ්‍යය . මෙම වෙබ් අඩවිය භාවිතයෙන් ඔබට ඕනෑම කේතයක් C # string වචනාර්ථයට පරිවර්තනය කළ හැකිය.

ඔබට මෙම ක්‍රම දෙක භාවිතා කළ හැකිය:

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

SplitLineToMultiline () හි, ඔබට භාවිතා කිරීමට අවශ්‍ය නූල් සහ පේළි දිග නිර්වචනය කළ යුතුය, එය ඉතා සරල ය. ඔබට ස්තුතියි .