एक स्ट्रिंग विभाजित करने के लिए कैसे पाइप (जो दोहरे उद्धरण चिह्नों

Question

मैं नीचे की तरह एक स्ट्रिंग है, जो पाइप अलग किया जाता है है अंदर नहीं है के रूप में सीमांकित साथ यह स्ट्रिंग को दोहरे उद्धरण चिह्नों (पूर्व है ? (जो दोहरे उद्धरण चिह्नों के भीतर नहीं हैं) मैं पाइप सीमांकक के साथ इस विभाजित कर

511186|"ANI"|"ABCD-102091474|E|EFG"||"2013-07-20 13:47:19.556" 

और splitted मूल्यों नीचे की तरह हो shoule:

511186 
"ANI" 
"ABCD-102091474|E|EFG" 

"2013-07-20 13:47:19.556" 

किसी भी मदद की सराहना की जाएगी

संपादित

जवाब है कि मैं स्वीकार किए जाते हैं, उन श्रृंखलाएं जिनमें दोहरे उद्धरण चिह्नों के अंदर है के लिए काम नहीं किया। कोई विचार, मुद्दा क्या होना चाहिए?

using System.Text.RegularExpressions; 
string regexFormat = string.Format(@"(?:^|\{0})(""[^""]*""|[^\{0}]*)", '|'); 
string[] result = Regex.Matches("111001103|\"E\"|\"BBB\"|\"XXX\"|||10000009|153086649|\"BCTV\"|\"REV\"|||1.00000000|||||\"ABC-BT AD\"|\"\"\"ABC - BT\"\" AD\"|||\"N\"||\"N\"|||\"N\"||\"N",regexFormat) 
    .Cast<Match>().Select(m => m.Groups[1].Value).ToArray(); 
    foreach(var i in result) 
    Console.WriteLine(i) 

Answer 1

आप स्ट्रिंग में आइटम मिलान करने के लिए रेगुलर एक्सप्रेशन का उपयोग कर सकते हैं:

string[] result = Regex.Matches(s, @"(?:^|\|)(""[^""]*""|[^|]*)") 
    .Cast<Match>() 
    .Select(m => m.Groups[1].Value) 
    .ToArray(); 

स्पष्टीकरण:

(?:  A non-capturing group 
^|\|  Matches start of string or a pipe character 
)   End of group 
(  Capturing group 
"[^"]*" Zero or more non-quotes surrounded by quotes 
|   Or 
[^|]*  Zero or more non-pipes 
)   End of group 

Answer 2

string.Split("|", inputString); 

... आप अलग अलग हिस्सों दे देंगे, लेकिन अगर कुछ हिस्सों के किसी भी उन में एक पाइप विभाजक है असफल हो जायेगी।

यदि यह एक सीएसवी फ़ाइल है, तो कैरेक्टर-एस्केपिंग इत्यादि के बारे में सभी सामान्य सीएसवी नियमों का पालन करें (लेकिन कॉमा के बजाए पाइप प्रतीक का उपयोग करके), तो आपको CsvHelper का उपयोग करना चाहिए, जो एक NuGet पैकेज पढ़ने और लिखने के लिए डिज़ाइन किया गया है सीएसवी फाइलें यह सभी कड़ी मेहनत करता है, और सभी कोने के मामलों से संबंधित है जो आपको अन्यथा खुद करना है।

Answer 3

यहाँ एक तरह से यह करने के लिए है:

public List<string> Parse(string str) 
{ 
    var parts = str.Split(new[] {"|"}, StringSplitOptions.None); 

    List<string> result = new List<string>(); 

    for (int i = 0; i < parts.Length; i++) 
    { 
     string part = parts[i]; 

     if (IsPartStart(part)) 
     { 
      List<string> sub_parts = new List<string>(); 

      do 
      { 
       sub_parts.Add(part); 
       i++; 
       part = parts[i]; 
      } while (!IsPartEnd(part)); 

      sub_parts.Add(part); 

      part = string.Join("|", sub_parts); 
     } 

     result.Add(part); 
    } 

    return result; 

} 

private bool IsPartStart(string part) 
{ 
    return (part.StartsWith("\"") && !part.EndsWith("\"")) ; 
} 

private bool IsPartEnd(string part) 
{ 
    return (!part.StartsWith("\"") && part.EndsWith("\"")); 
} 

यह सब कुछ विभाजित करके काम करता है, और यह तब भागों कि भागों कि " साथ शुरू होता है के लिए खोज और भागों है कि साथ समाप्त होता है इसी से शामिल होने की जरूरत है में से कुछ में शामिल "।

Answer 4

यहां मैं यह कैसे करूँगा। यह काफी सरल है और मुझे लगता है कि आपको यह भी बहुत तेज़ लगेगा। मैंने कोई परीक्षण नहीं किया है, लेकिन मुझे पूरा भरोसा है कि यह नियमित अभिव्यक्तियों से तेज़ है।

IEnumerable<string> Parse(string s) 
{ 
    int pos = 0; 

    while (pos < s.Length) 
    { 
     char endChar = '|'; 

     // Test for quoted value 
     if (s[pos] == '"') 
     { 
      pos++; 
      endChar = '"'; 
     } 

     // Extract this value 
     int newPos = s.IndexOf(endChar, pos); 
     if (newPos < 0) 
      newPos = s.Length; 
     yield return s.Substring(pos, newPos - pos); 

     // Move to start of next value 
     pos = newPos + 1; 
     if (pos < s.Length && s[pos] == '|') 
      pos++; 
    } 
}