Pointers in C#

C# in Hindiये Article इस वेबसाईट पर Selling हेतु उपलब्‍ध EBook C#.NET in Hindi से लिया गया है। इसलिए यदि ये Article आपके लिए उपयोगी रहा, तो निश्चित रूप से ये पुस्तक भी आपके लिए काफी उपयोगी साबित होगी। 

C#.NET in Hindi | Page:908 | Format: PDF

BUY NOW DOWNLOAD READ ONLINE

Pointers in C#: हमने पहले भी कहा था कि C# वास्तव में C, C++, Java Visual Basic Programming Languages के विभिन्न उपयोगी Features का Collection है। इसलिए इन सभी Programming Languages के विभिन्न Concepts व Programming Constructs को किसी न किसी तरह से C# में जरूर Implement किया गया है और इन्हीं उपयोगी Features में से एक Pointer Type भी है, जो कि C/C++ Programming Languages की Performance का मुख्‍य आधार होता है।

हालांकि C# में Pointer को Use करना जरूरी नहीं है और हम बिना Pointers का प्रयोग किए हुए भी अपनी विभिन्न प्रकार की जरूरतों को पूरा कर सकते हैं। लेकिन फिर भी कुछ ऐसी जरूरतें हो सकती हैं, जहां Pointers को Use करने के अलावा हमारे पास और कोई रास्ता नहीं होता।

C# में अभी तक हमने केवल दो तरह के Data को Use किया है, जिन्हें Value Types Reference Types के नाम से जाना जाता है। लेकिन Pointer Type, C# द्वारा Supported तीसरा Type है, जिसे हालांकि सबसे कम Use किया जाता है, लेकिन जरूरत होने पर इसे Use किया जा सकता है। जबकि Java में Pointer Type को पूरी तरह से Ignore किया गया है।

Pointer Types का मुख्‍य उपयोग C API के साथ Interoperability प्राप्त करने के लिए ही किया जाता है। लेकिन क्योंकि हम Pointers का प्रयोग करके अपने System के Resources को Hardware Level पर Directly Access कर सकते हैं, इसलिए Pointers एक बहुत ही Powerful Type की तरह भी Use हो सकते हैं।

चूंकि Pointers का प्रयोग करके हम Heap Area से बाहर के Memory को भी Access कर सकते हैं, इसलिए सामान्‍यत: Pointers का प्रयोग करके विभिन्न प्रकार के Virus व Malicious Codes Create किए जा सकते हैं, जो अन्‍य Programs के Memory Area के साथ छेडछाड करके उन्हें Corrupt कर सकते हैं। जबकि Pointers के अलावा अन्‍य किसी Type में ये क्षमता नहीं है।

हालांकि Pointer Type को Manage व Control करना थोडा Typical होता है। लेकिन Value Type व Reference Type की तुलना में Pointer Types की Performance सबसे अच्छी होती है। इसीलिए आज भी ज्यादातर Games व ऐसे Software जिसमें Multimedia का काफी ज्यादा उपयोगी होता है, C++ जैसी Programming Languages में ही Develop किए जाते हैं, क्योंकि C++ या Managed C++/CLI में Pointers को उपयोग में लेने की अच्छी सुविधा रहती है।

यद्धपि सामान्‍य प्रकार के ज्यादातर Software Multimedia या Resources का ज्यादा उपयोग नहीं करते, इसलिए इन्हें Pointer Types Supported C++ Programming Language के स्थान पर Java या C# जैसी Programming Languages में ही Develop किया जाता है।

जब हम C# में Pointer Types को Use करना चाहते हैं, तब C# हमें कुछ Specific Operators व Keywords Provide करता है, जिनका प्रयोग करके CLR के Memory Management Scheme को Bypass कर सकते हैं। ये Operators व Keywords निम्नानुसार हैं:

