آموزش جامع Visual C# 2005

[Borna66]

آموزش جامع Visual C# 2005
درس اول : آغاز كار با C#



ليست 1-1، يك برنامة ساده با عنوان Welcome در زبان C#



// Namespace اعلان
using System;

// كلاس آغازين برنامه
classWelcomeCSS
{
// آغاز كار اجراي برنامه
public static void Main()
{
// نوشتن متن در خروجي
Console.WriteLine("Welcome to the C# Persian Tutorial!");
}
}


برنامة ليست 1-1 داراي 4 پارامتر اصلي است، اعلان Namespace، كلاس، متد Main() و يك دستور زبان C#.
در همين جا بايد به يك نكته اشاره كنم، براي زبان C# همانند بيشتر زبانهاي برنامه‌سازي دو نوع كامپايلر وجود دارد. يك نوع كامپايلر كه به كامپايلر Command Lineمعروف است و نوع ديگر كامپايلر Visualاست. كامپايلر‌هاي Command Lineمحيطي شبيه به محيط DOS دارند و با دادن يك سري دستورات به اجرا در مي‌آيند. كامپايلرهاي Visualمحيطي همانند ويندوز دارند كه با دارا بودن محيط گرافيكي و ابزارهاي خاص، برنامه‌نويس را در امر برنامه‌سازي كمك مي‌كنند. از نمونه‌هاي هر يك از كامپايلرها، مي‌توان به Microsoft C# Command Line Compiler كه يك كامپايلر Command Line و Microsoft Visual C# كه يك كامپايلر Visual است، اشاره كرد. البته در حال حاضر بيشتر از كامپايلرهاي ويژوال استفاده مي‌شود.
من سعي مي‌كنم در آينده به توضيح محيط Visual C# و Visual Studio.Net بپردازم. اما فعلاً براي اجراي برنامه‌ها مي‌توانيد از Visual Studio.Net استفاده كنيد. پس از نصب آن، وارد محيط C# شده و در قسمت انتخاب برنامة جديد گزينة Console را جهت اجراي برنامه‌ها انتخاب نماييد.
براي اين درس، فعلاً به توضيحات بيشتر دربارة محيط ويژوال نمي‌پردازم اما در آينده به توضيح كامل محيط Visual Studio.Net خواهم پرداخت.
براي اجراي كد بالا در صورتيكه از محيط ويژوال استفاده مي‌كنيد بايد بر روي دكمة Run كليك كنيد و در صورتيكه كامپايلر Command Line داريد با دستور زير مي‌توانيد برنامه را اجرا كنيد : csc Welcome.cs
پس از اجراي برنامه، كامپايلر براي شما يك فايل قابل اجرا(Executable) تحت نام Welcome.exe توليد مي‌كند.
نكته : در صورتيكه از Visual Studio.Net(VS.Net) استفاده كنيد، پس از اجراي برنامه، يك صفحه براي نمايش خروجي به سرعت باز شده و بسته مي‌شود و شما قادر به ديدن خروخي نخواهيد بود. براي اينكه بتوانيد خروجي برنامه را ببينيد، در انتهاي برنامه دستور زير را وارد نماييد :
‍Console.ReadLine();
استفاده از اين دستور باعث مي‌شود تا برنامه منتظر دريافت يك ورودي از كاربر بماند، كه در اين حالت شما مي‌توانيد خروجي برنامه خود را ديده و سپس با زدن كليد Enter برنامه را خاتمه دهيد.

نكتة ديگري كه در مورد زبان برنامه‌نويسي C# بايد مورد توجه قرار دهيد اينست كه اين زبان Case Sensitive است، بدين معنا كه به حروف كوچك و بزرگ حساس است يعني براي مثال ReadLine با readLine متفاوت است به طوريكه اولي جزو دستورات زبان C# و دومي به عنوان يك نام براي متغير يا يك تابع كه از طرف كاربر تعريف شده است در نظر گرفته مي‌شود.

اعلان Namespace به سيستم اعلان مي‌نمايد كه شما از توابع كتابخانه‌اي Systemجهت اجراي برنامه‌ها خود استفاده مي‌نماييد. دستوراتي مانند WriteLine و ReadLine جزو توابع كتابخانه‌اي System مي‌باشند. اغلب دستورات و توابع مهم و كليدي استفاده از كنسول ورودي/خروجي در اين كتابخانه مي‌باشد. در صورتيكه در ابتداي برنامه از using System استفاده نكنيد، يابد در ابتداي هر يك از دستورات برنامه كه مربوط اين كتابخانه است، از كلمة System استفاده نماييد. بعنوان مثال در صورت عدم استفاده از using System بايد از دستور System.Console.WriteLine() به جاي Console.WriteLine() استفاده نماييد.

تعريف كلاس،Class Welcome CSS، شامل تعريف داده‌ها(متغيرها) و متدها جهت اجراي برنامه است. يك كلاس، جزو معدود عناصر زبان C# است كه بوسيلة آن مي‌توان به ايجاد يك شي (Object) از قبيل واسط‌ ها (Interfaces) و ساختارها(Structures)، پرداخت. توضيحات بيشتر در اين زمينه در درس‌هاي آينده ذكر مي‌شوند. در اين برنامه كلاس هيچ داده‌ و متغيري ندارد و تنها شامل يك متد است. اين متد، رفتار(Behavior) اين كلاس را مشخص مي‌كند.

متد درون اين كلاس بيان مي‌كند كه اين كلاس چه كاري را پس از اجرا شدن انجام خواهد داد. كلمة كليدي Main() كه نام متد اين كلاس نيز مي‌باشد جزو كلمات رزرو شده زبان C# است كه مشخص مي‌كند برنامه از كجا بايد آغاز به كار نمايد. وجود متد Main() در تمامي برنامه‌هاي اجرايي ضروري است. در صورتيكه يك برنامه حاوي متد Main() نباشد بعنوان توابع سيستمي همانند dll هاي ويندوز در نظر گرفته مي‌شود.
قبل از كلمة Main() كلمه ديگري با عنوان static آورده شده است. اين كلمه در اصطلاح Modifier مي‌گويند. استفاده از static براي متد Main() بيان مي‌دارد كه اين متد تنها در در همين كلاس قابل اجراست و هيچ نمونه‌اي (Instance) ديگري از روي آن قابل اجرا نمي‌باشد. استفاده از static براي متد Main() الزامي است زيرا در ابتداي آغاز برنامه هيچ نمونه‌اي از هيچ كلاس و شي‌اي موجود نمي‌باشد و تنها متد Main() است كه اجرا مي‌شود. (در صورتيكه با برخي اصطلاحات اين متن از قبيل كلاس، شي، متد و نمونه آشنايي نداريد، اين به دليل آنست كه اين مفاهيم جزو مفاهيم اولية برنامه‌نويسي شي‌گرا (OOP) هستند. سعي مي‌كنم در درس‌هاي آينده به توضيح اين مفاهيم نيز بپردازم، ولي فعلاً در همين حد كافي مي‌باشد.)

هر متد بايد داراي يك مقدار بازگشتي باشد، يعني بايد مقداري را به سيستم بازگرداند، در اين مثال نوع بازگشتي void تعزيف شده است كه نشان دهنده آنست كه اين متد هيچ مقداري را باز نمي‌گرداند يا به عبارت بهتر خروجي ندارد. همچنين هر متد مي‌تواند داراي پارامترهايي نيز باشد كه ليست پارامترهاي آن در داخل پرانتزهاي جلوي آن قرار مي‌گيرد. براي سادگي كار در اين برنامه متد ما داراي هيچ پارامتري نيست ولي در ادامة همين درس به معرفي پارامترها نيز مي‌پردازم.

متد Main() رفتار و عمل خود را بوسيله Console.WriteLine(…) مشخص مي‌نمايد. Consoleكلاسي در System است و WriteLine()متدي در كلاس Console. در زبان C# از اپراتور "." (نقطه dot) جهت جداسازي زيرروتين‌ها و زيرقسمتها استفاده مي‌كنيم. همانطور كه ملاحظه مي‌كنيد چون WriteLine() يك متد درون كلاس Console است به همين جهت از "." جهت جداسازي آن استفاده كرده‌ايم.

در زبان ‍C#، براي قرار دادن توضيحات در كد برنامه از // استفاده مي‌كنيم. بدين معنا كه كامپايلر در هنگام اجراي برنامه توجهي به اين توضيحات نمي‌كند و اين توضيحات تنها به منظور بالا بردن خوانايي متن و جهت و كمك به فهم بهتر برنامه قرار مي‌گيرند. استفاده از // تنها در مواردي كاربرد دارد كه توضيحات شما بيش از يك خط نباشد. در صورت تمايل براي استفاده از توضيحات چند خطي بايد در ابتداي شروع توضيحات از /* و در انتها آن از */ استفاده نماييد. در اين حالت تمامي مطالبي كه بين /* */ قرار مي‌گيرند به عنوان توضيحات (Comments) در نظر گرفته مي‌شوند.

