Подтвердить что ты не робот

Преобразовать массив объектов в конкатенированную строку

если у меня есть:

 List<Car>

где автомобиль:

 public class Car
 {
      public int Year;
      public string Name;
 }

и я хочу взять этот массив и создать конкатенированную строку на ","

чтобы он возвращался:

"Toyota, Ford, Chevy"

Я могу сделать это вручную следующим образом:

  private static string CreateConcatenatedList(List<Car> parts_)
    {
        StringBuilder b = new StringBuilder();
        foreach (Car bp in parts_)
        {
            b.Append(bp.Name + ", ");
        }
        b.Remove(b.Length - 2, 2);
        return b.ToString();
    }

но я подумал, что может быть более элегантный способ

Ответ 1

List<Car> cars = //whatever;
string concat = String.Join(",", cars.Select(c => c.Name).ToArray());

EDIT: вы также можете использовать Aggregate, если вы беспокоитесь о создании промежуточного массива:

string concat = cars.Select(c => c.Name).Aggregate(new StringBuilder(), (sb, current) =>
{
    return sb.Length == 0 ? sb.Append(current) : sb.AppendFormat(",{0}", current);
}).ToString();

Ответ 2

Потому что вы спросили в комментарии к Лису, отвечают ли он быстрее/медленнее или просто меньше кода. Я попробовал немного, и написал небольшой класс автомобилей:

public class Car
{
    public string Name { get; set; }
    public Car(string name) { Name = name; }
}

Протестировал его с произвольно сгенерированными строками длиной 5-10:

private static Random random = new Random((int)DateTime.Now.Ticks);
private static string RandomString(int min, int max)
{
    string str = "";
    int size = random.Next(min, max + 1);
    for (int i = 0; i < size; i++)
        str += Convert.ToChar(Convert.ToInt32(
                       Math.Floor(26 * random.NextDouble() + 65)));
    return str;
}

public static void MeassureTicks(int numberCars, int minLength, int maxLength)
{
    // Generate random list
    List<Car> cars = Enumerable.Range(0, numberCars)
                     .Select(x => new Car(RandomString(
                             minLength, maxLength))).ToList();

    Stopwatch sw1 = new Stopwatch(), sw2 = new Stopwatch(),
              sw3 = new Stopwatch(), sw4 = new Stopwatch();

    sw1.Start();
    string concat1 = CreateConcatenatedList(cars);
    sw1.Stop();
    sw2.Start();
    string concat2 = String.Join(",", cars.Select(c => c.Name).ToArray());
    sw2.Stop();
    sw3.Start();
    if (numberCars <= 5000)
    {
        string concat3 = cars.Select(c => c.Name).Aggregate("",
                (str, current) =>
                {
                    return str.Length == 0 ? str = current :
                           str += "," + current;
                }).ToString();
    }
    sw3.Stop();
    sw4.Start();
    string concat4 = cars.Select(c => c.Name).Aggregate(
            new StringBuilder(), (sb, current) =>
            {
                return sb.Length == 0 ? sb.Append(current) :
                       sb.AppendFormat(",{0}", current);
            }).ToString();
    sw4.Stop();

    Console.WriteLine(string.Format("{0} car strings joined:\n" +
                "\tYour method:                  {1} ticks\n" + 
                "\tLinq+String.Join:             {2} ticks\n" + 
                "\tLinq+Aggregate+String.Concat: {3} ticks\n" + 
                "\tLinq+Aggregate+StringBuilder: {4} ticks\n",
                cars.Count, sw1.ElapsedTicks, sw2.ElapsedTicks, 
                numberCars <= 5000 ? sw3.ElapsedTicks.ToString() : "-", 
                sw4.ElapsedTicks));

Update: Теперь я пытаюсь использовать оба метода, которые также используют агрегат.

Выходы на моем компьютере для некоторого разного количества автомобилей:

5 car strings joined:
        Your method:                  14 ticks
        Linq+String.Join:             20 ticks
        Linq+Aggregate+String.Concat: 11 ticks
        Linq+Aggregate+StringBuilder: 15 ticks

50 car strings joined:
        Your method:                  50 ticks
        Linq+String.Join:             45 ticks
        Linq+Aggregate+String.Concat: 70 ticks
        Linq+Aggregate+StringBuilder: 73 ticks

500 car strings joined:
        Your method:                  355 ticks
        Linq+String.Join:             348 ticks
        Linq+Aggregate+String.Concat: 5365 ticks
        Linq+Aggregate+StringBuilder: 619 ticks

5000 car strings joined:
        Your method:                  3584 ticks
        Linq+String.Join:             3357 ticks
        Linq+Aggregate+String.Concat: 379635 ticks
        Linq+Aggregate+StringBuilder: 6078 ticks

50000 car strings joined:
        Your method:                  33705 ticks
        Linq+String.Join:             34082 ticks
        Linq+Aggregate+String.Concat: - ticks
        Linq+Aggregate+StringBuilder: 92839 ticks

500000 car strings joined:
        Your method:                  508439 ticks
        Linq+String.Join:             376339 ticks
        Linq+Aggregate+String.Concat: - ticks
        Linq+Aggregate+StringBuilder: 616048 ticks

Метод Linq + String.Join действительно немного быстрее и меньше кода. Совокупность вместе с шкалой StringBuilter очень хорошо (не как конкатенация строк), но немного медленнее. Поэтому либо используйте свой метод, либо Linq + String.Join, который является хорошим oneliner, а также легко читаемым.

Ответ 3

List<Car> cars = ....
var result = string.Join(",", cars.Select(car => car.Name).ToArray());

Ответ 4

Я думаю, что вы действительно хотите:

"Toyota, Ford, Chevy"

и не:

"Toyota", "Ford", "Chevy"

как написано в вашем вопросе. Это можно сделать так:

var cars = new List<Car>();

var delimitedString = string.Join(", ", cars.Select(c => c.Name).ToArray());

Ответ 5

ArrayList<Car> cars = ...
string finalValue = string.Join(",", cars.Select(c => c.Name).ToArray());

Ответ 6

Я написал следующий метод расширения для этого типа случая. Он использует строковый построитель и агрегат вместо string.Join и массив для небольшого улучшения производительности.

public static string Concatenate(
    this IEnumerable<string> collection, 
    string separator)
{
    return collection
        .Skip(1)
        .Aggregate(
            new StringBuilder().Append(collection.First()),
            (b, s) => b.Append(separator).Append(s))
        .ToString();
}

Тогда в вашем случае это просто

cars.Select(c=>Name).Concatenate(", ");