C # dizisinin tüm içeriğini yazdırma

Bir dizinin içeriğini, onu değiştiren bazı yöntemleri çalıştırdıktan sonra yazdırmaya çalışıyorum, Java'da kullanıyorum:

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

bunu c # 'da nasıl yaparım?

Bunu deneyebilirsiniz:

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

Ayrıca şuna benzer bir şey denemek isteyebilirsiniz:

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

DÜZENLEME: tek satırda çıktı almak için [yorumunuza göre]:

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

DÜZENLEME (2019): Diğer cevaplarda da belirtildiği gibi Array.ForEach<T>yöntem kullanmak daha iyidir ve ToListadımı atmaya gerek yoktur .

Array.ForEach(yourArray, Console.WriteLine);

Bunu yapmanın birçok yolu var, diğer cevaplar iyi, işte bir alternatif:

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

En kolayı, örneğin bu string gibi bildirilmiş bir dizge diziniz varsa [] myStringArray = new string [];

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

İş yerinde biraz kesinti yaşadığım için, burada yayınlanan farklı yöntemlerin hızlarını test etmeye karar verdim.

Bunlar kullandığım dört yöntem.

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

Sonuçlar aşağıdaki gibidir:

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

Dolayısıyla Print3 en hızlısıdır, çünkü sadece bir çağrısı vardır ve Console.WriteLinebu, bir diziyi yazdırma hızı için ana darboğaz gibi görünür. Print4, Print2'den biraz daha hızlıdır ve Print1, hepsinin en yavaş olanıdır.

Print3'ün daha hızlı olmasına rağmen Print4'ün muhtemelen test ettiğim 4'ün en çok yönlü olduğunu düşünüyorum.

Herhangi bir hata yaptıysam, bana bildirmekten / kendi başınıza düzeltmekten çekinmeyin!

DÜZENLE: Oluşturulan IL'yi aşağıya ekliyorum

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   

Sınıfın Array.ForEach<T> Method (T[], Action<T>)yöntemiyle başka bir yaklaşımArray

Array.ForEach(myArray, Console.WriteLine);

Bu, array.ToList().ForEach(Console.WriteLine)iki yineleme alan ve dahili olarak List(çift yineleme çalışma zamanı ve çift bellek tüketimi) için ikinci bir dizi oluşturanla karşılaştırıldığında yalnızca bir yineleme alır

C # 'da her bir öğeyi yazdıran dizi boyunca döngü yapabilirsiniz. System.Object öğesinin bir ToString () yöntemini tanımladığını unutmayın. System.Object () 'den türetilen herhangi bir tür, bunu geçersiz kılabilir.

Mevcut nesneyi temsil eden bir dize döndürür.

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

Varsayılan olarak, nesnenin tam tür adı yazdırılacaktır, ancak birçok yerleşik tür daha anlamlı bir sonuç yazdırmak için varsayılanı geçersiz kılar. Anlamlı çıktı sağlamak için kendi nesnelerinizde ToString () öğesini geçersiz kılabilirsiniz.

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

Kendi Foo sınıfınız varsa, ToString () 'i şu şekilde geçersiz kılabilirsiniz:

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

Başlayarak C # 6.0 , $ - dize enterpolasyon tanıtıldı, bir daha yolu var:

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

//output
A, B, C

Birleştirme kullanarak arşivlenmiş olabilir System.Linq, dönüştürmek string[]için char[]ve a olarak yazdırmakstring

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

//output
ABC

Sevimli olmak istiyorsanız IEnumerable<object>, konsola bir sekans yazan bir genişletme yöntemi yazabilirsiniz . Bu, her türden numaralandırılabilir, çünkü IEnumerable<T>T üzerinde kovaryanttır:

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

(Bunu test kodu dışında kullanacağınızı sanmıyorum.)

Eklenti yöntemi yanıtını Matthew Watson tarafından destekledim, ancak Python'dan gelen geçiş yapıyorsanız / ziyaret ediyorsanız, böyle bir yöntemi yararlı bulabilirsiniz:

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

-> bu, sağlanan ayırıcıyı kullanarak herhangi bir koleksiyonu yazdıracaktır. Oldukça sınırlıdır (iç içe geçmiş koleksiyonlar?).

Bir komut dosyası için (yani, yalnızca Program.cs'yi içeren ve çoğu şey içinde olan bir C # konsol uygulaması Program.Main) - bu iyi olabilir.

diziyi kullanarak dizgiyi yazdırmanın en kolay yolu bu !!!

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

Bir dizi dizeyse Aggregate'i kullanabilirsiniz.

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

bu şekilde parametrelerin sırasını değiştirerek sırayı tersine çevirebilirsiniz.

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

Döngü için kullanabilirsiniz

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

Dizi işlevini kullanmak istemiyorsanız.

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