c# - array - Console.WriteLine y lista genérica

return list c#

Question

Con frecuencia me encuentro escribiendo código como este:

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

Mejor sería algo como esto:

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

Sospecho que hay una forma inteligente de hacerlo, pero no lo veo. ¿Alguien tiene una mejor solución que el primer bloque?

Answer 1

Hacer esto:

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

EDITAR: Para otros que han respondido, él los quiere a todos en la misma línea, con pestañas entre ellos. :)

Answer 2

Un enfoque diferente, solo para patadas:

Console.WriteLine(string.Join("/t", list.Cast<string>().ToArray()));

Answer 3

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

editar: ahhh, él me golpeó.

Answer 4

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

Editar: ¡Maldición! demoró demasiado para abrir el estudio visual y probarlo.

Answer 5

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

Answer 6

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

Entonces despúes...

list.WriteLine();

Answer 7

nueva lista {1, 3, 5} .ForEach (Console.WriteLine);

Answer 8

Si hay un fragmento de código que repites todo el tiempo de acuerdo con Do not Repeat Yourself, debes ponerlo en tu propia biblioteca y llamarlo. Con eso en mente, hay dos aspectos para obtener la respuesta correcta aquí. El primero es la claridad y la brevedad en el código que llama a la función de la biblioteca. El segundo son las implicaciones de rendimiento de foreach.

Primero pensemos en la claridad y brevedad en el código de llamada.

Puedes hacer foreach de varias maneras:

1. en bucle
2. bucle foreach
3. Colección.ParaEach

De todas las maneras de hacer una lista Foreach. ParaEach con un lamba es el más claro y breve.

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

Entonces, en esta etapa, puede parecerse a la Lista. Por lo tanto, es el camino a seguir. Sin embargo, ¿cuál es el rendimiento de esto? Es cierto que en este caso el tiempo para escribir en la consola regirá el rendimiento del código. Cuando sabemos algo sobre el rendimiento de una característica particular del lenguaje, al menos debemos considerarlo.

Según las mediciones de rendimiento de foreach de Duston Campbell, la forma más rápida de iterar la lista con código optimizado es usar un bucle for sin una llamada a List.Count.

Sin embargo, el bucle for es una construcción verbosa. También se lo ve como una forma muy iterativa de hacer las cosas que no concuerda con la tendencia actual hacia los modismos funcionales.

Entonces, ¿podemos obtener brevedad, claridad y rendimiento? Podemos mediante un método de extensión. En un mundo ideal, creamos un método de extensión en la consola que toma una lista y la escribe con un delimitador. No podemos hacer esto porque Console es una clase estática y los métodos de extensión solo funcionan en instancias de clases. En su lugar, debemos poner el método de extensión en la lista misma (según la sugerencia de David B):

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

Este código se usará en muchos lugares, por lo que debemos llevar a cabo las siguientes mejoras:

• En lugar de usar foreach, debemos usar la forma más rápida de iterar la colección, que es un ciclo for con un recuento en caché.
• Actualmente, solo la Lista se puede pasar como un argumento. Como función de biblioteca, podemos generalizarla mediante una pequeña cantidad de esfuerzo.
• El uso de Lista nos limita a solo Listas, El uso de IList permite que este código también funcione con Matrices.
• Dado que el método de extensión estará en un IList, necesitamos cambiar el nombre para que quede más claro en lo que estamos escribiendo:

Así es como se vería el código de la función:

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();
}

Podemos mejorar esto aún más permitiendo que el cliente pase el delimitador. A continuación, podríamos proporcionar una segunda función que escribe en la consola con el delimitador estándar de esta manera:

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();
}

Entonces, dado que queremos una forma breve y clara de escribir listas en la consola, tenemos una. Aquí está todo el código fuente, incluida una demostración del uso de la función de la biblioteca:

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();
        }
    }
}

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

Puede pensar que este debería ser el final de la respuesta. Sin embargo, hay una nueva generalización que se puede hacer. No queda claro por la pregunta de Fatcat si él siempre está escribiendo en la consola. Quizás hay algo más que hacer en el foreach. En ese caso, la respuesta de Jason Bunting va a dar esa generalidad. Aquí está su respuesta de nuevo:

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

Eso es a menos que hagamos un refinamiento más a nuestros métodos de extensión y agreguemos FastForEach de la siguiente manera:

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();
    }

Esto nos permite ejecutar cualquier código arbitrario contra cada elemento de la colección utilizando el método de iteración más rápido posible .

Incluso podemos cambiar la función WriteToConsole para usar FastForEach

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

Así que ahora todo el código fuente, incluido un uso de ejemplo de FastForEach es:

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();
        }
    }
}

Answer 9

También puedes unirte:

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