IList <string> या IEnumerable <string> से अल्पविराम से अलग सूची बनाना

Question

IList<string>या से स्ट्रिंग मानों की अल्पविराम से अलग सूची बनाने का सबसे साफ तरीका क्या है IEnumerable<string>?

String.Join(...)एक string[]प्रकार से काम करना बोझिल हो सकता है जब प्रकार के साथ काम करना जैसे कि IList<string>या IEnumerable<string>आसानी से एक स्ट्रिंग सरणी में परिवर्तित नहीं किया जा सकता है।

Comments

ओह ... वूप्स। मैं 3.5 में टोआरे विस्तार पद्धति को जोड़ने से चूक गया:public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)

— डैनियल फोर्टुनोव

यदि आप सीएसवी लिखने के साधन की तलाश में इस सवाल पर आए हैं, तो यह याद रखने योग्य है कि वस्तुओं के बीच बस कॉमा डालना अपर्याप्त है और स्रोत डेटा में उद्धरण और कॉमा के मामले में विफलता का कारण होगा।

— स्पेंडर

Answer 1

.NET 4+

IList<string> strings = new List<string>{"1","2","testing"};
string joined = string.Join(",", strings);

विस्तार और पूर्व .Net 4.0 समाधान

IEnumerable<string>LINQ (.NET 3.5) के साथ बहुत आसानी से एक स्ट्रिंग सरणी में परिवर्तित किया जा सकता है :

IEnumerable<string> strings = ...;
string[] array = strings.ToArray();

यदि आपको इसकी आवश्यकता है तो समतुल्य सहायक विधि लिखना काफी आसान है।

public static T[] ToArray(IEnumerable<T> source)
{
    return new List<T>(source).ToArray();
}

फिर इसे इस तरह से कॉल करें:

IEnumerable<string> strings = ...;
string[] array = Helpers.ToArray(strings);

फिर आप कॉल कर सकते हैं string.Join। बेशक, आपको एक सहायक विधि का उपयोग करने की आवश्यकता नहीं है :

// C# 3 and .NET 3.5 way:
string joined = string.Join(",", strings.ToArray());
// C# 2 and .NET 2.0 way:
string joined = string.Join(",", new List<string>(strings).ToArray());

उत्तरार्द्ध हालांकि एक कौर का एक सा है :)

यह काफी performant रूप में अच्छी तरह यह करने के लिए सबसे आसान तरीका होने की संभावना है, और - वहाँ के बारे में अन्य सवाल कर रहे हैं कि वास्तव में क्या प्रदर्शन की तरह, (लेकिन इतने तक ही सीमित नहीं) है यह एक ।

.NET 4.0 के अनुसार, इसमें अधिक अधिभार उपलब्ध हैं string.Join, इसलिए आप वास्तव में सिर्फ लिख सकते हैं:

string joined = string.Join(",", strings);

बहुत सरल :)

Comments

सहायक विधि में दो अनावश्यक सूची बनाना शामिल है। क्या यह वास्तव में समस्या को हल करने का सबसे अच्छा तरीका है? फोरकास्ट लूप में इसे खुद क्यों नहीं मिलाएं?

— एरिक

सहायक विधि केवल एक सूची और एक सरणी बनाती है। मुद्दा यह है कि परिणाम के लिए एक सरणी होना चाहिए, एक सूची नहीं ... और आपको शुरू करने से पहले एक सरणी का आकार जानने की आवश्यकता है। सर्वश्रेष्ठ अभ्यास का कहना है कि आपको तब तक LINQ में एक से अधिक बार स्रोत की गणना नहीं करनी चाहिए जब तक कि आपके पास नहीं है - यह सभी प्रकार का गंदा सामान हो सकता है। इसलिए, आप बफ़र्स में पढ़ने और आपके जाते ही आकार बदलने से बच जाते हैं - जो वास्तव में यही List<T>करता है। पहिया को क्यों मजबूत करें?

— जॉन स्कीट

नहीं, मुद्दा यह है कि परिणाम को एक संक्षिप्त स्ट्रिंग होने की आवश्यकता है। इस लक्ष्य को प्राप्त करने के लिए एक नई सूची या एक नई सरणी बनाने की कोई आवश्यकता नहीं है। इस तरह की .NET मानसिकता मुझे दुखी करती है।

— एरिक

