C# Operators

C# Operators: C/C++ व Java Programming Language की तरह ही C# में भी Mathematical व Logical Calculations Perform करने के लिए कुछ Special Symbols को Define किया गया है। इन Special Symbols या शब्दों को Operators कहते हैं, जबकि ये Operators जिन Elements के साथ प्रक्रिया करके Result Generate करते हैं, उन Elements को इन Operators का Operand कहते हैं। Operators दो तरह के होते हैं:

C# Operators – Unary

जिस Operator को अपना Operation Perform करने के लिए सिर्फ एक Operand की जरूरत होती है, उसे Unary Operator कहते हैं।

उदाहरण के लिए Minus ( – ) एक Unary Operator है। जिसे किसी भी संख्‍या के Prefix की तरह Attach कर देने पर] उस संख्‍या का मान बदल कर Negative हो जाता है। जैसे 6 के साथ – Symbol को Prefix की तरह Specify कर देने से संख्‍या -6 हो जाता है। C# में मूल रूप से निम्नानुसार Unary Operators होते हैं:

इनके अलावा कुछ और Unary Operators भी होते हैं, जिन्हें सामान्‍यत: Special Operators के रूप में जाना जाता है।

C# Operators – Binary

जिन Operators को अपना Operation Perform करने के लिए दो Operands की जरूरत होती है, उन्हें Binary Operators कहते हैं।

उदाहरण के लिए 2 + 3 को जोडने के लिए दो Operands की जरूरत होती है, अत: Plus एक Binary Operator भी है।

C# में भी C/C++ व Java की तरह विभिन्न प्रकार के Operations को Perform करने के लिए Arithmetical, Relational, Ternary or Conditional, Logical, Increment and Decrement, आदि विभिन्न प्रकार के Operators को Define किया गया है।

चूंकि Operators कभी भी अपने स्तर पर कुछ उपयोगी काम नहीं कर सकते, इसलिए इन्हें हमेंशा किसी अन्‍य Programming Construct के साथ Use करते हुए ही उपयोगी Programs Develop किया जाता है।

Arithmetical Operators

C# में भी C/C++ व Java की तरह पांच Arithmetical Operators होते हैं, जिनका प्रयोग Arithmetical Operations को Perform करने के लिए किया जाता है। इन पांचों Arithmetical Operators को हम निम्नानुसार तरीके से Use कर सकते हैं:

// File Name: ArithmeticalOperators.cs
using System;

namespace CSharpFundamentals
{
    class ArithmeticalOperators
    {
        private static void Main(string[] args)
        {
            double value1, value2;

            Console.Write("Enter First Value: ");
            value1 = Convert.ToDouble(Console.ReadLine());

            Console.Write("Enter Second Value: ");
            value2 = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine();

            Console.WriteLine("Addition: {0} + {1} = {2}", value1, value2, value1 + value2);
            Console.WriteLine("Subtraction: {0} - {1} = {2}", value1, value2, value1 - value2);
            Console.WriteLine("Multiplication: {0} * {1} = {2}", value1, value2, value1 * value2);
            Console.WriteLine("Division: {0} / {1} = {2}", value1, value2, value1 / value2);
            Console.WriteLine("Reminder: {0} % {1} = {2}", value1, value2, value1 % value2);
        }
    }
}

// Output:
   Enter First Value: 10.5
   Enter Second Value: 3.0

   Addition: 10.5 + 3 = 13.5
   Subtraction: 10.5 - 3 = 7.5
   Multiplication: 10.5 * 3 = 31.5
   Division: 10.5 / 3 = 3.5
   Reminder: 10.5 % 3 = 1.5

इस Program में हमने value1 व value2 नाम के दो double Type के Variables Declare किए हैं और Keyboard से Value Read करके उनमें Store किया है।

चूंकि हम ReadLine() Method का प्रयोग करके Keyboard से जो भी Value Read करते हैं, वह Value वास्तव में एक String के रूप में ही Retrieve होता है। इसलिए Keyboard से आने वाली Value को double Type के Variables value1 व value2 में Directly Store नहीं किया जा सकता और यदि हम ऐसा करते हैं, तो इससे Type Mismatch की समस्या पैदा होती है।

अत: Keyboard से आने वाली String Formatted Numerical Values को double Type के Variables value1 व value2 में Store करने से पहले हमें इन्हें double Type के Data में Convert करना जरूरी होता है।

इस प्रकार का Conversion करने के लिए .NET Framework हमें System.Convert नाम की Class Provide करता है, जिसमें विभिन्न प्रकार के Data Type के Data को किसी दूसरे Appropriate Type में Convert करने के लिए विभिन्न Methods Define किए गए हैं।

चूंकि हमें Keyboard से आने वाली एक String Formatted Numerical Value को double Type के Data के रूप में Convert करना है, इसलिए हमने Convert.ToDouble() Method को Use किया है और Console.ReadLine() Method को इस Conversion Method के बीच Enclose किया है, ताकि Keyboard से आने वाला String Formatted Data, एक double Type के Data में Convert होने के बाद value1 व value2 Variable में Store हों।

Input लेने के बाद हमने Addition, Subtraction, Multiplication व Division Operators को Use करते हुए Keyboard से आने वाली Values पर Arithmetical Operations Perform किए हैं, जिसके बारे में विस्तार से Discuss करने की जरूरत नहीं है।

