Список Console.WriteLine и общий список

Я часто нахожу, что пишу код следующим образом:

List<int> list = new List<int> { 1, 3, 5 };
foreach (int i in list) {
    Console.Write("{0}\t", i.ToString()); }
Console.WriteLine();

Лучше было бы что-то вроде этого:

List<int> list = new List<int> { 1, 3, 5 };
Console.WriteLine("{0}\t", list);

Я подозреваю, что есть какой-то умный способ сделать это, но я этого не вижу. У кого-нибудь есть лучшее решение, чем первый блок?

Ответы

Ответ 1

Сделайте это:

list.ForEach(i => Console.Write("{0}\t", i));

EDIT: другим, которые ответили - он хочет, чтобы все они были в одной строке, с вкладками между ними.:)

Ответ 2

Другой подход, только для ударов ногами:

Console.WriteLine(string.Join("\t", list));

Ответ 3

Если есть фрагмент кода, который вы все время повторяете в соответствии с "Не повторяйте сами", вы должны поместить его в свою собственную библиотеку и вызвать это. Имея это в виду, есть два аспекта для получения правильного ответа здесь. Первая - это ясность и краткость в коде, который вызывает библиотечную функцию. Во-вторых, это последствия производительности foreach.

Сначала подумайте о ясности и краткости в вызывающем коде.

Вы можете сделать foreach несколькими способами:

  • для цикла
  • цикл foreach
  • Collection.ForEach

Из всех способов сделать список foreach.ForEach с lamba является самым ясным и кратчайшим.

list.ForEach(i => Console.Write("{0}\t", i));

Итак, на этом этапе это может выглядеть как List.ForEach - это путь. Но какова производительность этого? Это правда, что в этом случае время записи на консоль будет определять производительность кода. Когда мы что-то знаем о производительности определенной языковой функции, мы должны, по крайней мере, ее рассмотреть.

Согласно измерения производительности Duston Campbell foreach, самый быстрый способ повторения списка под оптимизированным кодом - использовать цикл for без вызова List.Count.

Петля for, однако, является многословной конструкцией. Он также рассматривается как очень итеративный способ делать вещи, которые не соответствуют текущей тенденции к функциональным идиомам.

Итак, можем ли мы получить краткость, ясность и производительность? Мы можем использовать метод расширения. В идеальном мире мы бы создали метод расширения на консоли, который берет список и записывает его с помощью разделителя. Мы не можем этого сделать, потому что Console является статическим классом, а методы расширения работают только с экземплярами классов. Вместо этого нам нужно поместить метод расширения в самый список (согласно предложению Дэвида Б.):

public static void WriteLine(this List<int> theList)
{
  foreach (int i in list)
  {
    Console.Write("{0}\t", t.ToString());
  }
  Console.WriteLine();
}

Этот код будет использоваться во многих местах, поэтому мы должны выполнить следующие улучшения:

  • Вместо использования foreach мы должны использовать самый быстрый способ итерации коллекции, которая является циклом for с кешированным счетом.
  • В качестве аргумента можно передать только List. В качестве библиотечной функции мы можем обобщить ее с помощью небольшого количества усилий.
  • Использование List ограничивает нас только списками, использование IList позволяет этому коду работать и с массивами.
  • Так как метод расширения будет на IList, нам нужно изменить имя, чтобы он стал более ясным, о чем мы пишем:

Вот как выглядит код для функции:

public static void WriteToConsole<T>(this IList<T> collection)
{
    int count = collection.Count();
    for(int i = 0;  i < count; ++i)
    {
        Console.Write("{0}\t", collection[i].ToString(), delimiter);
    }
    Console.WriteLine();
}

Мы можем улучшить это еще дальше, разрешив клиенту пройти в разделителе. Затем мы могли бы предоставить вторую функцию, которая записывает на консоль со стандартным разделителем следующим образом:

public static void WriteToConsole<T>(this IList<T> collection)
{
    WriteToConsole<T>(collection, "\t");
}

public static void WriteToConsole<T>(this IList<T> collection, string delimiter)
{
    int count = collection.Count();
    for(int i = 0;  i < count; ++i)
    {
         Console.Write("{0}{1}", collection[i].ToString(), delimiter);
    }
    Console.WriteLine();
}

