delimiters के साथ एक स्ट्रिंग को विभाजित करें, परिणामस्वरूप सी #

Question

में परिणामस्वरूप डिलिमिटर रखें, मैं एक स्ट्रिंग को डिलीमीटर के साथ विभाजित करना चाहता हूं लेकिन परिणामस्वरूप डिलीमीटर को रखना चाहता हूं।

मैं इसे सी # में कैसे करूं?

Answer 1

आप सीमांकक अपने 'खुद विभाजन "बनना चाहते हैं, तो आप का उपयोग Regex.Split जैसे कर सकते हैं:

string input = "plum-pear"; 
string pattern = "(-)"; 

string[] substrings = Regex.Split(input, pattern); // Split on hyphens 
foreach (string match in substrings) 
{ 
    Console.WriteLine("'{0}'", match); 
} 
// The method writes the following to the console: 
// 'plum' 
// '-' 
// 'pear' 

Answer 2

मैं (तर्क हंस Kesting पाला को छोड़ कर) यह पूरा करने के लिए सबसे आसान तरीका कहेंगे स्ट्रिंग को नियमित तरीके से विभाजित करना है, फिर सरणी पर फिर से भरना और प्रत्येक तत्व के लिए डिलीमीटर जोड़ें लेकिन अंतिम।

Answer 3

मैं इस तरह एक बहु स्ट्रिंग करना चाहता था लेकिन लाइन टूट जाता है रखने के लिए की जरूरत है तो मैं इस

string x = 
@"line 1 {0} 
line 2 {1} 
"; 

foreach(var line in string.Format(x, "one", "two") 
    .Split("\n") 
    .Select(x => x.Contains('\r') ? x + '\n' : x) 
    .AsEnumerable() 
) { 
    Console.Write(line); 
} 

पैदावार

line 1 one 
line 2 two 

Answer 4

मैं एक ही समस्या का सामना करना है, लेकिन कई सीमांकक के साथ आया था। केमलकेस चर नाम को अलग करने के साथ

public static string[] SplitLeft(this string @this, char[] delimiters, int count) 
    { 
     var splits = new List<string>(); 
     int next = -1; 
     while (splits.Count + 1 < count && (next = @this.IndexOfAny(delimiters, next + 1)) >= 0) 
     { 
      splits.Add(@this.Substring(0, next)); 
      @this = new string(@this.Skip(next).ToArray()); 
     } 
     splits.Add(@this); 
     return splits.ToArray(); 
    } 

नमूना::

var variableSplit = variableName.SplitLeft(
    Enumerable.Range('A', 26).Select(i => (char)i).ToArray()); 

Answer 5

इस संस्करण LINQ या रेगेक्स उपयोग नहीं करता है और इसलिए यह शायद अपेक्षाकृत कुशल है यहाँ मेरी समाधान है। मुझे लगता है कि रेगेक्स की तुलना में इसका उपयोग करना आसान हो सकता है क्योंकि आपको विशेष डिलीमीटर से बचने की चिंता करने की ज़रूरत नहीं है। यह IList<string> देता है जो हमेशा एक सरणी में कनवर्ट करने से अधिक कुशल होता है। यह एक विस्तार विधि है, जो सुविधाजनक है। आप डिलीमीटर में या तो सरणी या एकाधिक पैरामीटर के रूप में पास कर सकते हैं।

/// <summary> 
/// Splits the given string into a list of substrings, while outputting the splitting 
/// delimiters (each in its own string) as well. It's just like String.Split() except 
/// the delimiters are preserved. No empty strings are output.</summary> 
/// <param name="s">String to parse. Can be null or empty.</param> 
/// <param name="delimiters">The delimiting characters. Can be an empty array.</param> 
/// <returns></returns> 
public static IList<string> SplitAndKeepDelimiters(this string s, params char[] delimiters) 
{ 
    var parts = new List<string>(); 
    if (!string.IsNullOrEmpty(s)) 
    { 
     int iFirst = 0; 
     do 
     { 
      int iLast = s.IndexOfAny(delimiters, iFirst); 
      if (iLast >= 0) 
      { 
       if (iLast > iFirst) 
        parts.Add(s.Substring(iFirst, iLast - iFirst)); //part before the delimiter 
       parts.Add(new string(s[iLast], 1));//the delimiter 
       iFirst = iLast + 1; 
       continue; 
      } 

      //No delimiters were found, but at least one character remains. Add the rest and stop. 
      parts.Add(s.Substring(iFirst, s.Length - iFirst)); 
      break; 

     } while (iFirst < s.Length); 
    } 

    return parts; 
} 

कुछ इकाई परीक्षण:

text = "[a link|http://www.google.com]"; 
result = text.SplitAndKeepDelimiters('[', '|', ']'); 
Assert.IsTrue(result.Count == 5); 
Assert.AreEqual(result[0], "["); 
Assert.AreEqual(result[1], "a link"); 
Assert.AreEqual(result[2], "|"); 
Assert.AreEqual(result[3], "http://www.google.com"); 
Assert.AreEqual(result[4], "]"); 

Answer 6

नई लाइन के लिए चरित्र इस कोशिश को जोड़ने से बचने के लिए:

string[] substrings = Regex.Split(input,@"(?<=[-])");