English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

C# 基础教程

C# 高级教程

C# 面向对象(OOP)

المعادلات في C#

C#中的运算符是对操作数执行某些操作的一些特殊符号。在数学中，加号（+）是左右数之和。同样地，C#包括不同类型操作的各种运算符。

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：

  • 算术运算符

  • الدوال العلاقاتية

  • أجهزة الحساب المنطقية

  • عناصر العمليات الثنائية

  • دوال التعيين

  • عمليات أخرى

本教程将逐一讲解算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符及其他运算符。

算术运算符

下表显示了 C# 支持的所有算术运算符。假设变量 A القيمة هي 10، المتغير B القيمة هي 20، إذاً:

المعادلاتوصفالنموذج
+把两个操作数相加A + B 将得到 30
-从第一个操作数中减去第二个操作数A - B 将得到 -10
*把两个操作数相乘A * B 将得到 200
/分子除以分母B / A 将得到 2
%取模运算符，整除后的余数B % A 将得到 0
++自增运算符，整数值增加 1A++ 将得到 11
--自减运算符，整数值减少 1A-- 将得到 9

نموذج عبر الإنترنت

请看下面的示例，了解 C# 中所有可用的算术运算符：

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 21;
　　　　　　　　　　　　int b = 10;
　　　　　　　　　　　　int c;
　　　　　　　　　　　　c = a + b;
　　　　　　　　　　　　Console.WriteLine("Line 1 - c的价值是 {0}", c);
　　　　　　　　　　　　c = a - b;
　　　　　　　　　　　　Console.WriteLine("السطر 2 - قيمة c هي {0}", c);
　　　　　　　　　　　　c = a * b;
　　　　　　　　　　　　Console.WriteLine("السطر 3 - قيمة c هي {0}", c);
　　　　　　　　　　　　c = a / b;
　　　　　　　　　　　　Console.WriteLine("السطر 4 - قيمة c هي {0}", c);
　　　　　　　　　　　　c = a % b;
　　　　　　　　　　　　Console.WriteLine("السطر 5 - قيمة c هي {0}", c);
　　　　　　　　　　　　// ++a أولاً أزيد قيمة a ثم أعدلها
　　　　　　　　　　　　c = ++a;
　　　　　　　　　　　　Console.WriteLine("السطر 6 - قيمة c هي {0}", c);
　　　　　　　　　　　　// الآن قيمة a هي 22
　　　　　　　　　　　　// --a أولاً أقلل قيمة a ثم أعدلها
　　　　　　　　　　　　c = --a;
　　　　　　　　　　　　Console.WriteLine("خط 7 - قيمة c هي {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

عندما يتم ترميز وتنفيذ الكود أعلاه، سيظهر النتيجة التالية:

خط 1 - قيمة c هي 31
خط 2 - قيمة c هي 11
خط 3 - قيمة c هي 210
خط 4 - قيمة c هي 2
خط 5 - قيمة c هي 1
خط 6 - قيمة c هي 22
خط 7 - قيمة c هي 21

  • c = a++: أولاً أعدل قيمة a ثم أزيدها لـ c.

  • c = ++a: أولاً أزيد قيمة a ثم أعدلها لـ c.

  • c = a--: أولاً أعدل قيمة a ثم أقللها لـ c.

  • c = --a: أولاً أقلل قيمة a ثم أعدلها لـ c.

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 1;
　　　　　　　　　　　　int b;
　　　　　　　　　　　　// a++ أولاً أعدل القيمة ثم أزيدها
　　　　　　　　　　　　b = a++;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// ++a أولاً أزيد قيمة a ثم أعدلها
　　　　　　　　　　　　a = 1; // إعادة تعيين a
　　　　　　　　　　　　b = ++a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// a-- أولاً أعدل القيمة ثم أقللها
　　　　　　　　　　　　a = 1; // إعادة تعيين a
　　　　　　　　　　　　b = a--;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　// --a أولاً أقلل قيمة a ثم أعدلها
　　　　　　　　　　　　a = 1; // إعادة تعيين a
　　　　　　　　　　　　b = --a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

إذا قمت بتنفيذ البرنامج أعلاه، فإن النتيجة ستكون:

a = 2
b = 1
a = 2
b = 2
a = 0
b = 1
a = 0
b = 0

الدوال العلاقاتية

الجدول التالي يظهر جميع الدوال العلاقاتية التي يدعمها C#. افترض المتغير A القيمة هي 10، المتغير B القيمة هي 20، إذاً:

المعادلاتوصفالنموذج
==تتأكد من أن قيمتي العنصرين تساويان، إذا كانت متساويتين فإن الشرط صحيح.(A == B) غير صحيح.
!=تتأكد من أن قيمتي العنصرين تساويان، إذا كانت غير متساويتين فإن الشرط صحيح.(A != B) صحيح.
>تتأكد من أن قيمة العنصر الأيسر أكبر من قيمة العنصر الأيمن، إذا كانت كذلك فإن الشرط صحيح.(A > B) غير صحيح.
<تتأكد من أن قيمة العنصر الأيسر أقل من قيمة العنصر الأيمن، إذا كانت كذلك فإن الشرط صحيح.(A < B) صحيح.
>=تتأكد من أن قيمة العنصر الأيسر أكبر أو تساوي قيمة العنصر الأيمن، إذا كانت كذلك فإن الشرط صحيح.(A >= B) غير صحيح.
<=تتأكد من أن قيمة العنصر الأيسر أقل أو تساوي قيمة العنصر الأيمن، إذا كانت كذلك فإن الشرط صحيح.(A <= B) صحيح.

نموذج عبر الإنترنت

انظر إلى الأمثلة التالية لفهم جميع أجهزة الحساب العلاقية المتاحة في C#:

نموذج عبر الإنترنت

using System;
class Program
{
　　static void Main(string[] args)
　　{
　　　　　　int a = 21;
　　　　　　int b = 10;
　　　　　　
　　　　　　if (a == b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("خط 1 - a يساوي b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("خط 1 - a لا يساوي b");
　　　　　　}
　　　　　　if (a < b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("خط 2 - a أصغر من b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("خط 2 - a لا يقل عن b");
　　　　　　}
　　　　　　if (a > b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("خط 3 - a أكبر من b");
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("خط 3 - a لا يزيد عن b");
　　　　　　}
　　　　　　/* تغيير قيم a و b */
　　　　　　a = 5;
　　　　　　b = 20;
　　　　　　if (a <= b)
　　　　　　{
　　　　　　　　　Console.WriteLine("خط 4 - a أصغر أو مساوي لـ b");
　　　　　　}
　　　　　　if (b >= a)
　　　　　　{
　　　　　　　　　Console.WriteLine("خط 5 - b أكبر أو مساوي لـ a");
　　　　　　}
　　}
}

عندما يتم ترميز وتنفيذ الكود أعلاه، سيظهر النتيجة التالية:

خط 1 - a لا يساوي b
خط 2 - a لا يقل عن b
خط 3 - a أكبر من b
خط 4 - a أصغر أو مساوي لـ b
خط 5 - b أكبر أو مساوي لـ a

أجهزة الحساب المنطقية

يظهر الجدول أدناه جميع أجهزة الحساب المنطقية المدعومة في C#. افترض المتغير A للقيمة المنطقية true، المتغير B للقيمة المنطقية false،

المعادلاتوصفالنموذج
&&يسمى بعمودي و. إذا كان كلا المكونين غير صفر، فإن الشروط صحيحة.(A && B) خطأ.
||يسمى بعمودي أو. إذا كان أي من المكونين غير صفر، فإن الشروط صحيحة.(A || B) صحيح.
!يسمى بعمودي المنطق. يستخدم لتحويل حالة المكون. إذا كانت الشروط صحيحة، فإن عمودي المنطق ستجعله خطأ.!(A && B) صحيح.

نموذج عبر الإنترنت

انظر إلى الأمثلة التالية لفهم جميع أجهزة الحساب المنطقية المتاحة في C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　bool a = true;
　　　　　　　　　　　　bool b = true;
　　　　　　　　　　　
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　Console.WriteLine("خط 1 - الشروط صحيحة");
　　　　　　　　　　　　}
　　　　　　　　　　　　if (a || b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("خط 2 - الشروط صحيحة");
　　　　　　　　　　　　}
　　　　　　　　　　　　/* تغيير قيم a و b */
　　　　　　　　　　　　a = false;
　　　　　　　　　　　　b = true;
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("خط 3 - الشروط صحيحة");
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line 3 - Condition is not true");
　　　　　　　　　　　　}
　　　　　　　　　　　　if (!(a && b))
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Line 4 - Condition is true");
　　　　　　　　　　　　}
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

