المعاملات في C#: الحسابية وباقي القسمة والمنطقية والبتّية والأولوية

يأخذ المعامل (operator) معاملًا أو اثنين أو ثلاثة ويُنتج قيمة: a + b و!done وx ?? fallback. معاملات C# قريبة من معاملات C وJava وJavaScript، لكن بعضها يتصرف بطرق تفاجئ القادمين الجدد، وعلى رأسها قسمة الأعداد الصحيحة وإشارة %.

المعاملات الحسابية

تعمل + و- و* و/ و% مع كل نوع رقمي. يتبع نوع النتيجة المعاملين: قيمتا int تنتجان int، وint مع double ينتجان double.

using System;

class Program
{
    static void Main()
    {
        int apples = 17, boxes = 5;

        Console.WriteLine(apples + boxes);   // 22
        Console.WriteLine(apples - boxes);   // 12
        Console.WriteLine(apples * boxes);   // 85
        Console.WriteLine(apples / boxes);   // 3: integer division
        Console.WriteLine(apples % boxes);   // 2: remainder

        Console.WriteLine(apples / 5.0);            // 3.4
        Console.WriteLine((double)apples / boxes);  // 3.4
        Console.WriteLine((double)(apples / boxes)); // 3: divided first, then converted
        Console.WriteLine(apples / 5m);             // 3.4 as decimal
    }
}

المخرجات:

22
12
85
3
2
3.4
3.4
3
3.4

قسمة الأعداد الصحيحة تقتطع نحو الصفر. 17 / 5 تساوي 3 و-17 / 5 تساوي -3. وهذا يسبّب خطأً شائعًا جدًا: int percent = done / total * 100; تساوي 0 كلما كان done < total، لأن done / total تساوي 0 أصلًا. اضرب أولًا (done * 100 / total) أو اقسم كـ double.

قسمة عدد صحيح أو decimal على صفر ترمي DivideByZeroException. أما قسمة double على صفر فلا ترمي؛ بل تنتج ما لا نهاية، أو NaN لـ 0.0 / 0.0:

using System;

class Program
{
    static void Main()
    {
        double ratio = 5.0 / 0;
        double undefined = 0.0 / 0;
        Console.WriteLine(double.IsPositiveInfinity(ratio));
        Console.WriteLine(double.IsNaN(undefined));
        Console.WriteLine(undefined == undefined);   // NaN never equals anything

        int zero = 0;
        try
        {
            Console.WriteLine(10 / zero);
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("DivideByZeroException");
        }
    }
}

المخرجات:

True
True
False
DivideByZeroException

معامل باقي القسمة والأرقام السالبة

تعيد % باقي القسمة، وتأخذ نتيجتها إشارة المعامل الأول. وهذا يختلف عن Python وعن "mod" الرياضي، اللذين يكونان غير سالبين دائمًا مع مقسوم عليه موجب:

using System;

class Program
{
    static int Mod(int a, int n)
    {
        return ((a % n) + n) % n;   // always in 0..n-1
    }

    static void Main()
    {
        Console.WriteLine(7 % 3);     // 1
        Console.WriteLine(-7 % 3);    // -1
        Console.WriteLine(7 % -3);    // 1
        Console.WriteLine(Mod(-7, 3)); // 2

        // Common uses:
        int n = 42;
        Console.WriteLine(n % 2 == 0 ? "even" : "odd");

        int totalSeconds = 3725;
        Console.WriteLine($"{totalSeconds / 60} min {totalSeconds % 60} s");

        string[] days = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
        int today = 5, offset = -9;
        Console.WriteLine(days[Mod(today + offset, 7)]);  // wraps backwards safely

        Console.WriteLine(7.5 % 2);   // works on double: 1.5
    }
}

المخرجات:

1
-1
1
2
even
62 min 5 s
Thu
1.5