Operator/Keyword Meaning in Life
* इस Operator का प्रयोग Pointer Variable Create करने के लिए किया जाता है, जो कि Memory की किसी Location को Point करता है।
& इस Operator का प्रयोग किसी Variable के Memory Address को प्राप्त करने के लिए किया जाता है।
-> इस Operator का प्रयोग किसी Type के उस Field को Access करने के लिए किया जाता है, जिसे Pointer की तरह Declare किया गया है। C# Unsafe Version में इसे Dot Operator द्वारा Represent किया जाता है।
[] Unsafe Context में ये Operator हमें किसी Memory Slot को Pointer द्वारा Point करने की सुविधा देता है।
++, Unsafe Context में ये Operator हमें Pointer Types पर Increment व Decrement Operators को Use करने की सुविधा देता है।
+, Unsafe Context में ये Operator हमें Pointer Types पर Plus ( + ) व Minus ( – ) Operators को Use करने की सुविधा देता है।
==,!=, <, >, <=, => Unsafe Context में ये Operator हमें Pointer Types पर Relational Operators को Use करने की सुविधा देता है।
stackalloc Unsafe Context में ये Keyword हमें C# Array को Directly Stack में Memory Allocate करने की सुविधा देता है।
fixed Unsafe Context में ये Keyword हमें किसी Variable को Temporarily Fix करने की सुविधा देता है ताकि उसका Address प्राप्त किया जा सके।

चूंकि जब हम C# में Pointers का प्रयोग करते हैं, तो .NET Runtime पूरी तरह से हमारे Codes को Manage करने में अक्षम हो जाता है। इसलिए Pointer का प्रयोग करने के कारण यदि कोई परेशानी पैदा होती है, तो उसे .NET Runtime द्वारा किसी भी तरह से Handle नहीं किया जाता। बल्कि उसे पूरी तरह से हमें ही Manage व Control करना होता है।

इसलिए C# में Pointer का प्रयोग तभी करना चाहिए जबकि हमें हमारे Application के किसी Part की Performance Increase करने के लिए Memory को Directly Access करना हो या C Based API यानी .dll या COM Server से किसी Functionality को प्राप्त करना हो। हालांकि इस प्रकार की जरूरत के लिए हम System.IntPtr Type व System.Runtime.IntereopServices.Marshal Type के Members को Use कर सकते हैं।

जब हम C# Language में Pointer Type को Use करना चाहते हैं, तो अपने Program को Compile करते समय हमें हमारे C# Compiler को ये बताना जरूरी होता है कि हमने हमारे Program में Pointer Type को Use करते हुए “Unsafe Code” Create किया है और C# Compiler को इस बात की Information Program Compile करते समय /unsafe Flag द्वारा दिया जाता है। जैसे:

csc /unsafe *.cs

जबकि यदि हम Visual Studio का प्रयोग करते हैं तो हमें हमारे Project के Properties Page में जाकर “Allow Unsafe Code” Check Box को Check करना होता है।

Using unsafe Keyword for Unsafe Block of Pointer Code

जब हम C# में Pointers का प्रयोग करना चाहते हैं, तो हमें C# Compiler को बताना होता है कि हमारे Program का कौनसा Code Pointer Type को Use कर रहा है और “Unsafe Code” है और इस बात को बताने के लिए हमें unsafe Keyword का प्रयोग करते हुए एक Block Specify करना होता है, जिसमें हम हमारे Pointer Related Codes लिख सकते हैं।

जबकि जिस Code को unsafe Keyword द्वारा “Unsafe Code” के रूप में Mark नहीं किया जाताए उस Code में हम Pointers का प्रयोग नहीं कर सकते। जैसे:

	class Program
	{
		static void Main(string[] args)
		{
			unsafe
			{
				// Work with pointer types here!
			}

			// Can't work with pointers here!
		}
	}

जिस तरह से हम उपरोक्तानुसार unsafe Block Create कर सकते हैं, उसी तरह से हम unsafe Structures, Classes, Type Members व Parameters Create कर सकते हैं, जो कि Unsafe होते हैं। जैसे:

	unsafe struct Coordinate
	{
		int *x;
		int *y;
	}