عندما يتم ترميز وتنفيذ الكود أعلاه، سيظهر النتيجة التالية:

Line 1 - Condition is true
Line 2 - Condition is true
Line 3 - Condition is not true
Line 4 - Condition is true

عناصر العمليات الثنائية

عناصر العمليات الثنائية تعمل على الأعمدة، وتقوم بتنفيذ العمليات عموديًا. جدول الحقائق لـ &، | و ^ كما يلي:

pqp & qp | qp ^ q
00000
01011
11110
10011

افترض إذا كان A = 60، و B = 13، الآن يتم تمثيلها في شكل ثنائي كما يلي:

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011

الجدول التالي يبين عناصر العمليات الثنائية المدعومة في C#. افترض المتغير A قيمة 60، المتغير B إذا كانت قيمة 13، فإنه:

المعادلاتوصفالنموذج
&إذا كانت موجودة في كلا المعاملين، فإن عمليات الثنائية والجمع (AND) تنسخ رقماً واحدًا إلى النتيجة.(A & B) سيكون 12، أي 0000 1100
|إذا كانت موجودة في أي من المعاملين، فإن عمليات الثنائية أو (OR) تنسخ رقماً واحدًا إلى النتيجة.(A | B) سيكون 61، أي 0011 1101
^إذا كانت موجودة في أحد المعاملين ولكنها ليست موجودة في كلاهما، فإن عمليات الثنائية للإشارة أو (XOR) تنسخ رقماً واحدًا إلى النتيجة.(A ^ B) سيكون 49، أي 0011 0001
~عنصر النقل الثنائي إلى اليمين هو عمليات ثنائية ثنائية، لديها تأثير "القلب" للبنية، أي أن 0 يصبح 1، و1 يصبح 0، بما في ذلك موقع الإشارة.(~A) سيكون -61، أي 1100 0011، شكل التعويض الثنائي للأرقام المميزة.
<<عنصر النقل الثنائي إلى اليسار. قيمة المعامل الأيسر تتحرك إلى اليسار بمقدار عدد الأعمدة المحدد من المعامل الأيمن.A << 2 سيكون 240، أي 1111 0000
>>عنصر النقل الثنائي إلى اليمين. قيمة المعامل الأيسر تتحرك إلى اليمين بمقدار عدد الأعمدة المحدد من المعامل الأيمن.A >> 2 سيكون 15، أي 0000 1111