استخدم الدالة المساعدة Mod كلما أمكن أن يكون الطرف الأول سالبًا وكانت النتيجة فهرسًا: days[(today + offset) % 7] سترمي IndexOutOfRangeException لمجموع سالب. واختبار الأعداد الفردية فيه الفخ نفسه: n % 2 == 1 تساوي false للأعداد الفردية السالبة؛ اختبر n % 2 != 0.

الإسناد والإسناد المركّب والزيادة

= تُسند. تجمع الأشكال المركّبة += و-= و*= و/= و%= و&= و|= و^= و<<= و>>= عملية مع إسناد. تضيف ++ و-- واحدًا أو تطرحانه، ولهما شكل سابق وشكل لاحق يختلفان في القيمة التي يعيدانها:

using System;

class Program
{
    static void Main()
    {
        int stock = 10;
        stock -= 3;          // stock = stock - 3
        stock *= 2;          // stock = stock * 2
        Console.WriteLine(stock);   // 14

        string log = "start";
        log += ", step";     // += concatenates strings
        Console.WriteLine(log);

        int i = 5;
        int a = i++;   // a gets 5, then i becomes 6
        int b = ++i;   // i becomes 7, then b gets 7
        Console.WriteLine($"a={a} b={b} i={i}");

        byte level = 250;
        level += 10;   // compiles: compound assignment casts back to byte (and wraps)
        Console.WriteLine(level);
    }
}

المخرجات:

14
start, step
a=5 b=7 i=7
4

تُظهر حالة byte غرابة: level = level + 10; لا تُترجم، لأن byte + int نتيجتها int، لكن level += 10; تُترجم، لأن الإسناد المركّب يتضمن تحويلًا ضمنيًا إلى نوع المتغيّر. هذا التحويل يلتفّ عند التجاوز (250 + 10 تصبح 4).

معاملات المقارنة والمعاملات المنطقية

تعيد معاملات المقارنة (== و!= و< و> و<= و>=) قيمة bool. في النصوص تقارن == النص لا المراجع. والمعاملات المنطقية هي ! (النفي) و&& (و) و|| (أو) و^ (أو الحصرية).

using System;

class User
{
    public string Name;
    public bool IsActive;
}

class Program
{
    static bool Check(string label, bool result)
    {
        Console.WriteLine($"  evaluated {label}");
        return result;
    }

    static void Main()
    {
        Console.WriteLine(3 < 5 && "abc" == "ab" + "c");

        User user = null;
        // Safe: && stops at the first false, so user.IsActive is never read.
        if (user != null && user.IsActive)
            Console.WriteLine("active");
        else
            Console.WriteLine("no active user");

        Console.WriteLine("with ||:");
        bool r1 = Check("A", true) || Check("B", true);   // B is skipped

        Console.WriteLine("with |:");
        bool r2 = Check("A", true) | Check("B", true);    // both run

        Console.WriteLine(true ^ false);   // exactly one is true
    }
}

المخرجات:

True
no active user
with ||:
  evaluated A
with |:
  evaluated A
  evaluated B
True

تعمل && و|| بدارة قصيرة: لا يُنفَّذ المعامل الثاني إلا حين يمكنه تغيير النتيجة. هذا ما يجعل user != null && user.IsActive آمنة. أما & و| المفردتان على القيم المنطقية فتقيّمان الطرفين دائمًا، ونادرًا ما يكون هذا ما تريده في شرط.

المعاملات البتّية ومعاملات الإزاحة

على الأنواع الصحيحة تعمل & و| و^ و~ على البتات منفردة، وتزيحها << و>>. تُستخدم للأعلام والأقنعة والتجزئة والبروتوكولات منخفضة المستوى:

using System;

class Program
{
    const int Read = 1;     // 0001
    const int Write = 2;    // 0010
    const int Delete = 4;   // 0100

