Nullable Types in C#

Nullable Types in C#: जैसाकि हम जानते हैं कि सभी C# Data Types की एक Fixed Range होती है, जिसे System Namespace द्वारा Represent किया जाता है। उदाहरण के लिए यदि हम System.Boolean Type का Variable Declare करें, तो हम इस प्रकार के Variable में true या false में से किसी मान को Store कर सकते हैं। इसी तरह से यदि हमें बहुत छोटा Numerical मान Store करना हो, तो हम System.Byte Type का Variable Declare कर सकते, जो कि 0 से 255 तक के मान को Store कर सकता है।

सामान्‍यत: जब हम Database Applications Create कर रहे होते हैं, तब हमें कभी-कभी Compiler को ये बताना होता है कि हम जिस Field में किसी मान को Store करना चाहते हैं, वह मान Currently Unknown है, लेकिन भविद्ग; में उस Field में कोई Meaningful मान Store किया जाएगा।

Reference Types के लिए हम इस प्रकार के Variables में null मान Specify करके Empty Object Reference Set कर सकते हैं, जो कि Compiler के लिए इस बात का Signal होता है कि कोई Reference Type Currently किसी भी Actual Data को Refer नहीं कर रहा है, लेकिन जरूरत होने पर उसे किसी Actual Data के Memory Reference से Assign किया जा सकता है।

लेकिन हम जानते हैं कि सभी Numerical Data Types वास्तव में Value Type होते हैं और Value Type के किसी भी Variable को हम null Specify नहीं कर सकते, क्योंकि null वास्तव में Empty Reference Type को Represent करता है। परिणामस्वरूप हर Value Type Variable को Memory जरूर Allocate होता है, भले ही उसमें कोई Meaningful मान हो या न हो।

इस स्थिति में Unknown Values को Represent करने के लिए हमें किसी Particular Value Type Variable के साथ एक Boolean Indicator Associate करना जरूरी होता है, ताकि जब Variable में Valid Value Store किया जाए, तब इस Boolean Indicator का मान true करके C# Compiler को इस बात का Instruction दिया जा सके, कि हमने किसी Value Type Variable के Unknown Value को किसी उपयुक्त Value से Replace कर दिया है।

जबकि जब तक उस Variable में Valid Value Stored न हो, तब इस Boolean Indicator का मान false रखकर हम इस बात को Indicate कर सकते हैं कि किसी Particular Value Type में Currently कोई उपयुक्त मान Stored नहीं है।

C# में Add किया गया Nullable Type हमें ऐसा ही Value Type Variable Create करने की सुविधा Provide करता है, जिसे Valid अथवा Invalid Mark किया सकता है, ताकि इस प्रकार के Variable को Use करते समय हम इस बात को निश्चित कर सकें कि Value Type के Variable में एक Valid Value Stored है या नहीं।

Nullable Type हमेंशा किसी अन्‍य Type के साथ Use होता है, इसलिए यदि हम Nullable Bool Data Type Declare करते हैं, तो इसका मतलब ये होता है कि हम इस प्रकार के Boolean Variable को true, false या null में से कोई भी मान Assign कर सकते हैं।

Relational Database के साथ काम करते समय ये Nullable Type बहुत महत्वपूर्ण Role Play करता है और हमें किसी Table के किसी Undefined Column को Represent करने की सुविधा देता है। बिना Nullable Types का प्रयोग किए हुए यदि हम C# में No-Value Numerical Data को Represent करना चाहें, तो हमारे पास कोई Convenient तरीका नहीं होता।

Nullable Variable Type Define करने के लिए हमें Data Type के साथ Suffix के रूप में एक Question Mark (?) Symbol का प्रयोग करना होता है। ध्‍यान दें कि ये तरीका केवल तभी Valid होता है, जब हम Nullable Value Types के साथ प्रक्रिया कर रहे होते हैं। यदि हम कोई Nullable Reference Type Create करते समय ये तरीका Use करते हैं अथवा String के साथ ये तरीका Use करते हैं, तो C# Compiler Compile Time Error Trigger करता है।

