C# Language
ऑपरेटर्स

परिचय

वाक्य - विन्यास

• सार्वजनिक स्थैतिक ऑपरैंडटेप ऑपरेटर ऑपरेटर ऑपरेटर
• सार्वजनिक स्थैतिक ऑपरैंडटेप ऑपरेटर ऑपरेटर ऑपरेटर (ऑपरेंडटेप ऑपरैंड 1, ऑपरेंड टाइप 2 ऑपरेंड 2)

पैरामीटर

टिप्पणियों

अधिभार संचालक

सी # उपयोगकर्ता-परिभाषित प्रकारों को operator कीवर्ड का उपयोग करके स्थिर सदस्य कार्यों को परिभाषित करके ऑपरेटरों को ओवरलोड करने की अनुमति देता है।
निम्न उदाहरण + ऑपरेटर के कार्यान्वयन को दिखाता है।

यदि हमारे पास एक Complex वर्ग है जो एक जटिल संख्या का प्रतिनिधित्व करता है:

public struct Complex
{
    public double Real { get; set; }
    public double Imaginary { get; set; }
}

और हम इस वर्ग के लिए + ऑपरेटर का उपयोग करने का विकल्प जोड़ना चाहते हैं। अर्थात:

Complex a = new Complex() { Real = 1, Imaginary = 2 };
Complex b = new Complex() { Real = 4, Imaginary = 8 };
Complex c = a + b;

हमें कक्षा के लिए + ऑपरेटर को ओवरलोड करना होगा। यह एक स्थिर फ़ंक्शन और operator कीवर्ड का उपयोग करके किया जाता है:

public static Complex operator +(Complex c1, Complex c2)
{
   return new Complex 
   { 
       Real = c1.Real + c2.Real,
       Imaginary = c1.Imaginary + c2.Imaginary 
   };
}

ऑपरेटर्स जैसे + , - , * , / सभी ओवरलोडेड हो सकते हैं। इसमें वे ऑपरेटर भी शामिल हैं जो उसी प्रकार नहीं लौटाते हैं (उदाहरण के लिए, == और != ओवरलोडेड हो सकते हैं, बूलियनों को वापस करने के बावजूद) जोड़े से संबंधित नीचे का नियम भी यहां लागू किया गया है।

तुलना ऑपरेटरों को जोड़े में अतिभारित होना पड़ता है (जैसे कि अगर < अतिभारित है, > भी अतिभारित होना चाहिए)।

