C# में | और || ऑपरेटर्स में क्या अंतर है?

|| को लॉजिकल OR ऑपरेटर कहा जाता है और | को बिटवाइज़ लॉजिकल OR कहा जाता है, लेकिन उनके बीच मूल अंतर उनके निष्पादन के तरीके में है।

सिंटैक्स तुलना

// लॉजिकल OR (शॉर्ट-सर्किट)
bool_exp1 || bool_exp2

// बिटवाइज़ OR (नॉन-शॉर्ट-सर्किट)
bool_exp1 | bool_exp2

सिंटैक्स समान दिखता है लेकिन निष्पादन पूरी तरह से अलग है।

लॉजिकल OR (||) - शॉर्ट-सर्किट ऑपरेटर

• पहले bool_exp1 एक्जीक्यूट होता है
• अगर यह true लौटाता है, तो bool_exp2 एक्जीक्यूट **नहीं** होता (शॉर्ट-सर्किट)
• bool_exp2 केवल तभी एक्जीक्यूट होता है जब bool_exp1 false हो
• इसे शॉर्ट-सर्किट ऑपरेटर कहा जाता है क्योंकि यह पहले एक्सप्रेशन के परिणाम के आधार पर सर्किट (स्टेटमेंट) को छोटा कर देता है
• अधिक कुशल - अनावश्यक मूल्यांकन से बचाता है

उदाहरण: लॉजिकल OR

using System;

namespace DemoApplication
{
    public class Program
    {
        static void Main(string[] args)
        {
            if (Condition1() || Condition2())
            {
                Console.WriteLine("Logical OR If Condition Executed");
            }
            Console.ReadLine();
        }
        
        static bool Condition1()
        {
            Console.WriteLine("Condition 1 executed");
            return true;  // true लौटाता है
        }
        
        static bool Condition2()
        {
            Console.WriteLine("Condition 2 executed");
            return true;
        }
    }
}

आउटपुट

Condition 1 executed
Logical OR If Condition Executed

नोट: Condition 2 कभी एक्जीक्यूट नहीं हुआ क्योंकि Condition 1 ने true लौटाया।

बिटवाइज़ लॉजिकल OR (|) - नॉन-शॉर्ट-सर्किट

• कंपाइलर **दोनों** स्टेटमेंट्स एक्जीक्यूट करता है
• एक स्टेटमेंट के परिणाम की परवाह किए बिना दोनों एक्जीक्यूट होते हैं
• यह अकुशल है क्योंकि अगर एक true है तो दूसरे को एक्जीक्यूट करने का कोई मतलब नहीं
• परिणाम केवल तभी false होता है जब **दोनों** false हों
• बिटवाइज़ ऑपरेशन के लिए भी उपयोग किया जाता है (इंटीजर्स पर)

उदाहरण: बिटवाइज़ लॉजिकल OR

using System;

namespace DemoApplication
{
    public class Program
    {
        static void Main(string[] args)
        {
            if (Condition1() | Condition2())
            {
                Console.WriteLine("Bitwise OR If Condition Executed");
            }
            Console.ReadLine();
        }
        
        static bool Condition1()
        {
            Console.WriteLine("Condition 1 executed");
            return true;
        }
        
        static bool Condition2()
        {
            Console.WriteLine("Condition 2 executed");
            return true;
        }
    }
}

आउटपुट

Condition 1 executed
Condition 2 executed
Bitwise OR If Condition Executed

नोट: Condition 1 के true लौटाने के बावजूद Condition 2 भी एक्जीक्यूट हुआ।

बिटवाइज़ OR (|) इंटीजर्स पर

int a = 5;   // बाइनरी: 0101
int b = 3;   // बाइनरी: 0011
int result = a | b;  // बाइनरी: 0111 = 7

Console.WriteLine($"{a} | {b} = {result}");  // आउटपुट: 5 | 3 = 7

तुलना तालिका

व्यावहारिक निहितार्थ

साइड इफेक्ट्स के साथ सावधान रहें

// खतरनाक: | के साथ साइड इफेक्ट
if (GetUser() != null | GetUser().IsActive)  // GetUser() दो बार कॉल होता है!
{
    // ...
}

// सुरक्षित: || के साथ शॉर्ट-सर्किट
if (GetUser() != null && GetUser().IsActive)  // GetUser() दूसरी बार केवल अगर पहला true हो
{
    // ...
}

// बेहतर: वेरिएबल में स्टोर करें
var user = GetUser();
if (user != null && user.IsActive) { ... }

नल चेक पैटर्न

// || का उपयोग नल चेक के लिए (सुरक्षित)
string name = null;
if (name == null || name.Length > 10)  // name.Length कभी एक्सेस नहीं होता अगर name null है
{
    Console.WriteLine("Valid");
}

// | का उपयोग करेगा NullReferenceException फेंक देगा
// if (name == null | name.Length > 10)  // क्रैश!

सिफारिश: बूलियन लॉजिक के लिए लगभग हमेशा || (और &&) का उपयोग करें। | (और &) का उपयोग केवल बिटवाइज़ ऑपरेशन्स के लिए करें या जब आप स्पष्ट रूप से **दोनों** पक्षों का मूल्यांकन करना चाहते हों (दुर्लभ)।