कॉपी किए बिना सी # में किसी मौजूदा सरणी से उप-सरणी कैसे प्राप्त करें?

Question

मेरा प्रश्न Getting a sub-array from an existing array जैसा है हालांकि मेरे मामले में थोड़ा अलग धारणा बहुत महत्वपूर्ण है - मैं स्मृति प्रतिलिपि का उपयोग नहीं कर सकता।

मैं सरणी Y कि होगा, X से 9000 तत्व शामिल हैं X के सूचकांक 500

से शुरू की जरूरत है चलो कहते हैं कि मैं सरणी 10000 के X तत्वों करते हैं, लेकिन मैं करने के लिए X का हिस्सा नकल नहीं करना चाहते नई सरणी Y, इसलिए मैं Array.Copy, Array.Clone, System.Block.Copy, IENumerables इत्यादि का उपयोग नहीं करना चाहता हूं।के संदर्भ में Y वास्तव में X[500], Y[1]X[501] से मेल खाता है, .. ।, Y[9000]X[9500] है।

इस प्रकार, उदाहरण के लिए X[100] का मूल्य बदलना Y[600] का मूल्य बदल जाएगा। मैं इसे सी # में कैसे प्राप्त कर सकता हूं?

Answer 1

आप कुछ इस तरह के साथ एक और वस्तु में लपेट कर सकते हैं:

class View<T> 
{ 
    private T[] _array; 
    private long _start; 
    private long _length; 
    public View(T[] array, long start, long length) { ... } 
    public T this[long index] 
    { 
     get 
     { 
      if (/*do bounds check here*/) 
      { 
       return _array[_start + index]; 
      }  
     } 
    } 
} 

यह एक सरणी, लेकिन एक के एक प्रक्षेपण नहीं किया जाएगा।

Answer 2

आप ArraySegment का उपयोग कर सकते हैं।

String[] X = { "one", "two", "three", "four", "five"}; 

ArraySegment<String> arraySegment = new ArraySegment<String>(X, 1,3); // will contain {"two", "three", "four"} 
arraySegment.Array[arraySegment.Offset + 1] = "3"; // X will contain { "one", "two", "3", "four", "five"}; 
          // and arraySegment.Array will contain {"two", "3", "four"} 

Answer 3

दुर्भाग्य ArraySegment<T> बंद है यानी indexers और पसंद है, और आप आसानी से उचित सरणी-वाक्य रचना के साथ इसे बढ़ाया जा सकता था,: यहाँ एक उदाहरण है।

यदि मैं आप थे तो मैं ArraySegment<T> के साथ जाऊंगा और यदि इसमें उचित आवश्यकताएं नहीं हैं, जैसे ElementAt(n) अक्षम होने के लिए, बस एक बेहतर कार्यान्वयन लागू करें। पूर्व:

public static class ArrayExtensions 
{ 
    // Getter using underlying array 
    public static T GetValueAt<T>(this ArraySegment<T> array, int index) 
    { // No safe checks here, would recommend them in production though 
    return array.Array[array.Offset + index]; 
    } 
    // Setter using underlying array 
    public static void SetValueAt<T>(this ArraySegment<T> array, int index, T value) 
    { // maybe we should check that the calculated index is valid? Or just blow up? 
    array.Array[array.Offset + index] = value; 
    } 
}