जब हम इस तरह से Coordinate Type को Unsafe Create करते हैं, तो पूरा Coordinate Type ही Unsafe हो जाता है, जिसे Program के केवल Unsafe Area में ही Use किया जा सकता है। लेकिन यदि हम Type के केवल Members को Unsafe Declare करें, तो Type को तो Safe Area में Use कर सकते हैं, लेकिन उसके Members को Same Area में Use नहीं कर सकते। जैसे:

	struct Coordinate
	{
		public unsafe int *x;
		public unsafe int *y;
	}

किसी Type के Instance या Static Methods को भी unsafe Declare किया जा सकता है। जैसे:

	struct Coordinate
	{
		int *x;
		int *y;

		unsafe public void Display()
		{
			Console.WriteLine("X,Y" + *x, *y);
		}

		unsafe public static int Calculate()
		{
			return *x + *y;
		}
	}

हम किसी Unsafe Code को हमेंशा किसी Unsafe Block में ही Use कर सकते हैं। जबकि यदि हमारा पूरा Program की Unsafe Code को Use कर रहा हो, तो हम हमारे Main() Method को ही निम्नानुसार तरीके से Unsafe Declare कर सकते हैं:

	unsafe public static void Main(string[] args)
	{
		Coordinate pixelPosition = new Coordinate();
		pixelPosition.Display();
	}

जबकि यदि हमें Main() Program के किसी Specific Part में ही Pointer Type को Use करना हो, तो हम Unsafe Code को Use करने के लिए निम्नानुसार तरीके से एक unsafe Block Create कर सकते हैं:

	public static void Main(string[] args)
	{
		unsafe
		{
			Coordinate pixelPosition = new Coordinate();
			pixelPosition.Display();
		}
	}

Working with * and & Operators – Pointers in C#

जब हम हमारी जरूरत के अनुसार unsafe Context Create कर लेते हैं, तो हम उस Unsafe Context में जिस तरह से C/C++ Programs में Pointers को Use करते हैं, उसी तरह से C# Programs में भी Pointers को Use कर सकते हैं। लेकिन C# में * Operator केवल Underlying Type पर ही Apply हो सकता है, न कि Particular Variable पर। उदाहरण के लिए C# में निम्नानुसार तरीके से Declaration नहीं किया जा सकता:

int *x, *y;            //Error

यानी यदि हमें xy दोनों को Pointer Type Declare करना हो, तो हमें दोनों को निम्नानुसार अलग-अलग Declare करना होगा:

int *x;
int *y;

या फिर हम इन्हें निम्नानुसार भी Declare कर सकते हैं:

int* x, y;              //Correct

ये Statement xy दोनों को Integer Pointer Type का Declare करेगा, न कि केवल x को। क्योंकि C# में * Operator Underlying Type पर Apply होता है न कि Individual Variable पर, जैसाकि कि C/C++ में होता है।

चलिए, इन सभी Logics को Apply करते हुए एक Program Create करते हैं, जिसमें Swapping के लिए Safe Unsafe दोनों प्रकार के Methods को Define व Use किया गया है। हमारा Program कुछ निम्नानुसार हो सकता है:

File Name: UsingPointerType.cs
using System;

namespace CSharpClass
{
    class UsingPointers
    {
        unsafe public static void UnsafeSwap(int* i, int* j)
        {
            int temp = *i;
            *i = *j;
            *j = temp;
        }

        public static void SafeSwap(ref int i, ref int j)
        {
            int temp = i;
            i = j;
            j = temp;
        }

        static void Main()
        {
            int x = 10, y = 20;
            Console.WriteLine("Swapping via Safe Code");
            Console.WriteLine("Before Swapping: X={0} and Y={1}", x, y);
            SafeSwap(ref x, ref y);
            Console.WriteLine("After Swapping: X={0} and Y={1}", x, y);

            int p = 10, q = 20;
            Console.WriteLine("\nSwapping via Unsafe Code");
            Console.WriteLine("Before Swapping: P={0} and Q={1}", p, q);
            unsafe
            {
                UnsafeSwap(&p, &q);
            }
            Console.WriteLine("After Swapping: P={0} and Q={1}", p, q);

        }
    }
}

