在 C # 中打印数组的所有内容

在 C # 中，你可以循环打印数组中的每个元素。注意系统。对象定义一个方法 ToString ()。从 System 派生的任何给定类型。对象()可以覆盖这一点。

返回表示当前对象的字符串。

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

有很多方法可以做到这一点，其他的答案是好的，这里有一个替代方案:

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

如果你想变得可爱，你可以写一个扩展方法，写一个 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);
}
}
}

(我不认为您会在测试代码之外使用它。)

最简单的一个例子是，如果有一个类似字符串[] myStringArray = new string []的字符串数组;

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

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

- > ，这将使用提供的分隔符打印任何集合。它非常有限(嵌套集合?)。

对于一个脚本(例如一个只包含 Program.cs 的 C # 控制台应用，而且大多数事情都发生在 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();
}
}
}

使用 Array类的 Array.ForEach<T> Method (T[], Action<T>)方法的另一种方法

Array.ForEach(myArray, Console.WriteLine);

这只需要一次迭代，而 array.ToList().ForEach(Console.WriteLine)需要两次迭代，并在内部为 List创建第二个数组(双重迭代运行时和双重内存消耗)

我决定测试一下这里发布的不同方法的速度:

这是我使用的四种方法。

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

从 C # 6.0开始，当引入 $-string 插值时，还有一种方法:

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

如果不想使用 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();
}
}

如果是字符串数组，可以使用 总数

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

可以使用 for 循环

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