यूनिटी सी# ऑपरेटर्स को अवश्य जानना चाहिए

Unity एक गेम इंजन है जो कार्यक्षमता के मामले में डेवलपर्स के लिए बहुत कुछ करता है और उन्हें पूरी तरह से विकास प्रक्रिया पर ध्यान केंद्रित करने देता है। यह मुख्य प्रोग्रामिंग भाषा के रूप में C# का उपयोग करता है।

किसी भी प्रोग्रामिंग भाषा की तरह, C# में विशेष कार्यों, प्रकारों, कक्षाओं, पुस्तकालयों आदि की एक श्रृंखला होती है, लेकिन इसमें विशेष प्रतीकों (ऑपरेटरों) की एक सूची भी होती है, जिनमें से प्रत्येक का अपना कार्य होता है। इस पोस्ट में, मैं उन प्रतीकों को सूचीबद्ध करूंगा और समझाऊंगा कि वे क्या करते हैं, ताकि अगली बार जब आप कोई स्क्रिप्ट खोलें, तो आप जल्दी से समझ सकें कि प्रत्येक भाग का क्या अर्थ है।

C# में ऑपरेटर्स कुछ विशेष प्रतीक होते हैं जो ऑपरेंड पर कुछ क्रियाएं करते हैं।

C# में, 6 प्रकार के अंतर्निहित ऑपरेटर हैं: अंकगणित ऑपरेटर, तुलना ऑपरेटर, बूलियन लॉजिकल ऑपरेटर, बिटवाइज़ और शिफ्ट ऑपरेटर, समानता ऑपरेटर और विविध ऑपरेटर। उन सभी को जानने से आप तुरंत एक बेहतर प्रोग्रामर बन जायेंगे।

1. अंकगणितीय आपरेटर

निम्नलिखित ऑपरेटर संख्यात्मक प्रकार के ऑपरेंड के साथ अंकगणितीय संचालन करते हैं:

• यूनरी ++ (वृद्धि), - (कमी), + (प्लस), और - (माइनस) ऑपरेटर
• बाइनरी * (गुणा), / (विभाजन), % (शेष), + (जोड़), और - (घटाव) ऑपरेटर

इंक्रीमेंट ऑपरेटर++

"add one" ऑपरेटर (या ++) का अर्थ += 1 है, दूसरे शब्दों में, यह अतिरिक्त कोड टाइप किए बिना, एक संख्यात्मक मान में एक पूर्णांक जोड़ने का एक त्वरित तरीका है। इस ऑपरेटर को या तो मूल्य से पहले या मूल्य के बाद जोड़ा जा सकता है, जिसके परिणामस्वरूप एक अलग व्यवहार होगा:

//The result of x++ is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i++); // output: 4
Debug.Log(i);   // output: 5

//The result of ++x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(++a); // output: 3.5
Debug.Log(a);   // output: 3.5

डिक्रीमेंट ऑपरेटर--

"subtract one" ऑपरेटर ++ (-= 1) के विपरीत है, जिसका अर्थ है कि यह एक संख्यात्मक मान से एक पूर्णांक घटाता है। इसे किसी मान से पहले या बाद में भी जोड़ा जा सकता है:

The result of x-- is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i--); // output: 4
Debug.Log(i);   // output: 3

The result of --x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(--a); // output: 1.5
Debug.Log(a);   // output: 1.5

यूनरी + और - ऑपरेटर

यूनरी + ऑपरेटर अपने ऑपरेंड का मान लौटाता है और यूनरी-ऑपरेटर अपने ऑपरेंड के संख्यात्मक निषेध की गणना करता है।

Debug.Log(+5);     // output: 5

Debug.Log(-5);     // output: -5
Debug.Log(-(-5));  // output: 5

uint a = 6;
var b = -a;
Debug.Log(b);            // output: -6
Debug.Log(b.GetType());  // output: System.Int64