    static void Main()
    {
        int permissions = Read | Write;              // set two flags
        Console.WriteLine(permissions);                        // 3
        Console.WriteLine((permissions & Write) != 0);          // has Write?
        Console.WriteLine((permissions & Delete) != 0);         // has Delete?

        permissions |= Delete;                       // add a flag
        permissions &= ~Write;                       // remove a flag
        Console.WriteLine(Convert.ToString(permissions, 2));    // 101

        Console.WriteLine(1 << 10);                  // 1024
        Console.WriteLine(1000 >> 3);                // 125 (divide by 8)
        Console.WriteLine(6 ^ 3);                    // 110 xor 011 = 101 = 5
        Console.WriteLine(~0);                       // all bits set: -1
    }
}

المخرجات:

3
True
False
101
1024
125
5
-1

لمجموعات الأعلام المسمّاة يكون تعداد بالسمة [Flags] أوضح من الثوابت الصحيحة، وHasFlag أسهل قراءة من القناع. أضافت C# 11 المعامل >>>، وهو إزاحة بلا إشارة تملأ بالأصفار حتى مع الأرقام السالبة.

معاملات null

توجد ثلاثة معاملات للتعامل مع القيم التي قد تكون null:

using System;

class Program
{
    static void Main()
    {
        string nickname = null;
        string display = nickname ?? "Guest";         // fallback when null
        Console.WriteLine(display);

        Console.WriteLine(nickname?.Length);          // null, not an exception
        int length = nickname?.Length ?? 0;
        Console.WriteLine(length);

        int? discount = null;
        Console.WriteLine(discount ?? 5);
    }
}

المخرجات:

Guest

0
5

تعيد a ?? b القيمة a ما لم تكن null، وإلا b. وتعيد a?.Member قيمة null بدل رمي استثناء حين تكون a هي null. وأضافت C# 8 المعامل a ??= b، الذي يُسند b إلى a فقط حين تكون a هي null. هذه مشروحة بعمق في الأنواع القابلة لـ null.

أولوية المعاملات

حين يخلط تعبير عدة معاملات، ترتبط الصفوف الأعلى بقوة أكبر. تُجمَّع المعاملات في الصف نفسه بترتيب ورودها، باستثناء الإسناد و?? و?:، التي تُجمَّع بالترتيب المعاكس (من الأخير إلى الأول). (أما المعاملات نفسها فتُقيَّم دائمًا بترتيب كتابتها.)

نتيجتان تستحقان المعرفة: a + b * c تضرب أولًا، وx & mask == 0 تقارن أولًا (== ترتبط بقوة أكبر من &)، فمعناها x & (mask == 0) ولا تُترجم مع الأعداد الصحيحة. اكتب (x & mask) == 0. الأقواس لا تكلّف شيئًا وتجعل القصد واضحًا.

التحميل الزائد للمعاملات

تستطيع أنواعك تعريف معنى المعاملات. بهذا تدعم decimal وDateTime وTimeSpan المعاملين + و<:

using System;

struct Money
{
    public readonly decimal Amount;
    public Money(decimal amount) { Amount = amount; }

    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
    public static Money operator *(Money a, int n) => new Money(a.Amount * n);
    public static bool operator >(Money a, Money b) => a.Amount > b.Amount;
    public static bool operator <(Money a, Money b) => a.Amount < b.Amount;

    public override string ToString() => Amount.ToString("F2");
}

class Program
{
    static void Main()
    {
        var shirt = new Money(19.99m);
        var socks = new Money(4.50m);
        Money total = shirt + socks * 3;
        Console.WriteLine(total);
        Console.WriteLine(total > new Money(30m));
    }
}

المخرجات:

33.49
True

يجب أن تكون المعاملات public static، وبعضها يأتي في أزواج إلزامية: تعريف < يتطلب >، و== يتطلب !=. ومع تعريف == يحذّر المترجم أيضًا حتى تتجاوز Equals وGetHashCode بما يطابقه. لا تحمّل المعاملات تحميلًا زائدًا إلا حيث يكون المعنى بديهيًا، كما مع الأرقام والمتجهات والمال.