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

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

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

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

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

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

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

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

РЕДАКТИРОВАТЬ: чтобы получить вывод в одной строке [на основе вашего комментария]:

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

РЕДАКТИРОВАТЬ (2019): Как упоминается в других ответах, лучше использовать Array.ForEach<T>метод, и нет необходимости выполнять этот ToListшаг.

Array.ForEach(yourArray, Console.WriteLine);

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

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

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

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

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

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

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, вероятно, самый универсальный из четырех, которые я тестировал, хотя Print3 быстрее.

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

EDIT: я добавляю сгенерированный 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   

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

Array.ForEach(myArray, Console.WriteLine);

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

В 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.";
    }
}

Начиная с 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

Если вы хотите выглядеть симпатичным, вы можете написать метод расширения, который записывает 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);
        }
    }
}

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

Я поддержал ответ Мэтью Уотсона на метод расширения, но если вы переходите / посещаете с 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) - это может быть нормально.

это самый простой способ распечатать строку с помощью массива !!!

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

Если это массив строк, вы можете использовать Aggregate

var array = new string[] { "A", "B", "C", "D"};
Console.WriteLine(array.Aggregate((result, next) => $"{result}, {next}")); // A, B, C, D

таким образом вы можете изменить порядок, изменив порядок параметров следующим образом

Console.WriteLine(array.Aggregate((result, next) => $"{next}, {result}")); // D, C, B, A

Вы можете использовать цикл

    int[] random_numbers = {10, 30, 44, 21, 51, 21, 61, 24, 14}
    int array_length = random_numbers.Length;
    for (int i = 0; i < array_length; i++){
        if(i == array_length - 1){
              Console.Write($"{random_numbers[i]}\n");
        } else{
              Console.Write($"{random_numbers[i]}, ");
         }
     }

Если вы не хотите использовать функцию Array.

public class GArray
{
    int[] mainArray;
    int index;
    int i = 0;

    public GArray()
    {
        index = 0;
        mainArray = new int[4];
    }
    public void add(int addValue)
    {

        if (index == mainArray.Length)
        {
            int newSize = index * 2;
            int[] temp = new int[newSize];
            for (int i = 0; i < mainArray.Length; i++)
            {
                temp[i] = mainArray[i];
            }
            mainArray = temp;
        }
        mainArray[index] = addValue;
        index++;

    }
    public void print()
    {
        for (int i = 0; i < index; i++)
        {
            Console.WriteLine(mainArray[i]);
        }
    }
 }
 class Program
{
    static void Main(string[] args)
    {
        GArray myArray = new GArray();
        myArray.add(1);
        myArray.add(2);
        myArray.add(3);
        myArray.add(4);
        myArray.add(5);
        myArray.add(6);
        myArray.print();
        Console.ReadKey();
    }
}