// Output:
   Swapping via Safe Code
   Before Swapping: X=10 and Y=20
   After Swapping: X=20 and Y=10

   Swapping via Unsafe Code
   Before Swapping: P=10 and Q=20
   After Swapping: P=20 and Q=10

इस Program में हमने Swapping करने के लिए दो Static Methods Define किए हैं। हालांकि दोनों ही Methods समान काम करते हैं, लेकिन SafeSwap() Method ref Keyword के आधार पर Variables की Actual Values को Access करता है, जबकि UnsafeSwap() Method Pointer के आधार पर Variables की Actual Values को Directly Memory से Access करता है।

साथ ही UnsafeSwap() Static Method में Pointer Type का प्रयोग किया जा रहा है, इसलिए इस Program में इस UnsafeSwap() Method को निम्नानुसार unsafe Keyword के साथ Specify किया गया है:

        unsafe public static void UnsafeSwap(int* i, int* j)
        {
            int temp = *i;
            *i = *j;
            *j = temp;
        }

जबकि Main() Method में इस UnsafeSwap() Method को Use करने के लिए भी हमने निम्नानुसार एक unsafe Block Create किया है:

            unsafe
            {
                UnsafeSwap(&p, &q);
            }

क्योंकि हम Pointer Type Code को बिना unsafe Block Specify किए हुए उपयोग में नहीं ले सकते। हम देख सकते हैं कि UnsafeSwap() Method पूरी तरह से C/C++ के Function की तरह ही Call किया जा रहा है।

साथ ही उसमें Pass किए जाने वाले Variable Pointers को भी Exactly C/C++ के Pointer की तरह ही & Operator के साथ Specify किया जा रहा है। यानी हम C# में भी एक unsafe Block Create करके C/C++ के सभी Pointer Related Operations Perform कर सकते हैं।

Arrow ( -> ) Operator for Field Accessing via Pointers

जब हम C# में किसी Type के Members को Pointer के माध्‍यम से Access करना चाहते हैं, तो उस स्थिति में हमें Arrow Operator को Use करना होता है। जैसे:

File Name: AccessinMembersWithPointer-ArrowOperator.cs
using System;

namespace CSharpClass
{
    public struct Coordinate
    {
        public int x, y;
    }

    class UsingPointers
    {
        unsafe public static void UsingArrowOperator()
        {
            Coordinate pixel = new Coordinate();
            Coordinate* pixelPtr = &(pixel);
            pixelPtr->x = 134;
            pixelPtr->y = 34;

            Console.WriteLine("Pixel Position: {0},{1}", pixelPtr->x, pixelPtr->y);
        }

        static void Main()
        {
            unsafe
            {
                UsingArrowOperator();
            }
        }
    }
}

Output:
	Pixel Position: 134,34

इस Program में हमने Coordinate Type के Structure का एक pixel नाम का Object Create किया है, जिसका Address pixelPtr नाम के Coordinate Type के Variable में Store किया है। इसलिए इस Coordinate Type के Object के Public Members को pixelPtr Pointer द्वारा Access करने के लिए हमें उपरोक्त Program में Defined UsingArrowOperator() Unsafe Static Method में दर्शा, अनुसार Arrow Operator को Use करना होता है।

जब हम किसी Pointer द्वारा किसी Type के Members को इस Program में दर्शा, अनुसार Arrow Operators का प्रयोग करते हुए Use करना चाहते हैं, तो हमें हमेंशा इस बात का ध्‍यान रखना होता है कि हम हमेंशा किसी Value Type के Member यानी Structure के Members को ही इस तरह से Use कर सकते हैं।

