drukowanie całej zawartości tablicy w C #

Próbuję wydrukować zawartość tablicy po wywołaniu niektórych metod, które ją zmieniają, w Javie używam:

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

jak to zrobić w C #?

Możesz spróbować tego:

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

Możesz także spróbować czegoś takiego:

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

EDYCJA: aby uzyskać wynik w jednej linii [na podstawie twojego komentarza]:

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

EDYCJA (2019): Jak wspomniano w innych odpowiedziach lepiej jest użyć Array.ForEach<T>metody i nie ma potrzeby wykonywania tego ToListkroku.

Array.ForEach(yourArray, Console.WriteLine);

Jest na to wiele sposobów, inne odpowiedzi są dobre, oto alternatywa:

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

Najłatwiejszy, np. Jeśli masz zadeklarowaną tablicę ciągów, taką jak ta string [] myStringArray = new string [];

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

Ze względu na przestoje w pracy postanowiłem przetestować prędkości różnych metod zamieszczonych tutaj.

Oto cztery metody, których użyłem.

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

Wyniki są następujące:

 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

Tak więc Print3 jest najszybszy, ponieważ ma tylko jedno wywołanie, Console.WriteLinektóre wydaje się być głównym wąskim gardłem dla szybkości drukowania tablicy. Print4 jest nieco szybszy niż Print2, a Print1 jest najwolniejszy ze wszystkich.

Myślę, że Print4 jest prawdopodobnie najbardziej wszechstronnym z 4, które testowałem, mimo że Print3 jest szybszy.

Jeśli popełniłem jakieś błędy, daj mi znać / napraw je samodzielnie!

EDYCJA: poniżej dodaję wygenerowany 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   

Inne podejście z Array.ForEach<T> Method (T[], Action<T>)metodą Arrayklasy

Array.ForEach(myArray, Console.WriteLine);

To zajmuje tylko jedną iterację, w porównaniu z array.ToList().ForEach(Console.WriteLine)którą zajmuje dwie iteracje i tworzy wewnętrznie drugą tablicę dla List(środowiska uruchomieniowego z podwójną iteracją i podwójnego zużycia pamięci)

W C # możesz zapętlić tablicę, drukując każdy element. Zauważ, że System.Object definiuje metodę ToString (). Dowolny typ, który pochodzi od System.Object (), może to przesłonić.

Zwraca ciąg, który reprezentuje bieżący obiekt.

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

Domyślnie zostanie wydrukowana pełna nazwa typu obiektu, chociaż wiele typów wbudowanych zastępuje tę domyślną, aby wydrukować bardziej znaczący wynik. Możesz przesłonić ToString () we własnych obiektach, aby zapewnić znaczące dane wyjściowe.

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

Gdybyś miał własną klasę Foo, mógłbyś nadpisać ToString () na przykład:

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

Począwszy od C # 6.0 , gdy wprowadzono interpolację $ - string, jest jeszcze jeden sposób:

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

//output
A, B, C

Łączenie może być archiwizowane przy użyciu System.Linq, przekształcają string[]się char[]i wydrukowania w postacistring

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

//output
ABC

Jeśli chcesz uzyskać ładny wygląd, możesz napisać metodę rozszerzającą, która zapisałaby IEnumerable<object>sekwencję na konsoli. To zadziała z wyliczeniami dowolnego typu, ponieważ IEnumerable<T>jest kowariantna na 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);
        }
    }
}

(Nie sądzę, abyś użył tego innego niż w kodzie testowym).

Głosowałem za odpowiedzią na metodę rozszerzenia autorstwa Matthew Watsona, ale jeśli migrujesz / odwiedzasz pochodzącą z Pythona, taka metoda może Ci się przydać:

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

-> to wypisze każdą kolekcję przy użyciu dostarczonego separatora. Jest dość ograniczona (zbiory zagnieżdżone?).

W przypadku skryptu (tj. Aplikacji konsolowej C #, która zawiera tylko Program.cs i większość rzeczy się w niej dzieje Program.Main) - to może być w porządku.

jest to najłatwiejszy sposób na wydrukowanie ciągu przy użyciu tablicy !!!

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

Jeśli jest to tablica ciągów, możesz użyć Aggregate

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

w ten sposób możesz odwrócić kolejność, zmieniając kolejność parametrów w ten sposób

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

Możesz użyć pętli

    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]}, ");
         }
     }

Jeśli nie chcesz używać funkcji 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();
    }
}