सी #: स्प्लिट स्ट्रिंग और कई स्ट्रिंग चर

Question

मैं एक विशिष्ट चरित्र के द्वारा अलग कई क्षेत्रों, कुछ इस तरह से एक स्ट्रिंग के लिए असाइन परिणाम:

ए, बी, सी

मैं चाहता हूँ कॉमा पर स्ट्रिंग को विभाजित करने और प्रत्येक परिणामी फ़ील्ड को अपने स्ट्रिंग वेरिएबल को असाइन करने के लिए। पर्ल में मुझे लगता है कि सुंदर ढंग से कर सकते हैं इस तरह:

my ($varA, $varB, $varC) = split (/,/, $string); 

सरल और सबसे सुरुचिपूर्ण तरीका सी # में एक ही परिणाम प्राप्त करने के लिए क्या है?

मुझे पता है कि मैं एक सरणी में विभाजित कर सकते हैं:

string[] results = string.Split(','); 

लेकिन तब मैं अपने सूचकांक, उदा के माध्यम से खेतों का उपयोग करने के लिए होगा परिणाम [2]। पढ़ना मुश्किल है और त्रुटि-प्रवण - 3 बूथ 30 फ़ील्ड नहीं होने पर विचार करें। इसी कारण से मैं प्रत्येक फ़ील्ड मान को अपने नामित चर में रखना पसंद करता हूं।

Answer 1

मैं सहमत हूं। एक एडाप्टर वर्ग में विभाजित छिपाई जा रही है एक अच्छा दृष्टिकोण की तरह लगता है और अपने मंशा का नहीं बल्कि अच्छी तरह से:

public class MySplitter 
{ 
    public MySplitter(string split) 
    { 
     var results = string.Split(','); 
     NamedPartA = results[0]; 
     NamedpartB = results[1]; 
    } 

    public string NamedPartA { get; private set; } 
    public string NamedPartB { get; private set; } 
} 

Answer 2

कोई सी # में रास्ते में बनाया गया है जैसे आप पर्ल में कर सकते हैं एक से अधिक काम करने के लिए; हालांकि, प्रत्येक चर में डेटा को सामान्य पथ के माध्यम से प्राप्त करने के लिए कई समाधान हैं।

Answer 3

मैं एक शब्दकोश की सिफारिश करता हूं।

List<string> names = new List<string>(){"varA","varB","varC"}; 
Dictionary<string, string> map = new Dictionary<string, string>(); 
string[] results = myLongString.Split(','); 
for (int i = 0; i < results.Length; i++) map.Add(names[i], results[i]); 

Answer 4

आप टुपल्स (नेट 4 में जोड़ा गया) का उपयोग कर सकते हैं। Tuples in MSDN

यह:

public class MySplitter 
{ 
    public MySplitter(string split) 
    { 
     var results = split.Split(','); 
     NamedPartA = results[0]; 
     NamedpartB = results[1]; 
    } 

    public string NamedPartA { get; private set; } 
    public string NamedPartB { get; private set; } 
} 

कुछ इस तरह से हासिल किया जा सकता है:

public Tuple<string,string> SplitIntoVars(string toSplit) 
{ 
    string[] split = toSplit.Split(','); 
    return Tuple.Create(split[0],split[1]); 
} 

एक टपल के साथ आप उपयोग कर सकते हैं:

var x = SplitIntoVars(arr); 
// you can access the items like this: x.Item1 or x.Item2 (and x.Item3 etc.) 

तुम भी के लिए एक टपल बना सकते हैं आदि का उपयोग

इसके अलावा ... मुझे वास्तव में पैरामीटर पसंद नहीं हैं, इसलिए आप एक टुपल (और स्पष्ट रूप से, विभिन्न प्रकार के भी) का उपयोग करके कई मानों को वापस अनुकरण करते हैं। इस:

public void SplitIntoVariables(string input, out a, out b, out c) 
{ 
    string pieces[] = input.Split(','); 
    a = pieces[0]; 
    b = pieces[1]; 
    c = pieces[2]; 
} 

इस में बदल जाता है:

public Tuple<string,string,string> SplitIntoVariables(string[] input) 
    { 
     string pieces[] = input.Split(','); 
     return Tuple.Create(pieces[0],pieces[1],pieces[2]); 
    } 