यानी यदि हम हमारे इसी Program में Defined Coordinate Structure को निम्नानुसार एक Class में Convert कर दें:

    public class Coordinate
    {
        public int x, y;
    }

तो अब इसी Program को Run करने पर हमें निम्नानुसार Error Message प्राप्त होगा:

ArrowOperator.cs(15,5): error CS0208: Cannot take the address of, get the size of, or declare a pointer to a managed type ('CSharpClass.Coordinate')
ArrowOperator.cs(5,16): (Location of symbol related to previous error)
ArrowOperator.cs(15,28): error CS0208: Cannot take the address of, get the size of, or declare a pointer to a managed type ('CSharpClass.Coordinate')

ये Error इसलिए Return होता है, क्योंकि सभी Reference Types वास्तव में Managed Types होते हैं और Reference Types द्वारा Allocated Memory को .NET Platform के Garbage Collector द्वारा Collect किया जाता है, क्योंकि Reference Types हमेंशा Heap Area में Memory Reserve करते हैं।

जबकि Structure एक Value Type होता है, जो कि Stack में Memory Reserve करता है। इसलिए .NET Platform आसानी से Stack के Garbage को Collect कर लेता है, लेकिन Unsafe Code Use करने पर .NET Platform Reference Type के Heap Area के Garbage को Collect करने में अक्षम हो जाता है, क्योंकि Reference Types को Managed Type भी कहा जाता है और हम Managed Type का Pointer Create नहीं कर सकते।

ऐसी स्थिति में C# Compiler हमें उपरोक्तानुसार Error Return करता है, जो इसी बात का Indication है कि हमें Reference Type नहीं बल्कि Value Type के साथ ही Arrow Operator को Use करना चाहिए। हालांकि यदि हम चाहें तो Arrow Operator के स्थान पर हम निम्नानुसार तरीके से Dot Operator को भी Use कर सकते हैं:

        unsafe public static void UsingArrowOperator()
        {
            Coordinate pixel = new Coordinate();
            Coordinate* pixelPtr = &(pixel);
            (*pixelPtr).x = 134;
            (*pixelPtr).y = 34;
 
            Console.WriteLine("Pixel Position: {0},{1}", pixelPtr->x, pixelPtr->y);
        }

Using stackalloc Keyword for Unsafe Memory Allocation

जब हम Unsafe Context में होते हैं, तो हमें किसी Local Variable के लिए Directly Call Stack में Memory Allocate करने की जरूरत पड सकती है, जिससे .NET के Garbage Collector का कोई सम्बन्ध नहीं होता। इस प्रकार का Local Variable Create करने के लिए हमें stackalloc Keyword को Use करना पडता है जो कि C Runtime Library के _alloca() Function की तरह काम करता है।

File Name: stdallocKeywordUse.cs
using System;

namespace CSharpClass
{
    public struct Coordinate
    {
        public int x, y;
    }

    class UsingPointers
    {
        unsafe static void UnsafeStackAlloc()
        {
            char* p = stackalloc char[256];
            for (int k = 65; k < 91; k++)
                p[k] = (char)k;

            for (int k = 65; k < 91; k++)
                Console.Write(p[k] + "    ");
        }

        static void Main()
        {
            unsafe
            {
                UnsafeStackAlloc();
            }
        }
    }
}

Output:
  A    B    C    D    E    F    G    H    I    J    K    L    M    N    O    P    Q    R    S    T    U    V    W    X    Y    Z

Using fixed Keyword

जब हम stackalloc Keyword का प्रयोग करते हुए C# Program के Unsafe Context में Stack Area में Memory Allocation करते हैं, तो जैसे ही Memory Allocate करने वाला Method Execute होता है, वह Allocated Memory फिर से Free हो जाती है। लेकिन कई बार हमें ज्यादा Complex काम करने होते हैं। जहां हमें Method के Execute होने के बाद भी Allocated Memory की जरूरत रहती है।

