मैं C # में एक खाली सरणी कैसे शुरू करूं?

328

क्या आकार निर्दिष्ट किए बिना एक खाली सरणी बनाना संभव है?

उदाहरण के लिए, मैंने बनाया:

String[] a = new String[5];

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

c# arrays initialization

— योगेश
स्रोत

2

stackoverflow.com/questions/151936/… यू इस लिंक की जाँच करें, यह आपको सरणी चीजों को स्पष्ट रूप से समझने में मदद कर सकता है

— रवि गदग

2

यह भी देखें सभी संभव-सी तेज सरणी-आरंभीकरण-वाक्यविन्यास

— nawfal

435

यदि आप एक संग्रह का उपयोग करने जा रहे हैं जिसे आप पहले से आकार नहीं जानते हैं, तो सरणियों से बेहतर विकल्प हैं।

List<string>इसके बजाय का उपयोग करें - यह आपको आवश्यकतानुसार कई वस्तुओं को जोड़ने की अनुमति देगा और यदि आपको एक सरणी वापस करने की आवश्यकता है, ToArray()तो चर पर कॉल करें ।

var listOfStrings = new List<string>();

// do stuff...

string[] arrayOfStrings = listOfStrings.ToArray();

आप तो चाहिए एक खाली सारिणी निर्मित आप यह कर सकते हैं:

string[] emptyStringArray = new string[0];

— Oded
स्रोत

1

@Oded - string [] blankStringArray = नई स्ट्रिंग [0]; एक खाली सरणी में परिणाम नहीं करता है, है ना? ऐसा लगता है कि यह एक तत्व के साथ एक सरणी है जहां वह तत्व शून्य है।

— rory.ap

11

@ रोरैप - नहीं। इसका परिणाम है string[]कि कोई तत्व नहीं है। यदि आप एक्सेस करने की कोशिश करते हैं emptyStringArray[0], तो आपको IndexOutOfRangeException

— Oded

@Oded - धन्यवाद, मैं C # के लिए काफी नया हूं। वीबी में, प्रदान किया गया सूचकांक ऊपरी बाध्य है, तत्वों की संख्या नहीं।

— rory.ap

1

आप क्या बेहतर समझेंगे: var strings = new string [] {}; या var स्ट्रिंग्स = नई स्ट्रिंग [0]; BTW: मैं विधि मापदंडों के लिए एक खाली सरणी को पूरी तरह से वैध डिफ़ॉल्ट मानता हूं: सार्वजनिक शून्य EditItems (IEnumerable <Item> toEdit, IEnumerable <long> toDelete = new long [] {})

— realbart

6

@ रिकोशे - सी ++ सी # नहीं है। स्ट्रॉस्ट्रुप अपने सी ++ को जानता है - इसलिए नहीं कि वह अपने सी # और .NET जीसी को जानता है। तुम्हारे साथ धार्मिक युद्ध में नहीं जाने वाला।

— ओड

181

इसे इस्तेमाल करे:

string[] a = new string[] { };

— हेमंत
स्रोत

7

इस उत्तर पर विस्तार करते हुए, आप आकार या प्रकार को निर्दिष्ट किए बिना आइटम के साथ सरणी को भी रोक सकते हैं, संकलक या तो इनिशियलाइज़र से अनुमान लगाएगा: var a = new [] {"a", "b", "c"}; यह अभी भी एक मजबूत टाइप स्ट्रिंग स्ट्रिंग है।

— निक वेंडरपाइले

1

अखंडित अपवाद: System.IndexOutOfRangeException: सूचकांक सरणी के बाउंस डीएस के बाहर था। ArrayClass.Main (स्ट्रिंग [] args) पर। जब मैंने अपना int [] variable = new int [] {}

— योगेश

6

@ योगेश: यह अजीब है। उदाहरण के लिए जब लेखन int[] variable = new int[]{}और उदाहरण के लिए एक लूप में इसका उपयोग करना जैसे foreach (var s in variable){ Console.WriteLine(s);}कि कोड को संकलित किया जाता है: int[] args1 = new int[0];और foreach (int num in args1){Console.WriteLine(num);}। इसलिए उपयोग करने में कोई अंतर नहीं होना चाहिए new int[0]और new int[]{}दोनों एक ही कोड में संकलित होने चाहिए।