अन्य (अधिक कल्पनाशील) विकल्प एक ExpandoObject (गतिशील) है कि अपने मूल्यों (ViewBag के लिए कुछ समान ASP.NET MVC में) रखती है बनाने जा सकता है

Answer 5

और जो कुछ लिंक पागलपन का विरोध नहीं कर सकता!

string names = "Joe,Bob,Lucy"; 
var myVars = names.Split(',').Select((x, index) => Tuple.Create(index,x)).ToDictionary(x => "var" + x.Item1, y => y.Item2); 
Debug.WriteLine(myVars["var0"]); 

Answer 6

एक लाइन समाधान नहीं है।लेकिन, एक अतिरिक्त out पैरामीटर के साथ एक विस्तार विधि के बारे में कैसे?

public static IEnumerable<T> Unpack<T>(this IEnumerable<T> source, out T target) 
{ 
    target = source.First(); 
    return source.Skip(1); 
} 

उसके बाद, आप इस तरह विधि का उपयोग कर सकते हैं।

string values = "aaa,bbb,ccc"; 
string x, y, z; 
values.Split(',') 
    .Unpack(out x) 
    .Unpack(out y) 
    .Unpack(out z); 

ध्यान दें कि Unpack विधि दो बार अनुक्रम विश्लेषण करता है। इसलिए, मैं इसका उपयोग केवल तभी करूंगा जब IEnumerable ऑब्जेक्ट में डेटा दोहराने योग्य हो।

मुझे विधि के प्रदर्शन की जांच करने की परवाह नहीं थी क्योंकि मैंने सोचा था कि आम तौर पर हम एक बड़ी सरणी को अनपैक नहीं करेंगे।

बेशक, आप out के बजाय ref संशोधक का उपयोग कर सकते हैं, और उपयोग अलग होगा।

Answer 7

मैं हास्यास्पदता में जोड़ने का विरोध नहीं कर सका :) कृपया इस "समाधान" का उपयोग न करें, कम से कम नहीं।

static class StringExtensions 
{ 
    private static readonly Func<object, string, Action<object, object>> GetSetter = 
     (o1, n) => (o2, v) => o1.GetType().GetProperty(n).SetValue(o2, v, null); 

    public static T AssignFromCSV<T>(this string csv, T obj, string[] propertyNames) 
    { 
     var a = csv.Split(new[] {','}); 
     for (var i = 0 ; i < propertyNames.Length; i++) 
     { 
      GetSetter(obj, propertyNames[i])(obj, a[i]); 
     } 
     return obj ; 
    } 
} 

class TargetClass 
{ 
    public string A { get; set; } 

    public string B { get; set; } 

    public string C { get; set; } 
} 

उपयोग:

var target = "1,2,3".AssignFromCSV(new TargetClass(), new[] {"A", "B", "C"}) ; 

Answer 8

@pnvn अनपैक पैटर्न के साथ एक बहुत अच्छा विचार है, लेकिन यह गणनीय के अंत अतीत, एक भी पास में शुमार अधिक पुनरावृति चूक प्रदान करने के लिए सुधार किया जा सकता और एक अनुमानित तरीके से गणना के किसी भी प्रकार या आकार पर काम करते हैं।

यहां C# 7 out variables feature का उपयोग करके एक उदाहरण दिया गया है।

"A,B,C".Split(',') 
    .Unpack(out string varA) 
    .Unpack(out string varB); 

यह दो विस्तार के तरीकों, IEnumerable शुरू करने के लिए के लिए एक, प्रत्येक अनुवर्ती कॉल के लिए IEnumerator पर दूसरे की आवश्यकता है।

public static IEnumerator<T> Unpack<T>(this IEnumerable<T> source, out T item) 
{ 
    var enumerator = source.GetEnumerator(); 
    if (enumerator.MoveNext()) 
    { 
     item = enumerator.Current; 
     return enumerator; 
    } 
    item = default(T); 
    return null; 
} 

public static IEnumerator<T> Unpack<T>(this IEnumerator<T> enumerator, out T item) 
{ 
    if (enumerator != null && enumerator.MoveNext()) 
    { 
     item = enumerator.Current; 
     return enumerator; 
    }    
    item = default(T); 
    return null; 
}