Debug.Log(-double.NaN);  // output: NaN

गुणन संचालिका *

गुणन ऑपरेटर * अपने ऑपरेंड के गुणित उत्पाद की गणना करता है:

Debug.Log(6 * 3);         // output: 18
Debug.Log(1.5 * 3.5);     // output: 5.25
Debug.Log(0.1m * 24.4m);  // output: 2.44

डिवीजन ऑपरेटर /

डिवीजन ऑपरेटर / अपने बाएं हाथ के ऑपरेंड को उसके दाएं हाथ के ऑपरेंड से विभाजित करता है।

यदि एक ऑपरेंड दशमलव है, तो दूसरा ऑपरेंड न तो फ्लोट और न ही डबल हो सकता है, क्योंकि न तो फ्लोट और न ही डबल दशमलव में स्पष्ट रूप से परिवर्तनीय है। आपको फ़्लोट या डबल ऑपरेंड को स्पष्ट रूप से दशमलव प्रकार में परिवर्तित करना होगा।

Debug.Log(13 / 5);    // output: 2
Debug.Log(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Debug.Log((double)a / b);  // output: 2.6

Debug.Log(16.8f / 4.1f);   // output: 4.097561
Debug.Log(16.8d / 4.1d);   // output: 4.09756097560976
Debug.Log(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

शेष ऑपरेटर %

शेषफल ऑपरेटर % अपने बाएं हाथ के ऑपरेंड को उसके दाएं हाथ के ऑपरेंड से विभाजित करने के बाद शेष की गणना करता है।

• पूर्णांक प्रकार के ऑपरेंड के लिए, a % b का परिणाम a - (a / b) * b द्वारा निर्मित मान है

Debug.Log(5 % 4);   // output: 1
Debug.Log(5 % -4);  // output: 1
Debug.Log(-5 % 4);  // output: -1
Debug.Log(-5 % -4); // output: -1

• दशमलव ऑपरेंड के लिए, शेष ऑपरेटर % System.Decimal प्रकार के शेष ऑपरेटर के बराबर है।

Debug.Log(-5.2f % 2.0f); // output: -1.2
Debug.Log(5.9 % 3.1);    // output: 2.8
Debug.Log(5.9m % 3.1m);  // output: 2.8

अतिरिक्त ऑपरेटर +

अतिरिक्त ऑपरेटर + अपने ऑपरेंड के योग की गणना करता है। आप स्ट्रिंग संयोजन और प्रतिनिधि संयोजन के लिए + ऑपरेटर का भी उपयोग कर सकते हैं।

Debug.Log(6 + 5);       // output: 11
Debug.Log(6 + 5.3);     // output: 11.3
Debug.Log(6.1m + 5.2m); // output: 11.3

घटाव ऑपरेटर -

घटाव ऑपरेटर - अपने दाएं हाथ के ऑपरेंड को उसके बाएं हाथ के ऑपरेंड से घटाता है। आप प्रतिनिधि को हटाने के लिए - ऑपरेटर का भी उपयोग कर सकते हैं।

Debug.Log(48 - 4);      // output: 44
Debug.Log(6 - 5.3);     // output: 0.7
Debug.Log(8.5m - 3.3m); // output: 5.2

2. तुलना संचालक

< (less than), > (greater than), <= (less than or equal), and >= (इससे अधिक या बराबर) तुलना, जिसे रिलेशनल के रूप में भी जाना जाता है, ऑपरेटर अपने ऑपरेंड की तुलना करते हैं। वे ऑपरेटर सभी इंटीग्रल और फ़्लोटिंग-पॉइंट संख्यात्मक प्रकारों द्वारा समर्थित हैं।

ऑपरेटर से कम <

यदि < ऑपरेटर का बायाँ हाथ का ऑपरेंड उसके दाएँ हाथ के ऑपरेंड से कम है तो यह सत्य लौटाता है, अन्यथा गलत लौटाता है।

Debug.Log(8.0 < 6.1);   // output: False
Debug.Log(6.1 < 6.1);   // output: False
Debug.Log(1.0 < 6.1);   // output: True

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

ऑपरेटर से बड़ा >

यदि > ऑपरेटर का बाएँ हाथ का ऑपरेंड उसके दाएँ हाथ के ऑपरेंड से बड़ा है, तो सत्य लौटाता है, अन्यथा गलत लौटाता है।

Debug.Log(8.0 > 6.1);   // output: True
Debug.Log(6.1 > 6.1);   // output: False
Debug.Log(1.0 > 6.1);   // output: False

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

इससे कम या बराबर ऑपरेटर <=

<= ऑपरेटर सत्य लौटाता है यदि उसका बायां हाथ का ऑपरेंड उसके दाएं हाथ के ऑपरेंड से कम या उसके बराबर है, अन्यथा गलत है।

Debug.Log(8.0 <= 6.1);   // output: False
Debug.Log(6.1 <= 6.1);   // output: True
Debug.Log(1.0 <= 6.1);   // output: True

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

इससे बड़ा या बराबर ऑपरेटर >=

>= ऑपरेटर सत्य लौटाता है यदि उसका बायाँ हाथ का ऑपरेंड उसके दाएँ हाथ के ऑपरेंड से बड़ा या उसके बराबर है, अन्यथा गलत।

Debug.Log(8.0 >= 6.1);   // output: True
Debug.Log(6.1 >= 6.1);   // output: True
Debug.Log(1.0 >= 6.1);   // output: False

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

3. बूलियन तार्किक ऑपरेटर

निम्नलिखित ऑपरेटर बूल ऑपरेंड के साथ तार्किक संचालन करते हैं:

• यूनरी ! (तार्किक निषेध) संचालक।
• बाइनरी और (तार्किक और), | (तार्किक OR), और ^ (तार्किक अनन्य OR) ऑपरेटर। वे ऑपरेटर हमेशा दोनों ऑपरेंड का मूल्यांकन करते हैं।
• बाइनरी && (सशर्त तार्किक AND) और || (सशर्त तार्किक OR) ऑपरेटर। वे ऑपरेटर दाहिने हाथ के ऑपरेंड का मूल्यांकन केवल तभी करते हैं जब यह आवश्यक हो।

तार्किक निषेध संचालिका !

यूनरी उपसर्ग ! ऑपरेटर अपने ऑपरेंड के तार्किक निषेध की गणना करता है। अर्थात्, यदि ऑपरेंड असत्य का मूल्यांकन करता है, तो यह सत्य उत्पन्न करता है, और यदि ऑपरेंड सत्य का मूल्यांकन करता है, तो यह असत्य उत्पन्न करता है।

bool passed = false;
Debug.Log(!passed);  // output: True
Debug.Log(!true);    // output: False

तार्किक और ऑपरेटर और

& ऑपरेटर अपने ऑपरेंड के तार्किक AND की गणना करता है। यदि x और y दोनों का मूल्यांकन सत्य है तो x और y का परिणाम सत्य है। अन्यथा, परिणाम गलत है।

& ऑपरेटर दोनों ऑपरेंड का मूल्यांकन करता है, भले ही बाएं हाथ के ऑपरेंड का मूल्यांकन गलत हो, ताकि दाएं हाथ के ऑपरेंड के मूल्य की परवाह किए बिना ऑपरेशन का परिणाम गलत हो।

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

तार्किक अनन्य या ऑपरेटर ^

^ ऑपरेटर अपने ऑपरेंड के लॉजिकल एक्सक्लूसिव OR की गणना करता है, जिसे लॉजिकल XOR भी कहा जाता है। x ^ y का परिणाम सत्य है यदि x सत्य का मूल्यांकन करता है और y गलत का मूल्यांकन करता है, या x गलत का मूल्यांकन करता है और y सत्य का मूल्यांकन करता है। अन्यथा, परिणाम गलत है. अर्थात्, बूल ऑपरेंड के लिए, ^ ऑपरेटर असमानता ऑपरेटर != के समान परिणाम की गणना करता है।

Debug.Log(true ^ true);    // output: False
Debug.Log(true ^ false);   // output: True
Debug.Log(false ^ true);   // output: True
Debug.Log(false ^ false);  // output: False

तार्किक या ऑपरेटर |

द | ऑपरेटर अपने ऑपरेंड के तार्किक OR की गणना करता है। x | का परिणाम y सत्य है यदि x या y में से कोई भी सत्य का मूल्यांकन करता है, अन्यथा, परिणाम गलत है।

The | ऑपरेटर दोनों ऑपरेंड का मूल्यांकन करता है, भले ही बाएं हाथ के ऑपरेंड का मूल्यांकन सत्य हो, ताकि दाएं हाथ के ऑपरेंड के मूल्य की परवाह किए बिना ऑपरेशन का परिणाम सत्य हो।

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

सशर्त तार्किक और ऑपरेटर &&

सशर्त तार्किक AND ऑपरेटर &&, जिसे "short-circuiting" तार्किक AND ऑपरेटर के रूप में भी जाना जाता है, अपने ऑपरेंड के तार्किक AND की गणना करता है। यदि x और y दोनों का मूल्यांकन सत्य है तो x && y का परिणाम सत्य है, अन्यथा, परिणाम गलत है। यदि x का मूल्यांकन गलत है, तो y का मूल्यांकन नहीं किया जाता है।

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Debug.Log(a);
// Output:
// False

bool b = true && SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

सशर्त तार्किक या ऑपरेटर ||

सशर्त तार्किक OR ऑपरेटर ||, जिसे "short-circuiting" तार्किक OR ऑपरेटर के रूप में भी जाना जाता है, अपने ऑपरेंड के तार्किक OR की गणना करता है। x का परिणाम || यदि x या y में से कोई भी सत्य का मूल्यांकन करता है तो y सत्य है। अन्यथा, परिणाम गलत है. यदि x का मूल्यांकन सत्य है, तो y का मूल्यांकन नहीं किया जाता है।

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Debug.Log(a);
// Output:
// True

bool b = false || SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

4. बिटवाइज़ और शिफ्ट ऑपरेटर

निम्नलिखित ऑपरेटर इंटीग्रल संख्यात्मक प्रकार या चार प्रकार के ऑपरेंड के साथ बिटवाइज़ या शिफ्ट ऑपरेशन करते हैं:

• यूनरी ~ (बिटवाइज़ पूरक) ऑपरेटर
• बाइनरी << (left shift) and >> (राइट शिफ्ट) शिफ्ट ऑपरेटर
• बाइनरी और (तार्किक और), | (तार्किक OR), और ^ (तार्किक अनन्य OR) ऑपरेटर

बिटवाइज़ पूरक ऑपरेटर ~

~ ऑपरेटर प्रत्येक बिट को उलट कर अपने ऑपरेंड का बिटवाइज़ पूरक तैयार करता है।

uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Debug.Log(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

लेफ्ट-शिफ्ट ऑपरेटर <<

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

uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2)}");

uint y = x << 4;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000

राइट-शिफ्ट ऑपरेटर >>

>> ऑपरेटर अपने दाएं हाथ के ऑपरेंड द्वारा परिभाषित बिट्स की संख्या के अनुसार अपने बाएं हाथ के ऑपरेंड को दाईं ओर स्थानांतरित करता है।

uint x = 0b_1001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2), 4}");