تمامي دستورات (Statements) با ";"، سمي كولون، پايان مي‌يابند. كلاس‌ها و متد‌ها با } آغاز شده و با { خاتمه مي‌يابند. تمامي دستورات بين { } يك بلوك را مي‌سازند.

بسياري از برنامه‌ها از كاربر ورودي دريافت مي‌كنند. انواع گوناگوني از اين ورودي‌ها مي‌توانند به عنوان پارامتري براي متد Main() در نظر گرفته شوند. ليست 2-1 برنامه‌اي را نشان مي‌دهد نام كاربر را از ورودي دريافت كرده و آن را بر روي صفحه نمايش مي‌دهد. اين ورودي به صورت پارامتري براي متد Main() در نظر گرفته شده است.

ليست 2-1 : برنامه‌اي كه ورودي را از كاربر، بعنوان پارامتر Main()، دريافت مي‌كند.



// Namespace اعلان
usingSystem;
// كلاس آغازين برنامه
classNamedWelcome
{
// آغاز اجرا برنامه
public static voidMain(string[] args)
{
//نمايش بر روي صفحه
Console.WriteLine("Hello, {0}!", args[0]);
Console.WriteLine("Welcome to the C# Persian Tutorial!");
}
}


توجه داشته باشيد كه اين برنامه، ورودي را به صورت Command-Line دريافت مي‌كند و در هنگام اجراي برنامه بايد ورودي را در Command-Line وارد نماييد. در صورتيكه ورودي را وارد ننماييد برنامه دچار مشكل شده و متوقف خواهد شد.

همان طور كه در ليست 2-1 مشاهده مي‌نماييد، پارامتر متد Main() با عنوان argsمشخص شده است. با استفاده از اين نام در داخل متد مي‌توان آن استفاده نمود. نوع اين پارامتر از نوع آرايه‌اي از نوع رشته (string[]) در نظر گرفته شده است. انواع(types) و آرايه‌ها را در درس‌هاي بعدي بررسي مي‌كنيم. فعلاً بدانيد كه آرايه رشته‌اي جهت نگهداري چندين كاراكتر مورد استفاده قرار مي‌گيرد. [] مشخص كننده آرايه هستند كه مانند يك ليست عمل مي‌كند.

همانطور كه ملاحظه مي‌كنيد در اين برنامه دو دستور Console.WriteLine(…) وجود دارد كه اولين دستور مقداري با دستور دوم متفاوت است. همانطور كه مشاهده مي‌كنيد داخل دستور Console.WriteLine(…) عبارتي به شكل {0} وجود دارد. اين آرگومان، نشان مي‌دهد كه به جاي آن چه مقداري بايد نمايش داده شود كه در اين جا args[0] نشان داده مي‌شود. عبارتي كه داخل " " قرار دارد عيناً در خروجي نمايش داده مي‌شود، به جاي آرگومان {0}، مقداري كه پس از " قرار دارد، قرار مي‌گيرد. حال به آرگومان بعدي يعني args[0] توجه كنيد. مقدار صفر داخل [] نشان مي‌دهد كه كدام عنصر از آرايه مورد استفاده است. در C# انديس آرايه از صفر شروع مي‌شود به همين جهت براي دسترسي به اولين عنصر آرايه بايد از انديس صفر استفاده كنيم.(همانطور كه قبلاً نيز كفتم آرايه‌ها را در درس‌هاي آينده توضيح خواهم داد، هدف از اين درس تنها آشنايي با C# است.!)

مجدداً به آرگومان {0} بازگرديم. اين آرگومان نشان مي دهد كه يك مقدار بايد در رشته خروجي قرار گيرد، اين مقدار همان args[0] است. اگر شما اين برنامه را از طريق Command-Line اجرا نماييد خروجي شبيه به زير خواهيد گرفت :
>Hello!, Meysam!
>Welcome to C# Persian Tutorial!
همان گونه كه مي‌بينيد، پس از اجراي برنامه نام شما كه از طريق Command-Line آنرا وارد نموده‌ايد در خروجي ظاهر مي‌شود. استفاده از آرگومان {n}، كه در آن n يك مقدار عددي است، جهت فرمت دادن به متن خروجي است كه بر روي صفحه به نمايش در مي‌آيد. مقدار n از صفر آغاز شده و به ترتيب افزايش مي‌بايد. به مثال زير توجه كنيد :
Console.WriteLine("Hello! ,{0} ,{1}, {2}",args[0],args[1],args[2]);
اين خط از برنامه سه مقدار args[0],args[1],args[2] را در خروجي به ترتيب نمايش مي‌دهد. ملاحظه مي‌نماييد كه چون 3 مقدار را مي‌خواهيم نمايش دهيم، سه بار از آرگومان {n} استفاده كرده‌ايم و هر بار يك واحد به مقدار قبلي افزوده‌ايم. در آينده بيشتر با اين مفاهيم آشنا مي‌شويم.

مطلبي كه بايد در مورد ليست 2-1 به آن توجه شود آنست كه اين برنامه تنها از طريق Command-Lineقابل اجراست و در صورتيكه كاربر از اين مطلب كه برنامه بايد داراي ورودي به صورت Command-Line باشد، بي اطلاع باشد و ورودي را در Command-Line وارد نكند، برنامه متوقف شده و اجرا نمي‌شود. پس براي رفع چنين مشكلي بايد از روش بهتري جهت دريافت ورودي از كاربر استفاده كرد.

ليست 3-1 : يك برنامه كه قابليت محاوره با كاربر را دارد.




// Namespace اعلان
usingSystem;

// كلاس آغازين برنامه
classInteractiveWelcome
{
//آغاز اجراي برنامه
public static voidMain()
{
// متني بر روي صفحه نمايش داده مي‌شود
Console.Write("What is your name?: ");
//متني نمايش داده شده و برنامه منتظر دريافت ورودي مي‌ماند
Console.Write("Hello, {0}! ", Console.ReadLine());
Console.WriteLine("Welcome to the C# Persian Tutorial!");
}
}



همانطوريكه در اين برنامه ديده مي شود، متد Main() داراي پارامتر نيست. در عوض يك خط به متن برنامه ليست 2-1 اضافه شده است. در اولين خط از اين برنامه، متني با عنوان اينكه نام شما چيست؟ بر روي صفحه ظاهر مي‌شود. سپس در خط بعدي پس از نوشتن كلمه Hello, ، برنامه منتظر دريافت ورودي از كاربر مي‌شود. بدين معني كه اين بار تا زمانيكه كاربر متني را به عنوان نام خود وارد نكند اجراي برنامه به پيش نخواهد رفت و خط بعدي اجرا نمي‌شود. اين برنامه روش ايجاد ارتباط از طريق برنامه با كاربر را نمايش مي‌دهد. در اين مثال كاربر دقيقاً متوجه مي‌شود كه چه زماني بايد اطلاعات را وارد نمايد و اين اطلاعات چه بايد باشد در حاليكه در مثال قبل چنين نبود. همانگونه كه مي‌بينيد در اين برنامه آرگومان {0} مستقيماً از طريق دستور Console.ReadLine() دريافت مي‌شود و بلافاصله در خروجي نمايش داده مي‌شود. دستور ReadLine() نيز يكي از متدهاي كلاس Console است كه بوسيله آن رشته ورودي خوانده مي‌شود.
خروجي برنامه فوق به شكل زير است :
What is your name?:
(سپس برنامه منتظر دريافت متني از ورودي توسط كاربر مي‌ماند)
(پس از اينكه كاربر رشته‌اي را وارد كرد و كليدEnter را فشار داد، متن زير نمايش داده مي‌شود.)
Hello, Meysam!
(سپس اجراي برنامه به دستور بعدي منتقل مي‌شود)
Welcome to the C# Persian Tutorial!

خروجي كامل برنامه :
What is your name?:
Hello, Meysam! Welcome to the C# Persian Tutorial!
توجه كنيد كه ReadLine() به عنوان يك متد، مقداري را به سيستم بازمي‌گرداند. اين مقدار در اين برنامه به آرگومان {0} برگردانده مي‌شود. اين خط از برنامه را مي‌توان طور ديگري هم نوشت :



string myName=Console.ReadLine();
Console.WriteLine("Hello, {0}!",myName);



در اين حالت ما يك متغير از نوع رشته با نام myName تعريف كرده‌ايم كه مقدار ورودي در آن ذخيره مي‌شود و سپس از اين مقدار به عنوان مقداري‌ كه {0} مي‌پذيرد استفاده كرده‌ايم.

در اين درس آموختيد كه ساختار كلي يك برنامه C# چگونه است. هر برنامه C# از يك كلاس اصلي تشكيل مي‌شود كه اين كلاس شامل داده‌ها و متغيرها و متدهايي مي‌باشد. متد آغازين برنامه كه برنامه با آن شروع به اجرا مي‌كند، متد Main() است. با استفاده از توابع كتابخانه‌اي مي‌نوان به كلاسها و متدهاي C# دسترسي پيدا كرد. از جمله اين توابع System بود كه يكي از كلاسهاي آن Console و چند متد اين كلاس، متدهاي WriteLine() و ReadLine() بودند.

[Borna66]

درس دوم – عبارات، انواع و متغيرها در C#


متغيرها، به بيان بسيار ساده، مكانهايي جهت ذخيره اطلاعات هستند. شما اطلاعاتي را در يك متغير قرار مي‌دهيد و از اين اطلاعات بوسيله متغير در عبارات ‍‍C# استفاده مي‌نماييد. كنترل نوع اطلاعات ذخيره شده در متغيرها بوسيله تعيين كردن نوع براي هر متغير صورت مي‌پذيرد.
C# زباني بسيار وابسته به انواع است، بطوريكه تمامي عملياتي كه بر روي داده‌ها و متغيرها در اين زبان انجام مي‌گيرد با دانستن نوع آن متغير ميسر مي‌باشد. قوانيني نيز براي تعيين اينكه چه عملياتي بر روي چه متغيري انجام شود نيز وجود دارد.(بسته به نوع متغير)

انوع ابتدايي زبان C# شامل : يك نوع منطقي(Boolean) و سه نوع عددي اعداد صحيح(integer)، اعداد اعشاري(Floating points) و اعداد دسيمال(Decimal) مي‌باشد.(به انواع Boolean از اينرو منطقي مي‌گوييم كه تنها داراي دو حالت منطقي صحيح(True) و يا غلط(False) مي‌باشند.)

مثال 1 – نشان دادن مقادير منطقي (Boolean)




usingSystem;
classBooleans
{
public static voidMain()
{
boolcontent = true;
boolnoContent = false;
Console.WriteLine("It is {0} that C# Persian provides C# programming language
content.", content);
Console.WriteLine("The statement above is not {0}.", noContent);
}
}



در اين مثال، مقادير منطقي متغير‌هاي Boolean به عنوان قسمتي از جمله در خروجي نمايش داده مي‌شوند. متغير‌هاي bool تنها مي‌توانند يكي از دو مقدار true يا false را داشته باشند، يعني همانند برخي از زبانهاي برنامه‌سازي مشابه، مانند C و يا C++، مقدار عددي نمي‌پذيرند، زيرا همانگونه كه مي‌دانيد در اين دو زبان هر مقدار عددي صحيح مثبت بغير از صفر به عنوان true و عدد صفر به عنوان false در نظر گرفته مي‌شود و در حقيقت نوع bool در اين دو زبان نوعي integer مي‌باشند. اما در زبان C# انواع boolيكي از دو مقدار true يا false را مي‌پذيرند. خروجي برنامه بالا به صورت زير است :
It is True that C# Persian provides C# programming language content.
The statement above is not False.
جدول زير تمامي انواع عددي صحيح ‍C#، اندازه آنها و رنج قابل قبول آنها را نشان مي‌دهد.
رنج قابل قبول
اندازه به بيت
نوع
128- تا 127
8
sbyte
0 تا 255
8
byte
32768- تا 32767
16
short
0 تا 65535
16
ushort
2147483648- تا 2147483647
32
int
0 تا 4294967295
32
uint
9223372036854775808- تا 9223372036854775807
64
long
0 تا 18446744073709551615
64
ulong
از اين انواع براي محاسبات عددي استفاده مي‌گردد. يك نوع ديگر را نيز مي‌توان در اين جدول اضافه نمود و آن نوع char است. هر چند شايد از نظر بسياري از دوستاني كه با زبانهاي ديگر برنامه‌سازي كار كرده‌اند اين تقسيم بندي غلط به نظر آيد، اما بايد گفت كه در زبان C# نوع char نيز نوع خاصي از انواع عددي است كه رنجي بين صفر تا 65535 دارد و اندازه آن نيز 16 بيتي است، اما به جاي نمايش دادن مقادير عددي تنها مي‌تواند بيان كننده يك كاراكتر باشد. در آينده در اين مورد بيشتر توضيح خواهم داد.

جدول زير تمامي انواع عددي اعشاري زبان C# را نمايش مي‌دهد.
رنج قابل قبول
دقت
اندازه به بيت
نوع
تا
7 رقم
32
float
تا
15-16 رقم
64
double
تا
28-29 رقم دسيمال
128
decimal

انواعي از نوع floating point هنگامي استفاده مي‌شوند كه محاسبات عددي به دقت‌هاي اعشاري نياز داشته باشند. همچنين براي منظورهاي تجاري استفاده از نوع decimal بهترين گزينه است. اين نوع تنها در زبان C# وجود دارد و در زبانهاي مشابه به آن نظير Java چنين نوعي در نظر گرفته نشده است.

در يك زبان برنامه‌سازي نتايج بوسيله ايجاد يك سري عبارت توليد مي‌گردند. عبارات از تركيب متغيرها و عملگرها در دستورالعمل‌هاي يك زبان ايجاد مي‌گردند.(توجه نماييد كه عبارت معادل expression و دستورالعمل معادل statement مي‌باشد كه ايندو با يكديگر متفاوت مي‌باشند.) جدول زير عملگرهاي موجود در زبان C#، حق تقدم آنها و شركت‌پذيري آنها را نشان مي‌دهد.
شركت‌پذيري
عملگر(ها)
نوع عمل
از چپ
(x) x.y f(x) a[x] x++ x--
new typeof sizeof checked unchecked
عمليات ابتدايي
از چپ
+ - ! ~ ++x --x (T)x
عمليات يكاني
از چپ
* / %
عمليات ضربي
از چپ
- +
عمليات جمعي
از چپ
<< >>
عمل شيفت
از چپ
< > <= >= is
عمليات رابطه‌اي
از راست
== !=
عمليات تساوي
از چپ
&
عمل AND منطقي
از چپ
|
عمل OR منطقي
از چپ
^
عمل XOR منطقي
از چپ
&&
عمل AND شرطي
از چپ
||
عمل OR شرطي
از چپ
?:
عمل شرطي
از راست
= *= /= %= += -= <<= >>= &= ^= |=

[Borna66]

درس سوم – دستورالعمل‌هاي كنترلي و شرطي

بررسي دستور if و انواع مختلف آن
در درسهاي گذشته، برنامه‌هايي كه مشاهده مي‌كرديد از چندين خط دستور تشكيل شده بودند كه يكي پس از ديگري اجرا مي‌شدند و سپس برنامه خاتمه مي‌يافت. در اين برنامه‌ها هيچ عمل تصميم‌گيري صورت نمي‌گرفت و تنها دستورات برنامه به ترتيب اجرا مي‌شدند. مطالب اين درس نحوه تصميم‌گيري در يك برنامه را به شما نشان مي‌دهد.

اولين دستور تصميم‌گيري كه ما آنرا بررسي مي‌نماييم، دستورالعمل if است. اين دستور داراي سه فرم كلي : تصميم‌گيري ساده، تصميم‌گيري دوگانه، تصميم‌گيري چندگانه مي‌باشد.

مثال 1-3 – فرم‌هاي دستورالعمل if



usingSystem;

classIfSelect
{
public static voidMain()
{
stringmyInput;
intmyInt;
Console.Write("Please enter a number: ");
myInput = Console.ReadLine();
myInt = Int32.Parse(myInput);
//تصميم‌گيري ساده و اجراي عمل داخل دو كروشه
if(myInt > 0)
{
Console.WriteLine("Your number {0} is greater than zero.", myInt);
}
//تصميم‌گيري ساده و اجراي عمل بدون استفاده از دو كروشه
if(myInt < 0)
Console.WriteLine("Your number {0} is less than zero.", myInt);
// تصميم‌گيري دوگانه
if(myInt != 0)
{
Console.WriteLine("Your number {0} is not equal to zero.", myInt);
}
else
{
Console.WriteLine("Your number {0} is equal to zero.", myInt);
}
// تصميم‌گيري چندگانه
if(myInt < 0 || myInt == 0)
{
Console.WriteLine("Your number {0} is less than or equal to zero.", myInt);
}
else if(myInt > 0 && myInt <= 10)
{
Console.WriteLine("Your number {0} is between 1 and 10.", myInt);
}
else if (myInt > 10 && myInt <= 20)
{
Console.WriteLine("Your number {0} is between 11 and 20.", myInt);
}
else if(myInt > 20 && myInt <= 30)
{
Console.WriteLine("Your number {0} is between 21 and 30.", myInt);
}
else
{
Console.WriteLine("Your number {0} is greater than 30.", myInt);
}
} //Main()پايان متد
} //IfSelectپايان كلاس




برنامه 1-3 از يك متغير myInt براي دريافت ورودي از كاربر استفاده مي‌نمايد، سپس با استفاده از يك سري دستورات كنترلي، كه همان دستور if در اينجاست، عمليات خاصي را بسته به نوع ورودي انجام مي‌دهد. در ابتداي اين برنامه عبارت Please enter a umber: در خروجي چاپ مي‌شود. دستور Console.ReadLine() منتظر مي‌ماند تا كاربر ورودي وارد كرده و سپس كليد Enter را فشار دهد. همانطور كه در قبل نيز اشاره كرده‌ايم، دستور Console.ReadLine() عبارت ورودي را به فرم رشته دريافت مي‌نمايد پس مقدار ورودي كاربر در اينجا كه يك عدد است به فرم رشته‌اي در متغير myInput كه از نوع رشته‌اي تعريف شده است قرار مي‌گيرد. اما ميدانيم كه براي اجراي محاسبات و يا تصميم‌گيري بر روي اعداد نمي‌توان از آنها در فرم رشته‌اي استفاده كرد و بايد آنها را بصورت عددي مورد استفاده قرار داد. به همين منظور بايد متغير myInput را به نحوي به مقدار عددي تبديل نماييم. براي اين منظور از عبارت Int32.Parse() استفاده مي‌نماييم. اين دستور مقدار رشته‌اي متغير داخل پرانتزش را به مقدار عددي تبديل كرده و آنرا به متغير ديگري از نوع عددي تخصيص مي‌دهد. در اين مثال نيز همانطور كه ديده مي‌شود، myInput كه تز نوع رشته‌اي است در داخل پرانتز قرار گرفته و اين مقدار برابر با myInt كه از نوع int است قرار گرفته است. با اين كار مقدار عددي رشته ورودي كاربر به متغير myInt تخصيص داده مي‌شود. (توضيح كامل‌تري در مورد Int32 و ساير تبديلات مشابه به‌ آن در درسهاي آينده و در قسمت نوع‌هاي پيشرفته مورد بررسي قرار مي‌گيرند.)حال ما متغيري از نوع مورد نظر در دست داريم و مي‌توانيم با استفاده از دستور if بر روي آن پردازش انجام داده و تصميم‌گيري نماييم.

دستور if
اولين دستور بصورت if(boolean expression) {statements} آورده شده است. دستور if با استفاده از كلمه كليدي if آغاز مي‌شود. سپس يك عبارت منطقي درون يك زوج پرانتز قرار مي‌گيرد . پس از بررسي اين عبارات منطقي دستورالعمل/دستورالعمل‌هاي داخل كروشه اجرا مي‌شوند. همانطور كه مشاهده مي‌نماييد، دستور if يك عبارت منطقي را بررسي مي‌كند. در صورتيكه مقدار اين عبارات true باشد دستورهاي داخل بلوك خود را اجرا مي‌نمايد(قبلا توضيح داده شد كه دستورهايي كه داخل يك زوج كروشه {} قرار مي‌گيرند در اصطلاح يك بلوك ناميده مي‌شوند.) و در صورتيكه مقدار آن برابر با false باشد اجراي برنامه به بعد از بلوك if منتقل مي‌شود. در اين مثال همانطور كه ملاحظه مي‌نماييد، عبارت منطقي دستور if بشكل if(myInt > 0) است. در صورتيكه مقدار myInt بزرگتر از عدد صفر باشد، دستور داخل بلوك if اجرا مي‌شود و در غير اينصورت اجراي برنامه به بعد از بلوك if منتقل مي‌گردد.

دومين دستور if دراين برنامه بسيار شبيه به دستور اول است، با اين تفاوت كه در اين دستور، دستور اجرايي if درون يك بلوك قرار نگرفته است. در صورتيكه بخواهيم با استفاده از دستور if تنها يك دستورالعمل اجرا شود، نيازي به استفاده از بلوك براي آن دستورالعمل نمي‌باشد. استفاده از بلوك تنها زماني ضروري است كه بخواهيم از چندين دستور استفاده نماييم.

دستور if-else
در بيشتر موارد از تصميم‌گيري‌هاي دوگانه يا چندگانه استفاده مي‌شود. در اين نوع تصميم‌گيري‌ها، دو يا چند شرط مختلف بررسي مي‌شوند و در صورت true بودن يكي از آنها عمل مربوط به آن اجرا مي‌گردد. سومين دستور if در اين برنامه نشان دهنده يك تصميم‌گيري دوگانه است. در اين حالت درصورتيكه عبارت منطقي دستور if برابر با true باشد دستور بعد از if اجرا مي‌شود و در غير اينصورت دستور بعد از else به اجرا در مي‌آيد. در حقيقت در اين حالت مي‌گوئيم " اگر شرط if صحيح است دستورات مربوط به if را انجام بده و درغير اينصورت دستورات else را اجرا كن".
فرم كلي دستور if-else بصورت زير است :



if(boolean expression)
{statements}
else
{statements}


كه در آن boolean expression عبارت منطقي است كه صحت آن مورد بررسي قرار مي‌گيرد و statements دستور يا دستوراتي است كه اجرا مي‌گردند.

دستور if-else if … else يا if تودرتو
در صورتيكه نياز باشد تا چندين حالت منطقي مورد بررسي قرار گيرد و دستورات مربوط به يكي از آنها اجرا شود، از فرم تصميم‌گيري چندگانه استفاده مي‌نماييم. اين نوع استفاده از دستور if در اصطلاح به if تودرتو (Nested If) معروف است چراكه در آن از چندين دستور if مرتبط به يكديگر استفاده شده است. چهارمين دستور if در مثال 1-3 استفاده از if تودرتو را نشان مي‌دهد. در اين حالت نيز دستور با كلمه كليدي if آغاز مي‌گردد. شرطي بررسي شده و در صورت true بودن دستورات مربوط به آن اجرا مي‌گردد. اما اگر مقدار اين عبارت منطقي false بود آنگاه شرطهاي فرعي ديگري بررسي مي‌شوند.اين شرطهاي فرعي با استفاده از else if مورد بررسي قرار مي‌گيرند. هر يك از اين شرطها داراي عبارات منطقي مربوط به خود هستند كه در صورت true بودن عبارت منطقي دستورات مربوط به آنها اجرا مي‌گردد و در غير اينصورت شرط بعدي مورد بررسي قرار مي‌گيرد. بايد توجه كنيد كه در ساختار if تودرتو تنها يكي از حالتها اتفاق مي‌افتد و تنها يكي از شرطها مقدار true را بازمي‌گرداند.
فرم كلي if تودرتو بشكل زير است :



if(boolean expression)
{statements}
elseif(boolean expression)
{statements}
…
else
{statements}



عملگرهاي OR و AND (|| و &&)
نكته ديگري كه بايد در اينجا بدان اشاره كرد، نوع شرطي است كه در عبارت منطقي دستور if آخر مورد استفاده قرار گرفته است. در اين عبارت منطقي از عملگر || استفاده شده است كه بيانگر OR منطقي است. عملگر OR زماني مقدار true بازمي‌گرداند كه حداقل يكي از عملوندهاي آن داراي مقدار true باشد. بعنوان مثال در عبارت (myInt < 0 || myInt == 0)، در صورتيكه مقدار متغير myInt كوچكتر يا مساوي با صفر باشد، مقدار عبارت برابر با true است. نكته قابل توجه آنست كه در زبان ‍C#، همانطور كه در درس دوم به آن اشاره شد، دو نوع عملگر OR وجود دارد. يكي OR منطقي كه با || نمايش داده مي‌شود و ديگري OR معمولي كه با | نشان داده مي‌شود. تفاوت بين اين دو نوع OR در آنست كه OR معمولي هر دو عملگر خود را بررسي مي‌نمايد اما OR منطقي تنها در صورتيكه عملگر اول آن مقدار false داشته باشد به بررسي عملگر دوم خود مي‌پردازد.

عبارت منطقي (myInt > 0 && myInt <= 10) حاوي عملگر AND شرطي (&&) مي‌باشد. اين عبارت در صورتي مقدار true بازمي‌گرداند كه هر دو عملوند AND داراي مقدار true باشند. يعني در صورتيكه myInt هم بزرگتر از صفر باشد و هم كوچگتر از 10، مقدار عبارت برابر با true مي‌گردد. در مورد AND نيز همانند OR دو نوع عملگر وجود دارد. يكي AND معمولي (&) و ديگري AND شرطي (&&). تفاوت اين دو نيز در آنست كه AND معمولي (&) هميشه هر دو عملوند خود را بررسي مي‌نمايد ولي AND شرطي (&&) تنها هنگامي به بررسي عملوند دوم خود مي‌پردازد كه مقدار اولين عملوندش برابر با true باشد. عملگرهاي منطقي (|| و &&) را در اصطلاح عملگرهاي ميانبر (short-circuit) مي‌نامند چراكه تنها در صورت لزوم عملوند دوم خود را بررسي مي‌نمايند و از اينرو سريعتر اجرا مي‌شوند.

بررسي دستور switch
همانند دستور if، دستور switch نيز امكان تصميم‌گيري را در يك برنامه فراهم مي‌نمايد.
مثال 2-3 – دستورالعمل switch




usingSystem;

classSwitchSelect
{
public static void Main()
{
stringmyInput;
intmyInt;
begin:
Console.Write("Please enter a number between 1 and 3: ");
myInput = Console.ReadLine();
myInt = Int32.Parse(myInput);
// بهمراه متغيري از نوع صحيح switch دستور
switch(myInt)
{
case1:
Console.WriteLine("Your number is {0}.", myInt);
break;
case2:
Console.WriteLine("Your number is {0}.", myInt);
break;
case3:
Console.WriteLine("Your number is {0}.", myInt);
break;
default:
Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
break;
} //switchپايان بلوك
decide:
Console.Write("Type \"continue\" to go on or \"quit\" to stop: ");
myInput = Console.ReadLine();
// بهمراه متغيري از نوع رشته‌اي switch دستور
switch(myInput)
{
case"continue":
gotobegin;
case"quit":
Console.WriteLine("Bye.");
break;
default:
Console.WriteLine("Your input {0} is incorrect.", myInput);
gotodecide;
} //switchپايان بلوك
} //Main()پايان متد
}//SwitchSelectپايان كلاس




مثال 2-3 دو مورد استفاده از دستور switch را نشان مي‌دهد. دستور switch بوسيله كلمه كليدي switch آغاز شده و به دنبال آن عبارت دستور switch قرار مي‌گيرد. عبارت دستور switch مي‌تواند يكي از انواع زير باشد : sbyte, byte, short, ushort, int, uint, long, ulong, char, string, enum .(نوع enum در مبحث جداگانه‌اي مورد بررسي قرار خواهد گرفت.) در اولين دستور switch در مثال 2-3، عبارت دستور switch از نوع عددي صحيح (int) مي‌باشد.

به دنبال دستور و عبارت switch، بلوك switch قرار مي‌گيرد كه در آن گزينه‌هايي قرار دارند كه جهت منطبق بودن با مقدار عبارت switch مورد بررسي قرار مي‌گيرند. هر يك از اين گزينه‌ها با استفاده از كلمه كليدي case مشخص مي‌شوند. پس از كلمه كليدي case خود گزينه قرار مي‌گيرد و به دنبال آن ":" و سپس دستوري كه بايد اجرا شود. بعنوان مثال به اولين دستور switch در اين برنامه توجه نماييد. در اينجا عبارت دستور switch از نوع int است. هدف از استفاده از دستور switch آنست كه از بين گزينه‌هاي موجود در بلوك switch، گزينه‌اي را كه مقدارش با مقدار عبارت switch برابر است پيدا شده و عمل مرتبط با آن گزينه اجرا شود. در اين مثال مقدار متغير myInt بررسي مي‌شود. سپس اگر اين مقدار با يكي از مقادير گزينه‌هاي داخل بلوك switch برابر بود، دستور يا عمل مربوط به آن گزينه اجرا مي‌گردد. توجه نماييد كه در اين مثال منظور ما از گزينه همان عدد پس از case است و منظور از دستور عبارتي است كه پس از ":" قرار گرفته است. بعنوان مثال، در دستور زير :

case1:
Console.WriteLine("Your number is {0}.", myInt);
عدد 1، گزينه مورد نظر ما و دستور Console.WriteLine(…)، عمل مورد نظر است. در صورتيكه مقدار myInt برابر با عدد 1 باشد آنگاه دستور مربوط به case 1 اجرا مي‌شود كه همان Console.WriteLine("Your number is {0}.", myInt); است. پس از منطبق شدن مقدار عبارت switch با يكي از case ها، بلوك switch بايد خاتمه يابد كه اين عمل بوسيله استفاده از كلمه كليدي break، اجراي برنامه را به اولين خط بعد از بلوك switch منتقل مي‌نمايد.

همانطور كه در ساختار دستور switch مشاهده مي‌نماييد، علاوه بر case و break، دستور ديگري نيز در داخل بلوك وجود دارد. اين دستور يعني default، براي زماني مورد استفاده قرار مي‌گيرد كه هيچ يك از گزينه‌هاي بلوك switch با عبارت دستور switch منطبق نباشند. به عبارت ديگر درصورتيكه مقدار عبارت switch با هيچ يك از گزينه‌هاي case برابر نباشد، دستور مربوط به default اجرا مي‌گردد. استفاده از اين دستور در ساختار بلوك switch اختياري است. همچنين قرار دادن دستور break پس از دستور default نيز اختياري مي‌باشد.

همانطور كه قبلاً نيز گفته شد پس از هر دستور case، به منظور خاتمه دادن اجراي بلوك switch بايد از يك break استفاده نمود. دو استثنا براي اين موضوع وجود دارد. اول اينكه دو دستور case بدون وجود كد و دستورالعملي در بين آنها، پشت سر هم قرار گيرند و ديگري در زمانيكه از دستور goto استفاده شده باشد.

در صورتيكه دو دستور case بدون وجود كدي در بين آنها، پشت سر يكديگر قرار گيرند، بدين معناست كه براي هر دو case مورد نظر يك عمل خاص در نظر گرفته شده است. به مثال زير توجه نماييد.




switch(myInt)
{
case1:
case2:
case3:
Console.WriteLine("Your number is {0}.", myInt);
break;
default:
Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
break;
}



در اين مثال، همانطور كه مشاهده مي‌كنيد، سه دستور case بدون وجود كدي در بين آنها پشت سر يكديگر قرار گرفته‌اند. اين عمل بدين معناست كه براي تمامي گزينه‌هاي 1، 2 و 3 دستور ;(Console.WriteLine("Your number is {0}.", myInt اجرا خواهد شد. يعني اگر مقدار myInt برابر با هر يك از مقادير 1، 2 و 3 باشد، يك دستور براي آن اجرا مي‌شود.

نكته قابل توجه ديگر در مورد بلوك switch آنست كه، دستورات case حتماً نبايد يك دستور باشد بلكه مي‌توان از يك بلوك دستور براي case استفاده نمود.

دومين استفاده از دستور switch در مثال 2-3، داراي عبارتي از نوع رشته‌ايست. در اين بلوك switch چگونگي استفاده از دستور goto نيز نشان داده شده است. دستور goto اجراي برنامه را به برچسبي (label) كه معين شده هدايت مي‌نمايد. در حين اجراي اين برنامه، اگر كاربر رشته continue وارد نمايد، اين رشته با يكي از گزينه‌هاي دومين switch منطبق مي‌شود. چون دستور case مربوط به اين گزينه داراي دستور goto است، اجراي برنامه به برچسبي كه اين دستور مشخص كرده فرستاده مي‌شود، بدين معني كه اجراي برنامه به ابتداي جايي مي‌رود كه عبارت begin: در آنجا قرار دارد (در اوايل متد Main()). بدين صورت اجراي برنامه از بلوك switch خارج شده و به ابتداي برنامه و در جائيكه برچسب begin: قرار گرفته ارسال مي‌شود. در اين برنامه، استفاده از چنين حالتي استفاده از goto باعث ايجاد يك حلقه شده است كه با وارد كردن عبارت quit اجراي آن به پايان مي‌رسد.

در صورتيكه هيچ يك از عبارات continue و يا quit وارد نشوند، اجراي switch به گزينه default مي‌رود و در اين گزينه ابتدا پيغام خطايي بر كنسول چاپ شده و سپس با استفاده از دستور goto پرشي به برچسب decide صورت مي‌گيرد. پس از پرش به برچسب decide، از كاربر پرسيده مي‌شود كه آيا مي‌خواهد اجراي برنامه را ادامه دهد يا خير.( با وارد كردن گزينه‌هاي continue يا quit) همانطور كه مي‌بينيد در اينجا نيز حلقه‌اي توليد شده است.

استفاده از دستور goto در بلوك switch مي‌تواند موثر باشد اما بايد توجه نماييد كه استفاده‌هاي بي مورد از دستور goto باعث ناخوانا شدن برنامه شده و عيب‌يابي (Debug) برنامه را بسيار دشوار مي‌نمايد. در برنامه‌نويسي‌هاي امروزي استفاده از دستور goto بغير از موارد بسيار لازم و ضروري منسوخ شده و به هيچ عنوان توصيه نمي‌شود. براي توليد و ساخت حلقه نيز دستورات مفيد و سودمندي در زبان تعبيه شده‌اند كه استفاده از goto را به حداقل مي‌رسانند. دستورات حلقه در مبحث آينده مورد بررسي قرار خواهند گرفت.

نكته پاياني اين مبحث آنست كه توجه نماييد كه به جاي استفاده از دستور switch مي‌توانيد از چندين دستور if-else استفاده نمايد. دو قطعه برنامه زير معادل يكديگر مي‌باشند.




switch(myChar)
{
case'A' :
Console.WriteLine("Add operation\n");
break;
case'M' :
Console.WriteLine("Multiple operation\n");
break;
case'S' :
Console.WriteLine("Subtraction operation\n");
break;
default:
Console.WriteLine("Error, Unknown operation\n");
break;
}
معادل بلوك switch با استفاده از if-else
if (myChar == 'A')
Console.WriteLine("Add operation\n");
elseif(myChar == 'M')
Console.WriteLine("Multiple operation\n");
elseif (myChar == 'S')
Console.WriteLine("Subtraction operation\n");
else
Console.WriteLine("Error, Unknown operation\n");




همانطور كه ملاحظه مي‌كنيد استفاده از بلوك دستور switch بسيار ساده‌تر از استفاده از if-else هاي تودرتو است.

در اين درس با نحوه تصميم‌گيري در برنامه بوسيله دستور if و switch آشنا شديد. با نحوه عملكرد و استفاده دستور goto نيز آشنايي پيدا كرديد. در پايان مجدداً يادآوري مي‌كنم كه در استفاده از دستور goto با احتياط عمل نماييد و به جز در موارد ضروري از آن استفاده نكنيد.

[Borna66]

عمل انتساب

شركت‌پذيري از چپ بدين معناست كه عمليات از چپ به راست محاسبه مي‌شوند. شركت‌پذيري از راست بدين معناست كه تمامي محاسبات از راست به چپ صورت مي‌گيرند. به عنوان مثال در يك عمل تساوي، ابتدا عبارات سمت راست تساوي محاسبه شده و سپس نتيجه به متغير سمت چپ تساوي تخصيص داده مي‌شود.

مثال 2- عملگرهاي يكاني (Unary)



usingSystem;
classUnary
{
public static voidMain()
{
intunary = 0;
intpreIncrement;
intpreDecrement;
intpostIncrement;
intpostDecrement;
intpositive;
intnegative;
sbytebitNot;
boollogNot;
preIncrement = ++unary;
Console.WriteLine("Pre-Increment: {0}", preIncrement);
preDecrement = --unary;
Console.WriteLine("Pre-Decrement: {0}", preDecrement);
postDecrement = unary--;
Console.WriteLine("Post-Decrement: {0}", postDecrement);
postIncrement = unary++;
Console.WriteLine("Post-Increment: {0}", postIncrement);
Console.WriteLine("Final Value of Unary: {0}", unary);
positive = -postIncrement;
Console.WriteLine("Positive: {0}", positive);
negative = +postIncrement;
Console.WriteLine("Negative: {0}", negative);
bitNot = 0;
bitNot = (sbyte)(~bitNot);
Console.WriteLine("Bitwise Not: {0}", bitNot);
logNot = false;
logNot = !logNot;
Console.WriteLine("Logical Not: {0}", logNot);
}
}



به هنگام محاسبه عبارات، دو عملگر x++ و x—(كه در اينجا كاراكتر x بيان كننده آن است كه عملگرهاي ++ و – در جلوي عملوند قرار مي‌گيرند post-increment و post-decrement) ابتدا مقدار فعلي عملوند (operand) خود را باز مي‌گرداند و سپس به عملوند خود يك واحد اضافه كرده يا از آن يك واحد مي‌كاهند. عملگر ++ يك واحد به عملوند خود اضافه مي‌كند و عملگر – يك واحد از عملوند خود مي‌كاهد. بدين ترتيب عبارت x++ معادل است با عبارت x=x+1 و يا x+=1 اما همانطور كه گفته شد بايد توجه داشته باشيد كه اين عملگرها(++ و --) ابتدا مقدار فعلي عملوند خود را برگشت مي‌دهند و سپس عمل خود را روي آنها انجام مي‌دهند. بدين معني كه در عبارت x=y++ در صورتيكه در ابتداي اجراي برنامه مقدار x=0 و y=1 باشد، در اولين اجراي برنامه مقدار x برابر با 1 يعني مقدار y مي‌شود و سپس به متغير y يك واحد افزوده مي‌شود، در صورتيكه اگر اين عبارت را بصورت x=++y بنويسيم در اولين اجراي برنامه، ابتدا به مقدار متغير y يك واحد افزوده مي‌شود و سپس اين مقدار به متغير x تخصيص داده مي‌شود كه در اين حالت مقدار متغير x برابر با 2 مي‌شود.(در مورد عملگر – نيز چنين است.) پس با اين توضيح مي‌توان گفت كه دو عملگر ++x و –x ابتدا به عملوند خود يك واحد اضافه يا يك واحد از آن كم مي‌كنند و سپس مقدار آنها را باز مي‌گردانند.

در مثال 2، مقدار متغير unary در قسمت اعلان برابر با 0 قرار گرفته است. هنگاميكه از عملگر ++x استفاده مي‌كنيم، به مقدار متغير unary يك واحد افزوده مي‌شود و مقدارش برابر با 1 مي‌گردد و سپس اين مقدار، يعني 1، به متغير preIncrement تخصيص داده مي‌شود. عملگر –x مقدار متغير unary را به 0 باز مي‌گرداند و سپس اين مقدار را به متغير preDecrement نسبت مي‌دهد.
هنگاميكه از عملگر x-- استفاده مي‌شود، مقدار متغير unary، يا همان مقدار صفر، به متغير postDecrement تخصيص داده مي‌شود و سپس از مقدار متغير unary يك واحد كم شده و مقدار اين متغير به 1- تغيير مي‌كند. سپس عملگر x++ مقدار متغير unary، يعني همان 1-، را به متغير postIncrement تخصيص مي‌دهد و سپس يك واحد به مقدار متغير unary مي‌افزايد تا مقدار اين متغير برابر با 0 (صفر) شود.

مقدار متغير bitNot در هنگام اعلان برابر با صفر است. با استفاده از عملگر نقيض بيتي (~) (يا عملگر مكمل‌گيري) متغير bitNot بعنوان يك بايت در نظر گرفته مي‌شود و مقدار آن منفي يا نقيض مي‌شود. در عمليات بيتي نقيض بدين معناست كه تمامي يكها به صفر و تمامي صفرها به يك تبديل شوند. در اين حالت نمايش باينري عدد صفر يا همان 00000000 به نقيض آن يعني 11111111 تبديل مي‌گردد.

در اين مثال به عبارت (sbyte)(~bitNot) توجه نماييد. هر عملي كه بر روي انواع short،unshort ، byte و sbyte انجام شود، مقداري از نوع int را باز مي‌گرداند. بمنظور اينكه بتوانيم نتيجه دلخواه را به متغير bitNot تخصيص دهيم بايد از فرمت (Type) operator استفاده نماييم كه در آن Type نوعي است مي‌خواهيم نتيجه ما به آن نوع تبديل شود و operator عملي است كه بر روي متغير صورت مي‌پذيرد. به بيان ديگر چون مي‌خواهيم مقدار متغير bitNot بصورت بيتي در نظر گرفته شود، پس بايد نتيجه عمل ما بصورت بيتي در آن ذخيره شود كه استفاده از نوع sbyte باعث مي‌شود تا نتيجه به فرم بيتي (يا بايتي) در متغير ما ذخيره شود. بايد توجه نماييد كه استفاده از فرمت (Type) يا در اصطلاح عمل Casting، در مواقعي كه مي‌خواهيم تغييري از يك نوع بزرگتر به نوع كوچكتر ايجاد نماييم، مورد استفاده قرار گيرد، چرا كه در اين حالات ممكن است با از دست دادن اطلاعات مواجه باشيم. در اين مثال چون مي‌خواهيم نوع بزرگتر int را به(32 بيتي) به نوع كوچكتر sbyte (8 بيتي) تبديل نماييم، بدين منظور بايد بطور صريح از عمل Casting استفاده نماييم تا اطلاعاتي در اين تبديل از بين نرود. در مورد تبديل انواع كوچكتر به انواع بزرگتر(مثلا تبديل sbyte به int) نيازي به استفاده از عمل Casting نيست چرا كه امكان از بين رفتن اطلاعات وجود ندارد. در ضمن بايد به يك نكته مهم توجه نماييد و آن تبديل انواع علامتدار(Signed) و بدون علامت(Unsigned) به يكديگر است. در اين حالت خطر بسيار مهمي داده‌هاي شما را تهديد مي‌نمايد. بحث در مورد مسائل پيچيده‌تر در مورد تبديل انواع علامتدار و و بدون علامت به يكديگر در اينجا نمي‌گنجد و سعي مي‌كنم تا آنها را در مطالب بعدي و در جاي لازم مورد بحث و بررسي قرار دهم.(در صورتيكه برخي از مطالب اين قسمتها براي شما به خوبي قابل درك نيست، نگران نباشيد چراكه در آينده در مثالهايي كه خواهيد ديد تمامي اين مطالب را در عمل نيز حس كرده و با آنها آشنا خواهيد شد.)

عملگر بعدي كه در اين برنامه مورد استفاده قرار گرفته است، عملگر نقيض منطقي يا همان "!" است كه امكان تغيير مقدار يك متغير Boolean را از true به false و بالعكس را فراهم مي‌آورد. در مثال بالا(مثال شماره 2) مقدار متغير logNot پس از استفاده از عملگر "!" از false به true تغيير كرده است. با توجه به توضيحات اخير خروجي زير از برنامه مثال 2 مورد انتظار است :
Pre-Increment: 1
Pre-Decrement 0
Post-Decrement: 0
Post-Increment -1
Final Value of Unary: 0
Positive: 1
Negative: -1
Bitwise Not: -1
Logical Not: True
مثال 3 – عملگرهاي دوتايي



usingSystem;
classBinary
{
public static voidMain()
{
intx, y, result;
floatfloatResult;
x = 7;
y = 5;
result = x+y;
Console.WriteLine("x+y: {0}", result);
result = x-y;
Console.WriteLine("x-y: {0}", result);
result = x*y;
Console.WriteLine("x*y: {0}", result);
result = x/y;
Console.WriteLine("x/y: {0}", result);
floatResult = (float)x/(float)y;
Console.WriteLine("x/y: {0}", floatResult);
result = x%y;
Console.WriteLine("x%y: {0}", result);
result += x;
Console.WriteLine("result+=x: {0}", result);
}
}



خروجي اين برنامه به فرم زير است :
x+y: 12
x-y: 2
x*y: 35
x/y: 1
x/y: 1.4
x%y: 2
result+=x: 9
مثال 3 استفاده‌هاي متفاوتي از عملگرهاي دوتايي را نشان مي‌دهد.(منظور از عملگر دوتايي، عملگري است كه داراي دو عملوند مي‌باشد مانند عملگر جمع "+"). بسياري از عملگرهاي مورد استفاده در اين مثال عملگرهاي رياضي هستند و نتيجه عمل آنها مشابه عملي است كه از آنها در رياضيات ديده‌ايد. از نمونه اين عملگرها مي‌توان به عملگرهاي جمع "+"، تفريق "-"، ضرب "*" و تقسيم "/" اشاره نمود.

متغير floatResult از نوع اعشاري يا float تعريف شده است. در اين مثال نيز صريحاً از عمل Casting جهت اسفاده از دو متغير x و y كه از نوع int هستند، براي انجام عملي كه نتيجه‌اش از نوع float است، استفاده كرده‌ايم.

در اين مثال از عملگر "%" نيز استفاده كرده‌ايم. اين عملگر در عمليات تقسيم كاربرد دارد و باقيمانده تقسيم را برمي‌گرداند. يعني دو عملوند خود را بر يكديگر تقسيم مي‌كند و باقيمانده اين تقسيم را برمي‌گرداند.

در اين مثال همچنين فرم جديدي از عمل انتساب را بصورت result+=x مشاهده مي‌نماييد. استفاده از عملگرهاي انتسابي كه خود تركيبي از دو عملگر هستند، جهت سهولت در امر برنامه‌نويسي مورد استفاده قرار مي‌گيرند. عبارت فوق معادل result = result+x مي‌باشد. يعني مقدار قبلي متغير result با مقدار متغير x جمع مي‌شود و نتيجه در متغير result قرار مي‌گيرد.

يكي ديگر از انواعي كه تا كنون با آن سر و كار داشته‌ايم نوع رشته‌اي (string)است. يك رشته، از قرار گرفتن تعدادي كاراكتر در كنار يكديگر كه داخل يك زوج كوتيشن " " قرار گرفته‌اند، ايجاد مي‌گردد. بعنوان مثال "Hi This is a string type". در اعلان متغيرها نيز در صورت تعريف متغيري از نوع رشته‌اي، در صورت نياز به تخصيص مقدار به آن، حتماً كاراكترهايي كه مي‌خواهيم بعنوان يك رشته به متغيرمان نسبت دهيم را بايد داخل يك زوج كوتيشن " " قرار دهيم. به مثال زير توجه نماييد.




string Name;
…
Name = "My name is Meysam";



همانطور كه در اين مثال مشاهده مي‌نماييد، متغيري از نوع رشته‌اي تحت نام Name تعريف شده است و سپس در جايي از برنامه كه نياز به تخصيص مقدار براي اين متغير وجود دارد، عبارت مورد نظر را داخل دو كوتيشن قرار داده و به متغير خود تخصيص داده‌ايم. رشته‌ها از پر كاربرد ترين انواع در زبان‌هاي برنامه‌سازي جهت ايجاد ارتباط با كاربر و دريافت اطلاعات از كاربر مي‌باشند.(همانطور كه در درس قبل اول نيز گفته شد، دستور Console.ReadLine() يك رشته را از ورودي دريافت مي‌نمايد.) در مثالهايي كه در طي درسهاي اين سايت خواهيد ديد، نمونه‌هاي بسياري از كاربرد انواع مختلف و نيز نوع رشته‌اي را خواهيد ديد.

آرايه‌ها(Arrays)

يكي ديگر از انواع داده‌اي در زبان C#، آرايه‌ها (Arrays) مي‌باشند. يك آرايه را به عنوان مخزني براي نگهداري اطلاعات در نظر مي‌گيريم كه داراي ليستي از محلهايي است كه در آنها اطلاعات ذخيره شده است و از طريق اين ليست مي‌توان به اطلاعات آنها دسترسي پيدا نمود. به هنگام اعلان آرايه‌ها بايد نوع، اندازه و تعداد بعد آنها را نيز معين نمود.

مثال 4- آرايه‌ها و عمليات بر روي آنها




usingSystem;
classArray
{
public static voidMain()
{
int[] myInts = { 5, 10, 15 };
bool[][] myBools = new bool[2][];
myBools[0] = new bool[2];
myBools[1] = new bool[1];
double[,] myDoubles = newdouble[2, 2];
string[] myStrings = newstring[3];
Console.WriteLine("myInts[0]: {0}, myInts[1]: {1}, myInts[2]: {2}", myInts[0],
myInts[1], myInts[2]);
myBools[0][0] = true;
myBools[0][1] = false;
myBools[1][0] = true;
Console.WriteLine("myBools[0][0]: {0}, myBools[1][0]: {1}", myBools[0][0],
myBools[1][0]);
myDoubles[0, 0] = 3.147;
myDoubles[0, 1] = 7.157;
myDoubles[1, 1] = 2.117;
myDoubles[1, 0] = 56.00138917;
Console.WriteLine("myDoubles[0, 0]: {0}, myDoubles[1, 0]: {1}", myDoubles[0, 0], myDoubles[1, 0]);
myStrings[0] = "Joe";
myStrings[1] = "Matt";
myStrings[2] = "Robert";
Console.WriteLine("myStrings[0]: {0}, myStrings[1]: {1}, myStrings[2]: {2}",
myStrings[0], myStrings[1], myStrings[2]);
}
}


خروجي مثال 4 بصورت زير است :
myInts[0]: 5, myInts[1]: 10, myInts[2]: 15
myBools[0][0]: True, myBools[1][0]: True
myDoubles[0, 0]: 3.147, myDoubles[1, 0]: 56.00138917
myStrings[0]: Joe, myStrings[1]: Matt, myStrings[2]: Robert

در اين مثال انواع مختلفي از آرايه‌ها اعلان شده‌اند. در ابتدا يك آرايه تك بعدي، سپس آرايه‌اي دندانه‌دار و در نهايت نيز يك آرايه دو بعدي در اين مثال اعلان شده‌اند.
اولين اعلان در اين برنامه مربوط به اعلان آرايه تك بعدي myInts مي‌باشد كه از نوع int بوده و داراي 3 عضو مي‌باشد كه تعداد اين اعضا با اعلان چند مقدار در داخل { } معين شده است. همانطور كه از اين اعلان دريافت ميشود، آرايه تك بعدي بصورت زير تعريف مي‌شود :
type[] arrayName;
كه در آن type نوع آرايه و arrayName نام آرايه ايست كه تعريف مي‌نمائيم.
اما در ابتدا گفته شد كه به هنگام اعلان آرايه‌ها اندازه آنها نيز بايد مشخص شود. براي تعيين اندازه آرايه، يعني تعدا عناصري كه آرايه در خود جاي مي‌دهد، مي‌توان به چند روش عمل نمود. اولين و ساده‌ترين روش كه در اين مثال نيز آورده شده است، تخصيص مقاديري به آرايه در داخل يك زوج { } است. بسته به نوع آرايه، تعداد عناصري كه داخل اين زوج { } قرار مي‌گيرند، تعداد عناصر آرايه مي‌باشند و مقادير عناصر آرايه نيز همان مقاديري است كه داخل { } قرار گرفته است. به عنوان مثال در مثال 4، اولين آرايه ما داراي 3 عنصر است كه مقادير آنها به ترتيب برابر با 5، 10 و 15 مي‌باشد.
روش ديگر جهت تعيين اندازه آرايه استفاده از روش تعريف كامل آرايه است كه به فرم كلي زير مي‌باشد.



type[] arrayName = new type[n];


كه در اين تعريف، استفاده از كلمه كليدي new باعث ايجاد نمونه‌اي جديد از نوع مورد نظر، مي‌شود. n نيز تعداد عناصر آرايه است كه مي‌خواهيم آنرا توليد نماييم. در اين حالت بايد توجه داشت كه آرايه‌اي تهي را توليد نموده‌ايم و هيچ عنصري را در آرايه جاي نداده‌ايم و در برنامه بايد آرايه را مقدار دهي نماييم. به مثال زير توجه كنيد.



int[] myArray = new int[15];


اين مثال آرايه‌اي تك بعدي از نوع int را با اندازه 15 عنصر توليد مي‌نمايد. يعني اين آرايه قادر است تا 15 عنصر از نوع int را در خود ذخيره نمايد.

گونه ديگري از آرايه‌ها، آرايه‌هاي چند بعدي (Multi Dimensional Arrays) هستند كه براي نگهداري اطلاعات از چندين بعد استفاده مي‌كنند و بيشتر براي نگداري جداول و ماتريسها مورد استفاده قرار مي‌گيرند. فرم كلي اعلان اين آرايه‌ها بصورت زير است :



type[ , , … , ] arrayName = new type[n1, n2, …. , nm];


كه در آن تعداد ابعاد آرايه با ويرگول مشخص شده و n1 تا nm نيز تعداد عناصر هر يك از ابعاد است. بعنوان مثال تعريف يك آرايه سه بعدي به فرم زير است :



char[ , , ] charArray = new char[3,5,7];


در اين مثال يك آرايه سه بعدي از نوع char توليد كرده‌ايم كه ابعاد آن به ترتيب داراي 3، 5 و 7 عنصر مي‌باشند.

[Borna66]

نوع ديگري از آرايه‌ها، آرايه‌هاي دندانه‌دار (Jagged Arrays) هستند. اين نوع آرايه‌ها تنها در زبان ‍C# وجود دارند و در صرفه‌جويي حافظه بسيار موثر ميباسند. يك آرايه دندانه‌دار، در حقيقت يك آرايه تك بعدي است كه هر يك از اعضاي آن خود يك آرايه تك بعدي مي‌باشند. اندازه اين عناصر مي‌تواند متفاوت باشد و تفاوت اين آرايه‌ها با‌ آرايه‌هاي چند بعدي در همين جا نمايان مي‌شود. استفاده از اين آرايه‌ها در مواردي كاربرد دارد كهنيازي نيست تا تمامي ابعاد آرايه داراي تعداد عناصر مساوي باشند. بعنوان مثال فرض كنيد مي‌خواهيد آرايه‌اي جهت نگهداري تعداد روزهاي ماههاي مختلف سال تهيه كنيد. در صورتيكه بخواهيد از آرايه چند بعدي استفاده نماييد، چون تعداد روزهاي تمامي ماههاي سال يكسان نيست، مجبوريد تا تعداد عناصر تمام بعدهاي آرايه را برابر با بزرگترين تعداد روز ماهها، يعني 31، تعريف نماييد. ولي چون تنها 6 ماه داراي 31 روز مي‌باشند، براي 6 ماه ديگر تعدادي از عناصر آرايه هيچگاه مورد استفاده قرار نمي‌گيرند و حافظه را به هدر داده‌ايم. اما در صورتيكه براي اين مثال از آرايه‌هاي دندانه‌دار استفاده نماييم، مي‌توانيم يك آرايه دندانه‌دار 12 عنصري تعريف نماييم و سپس تعداد عناصر هر يك از اعضاي آنرا برابر با تعداد روزهاي ماه مورد نظر تعريف كنيم :



با استفاده از آرايه چند بعدي :
int[ , ] monthArray = new int[12,31];
با استفاده از آرايه دندانه‌دار :
int[][] monthArray = new int[12][];



در تعريف اول كه در آن از آرايه چند بعدي استفاده كرديم، مشاهده مي‌كنيد كه آرايه‌اي دو بعدي تعريف كرده‌ايم كه بعد اول آن 12 عضو و بعد دوم آن 31 عضو دارد. اين عمل دقيقاً همانند ايجاد يك جدول براي نگهداري روزهاي ماههاي سال است.
اما در حالت دوم كه در آن از آرايه دندانه‌دار بهره برده‌ايم، يك آرايه تعريف نموده‌ايم كه بعد اول آن 12 عضو دارد ولي بعد دوم آنرا را تعريف نكرده‌ايم كه داراي چند عضو است و هر يك از عناصر بعد اول آرايه مي‌تواند داراي تعداد اعضاي متفاوتي باشد كه با استفاده از اين روش مي‌توان به هر يك از ماههاي سال تعداد روزهاي مورد نظر آن ماه را تخصيص داد و فضايي بلا استفاده ايجاد نخواهيم كرد. توجه نماييد كه چون تعداد عناصر بعد ديگر اين آرايه معين نشده است در برنامه بايد اين تعداد عنصر را مشخص نماييم :



monthArray[1] = new int[31];
monthArray[10] = new int [30];


مشاهده مي‌كنيد كه به هر ماه، تعدا عنصر مورد نياز خود را تخصيص داده‌ايم. تنها بايد به تفاوت اعلان آرايه‌هاي دندانه‌دار با آرايه‌هاي چند بعدي توجه نماييد.

دسترسي به عناصر آرايه از طريق انديس امكان پذير است. انديس شماره محل ذخيره‌سازي داده‌هاي ما مي‌باشد كه با دادن اين شماره مي‌توانيم به داده مورد نظر دسترسي پيدا كنيم. در C# همانند C و C++ انديس خانه‌هاي آرايه از صفر آغاز مي‌گردد يعني اولين خانه آرايه داراي شماره صفر است و عناصر بعدي به ترتيب يك واحد به انديسشان اضافه مي‌گردد. پس شماره انديس آرايه هميشه يك واحد كمتر از تعداد عناصر آن است، يعني آرايه‌اي كه 10 عضو دارد بزرگترين انديس خانه‌هايش 9 مي‌باشد. دسترسي به عناصر هر يك از ابعاد آرايه با انديس امكان پذير است. معمولاً به بعد اول آرايه سطر و به بعد دوم آن ستون مي‌گويد. مثلاً monthArray[3,7] عنصر واقع در سطر 3 و ستون 7 آرايه را مشخص مي‌نمايد.(توجه داشته باشيد كه انديس دهي آرايه از صفر آغاز مي‌شود و بعنوان مثال intArray[12] به خانه شماره 12 آرايه اشاره مي‌كند اما فراموش نكنيد چون انديس آرايه از صفر آغاز مي‌شود خانه شماره 12 آرايه، سيزدهمين داده شما را در خود جاي مي‌دهد.)
12
11
10
9
8
7
6
5
4
3
2
1
0

اگر شكل فوق را آرايه‌اي تك بعدي تصور نماييد، مشاهده مي‌نماييد كه خانه شماره 5 آرايه حاوي اطلاعات مربوط به ششمين داده ورودي شما مي‌باشد.

نكته ديگري كه بايد در مورد تعريف آرايه‌هاي اين مثال متذكر شوم در مورد آريه‌هائيست كه از نوع string تعريف مي‌شوند. دوستاني كه با زبان C كار كرد‌ه‌اند حتماً مي‌دانند كه آرايه‌اي از نوع رشته‌اي در C وجود ندارد و براي نگهداري چندين رشته در يك آرايه بايد از آرايه دو بعدي استفاده كرد. در C# اين قابليت فراهم شده تا با استفاده از يك آرايه تك بعدي بتوان چندين رشته را ذخيره نمود بدين صورت كه هر يك از عناصر آرايه نك بعدي محلي براي ذخيره‌سازي يك رشته است و همانند زبان C نياز به پردازش‌هاي گاه پيچيده بر روي آرايه‌هاي چند بعدي بمنظور كار با رشته‌ها، وجود ندارد. بعنوان يك توضيح كمي اختصاصي عرض مي‌كنم كه در زبان‌هايي مانند C، در صورتيكه مي‌خواستيد چندين رشته را در آرايه‌اي ذخيره كنيد تا بتوانيد با انديس به آنها دسترسي داشته باشيد، مجبور به تعريف يك آرايه دو بعدي بوديد كه با استفاده از تنها انديس اول آرايه مي‌توانستيد به عناصر رشته‌اي آرايه دسترسي پيدا كنيد، اما در C# تنها با استفاده از يك آرايه تك بعدي مي‌توان همان كار را انجام داد.



string[] stringArray = {"My name is Meysam", "This is C# Persian Blog"}
…..
Console.WriteLine("{0}",stringArray[0]);
…..


همانطور كه در اين مثال ملاحظه مي‌كنيد، آرايه‌اي از نوع رشته تعريف شده و دو عنصر به آن تخصيص داده شده است و در جايي در متن برنامه با استفاده از انديس از اولين عنصر اين آرايه براي نمايش در خروجي استفاده گرديده است. خروجي اين برنامه به شكل زير است :
My name is Meysam



مطلب اين درس در اينجا به پايان مي‌رسد. در صورتيكه نياز داريد تا در مورد عملگرهاي زبان C# بيشتر توضيح دهم حتماً ذكر كنيد تا در مطلب بعدي توضيح كاملتري در مورد آنها براي شما تهيه كنم. خيلي دوست داشتم كه در مورد تمام عملگرهاي زبان C# در همين درس توضيح بدهم اما هم فرصت اندك است و هم حجم مطلب اين قسمت زياد مي‌شد و هم اينكه فكر كردم احتمالاً دوستان با اين عملگرها آشنايي دارند. نكته‌ ديگري كه بايد به آن اشاره كنم و اينست كه در اين سايت سعي شده است تا زبان برنامه‌نويسي C# به سادگي و به سرعت آموزش داده شود و علت اينكه به برخي از جزئيات تخصصي پرداخته نمي‌شود نيز همين مطلب مي‌باشد. در آينده در مورد آرايه‌ها بيشتر صحبت مي‌كنم چون عناصر مفيد و سودمندي هستند. اميد است پس از كامل كردن مطالب مقدماتي در اين سايت و با همكاري شما عزيزان بتوانم به مطالب پيشرفته‌تري از زبان C# بپردازم. بيان نظرات و پيشنهادات شما چه در زمينه مطالب ارائه شده و چه در زمينه متن ارائه شده به شما از لحاظ سادگي و رواني در درك، مرا در امر بهبود مطالب ياري مي‌نمايد.

[Borna66]

درس چهارم – دستورالعمل‌هاي كنترلي، حلقه‌ها


در درس قبل، نحوه ايجاد يك حلقه بسيار ساده را با استفاده از دستور goto را فرا گرفتيد. در همان مطلب نيز اشاره كرديم كه اين روش، روش مناسبي جهت ايجاد حلقه‌ نيست. در اين درس با نحوه صحيح ايجاد حلقه‌ها در زبان C# آشنا خواهيد شد. اولين دستوري كه با آن آشنا مي‌شويد نيز دستور while است.

حلقه while
ابتدا به مثال زير توجه نماييد.




usingSystem;

classWhileLoop
{
public static voidMain()
{
intmyInt = 0;
while(myInt < 10)
{
Console.Write("{0} ", myInt);
myInt++;
}
Console.WriteLine();
}
}



مثال 1-4 كه در بالا ملاحظه مي‌كنيد، يك حلقه whileساده را نشان مي‌دهد. اين حلقه با كلمه كليدي whileآغاز شده و سپس به دنبال آن يك عبارت منطقي قرار مي‌گيرد و مورد بررسي قرار مي‌گيرد. تمامي دستورالعمل‌هاي كنترلي از يك عبارت منطقي بهره مي‌گيرند و اين بدين معناست كه ابتدا اين عبارت بايد بررسي شود تا مشخص شود مقدار اين عبارت trueاست يا false. در اين مثال مقدار متغير myIntمورد بررسي قرار مي‌گيرد تا چك شود آيا مقدارش از 10 كوچكتر هست يا خير. چون در ابتداي برنامه به اين متغير مقدار صفر تخصيص داده شده است، عبارت منطقي مقدار trueرا باز مي‌گرداند و سپس بلوك قرار گرفته بعد از عبارت منطقي مورد اجرا قرار مي‌گيرد.

درون بلوك whileابتدا مقدار متغير myIntدر كنسول نمايش داده مي‌شود و سپس يك واحد به مقدار اين متغير افزوده مي‌گردد. پس از اتمام بلوك while، عبارت منطقي مجددا كنترل مي‌شود و در صورتيكه اين عبارت مقدار trueبازگرداند، حلقه whileمجدداً اجرا مي‌شود. زمانيكه عبارت منطقي مقدار falseبرگرداند، اجرا برنامه به اولين دستور بعد از بلوك whileمنتقل مي‌شود. در اين مثال اعداد صفر تا 9 بر روي صفحه نمايش داده مي‌شوند و سپس يك خط خالي چاپ شده و اجراي برنامه خاتمه مي‌يابد.
حلقه بعدي كه بسيار شبيه به حلقه whileمي‌باشد، حلقه do-while است.

حلقه do-while
ابتدا به مثال 2-4 توجه نماييد.




usingSystem;

classDoLoop
{
public static voidMain()
{
stringmyChoice;
do
{
// منويي نمايش داده مي‌شود
Console.WriteLine("My Address Book\n");
Console.WriteLine("A - Add New Address");
Console.WriteLine("D - Delete Address");
Console.WriteLine("M - Modify Address");
Console.WriteLine("V - View Addresses");
Console.WriteLine("Q - Quit\n");
Console.WriteLine("Choice (A,D,M,V,or Q): ");
//ورودي كاربر بررسي مي‌شود
myChoice = Console.ReadLine();
//تصميمي بر اساس ورودي كاربر گرفته مي‌شود
switch(myChoice)
{
case"A":
case"a":
Console.WriteLine("You wish to add an address.");
break;
case"D":
case"d":
Console.WriteLine("You wish to delete an address.");
break;
case"M":
case"m":
Console.WriteLine("You wish to modify an address.");
break;
case"V":
case"v":
Console.WriteLine("You wish to view the address list.");
break;
case"Q":
case"q":
Console.WriteLine("Bye.");
break;
default:
Console.WriteLine("{0} is not a valid choice", myChoice);
break;
}
Console.Write("Press Enter key to continue...");
Console.ReadLine();
Console.WriteLine();
} while(myChoice != "Q" && myChoice != "q");
}
}



مثال 2-4 نحوه استفاده از حلقه do-while را نشان مي‌دهد. ساختار نوشتاري اين دستور بصورت زير است :
do
{ <statements> } while (<boolean expression>);

دستورالعملهاي مورد استفاده در بلوك اين دستور، هر دستورالعمل معتبر زبان C# مي‌تواند باشد. عبارت منطقي نيز همانند نمونه‌هائيست كه تا كنون با آنها آشنا شديم و يكي از دو مقدار true يا false را بر مي‌گرداند.

يكي از مصارف عمده حلقه do به جاي حلقه while، مواردي است كه مي‌خواهيم يكسري دستورالعمل خاص، كه آنها را درون بلوك do قرار مي‌دهيم، حداقل يكبار اجرا شوند. در اين مثال ابتدا يك منو براي كاربر نمايش داده مي‌شود و سپس ورودي از وي دريافت مي‌گردد. چون حلقه while عبارت منطقي خود در ابتداي اجراي حلقه بررسي مي‌نمايد، از اينرو تضميني براي اجراي دستورات درون بلوك وجود نخواهد داشت، مگر شما بطور صريح برنامه را طوري طراحي نماييد كه اين عمل اتفاق بيفتد.

يك نگاه كلي به مثال 2-4 بيندازيم. در متد Main() متغير myChoice را از نوع رشته‌اي تعريف نموده‌ايم. سپس يكسري دستورات را بر روي كنسول چاپ نموده‌ايم. اين دستورات منوهاي انتخاب براي كاربر هستند. ما بايد ورودي از كاربر دريافت كنيم كه چون اين عمل از طريق Console.ReadLine() صورت گرفته، بايد در متغيري از نوع رشته‌اي قرار گيرد و از اينرو اين ورودي را در myChoice قرار داده‌ايم. ما بايد ورودي را از كاربر دريافت كنيم و بر روي آن پردازش انجام دهيم. يك روش كارآمد براي اين منظور استفاده از دستورالعمل switch است. همانطور كه در دستور switch ملاحظه مي‌كنيد، بري default نيز دستوري در نظر گرفته شده‌ است كه نشان مي‌دهد مقدار ورودي معتبر نيست.

حلقه for
به مثال 3-4 توجه كنيد.




usingSystem;

classForLoop
{
public static void Main()
{
for(inti=0; i < 20; i++)
{
if(i == 10)
break;
if(i % 2 == 0)
continue;
Console.Write("{0} ", i);
}
Console.WriteLine();
}
}



مثال 3-4 يك حلقه forرا نشان مي‌دهد. استفاده از حلقه forبراي زماني مناسب است كه دقيقاً بدانيد كه حلقه چندبار بايد تكرا شود. محتويات درون پرانتزهاي حلقه forاز سه قسمت تشكيل شده است :



(<initializer list>; <boolean expression>; <postloopaction list>)



initializer list ليستي از عبارات است كه بوسيله كاما از يكديگر جدا مي‌شوند. اين عبارات تنها يكبار در طول دوره كاري حلقه for پردازش مي‌شوند. همانطور كه در مثال 3-4 نيز ملاحظه مي‌كنيد، اين قسمت معمولا براي تعيين متغيري عددي جهت آغاز عمل شمارش مورد استفاده قرار مي‌گيرد.

پس از اينكه عبارتهاي دورن initializer list پردازش شد، حلقه forبه سراغ قسمت بعدي، يعني عبارات منطقي(boolean expression) مي‌رود. در اين قسمت تنها يك عبارت منطقي مي‌توان قرار داد ولي هر اندازه كه بخواهيد مي‌توانيد اين عبارت منطقي را پيچيده نماييد، فقط توجه نماييد كه اين عبارت بايد بگونه‌اي شود كه مقدار trueيا falseبرگرداند. از اين عبارت منطقي معمولا جهت كنترل متغير شمارشي استفاده مي‌شود.

هنگاميكه عبارت منطقي مقدار trueبازگرداند، دستورالعمل‌هاي بلوك forاجرا مي‌شوند. در مثال 3-4 ما از دو دستور if درون حلقه forنيز استفاده كرده‌ايم. اولين دستور if بررسي مي‌كند كه آيا مقدار متغير i برابر با 10 هست يا نه. در اينجا يك نمونه ديگر از استفاده دستور breakرا ملاحظه مي‌كنيد. عملكرد دستور breakدر اينجا نيز همانند مورد استفاده آن در دستور switchاست. در صورت اجراي دستور breakاجراي حلقه forخاتمه يافته و اجراي برنامه به اولين دستور بعد از حلقه forمنتقل مي‌شود.

دومين دستور if با اسقتاده از عملگر باقيمانده (%) بررسي مي‌كند كه آيا متغير i بر 2 بخش پذير هست يا نه. در صورتيكه متغير i بر 2 بخش پذير باشد، دستور continueاجرا مي‌شود. پس از اجراي دستور continueاز ساير دستورات حلقه forكه بعد از continueقرار گرفته‌اند صرفه‌نظر مي‌شود و اجراي برنامه به اول حلقه forباز مي‌گردد.

قسمت سوم در حلقه for، قسمت postloopaction list است. پس از اينكه تمامي دستورات درون حلقه forاجرا شد، اجراي حلقه به اين قسمت باز مي‌گردد. اين قسمت ليستي از عملياتي است كه مي‌خواهيد پس از اجراي دستورات درون بلوك حلقه for انجام شوند. در مثال 3-4 اين عمل، اضافه كردن يك واحد به متغير شمارشي است. پس از افزوده شدن يك واحد به متغير شمارشي، عبارت منطقي مجدداً مورد بررسي قرار مي‌گيرد و در صورتيكه مقدار اين عبارت برابر با trueباشد، حلقه forمجدداً اجرا مي‌گردد. حلقه forتا زمانيكه عبارت منطقي برابر با trueباشد اجرا مي‌شود.

حلقه foreach
به مثال 4-4 توجه كنيد.




usingSystem;

classForEachLoop
{
public static voidMain()
{
string[] names = {"Meysam", "Ghazvini", "C#", "Persian"};
foreach(stringperson innames)
{
Console.WriteLine("{0} ", person);
}
}
}



حلقه foreachبراي پيمايش مجموعه‌ها بسيار مناسب است. يك نمونه از مجموعه‌ها در C#، آرايه‌ها هستند كه در مثال 4-4 نيز مورد استفاده قرار گرفته است. اولين كاري كه در متد Main() صورت گرفته،‌ اعلان آرايه namesاز نوع رشته‌اي و مقدار دهي آن است.

درون پرانتزهاي foreachعبارتي متشكل از دو المان قرار دارد كه اين المان‌ها بوسيله كلمه كليدي inاز يكديگر جدا شده‌اند. المان سمت راست، مجموعه‌ايست كه مي‌خواهيد اعضاي آنرا مورد پيمايش قرار دهيد. المان سمت چپ، متغيري از نوع مجموعه مورد نظر است كه مقادير پيمايش شده را بر مي‌گرداند.

در هربار پيمايش،‌ عنصري جديدي از مجموعه درخواست مي‌شود. اين درخواستها از طريق متغير فقط خواندني تعريف شده درون پرانتزهاي foreachبازگردانده مي‌شوند. تا زمانيكه عنصري در مجموعه وجود داشته باشد كه مورد پيمايش قرار نگرفته است، حلقه foreachبه كار خود ادامه خواهد داد زيرا عبارت منطقي حلقه foreachمقدار trueرا باز مي‌گرداند. به محض اينكه تمامي عناصر مجموعه پيمايش شد، عبارت منطقي برابر با falseشده و اجراي حلقه foreachخاتمه مي‌يابد. در اين حالت اجراي برنامه به اولين دستور بعد از حلقه foreachمنتقل مي‌گردد.

در مثال 4-4، متغيري از نوع رشته‌ با نام personبراي نگهداري عناصري كه از آرايه namesخوانده مي‌شود، تعريف كرده‌ايم. تا زمانيكه اسمي در آرايه namesوجود داشته باشد، در متغير personقرار مي‌گيرد و درون حلقه foreachبوسيله دستور Console.WriteLine() در خروجي نمايش داده مي‌شود.

نكته : يكي از مهمترين ويژگيهاي حلقه foreach در آنست كه فقط مي‌تواند عناصر يك مجموعه را بخواند و نمي‌تواند تغييري در آنها ايجاد نمايد. مزيت ديگر آن، پيمايش تمامي عناصر مجموعه بدون اطلاع از تعداد عناصر موجود در آن است.

خلاصه
در اين درس با نحوه كار با دستورالعمل‌‌هاي for، while، do-while و foreach آشنا شديد. حلقه while تا زمانيكه شرطش صحيح باشد انجام مي‌شود بدين معني كه تا زمانيكه عبارت منطقي آن داراي مقدار true باشد، دستورات درون بلوك آن اجرا مي‌شوند. حلقه do، دستورات بلوك خود را حداقل يكبار اجرا مي‌كند و سپس شرط مورد نظر را بررسي مي‌نمايد و در صورتيكه عبارت منطقي آن مقدار ‌true بازگرداند، دستورات بلوك خود را تكرار مي‌نمايد. حلقه for دستورات بلوك خود را به تعداد دفعات مشخص اجرا مي‌نمايد و حلقه foreach عناصر يك مجموعه را مورد پيمايش قرار مي‌دهد. در نهايت نيز اشاره مي‌شود كه روند اجراي حلقه‌ها با استفاده از دستورات break و continue تغيير مي‌نمايد.