— दोपहर

1

@GlennGordon बिल्कुल, लेकिन यह C # संस्करण 3.0 (2007 से, विजुअल स्टूडियो 2008 के साथ) के रूप में नया है। वह संस्करण एक और सरल प्रारूप की भी अनुमति देता है var, हालाँकि केवल स्थानीय चर (खेतों के लिए नहीं) के लिए। हालाँकि C # 2.0 (Visual Studio 2005) और इससे पहले, आपको इस उत्तर (या string[] a = new string[0];) के सिंटैक्स का उपयोग करना था ।

— जेपी स्टिग नीलसन

113

.NET 4.6 में नई विधि का उपयोग करने का पसंदीदा तरीका है Array.Empty:

String[] a = Array.Empty<string>();

कार्यान्वयन संक्षिप्त है, का उपयोग कर कैसे सामान्य कक्षाओं में स्थिर सदस्यों नेट से व्यवहार करते हैं :

public static T[] Empty<T>()
{
    return EmptyArray<T>.Value;
}

// Useful in number of places that return an empty byte array to avoid
// unnecessary memory allocation.
internal static class EmptyArray<T>
{
    public static readonly T[] Value = new T[0];
}

^{(स्पष्टता के लिए हटाए गए कोड अनुबंध से संबंधित कोड)}

यह सभी देखें:

Array.Empty संदर्भ स्रोत पर स्रोत कोड
परिचय Array.Empty<T>()
मार्क ग्रेवेल - आवंटन, आवंटन, आवंटन - छोटे छिपे हुए आवंटन पर मेरी पसंदीदा पोस्ट।

— कोबी
स्रोत

@ जॉनसन - संपादन के लिए धन्यवाद, लेकिन मैंने इसे वापस ले लिया। मैंने इन पंक्तियों को उद्देश्य से छोड़ दिया: मैं सिर्फ दिलचस्प कार्यान्वयन को उद्धृत करना चाहता था। कोड कॉन्ट्रैक्ट और विशेषताएँ बस समझने के तरीके से मिलती हैं कि क्या हो रहा है (स्रोत का लिंक सब कुछ है, निश्चित रूप से)। मैंने स्टैक ओवरफ्लो पर स्क्रॉल करने से बचने के लिए टिप्पणी में एक नई पंक्ति भी जोड़ी है। यदि आप बुरा नहीं मानते हैं, तो मैं इसे इस तरह से पसंद करता हूं। धन्यवाद!

— कोबी

2

निश्चित रूप से पठनीयता के लिए एक सुधार:Enumerable.Empty<T>().ToArray()

— डैनियलवी

भले ही यह विधि निश्चित रूप से ज्यादातर मामलों में पसंद की जाती है, लेकिन यह मूल प्रश्न का उत्तर नहीं देती है। ओपी एक खाली सरणी बनाना चाहता है । Array.Empty<T>()करता नहीं एक सरणी पैदा करते हैं। यह एक पूर्व-आवंटित सरणी का संदर्भ देता है।

— l33t

33

आप इसे 0 के आकार के साथ inititialize कर सकते हैं, लेकिन आपको इसे फिर से संगठित करना होगा, जब आपको पता होगा कि आकार क्या है, जैसा कि आप सरणी में संलग्न नहीं कर सकते।

string[] a = new string[0];

— MatthiasG
स्रोत

यह सटीक उत्तर है

— abzarak

7

आकार के बिना एक सरणी घोषित करने में बहुत अधिक बिंदु नहीं है। एक सरणी आकार के बारे में है । जब आप विशिष्ट आकार की एक सरणी घोषित करते हैं, तो आप एक संग्रह में उपलब्ध स्लॉट की निश्चित संख्या निर्दिष्ट करते हैं जो चीजों को पकड़ सकते हैं, और तदनुसार स्मृति आवंटित की जाती है। इसमें कुछ जोड़ने के लिए, आपको किसी भी तरह मौजूदा सरणी को फिर से संगठित करना होगा (भले ही आप सरणी का आकार बदल रहे हों, इस धागे को देखें )। दुर्लभ मामलों में से एक जहां आप एक खाली सरणी को इनिशियलाइज़ करना चाहेंगे, वहीं एक तर्क के रूप में सरणी को पास करना होगा।