uint y = x >> 2;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2), 4}");
// Output:
// Before: 1001
// After:    10

उच्च-क्रम वाली खाली बिट स्थिति बाएं हाथ के ऑपरेंड के प्रकार के आधार पर निम्नानुसार निर्धारित की जाती है:

• यदि बाएं हाथ का ऑपरेंड int या long प्रकार का है, तो दाएं-शिफ्ट ऑपरेटर एक अंकगणितीय बदलाव करता है: बाएं हाथ के ऑपरेंड के सबसे महत्वपूर्ण बिट (साइन बिट) का मान उच्च-क्रम वाले खाली बिट में प्रसारित होता है पद. अर्थात्, यदि बाएं हाथ का ऑपरेंड गैर-नकारात्मक है तो उच्च-क्रम खाली बिट स्थिति शून्य पर सेट की जाती है और यदि यह नकारात्मक है तो एक पर सेट की जाती है।

int a = int.MinValue;
Debug.Log($"Before: {Convert.ToString(a, toBase: 2)}");

int b = a >> 3;
Debug.Log($"After:  {Convert.ToString(b, toBase: 2)}");
// Output:
// Before: 10000000000000000000000000000000
// After:  11110000000000000000000000000000

• यदि बाएं हाथ का ऑपरेंड uint या ulong प्रकार का है, तो दायां-शिफ्ट ऑपरेटर एक तार्किक बदलाव करता है: उच्च-क्रम खाली बिट स्थिति हमेशा शून्य पर सेट होती है।

uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
Debug.Log($"Before: {Convert.ToString(c, toBase: 2), 32}");

uint d = c >> 3;
Debug.Log($"After:  {Convert.ToString(d, toBase: 2), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After:     10000000000000000000000000000

तार्किक और ऑपरेटर और

& ऑपरेटर अपने अभिन्न ऑपरेंड के बिटवाइज़ लॉजिकल AND की गणना करता है।

uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10011000

तार्किक अनन्य या ऑपरेटर ^

^ ऑपरेटर अपने अभिन्न ऑपरेंड के बिटवाइज़ लॉजिकल एक्सक्लूसिव OR की गणना करता है, जिसे बिटवाइज़ लॉजिकल XOR के रूप में भी जाना जाता है।

uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 11100100

तार्किक या ऑपरेटर |

द | ऑपरेटर अपने अभिन्न ऑपरेंड के बिटवाइज़ लॉजिकल या की गणना करता है।

uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10110001

5. समानता संचालक

== (समानता) और != (असमानता) ऑपरेटर जाँचते हैं कि उनके ऑपरेंड बराबर हैं या नहीं।

समानता ऑपरेटर ==

समानता ऑपरेटर == यदि इसके ऑपरेंड बराबर हैं तो सत्य लौटाता है, अन्यथा गलत लौटाता है।

int a = 1 + 2 + 3;
int b = 6;
Debug.Log(a == b);  // output: True

char c1 = 'a';
char c2 = 'A';
Debug.Log(c1 == c2);  // output: False
Debug.Log(c1 == char.ToLower(c2));  // output: True

असमानता संचालिका !=

असमानता ऑपरेटर != यदि इसके ऑपरेंड समान नहीं हैं तो सत्य लौटाता है, अन्यथा गलत लौटाता है। अंतर्निहित प्रकारों के ऑपरेंड के लिए, अभिव्यक्ति x != y अभिव्यक्ति !(x == y) के समान परिणाम उत्पन्न करती है।

int a = 1 + 1 + 2 + 3;
int b = 6;
Debug.Log(a != b);  // output: True

string s1 = "Hello";
string s2 = "Hello";
Debug.Log(s1 != s2);  // output: False

object o1 = 2;
object o2 = 2;
Debug.Log(o1 != o2);  // output: True

6. विविध ऑपरेटर

सामान्य विविध ऑपरेटर हैं ?: सशर्त जांच के लिए, :: किसी उपनामित नामस्थान के सदस्य तक पहुंचने के लिए, और $ स्ट्रिंग इंटरपोलेशन के लिए।

?: ऑपरेटर

सशर्त ऑपरेटर ?:, जिसे टर्नरी कंडीशनल ऑपरेटर के रूप में भी जाना जाता है, एक बूलियन अभिव्यक्ति का मूल्यांकन करता है और दो अभिव्यक्तियों में से एक का परिणाम देता है, यह इस पर निर्भर करता है कि बूलियन अभिव्यक्ति सही या गलत का मूल्यांकन करती है, जैसा कि निम्नलिखित उदाहरण से पता चलता है:

bool condition = true;
Debug.Log(condition ? 1 : 2); // output: 1

:: ऑपरेटर

किसी अन्य नामस्थान के सदस्य तक पहुँचने के लिए नामस्थान उपनाम क्वालीफायर:: का उपयोग करें। आप:: क्वालीफायर का उपयोग केवल दो पहचानकर्ताओं के बीच कर सकते हैं। बाएं हाथ का पहचानकर्ता निम्नलिखित उपनामों में से कोई भी हो सकता है:

• उपनाम निर्देश का उपयोग करके बनाया गया एक नामस्थान उपनाम:

using forwinforms = System.Drawing;
using forwpf = System.Windows;

public class Converters
{
    public static forwpf::Point Convert(forwinforms::Point point) => new forwpf::Point(point.X, point.Y);
}

• एक बाहरी उपनाम.
• वैश्विक उपनाम, जो वैश्विक नामस्थान उपनाम है। वैश्विक नेमस्पेस वह नेमस्पेस है जिसमें ऐसे नेमस्पेस और प्रकार शामिल होते हैं जिन्हें नामित नेमस्पेस के अंदर घोषित नहीं किया जाता है। जब:: क्वालीफायर के साथ उपयोग किया जाता है, तो वैश्विक उपनाम हमेशा वैश्विक नामस्थान को संदर्भित करता है, भले ही उपयोगकर्ता द्वारा परिभाषित वैश्विक नामस्थान उपनाम हो।

namespace MyCompany.MyProduct.System
{
    class Program
    {
        static void Main() => global::System.Console.WriteLine("Using global alias");
    }

    class Console
    {
        string Suggestion => "Consider renaming this class";
    }
}

$ ऑपरेटर

$ विशेष वर्ण एक स्ट्रिंग अक्षरशः को एक प्रक्षेपित स्ट्रिंग के रूप में पहचानता है। एक इंटरपोलेटेड स्ट्रिंग एक स्ट्रिंग शाब्दिक है जिसमें इंटरपोलेशन अभिव्यक्तियाँ हो सकती हैं। जब एक इंटरपोलेटेड स्ट्रिंग को परिणाम स्ट्रिंग में हल किया जाता है, तो इंटरपोलेशन अभिव्यक्ति वाले आइटम को अभिव्यक्ति परिणामों के स्ट्रिंग प्रतिनिधित्व द्वारा प्रतिस्थापित किया जाता है।

इंटरपोलेटेड स्ट्रिंग्स में, डॉलर चिह्न ($) का उपयोग C# कंपाइलर को यह बताने के लिए किया जाता है कि इसके बाद आने वाली स्ट्रिंग को इंटरपोलेटेड स्ट्रिंग के रूप में व्याख्या किया जाना है। घुंघराले ब्रेसिज़ पाठ में शामिल करने के लिए मानों (चरों के) को समाहित करते हैं।

एक स्ट्रिंग शाब्दिक को एक इंटरपोलेटेड स्ट्रिंग के रूप में पहचानने के लिए, इसे $ प्रतीक के साथ जोड़ें। आपके पास $ और " के बीच कोई खाली स्थान नहीं हो सकता जो एक स्ट्रिंग अक्षरशः प्रारंभ करता है।

string name = "John";
var date = DateTime.Now;
Debug.Log($"Hello, {name}! Today is {date.DayOfWeek}, it's {date:HH:mm} now.");
// Output:
// Hello, John! Today is Wednesday, it's 19:40 now.