अधिभार संचालकों (साथ ही गैर-अधिभार संचालकों और कुछ अधिभार संचालकों पर लगाए गए प्रतिबंधों) की एक पूरी सूची MSDN - अधिभार संचालकों (C # प्रोग्रामिंग गाइड) पर देखी जा सकती है।

public class Cartesian
{
    public int X { get; }
    public int Y { get; }
}   

public static class Polar
{
    public static bool operator is(Cartesian c, out double R, out double Theta)
    {
        R = Math.Sqrt(c.X*c.X + c.Y*c.Y);
        Theta = Math.Atan2(c.Y, c.X);
        return c.X != 0 || c.Y != 0;
    }
}

var c = Cartesian(3, 4);
if (c is Polar(var R, *))
{
    Console.WriteLine(R);
}

संबंधपरक संकारक

बराबर

जाँच करता है कि आपूर्ति किए गए ऑपरेंड (तर्क) बराबर हैं या नहीं

"a" == "b"     // Returns false.
"a" == "a"     // Returns true.
1 == 0         // Returns false.
1 == 1         // Returns true.
false == true  // Returns false.
false == false // Returns true.

जावा के विपरीत, समानता तुलना ऑपरेटर मूल रूप से तार के साथ काम करता है।

समानता तुलना ऑपरेटर अलग-अलग प्रकार के ऑपरेंड के साथ काम करेगा यदि एक अंतर्निहित कास्ट एक से दूसरे में मौजूद है। यदि कोई उपयुक्त निहित कास्ट मौजूद नहीं है, तो आप एक स्पष्ट कास्ट को कॉल कर सकते हैं या एक संगत प्रकार में बदलने के लिए एक विधि का उपयोग कर सकते हैं।

1 == 1.0              // Returns true because there is an implicit cast from int to double.
new Object() == 1.0   // Will not compile.
MyStruct.AsInt() == 1 // Calls AsInt() on MyStruct and compares the resulting int with 1.

Visual Basic.NET के विपरीत, समानता तुलना ऑपरेटर समानता असाइनमेंट ऑपरेटर के समान नहीं है।

var x = new Object();
var y = new Object();
x == y // Returns false, the operands (objects in this case) have different references.
x == x // Returns true, both operands have the same reference.

^{असाइनमेंट ऑपरेटर ( = ) के साथ भ्रमित होने की नहीं।}

मान प्रकार के लिए, यदि ऑपरेटर दोनों मान समान में समान हैं, तो ऑपरेटर true ।
संदर्भ प्रकारों के लिए, ऑपरेटर true यदि दोनों ऑपरेंड संदर्भ में समान होते हैं (मान नहीं)। एक अपवाद यह है कि स्ट्रिंग ऑब्जेक्ट्स की तुलना मूल्य समानता के साथ की जाएगी।

न के बराबर

जाँच करता है कि आपूर्ति किए गए ऑपरेटर समान नहीं हैं।

"a" != "b"     // Returns true.
"a" != "a"     // Returns false.
1 != 0         // Returns true.
1 != 1         // Returns false.
false != true  // Returns true.
false != false // Returns false.

var x = new Object();
var y = new Object();
x != y // Returns true, the operands have different references.
x != x // Returns false, both operands have the same reference.

यह ऑपरेटर बराबर ( == ) ऑपरेटर के विपरीत परिणाम देता है

से अधिक

जाँचता है कि क्या पहला ऑपरेंड दूसरे ऑपरेंड से अधिक है।

3 > 5    //Returns false.
1 > 0    //Returns true.
2 > 2    //Return false.

var x = 10;
var y = 15;
x > y    //Returns false.
y > x    //Returns true.

से कम

जाँच करता है कि क्या पहला ऑपरेंड दूसरे ऑपरेंड से कम है।

2 < 4     //Returns true.
1 < -3    //Returns false.
2 < 2     //Return false.

var x = 12;
var y = 22;
x < y    //Returns true.
y < x    //Returns false.

के बराबर है

जाँचता है कि क्या पहला ऑपरेंड दूसरे ऑपरेंड के बराबर है।

7 >= 8    //Returns false.
0 >= 0    //Returns true.

के बराबर कम

जाँचता है कि क्या पहला ऑपरेंड दूसरे ऑपरेंड के बराबर कम है।

2 <= 4    //Returns true.
1 <= -3    //Returns false.
1 <= 1     //Returns true. 

शॉर्ट-सर्कुलेटिंग ऑपरेटर्स

परिभाषा के अनुसार, शॉर्ट-सर्कुलेटिंग बूलियन ऑपरेटर केवल दूसरे ऑपरेंड का मूल्यांकन करेंगे यदि पहला ऑपरेंड अभिव्यक्ति के समग्र परिणाम को निर्धारित नहीं कर सकता है।

इसका मतलब है कि, अगर आप && ऑपरेटर firstCondition && secondCondition के रूप में यह secondCondition का मूल्यांकन करेंगे केवल जब firstCondition सच है और कुल परिणाम ofcource सच हो जाएगा केवल अगर firstOperand और secondOperand के दोनों सच करने के लिए मूल्यांकन किया जाता है का उपयोग कर रहे हैं। यह कई परिदृश्यों में उपयोगी है, उदाहरण के लिए कल्पना करें कि आप जांचना चाहते हैं जबकि आपकी सूची में तीन से अधिक तत्व हैं लेकिन आपको यह भी जांचना होगा कि सूची को NullReferenceException में नहीं चलाने के लिए आरंभीकृत किया गया है। आप इसे नीचे के रूप में प्राप्त कर सकते हैं:

bool hasMoreThanThreeElements = myList != null && mList.Count > 3;

mList.Count> 3 की जाँच तब तक नहीं की जाएगी जब तक myList! = null से मुलाकात न हो जाए।

तार्किक और

&& मानक बूलियन और ( & ) ऑपरेटर का शॉर्ट-सर्कुलेटिंग समकक्ष है।

var x = true;
var y = false;

x && x // Returns true.
x && y // Returns false (y is evaluated).
y && x // Returns false (x is not evaluated).
y && y // Returns false (right y is not evaluated).

तार्किक या

|| मानक बूलियन या ( | ) ऑपरेटर का शॉर्ट-सर्कुलेटिंग समकक्ष है।

var x = true;
var y = false;

x || x // Returns true (right x is not evaluated).
x || y // Returns true (y is not evaluated).
y || x // Returns true (x and y are evaluated).
y || y // Returns false (y and y are evaluated).

उदाहरण उपयोग

if(object != null && object.Property)
// object.Property is never accessed if object is null, because of the short circuit.
    Action1();
else
    Action2();

इस आकार का

बाइट्स में एक प्रकार ^* के आकार को पकड़े हुए एक int देता है।

sizeof(bool)    // Returns 1.
sizeof(byte)    // Returns 1.
sizeof(sbyte)   // Returns 1.
sizeof(char)    // Returns 2.
sizeof(short)   // Returns 2.
sizeof(ushort)  // Returns 2.
sizeof(int)     // Returns 4.
sizeof(uint)    // Returns 4.
sizeof(float)   // Returns 4.
sizeof(long)    // Returns 8.
sizeof(ulong)   // Returns 8.
sizeof(double)  // Returns 8.
sizeof(decimal) // Returns 16.

^{* केवल सुरक्षित संदर्भ में कुछ आदिम प्रकारों का समर्थन करता है।}

एक असुरक्षित संदर्भ में, sizeof अन्य आदिम प्रकार और structs के आकार वापस जाने के लिए इस्तेमाल किया जा सकता।

public struct CustomType
{
    public int value;
}

static void Main()
{
    unsafe
    {
        Console.WriteLine(sizeof(CustomType)); // outputs: 4
    }
}

ओवरलोडिंग समानता ऑपरेटरों

केवल समानता ऑपरेटरों को ओवरलोड करना पर्याप्त नहीं है। विभिन्न परिस्थितियों में, निम्नलिखित में से सभी को बुलाया जा सकता है:

1. object.Equals और object.GetHashCode
2. IEquatable<T>.Equals (वैकल्पिक, मुक्केबाजी से बचने की अनुमति देता है)
3. operator == और operator != (वैकल्पिक, ऑपरेटरों का उपयोग करने की अनुमति देता है)

Equals से आगे GetHashCode , GetHashCode को भी ओवरराइड करना होगा। Equals लागू करते समय, कई विशेष मामले हैं: एक अलग प्रकार की वस्तुओं की तुलना करना, स्वयं की तुलना करना आदि।

जब Equals नहीं है तो विधि और == ऑपरेटर कक्षाओं और संरचनाओं के लिए अलग तरह से व्यवहार करते हैं। कक्षाओं के लिए सिर्फ संदर्भों की तुलना की जाती है, और संरचना के लिए गुणों के मूल्यों की तुलना प्रतिबिंब के माध्यम से की जाती है जो प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकते हैं। == जब तक यह ओवरराइड नहीं किया जाता है तब तक तुलना करने के लिए इसका उपयोग नहीं किया जा सकता है।

आमतौर पर समानता ऑपरेशन को निम्नलिखित नियमों का पालन करना चाहिए:

• अपवाद नहीं फेंकने चाहिए।
• रिफ्लेक्सीविटी: A हमेशा के बराबर होती है A (के लिए सच नहीं हो सकता NULL कुछ सिस्टम में मान)।
• Transitvity: अगर A बराबर होती है B , और B के बराबर होती है C है, तो A के बराबर होती है C ।
• यदि A , B बराबर है, तो A और B पास समान हैश कोड हैं।
• विरासत पेड़ स्वतंत्रता: अगर B और C के उदाहरण हैं Class2 से विरासत में मिली Class1 : Class1.Equals(A,B) हमेशा के लिए कॉल के रूप में ही मान लौटाना चाहिए Class2.Equals(A,B) ।

class Student : IEquatable<Student>
{
    public string Name { get; set; } = "";

    public bool Equals(Student other)
    {
        if (ReferenceEquals(other, null)) return false;
        if (ReferenceEquals(other, this)) return true;
        return string.Equals(Name, other.Name);
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;

        return Equals(obj as Student);
    }

    public override int GetHashCode()
    {
        return Name?.GetHashCode() ?? 0;
    }

    public static bool operator ==(Student left, Student right)
    {
        return Equals(left, right);
    }

    public static bool operator !=(Student left, Student right)
    {
        return !Equals(left, right);
    }
}

क्लास मेंबर ऑपरेटर्स: मेंबर एक्सेस

var now = DateTime.UtcNow;
//accesses member of a class.  In this case the UtcNow property.

क्लास मेंबर ऑपरेटर्स: नल कंडिशनल मेंबर एक्सेस

var zipcode = myEmployee?.Address?.ZipCode;
//returns null if the left operand is null.  
//the above is the equivalent of:
var zipcode = (string)null;
if (myEmployee != null && myEmployee.Address != null)
    zipcode = myEmployee.Address.ZipCode;

क्लास मेंबर ऑपरेटर्स: फंक्शन इनवोकेशन

var age = GetAge(dateOfBirth);
//the above calls the function GetAge passing parameter dateOfBirth.

क्लास मेंबर ऑपरेटर्स: एग्रीगेट ऑब्जेक्ट इंडेक्सिंग

var letters = "letters".ToCharArray();
char letter = letters[1];
Console.WriteLine("Second Letter is {0}",letter);
//in the above example we take the second character from the array
//by calling letters[1]
//NB: Array Indexing starts at 0; i.e. the first letter would be given by letters[0].

कक्षा सदस्य संचालक: अशक्त सशर्त अनुक्रमण

var letters = null;
char? letter = letters?[1];
Console.WriteLine("Second Letter is {0}",letter);
//in the above example  rather than throwing an error because letters is null
//letter is assigned the value null

"एक्सक्लूसिव या" ऑपरेटर

"एक्सक्लूसिव या" (शॉर्ट XOR के लिए) ऑपरेटर है: ^

यह ऑपरेटर सही होने पर वापस लौटता है, लेकिन आपूर्ति किए गए बूलों में से केवल एक ही सही है।

true ^ false   // Returns true
false ^ true   // Returns true
false ^ false  // Returns false
true ^ true    // Returns false

बिट-शिफ्टिंग ऑपरेटर

शिफ्ट ऑपरेटर प्रोग्रामर को इसके सभी बिट्स को बाईं या दाईं ओर शिफ्ट करके एक पूर्णांक समायोजित करने की अनुमति देते हैं। निम्न आरेख मूल्य को बाईं ओर एक अंक में स्थानांतरित करने के प्रभाव को दर्शाता है।

बायां शिफ्ट

uint value = 15;              // 00001111
 
uint doubled = value << 1;    // Result = 00011110 = 30
uint shiftFour = value << 4;  // Result = 11110000 = 240

सही बदलाव

uint value = 240;             // 11110000
 
uint halved = value >> 1;     // Result = 01111000 = 120
uint shiftFour = value >> 4;  // Result = 00001111 = 15

इंप्लिक्ट कास्ट और एक्सप्लोसिव कास्ट ऑपरेटर्स

सी # explicit और implicit कीवर्ड के उपयोग के माध्यम से असाइनमेंट और कास्टिंग को नियंत्रित करने के लिए उपयोगकर्ता-परिभाषित प्रकारों की अनुमति देता है। विधि का हस्ताक्षर फॉर्म लेता है:

public static <implicit/explicit> operator <ResultingType>(<SourceType> myType)

विधि कोई और तर्क नहीं दे सकती है, न ही यह एक उदाहरण विधि हो सकती है। हालाँकि, यह किसी भी प्रकार के निजी सदस्यों को एक्सेस कर सकता है।

एक implicit और explicit दोनों कलाकारों का एक उदाहरण:

public class BinaryImage 
{
    private bool[] _pixels;

    public static implicit operator ColorImage(BinaryImage im)
    {
        return new ColorImage(im);
    }

    public static explicit operator bool[](BinaryImage im)
    {
        return im._pixels;
    }
}

निम्नलिखित कलाकार वाक्य रचना की अनुमति:

var binaryImage = new BinaryImage();
ColorImage colorImage = binaryImage; // implicit cast, note the lack of type 
bool[] pixels = (bool[])binaryImage; // explicit cast, defining the type

कास्ट ऑपरेटर दोनों प्रकार से काम कर सकते हैं, आपके प्रकार से जा रहे हैं और आपके प्रकार पर जा रहे हैं :

public class BinaryImage
{
    public static explicit operator ColorImage(BinaryImage im)
    {
        return new ColorImage(im);
    }

    public static explicit operator BinaryImage(ColorImage cm)
    {
        return new BinaryImage(cm);
    }
}

अंत में, as कीवर्ड है, जो एक प्रकार पदानुक्रम के भीतर कास्टिंग में शामिल किया जा सकता है, इस स्थिति में मान्य नहीं है। explicit या implicit कलाकारों को परिभाषित करने के बाद भी, आप ऐसा नहीं कर सकते:

ColorImage cm = myBinaryImage as ColorImage;

यह एक संकलन त्रुटि उत्पन्न करेगा।

असाइनमेंट के साथ बाइनरी ऑपरेटर्स

C # में कई ऑपरेटर होते हैं जिन्हें ऑपरेटर के परिणाम का मूल्यांकन करने के लिए एक = चिन्ह के साथ जोड़ा जा सकता है और फिर परिणाम को मूल चर पर नियत किया जाता है।

उदाहरण:

x += y

के समान है

x = x + y

असाइनमेंट ऑपरेटर:

• +=
• -=
• *=
• /=
• %=
• &=
• |=
• ^=
• <<=
• >>=

? : टर्नरी ऑपरेटर

बूलियन अभिव्यक्ति के मूल्य के आधार पर दो में से एक मान लौटाता है।

वाक्य - विन्यास:

condition ? expression_if_true : expression_if_false;

उदाहरण:

string name = "Frank";
Console.WriteLine(name == "Frank" ? "The name is Frank" : "The name is not Frank");

टर्नरी संचालक दायां-सहयोगी है जो यौगिक टर्नरी अभिव्यक्तियों का उपयोग करने की अनुमति देता है। यह एक पैरेंट टर्नरी समीकरण के सही या गलत स्थिति में अतिरिक्त टर्नरी समीकरणों को जोड़कर किया जाता है। पठनीयता सुनिश्चित करने के लिए देखभाल की जानी चाहिए, लेकिन यह कुछ परिस्थितियों में उपयोगी शॉर्टहैंड हो सकता है।

इस उदाहरण में, एक यौगिक टर्नरी ऑपरेशन एक clamp फ़ंक्शन का मूल्यांकन करता है और वर्तमान मान लौटाता है यदि यह सीमा के भीतर है, min मान यदि यह सीमा से नीचे है, या max मान यदि यह सीमा से ऊपर है।

light.intensity = Clamp(light.intensity, minLight, maxLight);

public static float Clamp(float val, float min, float max)
{
    return (val < min) ? min : (val > max) ? max : val;
}

टर्नरी ऑपरेटरों को भी नेस्टेड किया जा सकता है, जैसे:

a ? b ? "a is true, b is true" : "a is true, b is false" : "a is false"

// This is evaluated from left to right and can be more easily seen with parenthesis:

a ? (b ? x : y) : z

// Where the result is x if a && b, y if a && !b, and z if !a

यौगिक टर्नरी स्टेटमेंट लिखते समय, पठनीयता में सुधार के लिए कोष्ठक या इंडेंटेशन का उपयोग करना आम है।

अभिव्यक्ति_if_true और अभिव्यक्ति_ if_false के प्रकार समान होने चाहिए या एक से दूसरे में अंतर्निहित रूपांतरण होना चाहिए।

condition ? 3 : "Not three"; // Doesn't compile because `int` and `string` lack an implicit conversion.

condition ? 3.ToString() : "Not three"; // OK because both possible outputs are strings.

condition ? 3 : 3.5; // OK because there is an implicit conversion from `int` to `double`. The ternary operator will return a `double`.

condition ? 3.5 : 3; // OK because there is an implicit conversion from `int` to `double`. The ternary operator will return a `double`.

प्रकार और रूपांतरण आवश्यकताएँ आपकी अपनी कक्षाओं में भी लागू होती हैं।

public class Car
{}

public class SportsCar : Car
{}

public class SUV : Car
{}

condition ? new SportsCar() : new Car(); // OK because there is an implicit conversion from `SportsCar` to `Car`. The ternary operator will return a reference of type `Car`.

condition ? new Car() : new SportsCar(); // OK because there is an implicit conversion from `SportsCar` to `Car`. The ternary operator will return a reference of type `Car`.

condition ? new SportsCar() : new SUV(); // Doesn't compile because there is no implicit conversion from `SportsCar` to SUV or `SUV` to `SportsCar`. The compiler is not smart enough to realize that both of them have an implicit conversion to `Car`.

condition ? new SportsCar() as Car : new SUV() as Car; // OK because both expressions evaluate to a reference of type `Car`. The ternary operator will return a reference of type `Car`.

प्रकार का

एक प्रकार के लिए System.Type ऑब्जेक्ट हो जाता है।

System.Type type = typeof(Point)        //System.Drawing.Point      
System.Type type = typeof(IDisposable)  //System.IDisposable
System.Type type = typeof(Colors)       //System.Drawing.Color
System.Type type = typeof(List<>)       //System.Collections.Generic.List`1[T]

रन-टाइम प्रकार प्राप्त करने के लिए, System.Type को प्राप्त करने के लिए GetType विधि का उपयोग करें।

ऑपरेटर typeof पैरामीटर के रूप में एक प्रकार का नाम लेता है, जिसे संकलन समय पर निर्दिष्ट किया जाता है।

public class Animal {} 
public class Dog : Animal {}

var animal = new Dog();

Assert.IsTrue(animal.GetType() == typeof(Animal)); // fail, animal is typeof(Dog) 
Assert.IsTrue(animal.GetType() == typeof(Dog));    // pass, animal is typeof(Dog)
Assert.IsTrue(animal is Animal);                   // pass, animal implements Animal

डिफ़ॉल्ट ऑपरेटर

मान प्रकार (जहाँ T: संरचना)

अंतर्निहित आदिम डेटा प्रकार, जैसे कि char , int , और float , साथ ही उपयोगकर्ता-परिभाषित प्रकार जो struct , या enum साथ घोषित किए गए हैं। उनका डिफ़ॉल्ट मान new T() :

default(int)            // 0
default(DateTime)       // 0001-01-01 12:00:00 AM
default(char)           // '\0' This is the "null character", not a zero or a line break.
default(Guid)           // 00000000-0000-0000-0000-000000000000
default(MyStruct)       // new MyStruct()

// Note: default of an enum is 0, and not the first *key* in that enum
// so it could potentially fail the Enum.IsDefined test
default(MyEnum)         // (MyEnum)0

संदर्भ प्रकार (जहां टी: वर्ग)

किसी भी class , interface , सरणी या प्रतिनिधि प्रकार। उनका डिफ़ॉल्ट मान null :

default(object)         // null
default(string)         // null
default(MyClass)        // null
default(IDisposable)    // null
default(dynamic)        // null

nameof ऑपरेटर

एक स्ट्रिंग लौटाता है जो एक variable , type , या member के अयोग्य नाम का प्रतिनिधित्व करता है।

int counter = 10;
nameof(counter); // Returns "counter"
Client client = new Client();
nameof(client.Address.PostalCode)); // Returns "PostalCode"