यदि आप एक संग्रह को परिभाषित करना चाहते हैं, जब आप नहीं जानते कि यह किस आकार का हो सकता है, तो सरणी आपकी पसंद नहीं है, लेकिन कुछ ऐसा है List<T> या समान है।

उस ने कहा, आकार निर्दिष्ट किए बिना एक सरणी घोषित करने का एकमात्र तरीका 0 के खाली सरणी का होना है । हेमंत और एलेक्स डायन दो तरीके प्रदान करते हैं। एक और सरल विकल्प सिर्फ :

string[] a = { };

[ ब्रैकेट के अंदर के तत्वों को स्पष्ट रूप से परिभाषित प्रकार के लिए परिवर्तनीय होना चाहिए, उदाहरण के लिए,string[] a = { "a", "b" }; ]

या फिर एक और:

var a = Enumerable.Empty<string>().ToArray();

यहाँ एक और अधिक घोषणात्मक तरीका है :

public static class Array<T>
{
    public static T[] Empty()
    {
        return Empty(0);
    }

    public static T[] Empty(int size)
    {
        return new T[size];
    }
}

अब आप कॉल कर सकते हैं:

var a = Array<string>.Empty();

//or

var a = Array<string>.Empty(5);

— nawfal
स्रोत

1

जब आप एक पैरामीटर के रूप में एक सरणी पास करने के लिए मिला तो मैं किसी भी उपयोग के बारे में नहीं सोच सकता। परावर्तन में कुछ मामले हैं जहां एक विधि वस्तुओं की एक सरणी को स्वीकार करती है और आप डिफ़ॉल्ट क्रिया को प्रभावित करने के लिए एक खाली सरणी को पारित करना चाह सकते हैं। मैं अपने उत्तर को संपादित करूंगा।

— नवफल

उदाहरण के लिए आपके पास IEnumerable को वापस करने वाले कई वर्गों द्वारा लागू किया गया इंटरफ़ेस है और कार्यान्वयन में से एक में विधि के लिए तत्व नहीं हैं और उदाहरण के लिए एक खाली सरणी देता है।

— इग्नासियो सोलर गार्सिया

@IgnacioSolerGarcia मैं उस मामले में एक सरणी लौटाऊंगा अगर और केवल अगर यह एक अत्यंत प्रदर्शन महत्वपूर्ण अनुप्रयोग है। मैं कहूंगा कि सरणियाँ पुरानी हैं और यदि आप कर सकते हैं तो बचना चाहिए। देखें Lippert द्वारा इस और इस तो सवाल

— nawfal

ध्यान रखें कि लौटा हुआ प्रकार IEnumerable है इसलिए सरणी केवल-पढ़ने के लिए है और इसे बदलने का इरादा नहीं है। मैं उदाहरण के लिए इस मामले में सूची क्यों लौटाऊंगा?

— इग्नासियो सोलर गार्सिया

1

खाली सरणी के लिए एक उपयोग का मामला सरल है - जब आप इसे वस्तुओं से भरना चाहते हैं और आपको नहीं पता कि आप कितने जोड़ेंगे!

— vapcguy

6

सरल और सुरुचिपूर्ण!

string[] array = {}

— disklosr
स्रोत

मैं बदल जाएगा arrayबस के लिए a, के रूप में arrayएक कीवर्ड जब पूंजीकृत है। एक कीवर्ड नाम को एक चर नाम के रूप में उपयोग करने के लिए केवल बुरा अभ्यास - भले ही मामला अलग हो। और मूल रूप से मेरे उत्तर के समान ही है, जबकि मैं String.Emptyवहां था।

— vapcguy

1

1. सरणी एसी # कीवर्ड नहीं है। एरे एक वर्ग है और एक कीवर्ड नहीं है। 2. "ए" भी खराब प्रैक्टिस है (हो सकता है कि कीवर्ड्स का उपयोग करने से भी बुरा अभ्यास हो)