साथ ही एक Non-Nullable Variable की तरह ही Local Variables को भी Use करने से पहले Initial Value से Assign करना जरूरी होता है अन्‍यथा C# Compiler Compile Time Error Trigger करता है। Nullable Variable निम्नानुसार तरीके से Create किया जा सकता है:

	static void LocalNullableVariables()
	{
		// Define some local Nullable Variables.
		int? nullableInt = 10;
		double? nullableDouble = 3.14;
		bool? nullableBool = null;
		char? nullableChar = 'a';
		int?[] arrayOfNullableInts = new int?[10];

		// Error! Strings are reference types!
		// string? s = "oops";
	}

C# Programming Language में “?” Suffix वास्तव में System.Nullable<T> Generic का Instance Create करने का एक Shorthand Notation होता है। हालांकि हम Generic के बारे में आगे विस्तार से समझेंगे, लेकिन यहां ये समझना जरूरी है कि System.Nullable<T> Type हमें बहुत सारे ऐसे उपयोगी Methods Provide करता है, जिनका प्रयोग Declare किए गए Nullable Type Variables के साथ किया जा सकता है।

उदाहरण के लिए हम Programmatically इस बात का पता लगा सकते हैं कि Nullable Type को null Value Assign किया गया है या नहीं और इस बात का पता लगाने के लिए हम HasValue या != Operator का प्रयोग कर सकते हैं। जबकि Nullable Type को Assigned Value को Directly अथवा Value Property द्वारा प्राप्त किया जा सकता है।

चूंकि “?” Suffix वास्तव में System.Nullable<T> Generic का Instance Create करने का एक Shorthand Notation होता है। इसलिए यदि हम चाहें तो उपरोक्त सभी Nullable Declarations को निम्नानुसार तरीके से भी Specify कर सकते हैं:

	static void LocalNullableVariables()
	{
		// Define some local Nullable Variables.
		Nullable<int> nullableInt = 10;
		Nullable<double> nullableDouble = 3.14;
		Nullable<bool> nullableBool = null;
		Nullable<char> nullableChar = 'a';
		Nullable<int>[] arrayOfNullableInts = new int?[10];
	}

जब हम कोई Nullable Type Variable Declare करते हैं, तो Compiler हमारे Variable से सम्बंधित कई प्रकार की बातों का ध्‍यान रखता है। उदाहरण के लिए यदि हम निम्नानुसार तरीके से एक Nullable Variable Declare करें:

        int? myNInt = 28;

तो Compiler सबसे पहले तो Integer Type की Value Store करने के लिए एक Variable Create करता है और साथ ही उस के साथ इस बात की Instruction भी Attach कर देता है, कि Create होने वाला Variable एक Nullable Variable है, जिसमें Value के रूप में null को भी Assign किया जा सकता है।

इसके अलावा Create होने वाले Nullable Type के लिए कई अन्‍य Methods भी Inherit हो जाते हैं, जिन्हें जरूरत के अनुसार Use किया जा सकता है।

उदाहरण के लिए Nullable Type के साथ HasValue नाम की एक Property Associate हो जाती है, जो इस बात का Indication देता है कि Nullable Type को कोई Valid Value Assign किया गया है या नहीं।

साथ ही Value नाम की एक और Property Associate हो जाती है, जिसका वही Type होता है, जो Nullable Type Variable का Type होता है और ये Property उस स्थिति में Nullable Type का Value Return करता है, जबकि Nullable Type को कोई Valid मान Assign किया गया हो।

परिणामस्वरूप उपरोक्त Nullable Type Declaration Memory में निम्नानुसार तरीके से Space Reserve करता है:

Nullable Type के Variable को भी Exactly उसी तरह से अपने Program में Use किया जाता है, जिस तरह से किसी सामान्‍य Type Variable को Use किया जाता है। यानी किसी Nullable Type के मान को Read करने पर उसका मान Return होता है। लेकिन जब हम किसी Nullable Type Variable का मान Read करते हैं, तब ये जरूरी होता है कि Nullable Type किसी Valid मान से Initialized हो। यानी Nullable Type Variable में null न हो। क्योंकि यदि हम किसी ऐसे Nullable Variable की Value को Read करने की कोशिश करते हैं, जिसमें null हो, तो C# Compiler एक Exception Generate करता है।