Итак, теперь, учитывая, что нам нужен краткий, четкий способ записи списков на консоль, у нас есть один. Вот полный исходный код, включающий демонстрацию использования библиотечной функции:

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleWritelineTest
{
    public static class Extensions
    {
        public static void WriteToConsole<T>(this IList<T> collection)
        {
            WriteToConsole<T>(collection, "\t");
        }

        public static void WriteToConsole<T>(this IList<T> collection, string delimiter)
        {
            int count = collection.Count();
            for(int i = 0;  i < count; ++i)
            {
                Console.Write("{0}{1}", collection[i].ToString(), delimiter);
            }
            Console.WriteLine();
        }
    }

    internal class Foo
    {
        override public string ToString()
        {
            return "FooClass";
        }
    }

    internal class Program
    {

        static void Main(string[] args)
        {
            var myIntList = new List<int> {1, 2, 3, 4, 5};
            var myDoubleList = new List<double> {1.1, 2.2, 3.3, 4.4};
            var myDoubleArray = new Double[] {12.3, 12.4, 12.5, 12.6};
            var myFooList = new List<Foo> {new Foo(), new Foo(), new Foo()};
            // Using the standard delimiter /t
            myIntList.WriteToConsole();
            myDoubleList.WriteToConsole();
            myDoubleArray.WriteToConsole();
            myFooList.WriteToConsole();
            // Using our own delimiter ~
            myIntList.WriteToConsole("~");
            Console.Read();
        }
    }
}

=============================================== ========

Вы можете подумать, что это должен быть конец ответа. Однако есть еще одно обобщение, которое можно сделать. Это не ясно из вопроса жирного, если он всегда пишет на консоль. Возможно, что-то еще предстоит сделать в преддверии. В этом случае ответ Джейсона Бэнтинга даст эту общность. Вот его ответ снова:

list.ForEach(i => Console.Write("{0}\t", i));

То есть, если мы не сделаем еще одно уточнение наших методов расширения и добавим FastForEach, как показано ниже:

public static void FastForEach<T>(this IList<T> collection, Action<T> actionToPerform)
    {
        int count = collection.Count();
        for (int i = 0; i < count; ++i)
        {
            actionToPerform(collection[i]);    
        }
        Console.WriteLine();
    }

Это позволяет нам выполнять любой произвольный код для каждого элемента в коллекции, используя самый быстрый способ итерации.

Мы можем изменить функцию WriteToConsole для использования FastForEach

public static void WriteToConsole<T>(this IList<T> collection, string delimiter)
{
     collection.FastForEach(item => Console.Write("{0}{1}", item.ToString(), delimiter));
}

Итак, теперь весь исходный код, включая пример использования FastForEach, это:

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleWritelineTest
{
    public static class Extensions
    {
        public static void WriteToConsole<T>(this IList<T> collection)
        {
            WriteToConsole<T>(collection, "\t");
        }

        public static void WriteToConsole<T>(this IList<T> collection, string delimiter)
        {
             collection.FastForEach(item => Console.Write("{0}{1}", item.ToString(), delimiter));
        }

        public static void FastForEach<T>(this IList<T> collection, Action<T> actionToPerform)
        {
            int count = collection.Count();
            for (int i = 0; i < count; ++i)
            {
                actionToPerform(collection[i]);    
            }
            Console.WriteLine();
        }
    }

    internal class Foo
    {
        override public string ToString()
        {
            return "FooClass";
        }
    }

    internal class Program
    {

        static void Main(string[] args)
        {
            var myIntList = new List<int> {1, 2, 3, 4, 5};
            var myDoubleList = new List<double> {1.1, 2.2, 3.3, 4.4};
            var myDoubleArray = new Double[] {12.3, 12.4, 12.5, 12.6};
            var myFooList = new List<Foo> {new Foo(), new Foo(), new Foo()};

            // Using the standard delimiter /t
            myIntList.WriteToConsole();
            myDoubleList.WriteToConsole();
            myDoubleArray.WriteToConsole();
            myFooList.WriteToConsole();

            // Using our own delimiter ~
            myIntList.WriteToConsole("~");

            // What if we want to write them to separate lines?
            myIntList.FastForEach(item => Console.WriteLine(item.ToString()));
            Console.Read();
        }
    }
}

Ответ 4

новый список {1, 3, 5}.ForEach(Console.WriteLine);

Ответ 5

        List<int> a = new List<int>() { 1, 2, 3, 4, 5 };
        a.ForEach(p => Console.WriteLine(p));

edit: ahhh он избил меня.

Ответ 6

list.ForEach(x=>Console.WriteLine(x));

Ответ 7

List<int> list = new List<int> { 1, 3, 5 };
list.ForEach(x => Console.WriteLine(x));

Изменить: Черт! занял слишком много времени, чтобы открыть визуальную студию для тестирования.

Ответ 8

Также вы можете присоединиться:

var qwe = new List<int> {5, 2, 3, 8};
Console.WriteLine(string.Join("\t", qwe));

Ответ 9

public static void WriteLine(this List<int> theList)
{
  foreach (int i in list)
  {
    Console.Write("{0}\t", t.ToString());
  }
  Console.WriteLine();
}

Затем, позже...

list.WriteLine();