— डिस्कलॉग

तकनीकी होने के नाते। क्लास, कीवर्ड, यह एक ऑब्जेक्ट प्रकार को परिभाषित करता है और अभी भी खराब है। आपको aबुरा क्यों लगता है?

— vapcguy

1

क्योंकि गैर-वर्णनात्मक और एक-अक्षर वाले चर नाम खराब अभ्यास हैं क्योंकि वे उन्हें परिभाषित करने के पीछे का कारण नहीं बताते हैं। "एरे" निश्चित रूप से "ए" से बेहतर नाम है। एक बेहतर नाम "खालीअरे" होगा।

— डिस्कलॉजर

4

string[] a = new string[0];

या लघु संकेतन:

string[] a = { };

अब पसंदीदा तरीका है:

var a = Array.Empty<string>();

मैंने एक छोटी नियमित अभिव्यक्ति लिखी है जिसका उपयोग आप विजुअल स्टूडियो में कर सकते हैं यदि आप शून्य-लंबाई के आवंटन को बदलना चाहते हैं जैसे new string[0]। विज़ुअल स्टूडियो में रेग्युलर एक्सप्रेशन विकल्प के साथ फाइंड स्टूडियो में खोजें (खोजें) का उपयोग करें:

new[ ][a-zA-Z0-9]+\[0\]

अब सभी खोजें या F3 (अगला ढूंढें) और सभी को Array.Empty के साथ बदलें <…> ()!

— juFo
स्रोत

3

आप रनटाइम पर सरणी आकार को परिभाषित कर सकते हैं ।

यह आपको सरणी के आकार को गतिशील रूप से गणना करने के लिए करने की अनुमति देगा। लेकिन, एक बार परिभाषित आकार अपरिवर्तनीय है।

Array a = Array.CreateInstance(typeof(string), 5);

— radarbob
स्रोत

4

वह सब क्यों करें? रनटाइम पर आप सरणी के आकार को सामान्य रूप से एक चर से परिभाषित कर सकते हैं:int i = 5; string[] a = new string[i];

— केविन ब्रॉक

खैर, मुझे लगता है कि जेनेरिक के साथ यह अप्रचलित प्रतीत होता है।

— राडारबॉब

2

मैंने कोशिश की थी:

string[] sample = new string[0];

लेकिन मैं इसमें केवल एक स्ट्रिंग सम्मिलित कर सकता हूं, और फिर मुझे एक अपवाद मिल गया।अगर त्रुटि, तो मैंने बस इसके लिए एक आकार रखा, जैसे

string[] sample = new string[100];

या मेरे लिए काम करने का एक और तरीका:

List<string> sample = new List<string>();

सूची के लिए मान निर्दिष्ट करना:

sample.Add(your input);

— Cs_Lu
स्रोत

1

जैसा कि मुझे पता है कि आप आकार के बिना सरणी नहीं बना सकते, लेकिन आप उपयोग कर सकते हैं

List<string> l = new List<string>()

और फिर l.ToArray()।

— एलेक्स डायन
स्रोत

1

@Nawfal और @Kobi सुझावों का मेल:

namespace Extensions
{
    /// <summary> Useful in number of places that return an empty byte array to avoid unnecessary memory allocation. </summary>
    public static class Array<T>
    {
        public static readonly T[] Empty = new T[0];
    }
}

उपयोग उदाहरण:

Array<string>.Empty

UPDATE 2019-05-14

(@ जैदर टी को श्रेय)

बेहतर उपयोग। नेट एपीआई:

public static T[] Empty<T> ();

https://docs.microsoft.com/en-us/dotnet/api/system.array.empty?view=netframework-4.8

प्र लागू होता है:

.NET कोर: 3.0 पूर्वावलोकन 5 2.2 2.1 2.0 1.1 1.0

.NET फ्रेमवर्क: 4.8 4.7.2 4.7.1 4.7 4.6.2 4.6.1 4.6

.NET मानक: 2.1 पूर्वावलोकन 2.0 1.6 1.5 1.4 1.3

...

HTH

— ShloEmi
स्रोत

1

.NET कोर 2 में, इसके लिए पहले से ही एक एक्सटेंशन है,arr = Array.Empty<string>();