किसी भी अन्‍य सामान्‍य Variable की तरह ही Nullable Variable की Value को Access करने के लिए भी हमें इसका नाम Specify करना होता है। जबकि Nullable Type Variable में कोई Valid Value है या नहीं, इस बात का पता लगाने के लिए हम Nullable Type Variable को या तो null के साथ Compare कर सकते हैं अथवा Nullable Type Variable की HasValue Property को Check कर सकते हैं। जैसे:

// File Name: NullableType.cs
using System;

namespace CSharpIntermediateConstructsNullable
{
    class NullableType
    {
        static void Main(string[] args)
        {
            int? myInt1 = 15;
            if (myInt1 != null)
                Console.WriteLine("Value of Nullable Type via != Comparision: {0}", myInt1);

            if (myInt1.HasValue)
                Console.WriteLine("Value of Nullable Type via HasValue Property: {0}", myInt1);
        }
    }
}

// Output:
   Value of Nullable Type via != Comparision: 15
   Value of Nullable Type via HasValue Property: 15

हम Nullable Types को भी किसी भी Non-Nullable Type में Convert कर सकते हैं। जब हम Nullable Type को Type Cast करते हैं, तब हमें मूल रूप से निम्नानुसार दो बातें ध्‍यान रखनी होती हैं:

• Non-Nullable Type व उसके Nullable Version के बीच जब Implicit Type Casting होती है, तब किसी Type Casting की जरूरत नहीं होती।
• Non-Nullable Type व उसके Nullable Version के बीच जब Implicit Type Casting नहीं होती, तब किसी न किसी Type Casting की जरूरत होती है।

उदाहरण के लिए निम्न Statement द्वारा हम दोनों ही Directions के Conversions को आसानी से समझ सकते हैं:

int? myInt1 = 15;                                      // Implicitly convert int to int?
int regInt = (int) myInt1;                       // Explicitly convert int? to int

इन Statements की पहली Line में int मान 15 एक Literal Value है जो Automatically int? Type में Convert हो जाता है। जबकि दूसरी Line में हमने Explicit Type Casting को Use करते हुए int? को int में Convert किया है।

Assign Nullable Types in C#

किसी भी Nullable Type को हम मूल रूप से तीन तरीकों से Assign कर सकते हैं:

• Nullable Type की Value से।
• समान Nullable Type के Value से।
• null Value से

जैसे:

int? myI1, myI2, myI3;
myI1 = 28;                                   // Value of underlying Type
myI2 = myI1;                              // Value of Nullable Type
myI3 = null;                                // null

The Null Coalescing Operator

Standard Arithmetic व Comparision Operators भी Nullable Types के साथ Normal तरीके से Processing कर सकते हैं। इनके अलावा Null Coalescing Operator नाम का एक Special Operator है, जो किसी Expression में उस स्थिति में एक Non-Null Value Return करता है, जब Nullable Type Variable में Null होता है।

इस Operator को दो Question Mark (??) Symbol द्वारा Represent किया जाता है। जहां पहला Operand Nullable Type का Variable होता है और दूसरा Operand Non-Nullable Type का Value होता है। यदि Run Time में First Operatnd null Evaluate करता है तो दूसरा Operand Expression के Result के रूप में Return हो जाता है। इसे हम निम्नानुसार तरीके से Use कर सकते हैं:

// File Name: NullCoalescingOperator.cs
using System;

namespace CSharpIntermediateConstructsNullable
{
    class NullCoalescingOperator
    {
        static void Main(string[] args)
        {
            int? myNullInt = null;
            Console.WriteLine("myNullInt: {0}", myNullInt ?? -1);

            myNullInt = 10;
            Console.WriteLine("myNullInt: {0}", myNullInt ?? -1);
        }
    }
}

// Output:
   myNullInt: -1
   myNullInt: 10

जैसाकि इस Program के Output द्वारा हम समझ सकते हैं कि जब myNullInt नाम के Nullable Type Variable में null होता है, तब निम्न Statement Execute होते समय ?? Operator के बाद Specified मान -1 Return होता है:

Console.WriteLine(“myNullInt: {0}”, myNullInt ?? -1);