बस। हर जवाब जॉन स्कीट की ओर जाता है। मैं सिर्फ varBooks = AmazonContainer.Where (p => p.Author == "जॉन स्कीट") का चयन करने जा रहा हूं।

— ज़ाचरी स्कॉट

@ codeMonkey0110: खैर वहाँ कोई क्वेरी अभिव्यक्ति होने, या कॉल करने का कोई मतलब नहीं है ToList। string myStr = string.Join(",", foo.Select(a => a.someInt.ToString()))हालांकि यह उपयोग करने के लिए ठीक है ।

— जॉन स्कीट

Answer 2

FYI करें, .NET 4.0 संस्करण string.Join()में कुछ अतिरिक्त अधिभार हैं , जो IEnumerableकेवल सरणियों के बजाय काम करते हैं, जिसमें एक ऐसा भी है जो किसी भी व्यक्ति से निपट सकता है T:

public static string Join(string separator, IEnumerable<string> values)
public static string Join<T>(string separator, IEnumerable<T> values)

Comments

इसे T.ToString () विधि कहेंगे?

— फिलिप लावोई

जॉन के जवाब पर सिर्फ यह टिप्पणी करने वाला था। उल्लेख करने के लिए धन्यवाद।

— दान बेचर

वैसे भी किसी वस्तु की संपत्ति पर ऐसा करने के लिए? (Ex: IEnumerable <Employee> और Employee ऑब्जेक्ट के पास एक स्ट्रिंग .SSN प्रॉपर्टी है, और SSN's की अल्पविराम से अलग की गई सूची प्राप्त कर रही है।)

— granadaCoder

आपको पहले स्ट्रिंग का चयन करना होगा, हालांकि आप एक विस्तार विधि बना सकते हैं जो ऐसा करती है। str = emps.Select(e => e.SSN).Join(",")

— जेवियर पाइनास 19

Answer 3

सबसे आसान तरीका मैं यह करने के लिए देख सकता हूँ LINQ Aggregateविधि का उपयोग कर रहा है :

string commaSeparatedList = input.Aggregate((a, x) => a + ", " + x)

Comments

यह केवल ToArray + Join की तुलना में अधिक जटिल (IMO) नहीं है, यह कुछ हद तक अक्षम भी है - एक बड़े इनपुट अनुक्रम के साथ, यह बहुत बुरा प्रदर्शन शुरू करने वाला है।

— जॉन स्कीट

फिर भी, यह सबसे सुंदर है।

— मेरिट

आप एग्रिगेट को एक स्ट्रिंगबर्ल बीज खिला सकते हैं, फिर आपका एग्रीगेट फंक बन जाता है Func<StringBuilder,string,StringBuider>। तो बस ToString()StringBuilder पर कॉल करें । यह निश्चित रूप से बहुत सुंदर नहीं है :)

— मैट ग्रीर

यह आईएमएचओ के लिए पूछे गए सवाल को करने का सबसे स्पष्ट तरीका है।

— डेरेक मॉरिसन

खबरदार है कि input.Count

— 1.43

Answer 4

मुझे लगता है कि स्ट्रिंग मानों की अल्पविराम से अलग की गई सूची बनाने का सबसे साफ तरीका है:

string.Join<string>(",", stringEnumerable);

यहाँ एक पूर्ण उदाहरण है:

IEnumerable<string> stringEnumerable= new List<string>();
stringList.Add("Comma");
stringList.Add("Separated");

string.Join<string>(",", stringEnumerable);

एक सहायक फ़ंक्शन बनाने की कोई आवश्यकता नहीं है, यह .NET 4.0 और इसके बाद के संस्करण में बनाया गया है।

Comments

ध्यान दें कि यह .NET 4 से शुरू होता है (जैसा कि उनके जवाब में जेवियर ने बताया)।

— डेरेक मॉरिसन

.NET 4 नौसिखिया के दृष्टिकोण से एक महीने से कम समय के अनुभव के साथ यह उत्तर शुद्धता और

— सक्सेसनेस

Answer 5

विजेता के प्रदर्शन की तुलना में "लूप इट, sb.Append, और स्टेप बैक करें" है। वास्तव में "enumerable और मैन्युअल मूव नेक्स्ट" एक ही अच्छा है (stddev पर विचार करें)।