इस स्थिति में हम Value Type Data के लिए Stack में Memory Allocate नहीं कर सकते, बल्कि हमें Reference Type Data के लिए Heap Area में Memory Allocate करना होता है, ताकि Method के Execution के बाद भी Memory Allocated रहे।

fixed Keyword का प्रयोग करके हम एक Managed Object को किसी Unmanaged Variable के साथ Pin कर देते हैं, जिसकी वजह से Garbage Collector उस Object की Memory को तब तक Collect नहीं करताए जब तक कि हम उस Fixed Block में होते हैं।

यानी जब हम किसी Structure को Define करते हैं, तो ये जरूरी होता है कि उसके सभी Members Unmanaged Types हों। इसलिए यदि हम किसी Structure में String या Array Type को Use करते हैं, तो हमारा String वास्तव में C/C++ की तरह ही Characters का एक One-Dimensional Array ही होता है।

इसलिए यदि हम Structure में Declared String Type को Unmanaged Code में Use करना चाहें या Unmanaged Code में Defined Characters के Array को Managed String के रूप में Use करना चाहें, तो हमें Manual Conversion करना जरूरी होता है और इस Manual Conversion के दौरान हमें fixed Keyword को Use करना होता है। जैसे:

[StructLayout (LayoutKind.Sequential)]
unsafe struct MySharedData
{
    // Allocate space for 200 chars (i.e., 400 bytes).
    const int MessageSize = 200;
    fixed char message [MessageSize];

    // One would most likely put this code into a helper class:
    public string Message
    {
        get 
        { 
		fixed (char* cp = message) return new string (cp); 
	}

        set
        {
            fixed (char* cp = message)
            {
                int i = 0;
                for (; i < value.Length && i < MessageSize - 1; i++)
                cp [i] = value [i];
                // Add the null terminator
                cp [i] = '\0';
            }
        }
    }
}

इस Program में हमने निम्नानुसार Statement द्वारा message नाम का एक One-Dimensional Character Array Declare किया है, जो कि unsafe Structure में Declared है:

fixed char message [MessageSize];

यहां हमने fixed Keyword इसलिए Use किया है, क्योंकि हम C# Compiler को इस बात का Indication दे रहे हैं, कि हमें Compulsory रूप से 200 Characters Store करने के लिए 200 Byte की Continuous Memory की जरूरत है। फिर हमने निम्नानुसार तरीके से एक get Accessor Create किया है:

        get 
        { 
		fixed (char* cp = message) return new string (cp); 
	}

इस Accessor में भी हमने fixed Keyword Use किया है और Parenthesis के बीच एक Character Pointer Declare करके message नाम के One-Dimensional Character Array का Base Address यानी First Character का Address cp नाम के Character Pointer को Assign कर दिया है।