— जैदर

iirc, .NetStandart [4.something] - में भी है।

— श्लोमी

0

तुम कर सकते हो:

string[] a = { String.Empty };

नोट: ओपी एक आकार निर्दिष्ट करने के लिए नहीं होने का मतलब है, न कि एक सरणी बनाने sizeless

— vapcguy
स्रोत

7

क्या यह लंबाई 1 की एक स्ट्रिंग सरणी नहीं बनाएगा?

— सुमेर इवांस

सच है, लेकिन यह साफ हो गया है। और ओपी ने एक आकार बताने के बिना सरणी घोषित करने के लिए कहा - यह फिट बैठता है।

— vapcguy

और यह एक पतन का पात्र है, क्यों? ओपी का मतलब specifyएक आकार से नहीं है, एक सरणी नहीं बनाना है sizeless।

— vapcguy

1

@vapcguy मैं नीच था। मुझे इसका अफसोस है। मैंने अपना उत्तर रद्द करने के लिए आपका उत्तर संपादित कर दिया है। आपकी टिप्पणी सवाल को थोड़ा संदिग्ध बनाती है। सुनिश्चित नहीं हैं कि अगर ओपी का मतलब क्या है।

— नवाफाल

4

ओपी ने एक खाली सरणी के लिए कहा । यह सरणी खाली नहीं है।

— कीथ

0

यहाँ एक वास्तविक दुनिया उदाहरण है। इसमें foundFilesपहले सरणी को शून्य लंबाई तक आरम्भ करना आवश्यक है ।

(जैसा कि अन्य उत्तरों में जोर दिया गया है: यह एक तत्व को नहीं शुरू करता है और विशेष रूप से सूचकांक शून्य के साथ एक तत्व नहीं है क्योंकि इसका मतलब यह होगा कि सरणी की लंबाई 1 थी। इस पंक्ति के बाद सरणी की लंबाई शून्य है!)।

यदि भाग = string[0]छोड़ा जाता है, तो संकलक त्रुटि होती है!

इसकी वजह है बिना रीथ्रो के कैच ब्लॉक। C # संकलक कोड पथ को पहचानता है, कि फ़ंक्शन Directory.GetFiles()एक अपवाद को फेंक सकता है, जिससे कि सरणी अनइंस्टॉल हो सके।

इससे पहले कि कोई कहे, अपवाद को फिर से न पकड़ना गलत त्रुटि से निपटने के लिए होगा: यह सच नहीं है। त्रुटि से निपटने के लिए आवश्यकताओं को पूरा करना होगा।

इस मामले में यह माना जाता है कि कार्यक्रम को एक निर्देशिका के मामले में जारी रहना चाहिए जिसे पढ़ा नहीं जा सकता है, और नहीं टूटना चाहिए - सबसे अच्छा उदाहरण एक निर्देशिका संरचना के माध्यम से कार्य करता है। यहां त्रुटि से निपटने केवल इसे लॉग कर रहा है। बेशक यह बेहतर किया जा सकता है, उदाहरण के GetFiles(Dir)लिए एक सूची में विफल कॉल के साथ सभी निर्देशिकाओं को इकट्ठा करना , लेकिन यह यहां बहुत दूर ले जाएगा।

यह बताने के लिए पर्याप्त है कि परहेज throwएक मान्य परिदृश्य है, और इसलिए सरणी को लंबाई शून्य तक आरंभीकृत किया जाना है। कैच ब्लॉक में ऐसा करना पर्याप्त होगा, लेकिन यह खराब शैली होगी।

GetFiles(Dir)सरणी को आकार बदलने के लिए कॉल ।

string[] foundFiles= new string[0];
string dir = @"c:\";
try
{
    foundFiles = Directory.GetFiles(dir);  // Remark; Array is resized from length zero
}
// Please add appropriate Exception handling yourself
catch (IOException)
{
  Console.WriteLine("Log: Warning! IOException while reading directory: " + dir);
  // throw; // This would throw Exception to caller and avoid compiler error
}

foreach (string filename in foundFiles)
    Console.WriteLine("Filename: " + filename);

— Philm
स्रोत