BenchmarkDotNet=v0.10.5, OS=Windows 10.0.14393
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233539 Hz, Resolution=309.2587 ns, Timer=TSC
  [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1637.0
  Clr    : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1637.0
  Core   : .NET Core 4.6.25009.03, 64bit RyuJIT


                Method |  Job | Runtime |     Mean |     Error |    StdDev |      Min |      Max |   Median | Rank |  Gen 0 | Allocated |
---------------------- |----- |-------- |---------:|----------:|----------:|---------:|---------:|---------:|-----:|-------:|----------:|
            StringJoin |  Clr |     Clr | 28.24 us | 0.4381 us | 0.3659 us | 27.68 us | 29.10 us | 28.21 us |    8 | 4.9969 |   16.3 kB |
 SeparatorSubstitution |  Clr |     Clr | 17.90 us | 0.2900 us | 0.2712 us | 17.55 us | 18.37 us | 17.80 us |    6 | 4.9296 |  16.27 kB |
     SeparatorStepBack |  Clr |     Clr | 16.81 us | 0.1289 us | 0.1206 us | 16.64 us | 17.05 us | 16.81 us |    2 | 4.9459 |  16.27 kB |
            Enumerable |  Clr |     Clr | 17.27 us | 0.0736 us | 0.0615 us | 17.17 us | 17.36 us | 17.29 us |    4 | 4.9377 |  16.27 kB |
            StringJoin | Core |    Core | 27.51 us | 0.5340 us | 0.4995 us | 26.80 us | 28.25 us | 27.51 us |    7 | 5.0296 |  16.26 kB |
 SeparatorSubstitution | Core |    Core | 17.37 us | 0.1664 us | 0.1557 us | 17.15 us | 17.68 us | 17.39 us |    5 | 4.9622 |  16.22 kB |
     SeparatorStepBack | Core |    Core | 15.65 us | 0.1545 us | 0.1290 us | 15.45 us | 15.82 us | 15.66 us |    1 | 4.9622 |  16.22 kB |
            Enumerable | Core |    Core | 17.00 us | 0.0905 us | 0.0654 us | 16.93 us | 17.12 us | 16.98 us |    3 | 4.9622 |  16.22 kB |

कोड:

public class BenchmarkStringUnion
{
    List<string> testData = new List<string>();
    public BenchmarkStringUnion()
    {
        for(int i=0;i<1000;i++)
        {
            testData.Add(i.ToString());
        }
    }
    [Benchmark]
    public string StringJoin()
    {
        var text = string.Join<string>(",", testData);
        return text;
    }
    [Benchmark]
    public string SeparatorSubstitution()
    {
        var sb = new StringBuilder();
        var separator = String.Empty;
        foreach (var value in testData)
        {
            sb.Append(separator).Append(value);
            separator = ",";
        }
        return sb.ToString();
    }

    [Benchmark]
    public string SeparatorStepBack()
    {
        var sb = new StringBuilder();
        foreach (var item in testData)
            sb.Append(item).Append(',');
        if (sb.Length>=1) 
            sb.Length--;
        return sb.ToString();
    }

    [Benchmark]
    public string Enumerable()
    {
        var sb = new StringBuilder();
        var e = testData.GetEnumerator();
        bool  moveNext = e.MoveNext();
        while (moveNext)
        {
            sb.Append(e.Current);
            moveNext = e.MoveNext();
            if (moveNext) 
                sb.Append(",");
        }
        return sb.ToString();
    }
}

https://github.com/dotnet/BenchmarkDotNet का उपयोग किया गया था

Answer 6

चूँकि मैं वस्तुओं की सूची की एक विशिष्ट संपत्ति में शामिल होने के लिए यहाँ पहुँचा था (और इसके बारे में नहीं) (यहाँ) यह स्वीकार किए गए उत्तर के अतिरिक्त है:

var commaDelimited = string.Join(",", students.Where(i => i.Category == studentCategory)
                                 .Select(i => i.FirstName));

Answer 7

यहाँ एक और विस्तार विधि है:

    public static string Join(this IEnumerable<string> source, string separator)
    {
        return string.Join(separator, source);
    }

Answer 8

इस चर्चा में थोड़ी देर हो रही है लेकिन यह मेरा योगदान है। मुझे IList<Guid> OrderIdsएक CSV स्ट्रिंग में परिवर्तित किया जाना है, लेकिन निम्नलिखित सामान्य है और अन्य प्रकारों के साथ काम नहीं करता है:

string csv = OrderIds.Aggregate(new StringBuilder(),
             (sb, v) => sb.Append(v).Append(","),
             sb => {if (0 < sb.Length) sb.Length--; return sb.ToString();});

छोटी और मीठी, नई स्ट्रिंग के निर्माण के लिए स्ट्रिंगबर्ल का उपयोग करती है, पिछले कॉमा को हटाने के लिए एक के बाद एक स्ट्रिंग स्ट्रिंगबिनस्ट लंबाई को छोटा करती है और सीएसवी स्ट्रिंग लौटाती है।

मैंने Append()स्ट्रिंग + कॉमा को जोड़ने के लिए कई का उपयोग करने के लिए इसे अपडेट किया है । जेम्स की प्रतिक्रिया से मैंने रिफ्लेक्टर का इस्तेमाल किया StringBuilder.AppendFormat()। बाहर मुड़ता है AppendFormat()एक स्ट्रिंग स्ट्रिंग का निर्माण करने के लिए StringBuilder का उपयोग करता है जो इसे इस संदर्भ में केवल एकाधिक का उपयोग करने Appends()की तुलना में कम कुशल बनाता है ।

Comments

गज़म्पेड, धन्यवाद जेवियर मुझे .Net4 में उस अपडेट के बारे में पता नहीं था। जिस परियोजना पर मैं काम कर रहा हूं, उसने अभी तक छलांग नहीं लगाई है, इसलिए मैं इस बीच अपने अब के पैदल चलने वाले उदाहरण का उपयोग करता रहूंगा।

— डेविड क्लार्क

यह एक शून्य-आइटम IEnumerable स्रोत के साथ विफल हो जाएगा। sb.Length-- एक सीमा जाँच की जरूरत है।

— जेम्स डुन

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

— डेविड क्लार्क

@ मुझे लगता है कि sb.Length-- हैक को कॉल करना थोड़ा कठोर है। प्रभावी रूप से मैं सिर्फ आपके "if (notdone)" परीक्षण से बच रहा हूं, जब तक कि प्रत्येक पुनरावृत्ति में ऐसा करने के बजाय अंत तक।

— डेविड क्लार्क

@ मेरी बात यह है कि अक्सर पूछे जाने वाले प्रश्नों का एक से अधिक सही उत्तर होता है और किसी को "हैक" के रूप में संदर्भित करने का मतलब है कि यह गलत है जो मैं विवाद करूंगा। छोटी संख्या के लिए मैं ऊपर डेनियल के जवाब को समझ रहा हूँ शायद पूरी तरह से पर्याप्त होगा और यह निश्चित रूप से अधिक रसीला / पठनीय है तो मेरा जवाब है। मैं अपने कोड में केवल एक ही स्थान पर इसका उपयोग कर रहा हूं और मैं केवल एक अल्पविराम के रूप में एक अल्पविराम का उपयोग करूंगा। YAGNI का कहना है कि ऐसी किसी चीज़ का निर्माण न करें जिसकी आपको ज़रूरत नहीं है। DRY तब लागू होता है जब मुझे इसे एक से अधिक बार करने की आवश्यकता होती है जिस बिंदु पर मैं एक एक्सस् टेशन विधि बनाऊंगा। HTH।

— डेविड क्लार्क

Answer 9

कुछ थोड़ा सा, लेकिन यह काम करता है:

string divisionsCSV = String.Join(",", ((List<IDivisionView>)divisions).ConvertAll<string>(d => d.DivisionID.ToString("b")).ToArray());

आपके द्वारा सूची देने के बाद आपको एक CSV से CSV देता है (इस मामले में d => d.DivisionID.ToString ("b")।

हैकी लेकिन काम करता है - शायद एक विस्तार विधि में बनाया जा सकता है?

Answer 10

यहाँ मैंने इसे किया है, जिस तरह से मैंने इसे अन्य भाषाओं में किया है:

private string ToStringList<T>(IEnumerable<T> list, string delimiter)
{
  var sb = new StringBuilder();
  string separator = String.Empty;
  foreach (T value in list)
  {
    sb.Append(separator).Append(value);
    separator = delimiter;
  }
  return sb.ToString();
}

Answer 11

विशिष्ट आवश्यकता तब होती है जब हमें 'द्वारा, पूर्व से घिरा होना चाहिए:

        string[] arr = { "jj", "laa", "123" };
        List<string> myList = arr.ToList();

        // 'jj', 'laa', '123'
        Console.WriteLine(string.Join(", ",
            myList.ConvertAll(m =>
                string.Format("'{0}'", m)).ToArray()));

Answer 12

हमारे पास एक उपयोगिता समारोह है, कुछ इस तरह से:

public static string Join<T>( string delimiter, 
    IEnumerable<T> collection, Func<T, string> convert )
{
    return string.Join( delimiter, 
        collection.Select( convert ).ToArray() );
}

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

int[] ids = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233};

string csv = StringUtility.Join(",", ids, i => i.ToString() );

ध्यान दें कि लैम्बडा से पहले हमारे पास संग्रह परम है क्योंकि इंटेलीजेंस तब संग्रह प्रकार को चुनता है।

यदि आपके पास पहले से ही तार की एक गणना है जो आपको करने की आवश्यकता है:

string csv = string.Join( ",", myStrings.ToArray() );

Comments

मेरे पास एक विस्तार विधि है जो लगभग बिल्कुल एक ही काम करती है, बहुत उपयोगी है: stackoverflow.com/questions/696850/…

— 22

हाँ, आप इसे आसानी से पर्याप्त रूप में .ToDelimitedString एक्सटेंशन विधि के रूप में लिख सकते हैं। मैं अपनी सिंगल लाइन स्ट्रिंग के साथ जाऊँगा। स्टनिंगब्यूलर को ट्रिम करने के बजाए अंतिम चार का उपयोग करने के बजाय।

— कीथ

Answer 13

आप ToArray का उपयोग करके IList को एक सरणी में बदल सकते हैं और फिर array पर एक string.join कमांड चला सकते हैं।

Dim strs As New List(Of String)
Dim arr As Array
arr = strs.ToArray

Answer 14

उन्हें .NET 3.5 में Linq एक्सटेंशन का उपयोग करके आसानी से एक सरणी में परिवर्तित किया जा सकता है।

   var stringArray = stringList.ToArray();

Answer 15

जब आप इसे किसी अन्य द्वारा सूचीबद्ध विधियों में से किसी एक विधि में बदलकर सरणी में परिवर्तित कर लेते हैं, तो आप निम्नलिखित जैसे कुछ का उपयोग कर सकते हैं:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;
using System.Configuration;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            CommaDelimitedStringCollection commaStr = new CommaDelimitedStringCollection();
            string[] itemList = { "Test1", "Test2", "Test3" };
            commaStr.AddRange(itemList);
            Console.WriteLine(commaStr.ToString()); //Outputs Test1,Test2,Test3
            Console.ReadLine();
        }
    }
}