फिर इस cp नाम के Character Pointer को string() Constructor में Pass करके इस Unmanaged One-Dimensional Character Pointer को एक String Object में Convert करके Return कर दिया है, जो कि एक Managed Type होता है। इसी तरह से जब निम्नानुसार set Accessor Execute होता है

        set
        {
            fixed (char* cp = message)
            {
                int i = 0;
                for (; i < value.Length && i < MessageSize - 1; i++) cp [i] = value [i];

                // Add the null terminator
                cp [i] = '\0';
            }

तो इस बार fixed statement द्वारा एक Fixed Block Create किया जाता है, जिसमें फिर से cp नाम का एक One-Dimensional Character Pointer Declare किया जाता है और उसमें message नाम के One-Dimensional Character Array का Base Address यानी First Character का Address Assign कर दिया जाता है। इस तरह से get Accessor द्वारा एक Unmanaged Character Array को Managed Object में Convert किया जाता है।

फिर इसी Accessor में value नाम के String Type के Object के Characters को One by One Access करके cp नाम के Pointer के माध्‍यम से message नाम के Character Array में Store किया जाता है व String का अन्त दर्शाने के लिए अन्त में cp[i] = ‘\0’; Statement द्वारा One-Dimensional Character Array का अन्त किया जाता है। इस तरह से set Accessor द्वारा एक Managed String Object को Unmanaged Character Array में Convert किया जाता है।

यानी जब हम Managed Type से Unmanaged Type या Unmanaged Type से Managed Type में Conversion करते हैं, तब ये जरूरी होता है कि हम किसी तरह से .NET Compiler को इस बात का Instruction दें कि .NET GC द्वारा Managed Object को Collect न कर लिया जाए और fixed Keyword द्वारा हम .MET Compiler को यही Instruction देते हैं।

sizeof Keyword

ये Keyword Exactly C/C++ के sizeof Operator की तरह ही काम करता है और हम जिस Type या Type के Object या Variable को इस Keyword के साथ Paranthesis के बीच Specify कर देते हैं, ये Keyword उस Type द्वारा Memory में Reserve की जाने वाली Memory की Size Return कर देता है। जैसे:

File Name: sizeofKeyword.cs
using System;

namespace CSharpClass
{
    public struct Coordinate
    {
        public int x, y;
    }

    class UsingPointers
    {
        unsafe static void UseSizeOfOperator()
        {
            Console.WriteLine("The size of short is {0}.", sizeof(short));
            Console.WriteLine("The size of int is {0}.", sizeof(int));
            Console.WriteLine("The size of long is {0}.", sizeof(long));
            Console.WriteLine("The size of Coordinate is {0}.", sizeof(Coordinate));
        }

        static void Main()
        {
            unsafe
            {
                UseSizeOfOperator();
            }
        }
    }
}

// Output:
   The size of short is 2.
   The size of int is 4.
   The size of long is 8.
   The size of Coordinate is 8.

इस Program में हम देख सकते हैं कि हमारे User Defined Structure “Coordinate” में हमने Integer Type के दो Variables xy Declare किए हैं, इसलिए हमारे Structure Coordinate Type का हर Object Memory में दो Integer यानी कुल 8 Byte की Spacer Reserve करता है। इस तरह से sizeof Keyword का प्रयोग करके हम किसी भी Type द्वारा Reserve की जाने वाली कुल Memory का पता लगा सकते हैं।

जैसाकि हमने पहले भी कहा कि हालांकि हम C# में unsafe Keyword का प्रयोग करके ऐसा Block Create कर सकते हैं, जिसमें हम Unmanaged Codes के रूप में Pointers से सम्बंधित विभिन्न प्रकार के Codes लिख सकते हैं और अपने Computer के Resources के Memory Location को Directly Access कर सकते हैं।

लेकिन फिर भी ऐसी बहुत कम तरह की जरूरतें ही होती हैं, जब हमें Pointers का प्रयोग करते हुए अपने Program में unsafe Context को Use करना पडे। इसलिए जब तक किसी अन्‍य तरीके से किसी जरूरत को पूरा किया जा सकता हो, हमें C# में Pointers को Use करते हुए Unsafe Code Create नहीं करना चाहिए।

Operator Overloading in C#.NET
Inheritance in C#

******

ये पोस्‍ट Useful लगा हो, तो Like कर दीजिए।

C# in Hindiये Article इस वेबसाईट पर Selling हेतु उपलब्‍ध EBook C#.NET in Hindi से लिया गया है। इसलिए यदि ये Article आपके लिए उपयोगी रहा, तो निश्चित रूप से ये पुस्तक भी आपके लिए काफी उपयोगी साबित होगी। 

C#.NET in Hindi | Page:908 | Format: PDF

BUY NOW DOWNLOAD READ ONLINE

Download All Hindi EBooks

सभी हिन्दी EBooks C, C++, Java, C#, ASP.NET, Oracle, Data Structure, VB6, PHP, HTML5, JavaScript, jQuery, WordPress, etc... के DOWNLOAD LINKS प्राप्‍त करें, अपने EMail पर।

Register करके Login करें। इस Popup से छुटकारा पाएें।