مشغلو Unity C# الذين يجب معرفتهم

Unity هو محرك ألعاب يقوم بالكثير من "heavy-lifting" للمطورين من حيث الوظائف ويتيح لهم التركيز بشكل كامل على عملية التطوير. يستخدم C# كلغة البرمجة الرئيسية.

كما هو الحال مع أي لغة برمجة، تتكون لغة #C من مجموعة من الوظائف الخاصة والأنواع والفئات والمكتبات وما إلى ذلك، ولكنها تحتوي أيضًا على قائمة من الرموز الخاصة (العوامل) التي لكل منها وظيفتها الخاصة. في هذا المنشور، سأدرج هذه الرموز وسأشرح ما تفعله، بحيث تتمكن في المرة القادمة التي تفتح فيها البرنامج النصي من فهم معنى كل جزء بسرعة.

العوامل في C# هي بعض الرموز الخاصة التي تؤدي بعض الإجراءات على المعاملات.

في C#، هناك 6 أنواع من العوامل المضمنة: العوامل الحسابية، وعوامل المقارنة، والعوامل المنطقية المنطقية، وعوامل Bitwise وshift، وعوامل المساواة، وعوامل التشغيل المتنوعة. إن معرفة كل منهم سيجعلك مبرمجًا أفضل على الفور.

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. العوامل المنطقية المنطقية

تقوم العوامل التالية بتنفيذ عمليات منطقية باستخدام المعاملات المنطقية:

  • الأحادي! عامل (النفي المنطقي).
  • ثنائي & (منطقي AND)، | (المنطقية 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 ^

يحسب عامل التشغيل ^ OR المنطقي الحصري، المعروف أيضًا باسم XOR المنطقي، لمعاملاته. تكون نتيجة x ^ y صحيحة إذا تم تقييم x إلى true وتم تقييم y إلى false، أو تم تقييم x إلى false وتم تقييم y إلى true. وإلا فإن النتيجة كاذبة. أي أنه بالنسبة للمعاملات المنطقية، يحسب عامل التشغيل ^ نفس النتيجة التي يحسبها عامل المتباينة !=.

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 المنطقي لمعاملاته. نتيجة س | تكون y صحيحة إذا تم تقييم x أو y على أنها true، وإلا فستكون النتيجة خاطئة.

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 المنطقي الشرطي &&

يحسب عامل التشغيل AND المنطقي الشرطي &&، المعروف أيضًا باسم عامل التشغيل المنطقي "short-circuiting"، معامل 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

عامل التشغيل المنطقي الشرطي ||

عامل التشغيل المنطقي الشرطي ||، المعروف أيضًا باسم عامل التشغيل المنطقي "short-circuiting"، يحسب معامل OR المنطقي لمعاملاته. نتيجة س || تكون y صحيحة إذا تم تقييم x أو y إلى true. وإلا فإن النتيجة كاذبة. إذا تم تقييم 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. مشغلي Bitwise وshift

تقوم عوامل التشغيل التالية بتنفيذ عمليات البت أو التحويل مع معاملات الأنواع الرقمية المتكاملة أو نوع char:

  • مشغل أحادي ~ (مكمل للبت).
  • مشغلي التحول الثنائي << (left shift) and >> (التحول الأيمن).
  • ثنائي & (منطقي AND)، | (المنطقية OR)، و^ (المنطقية الحصرية OR).

مشغل تكملة Bitwise ~

يُنتج عامل التشغيل ~ تكملة للمعامل الخاص به عن طريق عكس كل بت.

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 ^

يحسب عامل التشغيل ^ وحدة البت المنطقية الحصرية 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 لمعاملاته المتكاملة.

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.
الوحدة Unity3D CSharp البرمجة المشغلين مايكروسوفت ويندوز الدوت نت
المقالات المقترحة
كيف تصبح مبرمجًا أفضل في Unity
فهم الوظائف واستدعاءات الطريقة
مقدمة إلى لغة البرمجة النصية Unity C#
تنفيذ العمليات الحسابية الأساسية في رمز الوحدة
إضافة دخول اللاعب إلى السيارة في Unity
إنشاء وحدة تحكم البرج في الوحدة
إضافة تأثير Sway إلى الأسلحة في Unity
المزيد من المشاركات »
المواد شعبية
التحديث مقابل التحديث الثابت مقابل التحديث المتأخر
الوحدة تنفذ أصوات الخطوات
إنشاء عبارات شرطية (إذا كانت غير ذلك) في رمز الوحدة
نهج عملي للتعليمات البرمجية المعيارية في الوحدة
تنفيذ الأهداف في ألعاب الوحدة
تنفيذ معدل التحديث المخصص في الوحدة
ترميز نظام جرد بسيط مع سحب واجهة المستخدم وإسقاطها في الوحدة