نموذج عبر الإنترنت

الرجاء النظر في المثال التالي لفهم جميع عناصر العمليات الثنائية في C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 60; /* 60 = 0011 1100 */　　
　　　　　　　　　　　　int b = 13; /* 13 = 0000 1101 */
　　　　　　　　　　　　int c = 0;　　　　　　　　　　　
　　　　　　　　　　　　　c = a & b; /* 12 = 0000 1100 */　
　　　　　　　　　　　　　Console.WriteLine("السطر 1 - قيمة c هي {0}", c);
　　　　　　　　　　　　　c = a | b; /* 61 = 0011 1101 */
　　　　　　　　　　　　　Console.WriteLine("السطر 2 - قيمة c هي {0}", c);
　　　　　　　　　　　　　c = a ^ b; /* 49 = 0011 0001 */
　　　　　　　　　　　　　Console.WriteLine("السطر 3 - قيمة c هي {0}", c);
　　　　　　　　　　　　　c = ~a; /* -61 = 1100 0011 */
　　　　　　　　　　　　　Console.WriteLine("السطر 4 - قيمة c هي {0}", c);
　　　　　　　　　　　　　c = a << 2; /* 240 = 1111 0000 */
　　　　　　　　　　　　　Console.WriteLine("السطر 5 - قيمة c هي {0}", c);
　　　　　　　　　　　　　c = a >> 2; /* 15 = 0000 1111 */
　　　　　　　　　　　　　Console.WriteLine("السطر 6 - قيمة c هي {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

عندما يتم ترميز وتنفيذ الكود أعلاه، سيظهر النتيجة التالية:

السطر 1 - قيمة c هي 12
السطر 2 - قيمة c هي 61
السطر 3 - قيمة c هي 49
السطر 4 - قيمة c هي -61
السطر 5 - قيمة c هي 240
السطر 6 - قيمة c هي 15

دوال التعيين

الجدول أدناه يوضح الدوال المدرجة لدوال التعيين لدى C#:

المعادلاتوصفالنموذج
=عنصر التعيين البسيط، يقوم بتعيين قيمة المقدم للواحدC = A + B سيقوم بتعيين قيمة A + B لـ C
+=عنصر الإضافة والتعيين، يقوم بالإضافة بين المقدم والواحد ويقوم بتعيين النتيجة للواحدC += A يعادل C = C + A
-=عنصر الطرح والتعيين، يقوم بطرح المقدم من المطلوب ويقوم بتعيين النتيجة للواحدC -= A يعادل C = C - A
*=عنصر الضرب والتعيين، يقوم بضرب المقدم في المطلوب ويقوم بتعيين النتيجة للواحدC *= A يعادل C = C * A
/=عنصر التوزيع والتعيين، يقسم المطلوب على المقدم ويقوم بتعيين النتيجة للواحدC /= A يعادل C = C / A
%=وظيفة أوصال المتبقي، تعطي قيمة المتبقي من قسيمة الديناميكياتC %= A يعادل C = C % A
<<=وظائف تحريك الأطراف المائلةC <<= 2 يعادل C = C << 2
>>=وظائف تحريك الأطراف المائلةC >>= 2 يعادل C = C >> 2
&=وظائف أوصال الأطراف المائلةC &= 2 يعادل C = C & 2
^=وظائف أوصال الأطراف المائلةC ^= 2 يعادل C = C ^ 2
|=وظائف أوصال الأطراف المائلةC |= 2 يعادل C = C | 2

نموذج عبر الإنترنت

يرجى النظر إلى المثال أدناه لفهم جميع محولات الربط المتاحة في C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a = 21;
　　　　　　　　　　　　int c;
　　　　　　　　　　　　c = a;
　　　　　　　　　　　　Console.WriteLine("خط 1 - = قيمة c = {0}", c);
　　　　　　　　　　　　c += a;
　　　　　　　　　　　　Console.WriteLine("خط 2 - += قيمة c = {0}", c);
　　　　　　　　　　　　c -= a;
　　　　　　　　　　　　Console.WriteLine("خط 3 - -= قيمة c = {0}", c);
　　　　　　　　　　　　c *= a;
　　　　　　　　　　　　Console.WriteLine("خط 4 - *= قيمة c = {0}", c);
　　　　　　　　　　　　c /= a;
　　　　　　　　　　　　Console.WriteLine("خط 5 - /= قيمة c = {0}", c);
　　　　　　　　　　　　c = 200;
　　　　　　　　　　　　c %= a;
　　　　　　　　　　　　Console.WriteLine("خط 6 - %= قيمة c = {0}", c);
　　　　　　　　　　　　c <<= 2;
　　　　　　　　　　　　Console.WriteLine("خط 7 - <<= قيمة c = {0}", c);
　　　　　　　　　　　　c >>= 2;
　　　　　　　　　　　　Console.WriteLine("خط 8 - >>= قيمة c = {0}", c);
　　　　　　　　　　　　c &= 2;
　　　　　　　　　　　　Console.WriteLine("خط 9 - &= قيمة c = {0}", c);
　　　　　　　　　　　　c ^= 2;
　　　　　　　　　　　　Console.WriteLine("خط 10 - ^= قيمة c = {0}", c);
　　　　　　　　　　　　c |= 2;
　　　　　　　　　　　　Console.WriteLine("خط 11 - |= قيمة c = {0}", c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

عندما يتم ترميز وتنفيذ الكود أعلاه، سيظهر النتيجة التالية:

خط 1 - = قيمة c = 21
خط 2 - += قيمة c = 42
السطر 2 - -=  c القيمة = 21
السطر 3 - *=  c القيمة = 441
السطر 4 - /=  c القيمة = 21
السطر 5 - %=  c القيمة = 11
السطر 6 - <<=  c القيمة = 44
السطر 7 - >>=  c القيمة = 11
السطر 9 - &=  c القيمة = 2
السطر 10 - ^=  c القيمة = 0
السطر 11 - |=  c القيمة = 2

عمليات أخرى

الجدول أدناه يعرض بعض العمليات الأخرى المهمة التي يدعمها C#، بما في ذلك sizeof、typeof و ? :.

المعادلاتوصفالنموذج
sizeof();سيقوم بإرجاع حجم نوع البيانات.sizeof(int)،سيقوم بإرجاع 4.
typeof();سيقوم بإرجاع نوع فئة.typeof(StreamReader);
&سيقوم بإرجاع عنوان المتغير.&a; سيحصل على عنوان المتغير الفعلي.
*المرجع إلى متغير.*a; سيقوم بالإشارة إلى متغير.
? :عبرة شرطيةإذا كان الشرط صحيحاً ? فسيكون X : وإلا Y
isتحديد ما إذا كان العنصر هو نوع معين.If( Ford is Car) // التحقق مما إذا كان Ford هو عنصر من فئة Car.
asالتحويل القسري، حتى إذا فشل التحويل لن يرفع استثناء.Object obj = new StringReader("Hello");
　 　StringReader r = obj as StringReader;

نموذج عبر الإنترنت

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　/* مثال على عملاقية sizeof */
　　　　　　　　　Console.WriteLine("حجم int هو {0}", sizeof(int));
　　　　　　　　　Console.WriteLine("حجم short هو {0}", sizeof(short));
　　　　　　　　　Console.WriteLine("حجم double هو {0}", sizeof(double));
　　　　　　　　　
　　　　　　　　　/* مثال على عملاقية الثلاثية */
　　　　　　　　　int a, b;
　　　　　　　　　a = 10;
　　　　　　　　　b = (a == 1) ? 20 : 30;
　　　　　　　　　Console.WriteLine("قيمة b هي {0}", b);
　　　　　　　　　b = (a == 10) ? 20 : 30;
　　　　　　　　　Console.WriteLine("قيمة b هي {0}", b);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

عندما يتم ترميز وتنفيذ الكود أعلاه، سيظهر النتيجة التالية:

حجم int هو 4
حجم short هو 2
حجم double هو 8
قيمة b هي 30
قيمة b هي 20

أولوية العمليات في C#

يحدد أولوية العمليات ترتيب العناصر في التعبير. هذا يؤثر على كيفية حساب التعبير. بعض العمليات لديها أولوية أعلى من العمليات الأخرى، مثل عمليات الضرب والقسمة لديها أولوية أعلى من عمليات الإضافة والطرح.

على سبيل المثال x = 7 + 3 * 2، هنا، يتم تعيين x بـ 13 وليس 20، لأن عمليات الضرب * لديها أولوية أعلى من عمليات الإضافة +، لذا يتم حساب الضرب 3*2 أولاً، ثم يتم إضافة 7.

الجدول أدناه يقوم بترتيب جميع المعادلات حسب أولوية العمليات من أعلى إلى أسفل، حيث تظهر المعادلات ذات الأولوية العالية في الأعلى والمعادلات ذات الأولوية المنخفضة في الأسفل. في التعبير، يتم حساب العمليات ذات الأولوية العالية أولاً.

التصنيف　المعادلات　الترابط　
الجزء التالي　( ) [] -> . ++ -- 　من اليسار إلى اليمين　
الواحدية　+ - ! ~ ++ -- (type)* & sizeof　من اليمين إلى اليسار　
الضرب والقسمة　* / %　من اليسار إلى اليمين　
الإضافة والطرح　+ -　من اليسار إلى اليمين　
التنقل　<< >>　من اليسار إلى اليمين　
العلاقات　< <= > >=　من اليسار إلى اليمين　
التناظرية　== !=　من اليسار إلى اليمين　
الوظيفة AND　&　من اليسار إلى اليمين　
الوظيفة XOR　^　من اليسار إلى اليمين　
الوظيفة OR　|　من اليسار إلى اليمين　
ال逻辑ية والـ AND　&&　من اليسار إلى اليمين　
ال逻辑ية أو OR　||　من اليسار إلى اليمين　
الشرطية　?:　من اليمين إلى اليسار　
التعيين　= += -= *= /= %= >>= <<= &= ^= |=　من اليمين إلى اليسار　
الcomma　,　من اليسار إلى اليمين　

نموذج عبر الإنترنت

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　int a = 20;
　　　　　　　　　int b = 10;
　　　　　　　　　int c = 15;
　　　　　　　　　int d = 5;
　　　　　　　　　int e;
　　　　　　　　　e = (a + b) * c / d; // (30 * 15) / 5
　　　　　　　　　Console.WriteLine("(a + b) * c / d القيمة هي {0}", e);
　　　　　　　　　e = ((a + b) * c) / d; // (30 * 15) / 5
　　　　　　　　　Console.WriteLine("((a + b) * c) / d القيمة هي {0}", e);
　　　　　　　　　e = (a + b) * (c / d); // (30) * (15/5)
　　　　　　　　　Console.WriteLine("(a + b) * (c / d) القيمة هي {0}", e);
　　　　　　　　　e　=　a　+　(b　*　c)　/　d;　　　　//　　20　+　(150/5)
　　　　　　　　　e = a + (b * c) / d;    // 20 + (150/5)
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

عندما يتم ترميز وتنفيذ الكود أعلاه، سيظهر النتيجة التالية:

قيمة (a + b) * c / d هي 90
قيمة ((a + b) * c) / d هي 90
قيمة (a + b) * (c / d) هي 90
قيمة a + (b * c) / d هي 50
FileInfo في C#الواجهة في C# (Interface)