nameof ऑपरेटर को सी # 6.0 में पेश किया गया था। इसका संकलन-समय पर मूल्यांकन किया जाता है और संकलक द्वारा लौटाए गए स्ट्रिंग मान को इनलाइन में सम्मिलित किया जाता है, इसलिए इसका उपयोग ज्यादातर मामलों में किया जा सकता है जहां निरंतर स्ट्रिंग का उपयोग किया जा सकता है (उदाहरण के लिए, switch स्टेटमेंट, विशेषताओं आदि में case लेबल)। ।)। यह अपवादों, विशेषताओं, MVC एक्शन लिंक आदि को बढ़ाने और लॉग करने जैसे मामलों में उपयोगी हो सकता है ...

?। (नल संचालक ऑपरेटर)

var bar = Foo.GetBar()?.Value; // will return null if GetBar() returns null
var baz = Foo.GetBar()?.IntegerValue; // baz will be of type Nullable<int>, i.e. int?

event EventHandler<string> RaiseMe;
RaiseMe?.Invoke("Event raised");

उपसर्ग और उपसर्ग वृद्धि और क्षय

पोस्टफ़िक्स इंक्रीमेंट X++ 1 से x जोड़ देगा

var x = 42;
x++;
Console.WriteLine(x); // 43

X-- घटाव X-- एक X--