लेकिन Reminder या Modules Operator एक Special Operator है, जो कि C/C++ Programming Language के Reminder Operator की तुलना में थोडा अलग तरीके से व्‍यवहार करते हुए वास्तव में Java के Reminder Operator की तरह व्‍यवहार करता है।

ये Operator केवल Integer संख्‍या का ही Reminder Return नहीं करताए बल्कि यदि Reminder एक दसमलव वाली संख्‍या हो, तब भी ये Operator Normal तरीके से काम करते हुए दसमलव युक्त Reminder Return करने की क्षमता रखता है, जबकि C/C++ में हम किसी दसमलव वाली संख्‍या के साथ Reminder Operator का प्रयोग नहीं कर सकते।

Relational Operators

C/C++ व Java की तरह ही C# में भी जब किसी Program में दो Values का आपस में Comparision करते हुए किसी Operation को Perform करना होता है, तब Relational Operators का प्रयोग किया जाता है। किसी Expression में इनका प्रयोग करने पर यदि Expression में Specified Statement सत्; होता है, तो प्रोग्राम true Return करता है जबकि Statement के असत्; होने की स्थिति में false Return होता है। C# Supported विभिन्न Relational Operators निम्नानुसार हैं:

Relational Operators का प्रयोग सामान्‍यत: Conditional, Branching या Looping Statements में किया जाता है। सभी Relational Operators, Binary Operators होते हैं, इसलिए इनके Left व Right दोनों Sides में कोई न कोई Operand होना जरूरी होता है, जिस पर Operate करके ये Operator bool Type का true या false मान Return करता है।

इस Operator के Left व Right Side के मानों के आधार पर Perform होने वाले Operation व Return होने वाले Boolean मान को हम निम्नानुसार Program द्वारा आसानी से समझ सकते हैं:

// File Name: RelationalOperators.cs
using System;

namespace CSharpFundamentals
{
    class RelationalOperators
    {
        private static void Main(string[] args)
        {
            Console.WriteLine("Less Then ( < ) Relational Operator");
            Console.WriteLine("10 < 10 : {0}", 10 < 10);
            Console.WriteLine("10 < 20 : {0}", 10 < 20);
            Console.WriteLine("20 < 10 : {0}\n", 20 < 10);

            Console.WriteLine("Greater Then ( > ) Relational Operator");
            Console.WriteLine("10 > 10 : {0}", 10 > 10);
            Console.WriteLine("10 > 20 : {0}", 10 > 20);
            Console.WriteLine("20 > 10 : {0}\n", 20 > 10);

            Console.WriteLine("Less Then or Equal To ( <= ) Relational Operator");
            Console.WriteLine("10 <= 10 : {0}", 10 <= 10);
            Console.WriteLine("10 <= 20 : {0}", 10 <= 20);
            Console.WriteLine("20 <= 10 : {0}\n", 20 <= 10);

            Console.WriteLine("Greater Then or Equal To( >= ) Relational Operator");
            Console.WriteLine("10 >= 10 : {0}", 10 >= 10);
            Console.WriteLine("10 >= 20 : {0}", 10 >= 20);
            Console.WriteLine("20 >= 10 : {0}\n", 20 >= 10);

            Console.WriteLine("Equal To( == ) Relational Operator");
            Console.WriteLine("10 == 10 : {0}", 10 == 10);
            Console.WriteLine("10 == 20 : {0}", 10 == 20);
            Console.WriteLine("20 == 10 : {0}\n", 20 == 10);

            Console.WriteLine("Not Equal To( != ) Relational Operator");
            Console.WriteLine("10 != 10 : {0}", 10 != 10);
            Console.WriteLine("10 != 20 : {0}", 10 != 20);
            Console.WriteLine("20 != 10 : {0}\n", 20 != 10);
        }
    }
}

Output:

Less Then ( < ) Relational Operator

10 < 10 : False
10 < 20 : True
20 < 10 : False

Greater Then ( > ) Relational Operator

10 > 10 : False
10 > 20 : False
20 > 10 : True

Less Then or Equal To ( <= ) Relational Operator

10 <= 10 : True
10 <= 20 : True
20 <= 10 : False

Greater Then or Equal To( >= ) Relational Operator

10 >= 10 : True
10 >= 20 : False
20 >= 10 : True

Equal To( == ) Relational Operator

10 == 10 : True
10 == 20 : False
20 == 10 : False

Not Equal To( != ) Relational Operator

10 != 10 : False
10 != 20 : True
20 != 10 : True

इस Program के Output को देखकर हम आसानी से समझ सकते हैं कि कौनसा Relational Operator अपने Left व Right Side के मानों के आधार पर किस प्रकार का Boolean मान Return करता है।

Increment and Decrement Operators

जब हमे किसी Variable में क्रम से एक जोडना या घटाना हो, तो हम Increment ( ++ ) या Decrement ( – – ) Operators का प्रयोग करते हैं। Variable के साथ इनकी दिशा (Prefix or Postfix) बदल देने से इनके स्वभाव में परिवर्तन आ जाता है। इनका प्रयोग सामान्‍यत: Looping Statements में किया जाता है, जहां क्रम से किसी Calculation को तब तक करते रहना होता है, जब तक कि Condition असत्; ना हो जाए। इस Operator को निम्नानुसार Represent किया जा सकता है:

sum = 10
++sum = 11                   1 + 10 = 11
sum++ =11                    10 + 1 = 11
–sum = 9                       -1 + 10 = 9
sum– = 9                       10 – 1 = 9