लेकिन जब myNullInt को मान 10 Assign कर दिया जाता है, तब निम्न Statement Execute होते समय ?? Operator से पहले Specified myNullInt Variable का मान Return हो जाता है।

इसी तरह से जब हम दो समान Nullable Type Values को Compare करते हैं, जहां दोनों ही Nullable Type Variables में null होता है, तब दोनों Equality Operators == व != इन्हें समान ही मानते हैं। जैसे:

// File Name: NullableTypeEqualityOperators.cs
using System;

namespace CSharpIntermediateConstructsNullable
{
    class NullableTypeEqualityOperators
    {
        static void Main(string[] args)
        {
            int? i1 = null, i2 = null; 	// Both are null.
            if (i1 == i2) 		// Operator returns true.
                Console.WriteLine("Both Nullable Type Variables are Equal");
        }
    }
}

// Output:
	Both Nullable Type Variables are Equal

Nullable User Defined Types

Nullable Types को हम User Defined Type में भी उसी तरह से Use कर सकते हैं, जिस तरह से Predefined Types के साथ Use करते हैं। हम User Defined Types का भी Nullable Form Create कर सकते हैं, लेकिन जब हम User Defined Types का Nullable Form Create करते हैं, तब कुछ ऐसे Issues Generate होते हैं, जो कि Simple Types के साथ नहीं होते।

जो मुख्‍य Issue Generate होता है, वो यही है कि User Defined Types के Members को कैसे Access किया जाए। क्योंकि Nullable Type कभी भी उस Type के Members को Directly Expose नहीं करताए जिसका Nullable Type Variable या Object Create किया जा रहा होता है। जैसे:

// File Name: UserDefinedNullableType.cs
using System;

namespace CSharpIntermediateConstructsNullable
{
    struct MyStruct 	    		// Declare a struct.
    {
        public int X; 	        			// Field
        public int Y; 				// Field
        public MyStruct(int xVal, int yVal) 	// Constructor
        { X = xVal; Y = yVal; }
    }

    class UserDefinedNullableType
    {
        static void Main(string[] args)
        {
            MyStruct mSStruct = new MyStruct(6, 11); 	// Variable of struct
            MyStruct? mSNull = new MyStruct(5, 10); 	// Variable of nullable type

            Console.WriteLine("mSStruct.X: {0}", mSStruct.X);
            Console.WriteLine("mSStruct.Y: {0}", mSStruct.Y);
            Console.WriteLine("mSNull.X: {0}", mSNull.Value.X);
            Console.WriteLine("mSNull.Y: {0}", mSNull.Value.Y);
        }
    }
}

// Output:
   mSStruct.X: 6
   mSStruct.Y: 11
   mSNull.X: 5
   mSNull.Y: 10

इस Code में हमने MyStruct नाम का एक Structure Create किया है, जो कि एक User Defined Value Type होता है और इसमें दो Public Fields Declare किए हैं। चूंकि Structure के दोनों ही Fields Public हैं, इसलिए Structure के किसी भी Instance द्वारा Directly Accessible हैं, जैसाकि निम्न चित्र द्वारा समझा जा सकता है:

Structure का Nullable Version भी Structure के Members को Expose करता है, लेकिन Directly नहीं बल्कि Value Property के माध्‍यम से। हालांकि Structure के Members Public हैं, लेकिन फिर भी Nullable Type के लिए वे Public नहीं हैं, जिसे निम्न चित्र द्वारा समझा जा सकता है:

इसीलिए जब हम इस Program द्वारा Nullable User Defined Structure Type का Variable Create करते हैं, तो Program के निम्न दो Statements द्वारा तो Structure के Members Directly Accessible रहते हैं:

Console.WriteLine(“mSStruct.X: {0}”, mSStruct.X);
Console.WriteLine(“mSStruct.Y: {0}”, mSStruct.Y);

लेकिन अन्तिम दो Lines के Code द्वारा इन Members को निम्नानुसार Value Property का प्रयोग करते हुए Access किया जाता है:

Console.WriteLine(“mSNull.X: {0}”, mSNull.Value.X);
Console.WriteLine(“mSNull.Y: {0}”, mSNull.Value.Y);

क्योंकि Nullable User Defined Type के Data Members को Directly Access नहीं किया जा सकता।