यूनिटी C# के अवश्य जानने योग्य ऑपरेटर

Unity यह एक गेम इंजन है जो कार्यक्षमता के मामले में डेवलपर्स के लिए बहुत सारे "heavy-lifting" करता है और उन्हें पूरी तरह से विकास प्रक्रिया पर ध्यान केंद्रित करने देता है। यह मुख्य प्रोग्रामिंग भाषा के रूप में 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 >= (अधिक से अधिक या बराबर) तुलना, जिसे रिलेशनल ऑपरेटर भी कहा जाता है, अपने ऑपरेंड की तुलना करते हैं। वे ऑपरेटर सभी इंटीग्रल और फ़्लोटिंग-पॉइंट संख्यात्मक प्रकारों द्वारा समर्थित हैं।

से कम ऑपरेटर <

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

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. बूलियन तार्किक ऑपरेटर

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

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

तार्किक निषेध ऑपरेटर!

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

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

तार्किक AND ऑपरेटर &

& ऑपरेटर अपने ऑपरेंड के तार्किक 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 ऑपरेटर ^

^ ऑपरेटर अपने ऑपरेंड के लॉजिकल एक्सक्लूसिव 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 ऑपरेटर |

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

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

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 ऑपरेटर &&

सशर्त तार्किक 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 ऑपरेटर ||

सशर्त तार्किक OR ऑपरेटर ||, जिसे "short-circuiting" तार्किक OR ऑपरेटर के रूप में भी जाना जाता है, अपने ऑपरेंड के तार्किक OR की गणना करता है। x || y का परिणाम सत्य है यदि x या 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 >> (राइट शिफ्ट) शिफ्ट ऑपरेटर
  • बाइनरी & (तार्किक 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 ऑपरेटर &

& ऑपरेटर अपने अभिन्न ऑपरेंडों के बिटवाइज तार्किक 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 ऑपरेटर ^

^ ऑपरेटर अपने इंटीग्रल ऑपरेंडों के बिटवाइज़ लॉजिकल एक्सक्लूसिव 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

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

| ऑपरेटर अपने अभिन्न ऑपरेंडों के बिटवाइज तार्किक OR की गणना करता है।

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 उपनाम निर्देश के साथ बनाया गया नामस्थान उपनाम:
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.
यूनिटीयूनिटी3डीसीशार्पप्रोग्रामिंगऑपरेटर्समाइक्रोसॉफ्टविंडोजडॉटनेट
सुझाए गए लेख
यूनिटी में वर्चुअल रियलिटी गेम बनाना
यूनिटी में रनटाइम एनिमेटर नियंत्रक का उपयोग करना
यूनिटी में प्रोग्रामिंग में वेरिएबल्स और डेटा प्रकारों का परिचय
यूनिटी में एक बेहतर प्रोग्रामर कैसे बनें
यूनिटी में गेम को पुनः आरंभ कैसे करें
यूनिटी में स्टेल्थ मैकेनिक्स जोड़ना
यूनिटी में गन कंट्रोलर बनाना
लोकप्रिय लेख
C# में उपयोगी कीवर्ड की एकता सूची
यूनिटी ऑबफस्केशन मेथड्स और एंटी-हैक प्रोटेक्शन
एकता में मोनोबिहेवियर के लिए गाइड
यूनिटी में एक बेहतर प्रोग्रामर कैसे बनें
यूनिटी कोड में अपवादों और त्रुटि प्रबंधन को संभालना
एकता पदयात्रा ध्वनि को क्रियान्वित कर रही है
यूनिटी में स्क्रिप्टेबलऑब्जेक्ट बनाएं
लिंक
Unity 6