सरणी की सभी सामग्रियों को C # में प्रिंट करना

100

मैं कुछ तरीकों को लागू करने के बाद एक सरणी की सामग्री को प्रिंट करने की कोशिश कर रहा हूं जो इसे बदल देता है, जावा में मैं उपयोग करता हूं:

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

मैं सी # में यह कैसे करूँ?

c#  .net  arrays  linq 
— पादरी कनिंघम
स्रोत

जवाबों:

184

आप यह कोशिश कर सकते हैं:

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]

EDIT (2019): जैसा कि अन्य उत्तरों में उल्लेख किया गया है कि Array.ForEach<T>विधि का उपयोग करना बेहतर है और ToListचरण करने की कोई आवश्यकता नहीं है ।

Array.ForEach(yourArray, Console.WriteLine);
— होसेन नारिमनी राड
स्रोत
3
ध्यान दें कि .ToString आवश्यक नहीं है क्योंकि WriteLine में एक वस्तु लेने वाले एक कमबैक सहित विभिन्न अधिभार हैं।
— एरेन एर्सोन्मेज़
1
मैंने alg.Id.ToList ()। ForEach (Console.WriteLine) का उपयोग किया, जिसने आपको अच्छी तरह से धन्यवाद दिया। क्या वास्तव में इसे प्रिंट करना संभव है: [8, 1, 8, 8, 4, 8, 6, 8, 8, 8]
— पादरी कनिंघम
@ ErenErsönmez हां। तुम सही हो। लेकिन क्या होगा यदि आइटम अपने स्वयं के ToStringतंत्र के साथ एक कस्टम वर्ग था ।
— होसैन नरीमनी रेड
1
पर ForEachदृष्टिकोण उपयोग: expected.ToList().ForEach(Console.WriteLine);आप एक विधि संदर्भ बजाय एक लैम्ब्डा है कि एक नए बेकार गुमनाम विधि पैदा करेगा के उपयोग कर सकते हैं।
— मिगुएल गैंबोआ
ToListकेवल ForEachविधि का उपयोग करने के लिए एक सूची बनाना एक भयानक अभ्यास IMHO है।
— जुखर
61

इसे करने के कई तरीके हैं, अन्य उत्तर अच्छे हैं, यहाँ एक विकल्प है:

Console.WriteLine(string.Join("\n", myArrayOfObjects));
— मैट ग्रीर
स्रोत
मुझे यह पसंद है क्योंकि लॉग इन करने के लिए मेरे लिए यह अच्छी तरह से फिट बैठता है: उदाहरण के लिए myArrayObjects है _validExtensions: Write2Log ("exenstions के साथ ब्लाबला शुरू करें:" + string.Join ("", _validImgExtensions) + "और इसी तरह");
— Teo
मुझे यह भी पसंद है क्योंकि यह लॉगिंग के साथ अच्छी तरह से फिट बैठता है; और यदि सरणी तत्व आपकी वस्तुओं में से एक है, तो आप ToString()वहां प्रारूपण को ओवरराइड और संभाल सकते हैं । var a = new [] { "Admin", "Peon" };_log.LogDebug($"Supplied roles are '{string.Join(", ", a)}'.");
— हारून
16

सबसे आसान एक जैसे अगर आपके पास इस स्ट्रिंग की तरह घोषित स्ट्रिंग सरणी है [] myStringArray = नया स्ट्रिंग []; 

Console.WriteLine("Array : ");
Console.WriteLine("[{0}]", string.Join(", ", myStringArray));
— नई
स्रोत
10

काम के दौरान कुछ डाउनटाइम होने के कारण, मैंने यहां पोस्ट किए गए विभिन्न तरीकों की गति का परीक्षण करने का निर्णय लिया।

ये चार विधियाँ हैं जिनका मैंने उपयोग किया।

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
— टीजे वोल्सचॉन
स्रोत
8

कक्षा की Array.ForEach<T> Method (T[], Action<T>)विधि के साथ एक और दृष्टिकोणArray

Array.ForEach(myArray, Console.WriteLine);

इसकी तुलना में केवल एक पुनरावृत्ति होती है, array.ToList().ForEach(Console.WriteLine)जो दो पुनरावृत्तियों को लेती है और आंतरिक रूप से List(डबल पुनरावृत्ति रनटाइम और डबल मेमोरी खपत) के लिए दूसरा सरणी बनाती है

— Fubo
स्रोत
1
मुझे आपकी विधि सबसे अच्छी लगती है, यह मेरे परीक्षण के अनुसार दूसरा सबसे तेज़ है लेकिन यह सबसे तेज़ विधि (मेरी राय में) से अधिक बहुमुखी है।
— टीजे वोल्सचॉन
2

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
}

यदि आपकी अपनी कक्षा फू थी, तो आप ToString () को ओवरराइड कर सकते हैं:

public class Foo
{
    public override string ToString()
    {
        return "This is a formatted specific for the class Foo.";
    }
}
— एरिक जे।
स्रोत
2

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

यदि आप प्यारा प्राप्त करना चाहते हैं, तो आप एक विस्तार विधि लिख सकते हैं IEnumerable<object>जिसने कंसोल को एक अनुक्रम लिखा है। यह किसी भी प्रकार के गणना के साथ काम करेगा, क्योंकि IEnumerable<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);
        }
    }
}

(मुझे नहीं लगता कि आप परीक्षण कोड के अलावा इसका उपयोग करेंगे।)

— मैथ्यू वाटसन
स्रोत
मुझे पूरी तरह से समझने में थोड़ा समय लगा, लेकिन यह बहुत आसान है, मुझे पायथन के लिए इस्तेमाल किया जाता है और डिबग में मदद करने के लिए प्रिंट स्टेटमेंट डालते हैं ताकि यह मेरे लिए अच्छा हो। धन्यवाद
— Padraic Cunningham
0

मैंने मैथ्यू वाटसन द्वारा विस्तार विधि का उत्तर दिया, लेकिन यदि आप पाइथन से आ रहे हैं / यात्रा कर रहे हैं, तो आपको ऐसी विधि उपयोगी लग सकती है:

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

यह सबसे आसान तरीका है कि आप ऐरे का उपयोग करके स्ट्रिंग को प्रिंट कर सकते हैं !!!

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

यदि यह स्ट्रिंग्स की एक सरणी है तो आप एग्रीगेट का उपयोग कर सकते हैं

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
— BluePositive
स्रोत
0

आप लूप के लिए उपयोग कर सकते हैं

    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]}, ");
         }
     }
— एल्डिन उगलेजन
स्रोत
-2

यदि आप ऐरे फ़ंक्शन का उपयोग नहीं करना चाहते हैं।

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();
    }
}
— ugurpolat
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.