संपादित करें: यहां एक और उदाहरण है

Answer 16

मैंने इस लेख के पार होने से पहले इस मुद्दे को हल किया। मेरा समाधान कुछ इस तरह है:

   private static string GetSeparator<T>(IList<T> list, T item)
   {
       return (list.IndexOf(item) == list.Count - 1) ? "" : ", ";
   }

जैसे कहा जाता है:

List<thing> myThings;
string tidyString;

foreach (var thing in myThings)
{
     tidyString += string.format("Thing {0} is a {1}", thing.id, thing.name) + GetSeparator(myThings, thing);
}

मैं भी बस के रूप में आसानी से व्यक्त किया जा सकता है और यह भी अधिक कुशल होता:

string.Join(“,”, myThings.Select(t => string.format(“Thing {0} is a {1}”, t.id, t.name)); 

Answer 17

मेरा जवाब एग्रीगेट समाधान से ऊपर है, लेकिन कम कॉल-स्टैक भारी होना चाहिए क्योंकि कोई स्पष्ट प्रतिनिधि कॉल नहीं हैं:

public static string ToCommaDelimitedString<T>(this IEnumerable<T> items)
{
    StringBuilder sb = new StringBuilder();
    foreach (var item in items)
    {
        sb.Append(item.ToString());
        sb.Append(',');
    }
    if (sb.Length >= 1) sb.Length--;
    return sb.ToString();
}

बेशक, कोई हस्ताक्षर को सीमांकित-स्वतंत्र करने के लिए बढ़ा सकता है। मैं वास्तव में sb.Remove () कॉल का प्रशंसक नहीं हूं और मैं इसे एक सीधे-अप होने के लिए रिफ्लेक्टर करना चाहता हूं जबकि IEnumerable पर लूप और एक कॉमा लिखने के लिए निर्धारित करने के लिए MoveNext () का उपयोग करता हूं। अगर मैं उस पर आता हूं तो मैं उस समाधान के चारों ओर फील करूंगा।

---

यहां वही है जो मैं शुरू में चाहता था:

public static string ToDelimitedString<T>(this IEnumerable<T> source, string delimiter, Func<T, string> converter)
{
    StringBuilder sb = new StringBuilder();
    var en = source.GetEnumerator();
    bool notdone = en.MoveNext();
    while (notdone)
    {
        sb.Append(converter(en.Current));
        notdone = en.MoveNext();
        if (notdone) sb.Append(delimiter);
    }
    return sb.ToString();
}

कोई अस्थायी सरणी या सूची भंडारण की आवश्यकता है और कोई StringBuilder Remove()या Length--आवश्यक उहू।

मेरी ढांचे पुस्तकालय में मैं इस विधि हस्ताक्षर पर कुछ रूपों, सहित के प्रत्येक संयोजन बनाया delimiterऔर converterके उपयोग के साथ मानकों ","और x.ToString()क्रमशः चूक के रूप में,।

Answer 18

उम्मीद है कि यह सबसे सरल तरीका है

 string Commaseplist;
 string[] itemList = { "Test1", "Test2", "Test3" };
 Commaseplist = string.join(",",itemList);
 Console.WriteLine(Commaseplist); //Outputs Test1,Test2,Test3

Answer 19

मैं इस चर्चा पर आया था कि स्ट्रिंग में शामिल होने के लिए एक अच्छी सी # विधि की खोज करूं जैसे कि यह MySql विधि के साथ किया जाता है CONCAT_WS()। यह विधि उस string.Join()विधि से अलग है जिसमें यह विभाजक संकेत नहीं जोड़ता है यदि तार NULL या रिक्त हैं।

CONCAT_WS (',', tbl.Lastname, tbl.Firstname)

केवल वापस आ जाएगी Lastnameअगर firstname खाली है, जबकि

string.Join (",", strLastname, strFirstname)

strLastname + ", "उसी मामले में वापस आ जाएगा ।

पहला व्यवहार चाहते हुए, मैंने निम्नलिखित तरीके लिखे:

    public static string JoinStringsIfNotNullOrEmpty(string strSeparator, string strA, string strB, string strC = "")
    {
        return JoinStringsIfNotNullOrEmpty(strSeparator, new[] {strA, strB, strC});
    }

    public static string JoinStringsIfNotNullOrEmpty(string strSeparator, string[] arrayStrings)
    {
        if (strSeparator == null)
            strSeparator = "";
        if (arrayStrings == null)
            return "";
        string strRetVal = arrayStrings.Where(str => !string.IsNullOrEmpty(str)).Aggregate("", (current, str) => current + (str + strSeparator));
        int trimEndStartIndex = strRetVal.Length - strSeparator.Length;
        if (trimEndStartIndex>0)
            strRetVal = strRetVal.Remove(trimEndStartIndex);
        return strRetVal;
    }

Answer 20

मैंने इसे करने के लिए कुछ विस्तार विधियाँ लिखीं जो इस तरह से कुशल हैं:

    public static string JoinWithDelimiter(this IEnumerable<String> that, string delim) {
        var sb = new StringBuilder();
        foreach (var s in that) {
            sb.AppendToList(s,delim);
        }

        return sb.ToString();
    }

यह निर्भर करता है

    public static string AppendToList(this String s, string item, string delim) {
        if (s.Length == 0) {
            return item;
        }

        return s+delim+item;
    }

Comments

तार को जोड़ने के लिए + ऑपरेटर का उपयोग करना महान नहीं है क्योंकि यह हर बार एक नया स्ट्रिंग आवंटित करने का कारण होगा। आगे और अधिक, हालांकि स्ट्रिंगबर्ल को एक स्ट्रिंग में अंतर्निहित रूप से डाला जा सकता है, ऐसा अक्सर (आपके लूप का हर पुनरावृत्ति) काफी हद तक एक स्ट्रिंग बिल्डर होने के उद्देश्य को हरा देगा।

— डैनियल फोर्टुनोव

Answer 21

आप उपयोग कर सकते हैं .ToArray()पर Listsऔर IEnumerables, और उसके बाद का उपयोग String.Join()के रूप में आप चाहते थे।

Answer 22

यदि आप जिस तार से जुड़ना चाहते हैं, वह वस्तुओं की सूची में हैं, तो आप ऐसा कुछ भी कर सकते हैं:

var studentNames = string.Join(", ", students.Select(x => x.name));