it-roy-ru.com

печать всего содержимого массива в C #

Я пытаюсь распечатать содержимое массива после вызова некоторых методов, которые меняют его, в Java, которую я использую:

System.out.print(Arrays.toString(alg.id));

как мне сделать это в C #?

41
Padraic Cunningham

Вы можете попробовать это:

foreach(var item in yourArray)
{
    Console.WriteLine(item.ToString());
}

Также вы можете попробовать что-то вроде этого:

yourArray.ToList().ForEach(i => Console.WriteLine(i.ToString()));

РЕДАКТИРОВАТЬ: или как предложено в комментариях:

yourArray.ToList().ForEach(Console.WriteLine);

Правка: чтобы получить вывод в одну строку [на основе вашего комментария]:

 Console.WriteLine("[{0}]", string.Join(", ", yourArray));
 //output style:  [8, 1, 8, 8, 4, 8, 6, 8, 8, 8]
84
Hossein Narimani Rad

Есть много способов сделать это, другие ответы хороши, вот альтернатива:

Console.WriteLine(string.Join("\n", myArrayOfObjects));
32
Matt Greer

Самый простой, например если у вас есть строковый массив, объявленный как эта строка [] myStringArray = new string []; 

Console.WriteLine("Array : ");
Console.WriteLine("[{0}]", string.Join(", ", myStringArray));
7
Nai

В C # вы можете перебирать массив, печатая каждый элемент. Обратите внимание, что System.Object определяет метод ToString (). Любой данный тип, производный от System.Object (), может переопределить это. 

Возвращает строку, которая представляет текущий объект.

http://msdn.Microsoft.com/en-us/library/system.object.tostring.aspx

По умолчанию будет напечатано полное имя типа объекта, хотя многие встроенные типы переопределяют это значение по умолчанию, чтобы вывести более значимый результат. Вы можете переопределить ToString () в своих собственных объектах, чтобы обеспечить значимый вывод.

foreach (var item in myArray)
{
    Console.WriteLine(item.ToString()); // Assumes a console application
}

Если бы у вас был свой собственный класс Foo, вы могли бы переопределить ToString (), например:

public class Foo
{
    public override string ToString()
    {
        return "This is a formatted specific for the class Foo.";
    }
}
3
Eric J.

Из-за некоторого простоя на работе, я решил проверить скорости различных методов, размещенных здесь. 

Вот четыре метода, которые я использовал.

static void Print1(string[] toPrint)
{
    foreach(string s in toPrint)
    {
        Console.Write(s);
    }
}

static void Print2(string[] toPrint)
{
    toPrint.ToList().ForEach(Console.Write);
}

static void Print3(string[] toPrint)
{
    Console.WriteLine(string.Join("", toPrint));
}

static void Print4(string[] toPrint)
{
    Array.ForEach(toPrint, Console.Write);
}

Результаты приведены ниже:

Strings per trial: 10000 Number of Trials: 100 Total Time Taken to complete: 00:01:20.5004836 Print1 Average: 484.37ms Print2 Average: 246.29ms Print3 Average: 70.57ms Print4 Average: 233.81ms

Таким образом, Print3 является самым быстрым, потому что он имеет только один вызов Console.WriteLine, который, кажется, является основным узким местом для скорости печати массива. Print4 немного быстрее, чем Print2, а Print1 - самый медленный из всех.

Я думаю, что Print4, вероятно, самый универсальный из 4 протестированных мною, хотя Print3 быстрее.

Если я допустил какие-либо ошибки, дайте мне знать/исправить их самостоятельно!

Правка: я добавляю сгенерированный IL ниже

g__Print10_0://Print1
IL_0000:  ldarg.0     
IL_0001:  stloc.0     
IL_0002:  ldc.i4.0    
IL_0003:  stloc.1     
IL_0004:  br.s        IL_0012
IL_0006:  ldloc.0     
IL_0007:  ldloc.1     
IL_0008:  ldelem.ref  
IL_0009:  call        System.Console.Write
IL_000E:  ldloc.1     
IL_000F:  ldc.i4.1    
IL_0010:  add         
IL_0011:  stloc.1     
IL_0012:  ldloc.1     
IL_0013:  ldloc.0     
IL_0014:  ldlen       
IL_0015:  conv.i4     
IL_0016:  blt.s       IL_0006
IL_0018:  ret         

