C# Language
.NET में असुरक्षित कोड

टिप्पणियों

for (int i = 0; i < array.Length; i++)
{
    array[i] = 0;
}

unsafe
{
    fixed (int* ptr = array)
    {
        for (int i = 0; i <= array.Length; i++)
        {
            *(ptr+i) = 0;
        }
    }
}

असुरक्षित एरे इंडेक्स

void Main()
{
    unsafe
    {
        int[] a = {1, 2, 3};
        fixed(int* b = a)
        {
            Console.WriteLine(b[4]);
        }
    }
}

इस कोड को चलाने से लंबाई 3 की एक सरणी बन जाती है, लेकिन फिर 5 वें आइटम (इंडेक्स 4) प्राप्त करने की कोशिश करता है। मेरी मशीन पर, यह 1910457872 मुद्रित 1910457872 , लेकिन व्यवहार परिभाषित नहीं है।

unsafe ब्लॉक के बिना, आप पॉइंटर्स का उपयोग नहीं कर सकते हैं, और इसलिए किसी अपवाद को समाप्त किए बिना किसी सरणी के अंत तक मानों को एक्सेस नहीं कर सकते हैं।

सरणियों के साथ असुरक्षित का उपयोग करना

पॉइंटर्स के साथ एरे को एक्सेस करते समय, कोई बाउंड चेक नहीं IndexOutOfRangeException और इसलिए कोई IndexOutOfRangeException नहीं IndexOutOfRangeException जाएगी। इससे कोड तेज होता है।

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

class Program
{
    static void Main(string[] args)
    {
        unsafe
        {
            int[] array = new int[1000]; 
            fixed (int* ptr = array)
            {
                for (int i = 0; i < array.Length; i++)
                {
                    *(ptr+i) = i; //assigning the value with the pointer
                }
            }
        }
    }
}

जबकि सुरक्षित और सामान्य समकक्ष होगा:

class Program
{
    static void Main(string[] args)
    {            
        int[] array = new int[1000]; 

        for (int i = 0; i < array.Length; i++)
        {
            array[i] = i;
        }
    }
}

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

तार के साथ असुरक्षित का उपयोग करना

var s = "Hello";      // The string referenced by variable 's' is normally immutable, but
                      // since it is memory, we could change it if we can access it in an 
                      // unsafe way.

unsafe                // allows writing to memory; methods on System.String don't allow this
{
  fixed (char* c = s) // get pointer to string originally stored in read only memory
    for (int i = 0; i < s.Length; i++)
      c[i] = 'a';     // change data in memory allocated for original string "Hello"
}
Console.WriteLine(s); // The variable 's' still refers to the same System.String
                      // value in memory, but the contents at that location were 
                      // changed by the unsafe write above.
                      // Displays: "aaaaa"