var x = 42
x--; 
Console.WriteLine(x); // 41

++x को उपसर्ग वृद्धि कहा जाता है यह x का मान बढ़ाता है और फिर x लौटाता है जबकि x++ का मान लौटाता है और फिर वेतन वृद्धि करता है

var x = 42;
Console.WriteLine(++x); // 43
System.out.println(x); // 43

जबकि

var x = 42;
Console.WriteLine(x++); // 42
System.out.println(x); // 43

दोनों आमतौर पर लूप के लिए उपयोग किए जाते हैं

for(int i = 0; i < 10; i++)
{
}

=> लाम्बा संचालक

string[] words = { "cherry", "apple", "blueberry" };

int shortestWordLength = words.Min((string w) => w.Length); //5

int shortestWordLength = words.Min(w => w.Length); //also compiles with the same result

(input parameters) => expression

// expression
(int x, string s) => s.Length > x

// expression
(int x, int y) => x + y

// statement
(string x) => Console.WriteLine(x)

// block
(string x) => {
        x += " says Hello!";
        Console.WriteLine(x);
    }

delegate void TestDelegate(string s);

TestDelegate myDelegate = s => Console.WriteLine(s + " World");

myDelegate("Hello");

void MyMethod(string s)
{
    Console.WriteLine(s + " World");
}

delegate void TestDelegate(string s);

TestDelegate myDelegate = MyMethod;

myDelegate("Hello");

असाइनमेंट ऑपरेटर '='

असाइनमेंट ऑपरेटर = दाएं हाथ के ऑपरेंड के मूल्य के लिए बाएं हाथ के ऑपरेंड के मूल्य को सेट करता है, और उस मूल्य को वापस करता है:

int a = 3;     // assigns value 3 to variable a
int b = a = 5; // first assigns value 5 to variable a, then does the same for variable b
Console.WriteLine(a = 3 + 4); // prints 7

?? नल-संचालक संचालक

अशक्त-संचालक संचालक ?? बायाँ हाथ नहीं होने पर वापस लौटेगा। यदि यह अशक्त है, तो यह दाईं ओर लौटेगा।

object foo = null;
object bar = new object();

var c = foo ?? bar;
//c will be bar since foo was null

?? ऑपरेटर श्रृंखलित जा सकती है, जिनमें से हटाने की अनुमति देता है if जाँच करता है।

//config will be the first non-null returned.
var config = RetrieveConfigOnMachine() ??
             RetrieveConfigFromService() ??
             new DefaultConfiguration();