g__Print20_1://Print2
IL_0000:  ldarg.0     
IL_0001:  call        System.Linq.Enumerable.ToList<String>
IL_0006:  ldnull      
IL_0007:  ldftn       System.Console.Write
IL_000D:  newobj      System.Action<System.String>..ctor
IL_0012:  callvirt    System.Collections.Generic.List<System.String>.ForEach
IL_0017:  ret         

g__Print30_2://Print3
IL_0000:  ldstr       ""
IL_0005:  ldarg.0     
IL_0006:  call        System.String.Join
IL_000B:  call        System.Console.WriteLine
IL_0010:  ret         

g__Print40_3://Print4
IL_0000:  ldarg.0     
IL_0001:  ldnull      
IL_0002:  ldftn       System.Console.Write
IL_0008:  newobj      System.Action<System.String>..ctor
IL_000D:  call        System.Array.ForEach<String>
IL_0012:  ret   
3
TJ Wolschon

Другой подход с использованием метода Array.ForEach<T> Method (T[], Action<T>) класса Array

Array.ForEach(myArray, Console.WriteLine);

Это занимает только одну итерацию по сравнению с array.ToList().ForEach(Console.WriteLine), которая занимает две итерации и создает внутри себя второй массив для List (время выполнения двойной итерации и двойное потребление памяти)

2
fubo

Если вы хотите стать милым, вы можете написать метод расширения, который записал бы последовательность IEnumerable<object> на консоль. Это будет работать с перечислимыми любого типа, потому что IEnumerable<T> ковариантен для T:

using System;
using System.Collections.Generic;

namespace Demo
{
    internal static class Program
    {
        private static void Main(string[] args)
        {
            string[] array  = new []{"One", "Two", "Three", "Four"};
            array.Print();

            Console.WriteLine();

            object[] objArray = new object[] {"One", 2, 3.3, TimeSpan.FromDays(4), '5', 6.6f, 7.7m};
            objArray.Print();
        }
    }

    public static class MyEnumerableExt
    {
        public static void Print(this IEnumerable<object> @this)
        {
            foreach (var obj in @this)
                Console.WriteLine(obj);
        }
    }
}

(Я не думаю, что вы использовали бы это, кроме как в тестовом коде.)

1
Matthew Watson

Я одобрил ответ по методу расширения Мэтью Уотсона, но если вы мигрируете/посещаете из Python, вам может пригодиться такой метод:

class Utils
{
    static void dump<T>(IEnumerable<T> list, string glue="\n")
    {
        Console.WriteLine(string.Join(glue, list.Select(x => x.ToString())));
    }
}

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

Для скрипта (то есть консольного приложения C #, которое содержит только Program.cs, и большинство вещей происходит в Program.Main) - это может быть просто прекрасно.

0
Tomasz Gandor

это самый простой способ, которым вы можете напечатать строку, используя массив !!!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace arraypracticeforstring
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] arr = new string[3] { "Snehal", "Janki", "Thakkar" };

            foreach (string item in arr)
            {
                Console.WriteLine(item.ToString());
            }
            Console.ReadLine();
        }
    }
}
0
Snehal Thakkar

Начиная с C # 6.0 , когда была введена $ - строковая интерполяция, есть еще один способ:

var array = new[] { "A", "B", "C" };
Console.WriteLine($"{string.Join(", ", array}");

//output
A, B, C

Конкатенация может быть заархивирована с использованием System.Linq, преобразовать string[] в char[] и распечатать как string

var array = new[] { "A", "B", "C" };
Console.WriteLine($"{new String(array.SelectMany(_ => _).ToArray())}");

//output
ABC
0
Johnny