لغة #C إحدى أبرز لغات البرمجة التي تطورها شركة مايكروسوفت ضمن بيئة التطوير المتكاملة Visual Studio. تعمل هذه اللغة ضمن بيئة تنفيذ اللغة المشتركة Common Language Runtime أو CLR اختصارًا والتي توفر ميزات عديدة مثل التكامل بين اللغات المختلفة ومعالجة الاستثناءات وتعزيز مستويات الأمان.

وتعد لغة #C النموذج الأبسط والأكثر انتشارًا للغات التي تعمل ضمن بيئة CLR وهي تستخدم في مختلف أنواع التطبيقات سواء تطبيقات سطح المكتب أو تطبيقات الهاتف المحمول أو تطبيقات الجوال أو حتى ضمن خوادم البيانات.

لغة #C هي لغة كائنية التوجه OOP وصارمة في تحديد الأنواع أي يجب تحديد نوع البيانات لكل متغير، وتساعد عمليات التحقق الصارمة من أنواع البيانات خلال مرحلة التصريف compile إلى اكتشاف أغلب الأخطاء البرمجية وتحديد مواقعها بدقة وتسريع معالجتها، مقارنة بلغات البرمجة التي تعتمد أسلوب تتبع الأخطاء في مرحلة التنفيذ runtime مما يزيد من صعوبة معرفة السبب الأساسي للخطأ، ومع ذلك يتجاهل العديد من مبرمجي لغة #C الفوائد الكبيرة من الكشف المبكر عن الأخطاء الأمر الذي قد ينجم عنه بعض المشكلات والأخطاء.

يناقش هذا المقال أبرز أخطاء لغة #C على وجه الخصوص، لكن الأخطاء المطروحة هنا  تعمم على جميع لغات البرمجة التي تعمل ضمن بيئة CLR، أو اللغات التي تستخدم مكتبة الأصناف القياسية FCL.

الخطأ 1: استخدام المرجع كقيمة أو العكس

يمكن للمطورين بلغة ++C -وغيرها من لغات البرمجة- التحكم في القيم المسندة إلى المتغيرات سواء كانت قيم مباشرة values أو مراجع references تشير إلى لموقع الذاكرة لمتغير أو كائن موجود مسبقًا، أما في لغة البرمجة #C فمن يتحكم بهذا القرار هو المبرمج الذي كتب الكائن object وليس المبرمج الذي أنشأ نسخة instance من هذا الكائن وأسندها للمتغير، وهذا هو الخطأ الأول الشائع للأشخاص الذين يتعلمون البرمجة.

لنأخذ المثال التالي الذي يوضح بعض المفاجآت التي يمكن أن تحدث إذا لم تكن على دراية بنوع الكائن الذي تستخدمه في برنامجك هل هو من نوع قيمة أم من نوع مرجع كما يلي:

 Point point1 = new Point(20, 30);
      Point point2 = point1;
      point2.X = 50;
      Console.WriteLine(point1.X);       // 20 (هل تفاجأت من هذه النتيجة)
      Console.WriteLine(point2.X);       // 50

      Pen pen1 = new Pen(Color.Black);
      Pen pen2 = pen1;
      pen2.Color = Color.Blue;
      Console.WriteLine(pen1.Color);     // Blue (أم تفاجأت من هذه النتيجة)
      Console.WriteLine(pen2.Color);     // Blue

لاحظ أن كلًا من الكائنين point وpen أنشئا بنفس الطريقة تمامًا، لكن قيمة point1 بقيت على حالها دون تغيير عند تعيين قيمة جديدة للإحداثي X فيpoint2.

أما في الحالة الثانية فقد تعدلت قيمة pen1 عند إسناد قيمة لون جديدة إلى pen2، وبالتالي يمكننا استنتاج أن كلًا من point1 وpoint2 يحتويان على نسخة من الكائن الأصلي point أما pen1 وpen2 فيحتويان على مراجع references تشير للكائن الأساسي pen وهذا ما يمكنه أن نتعلمه من خلال التجربة.

لمعرفة الفرق بين الحالتين يمكننا العودة إلى التعريف الخاص بكل كائن وهو ما يمكننا القيام به بسهولة في بيئة التطوير Visual Studio من خلال وضع المؤشر على اسم الكائن والضغط على المفتاح F12.

public struct Point { ... }     // نوع قيمة value
public class Pen { ... }        // نوع مرجع reference

تستخدم الكلمة المفتاحية struct في لغة البرمجة #C لتعريف النوع كقيمة value في حين تستخدم الكلمة المفتاحية class لتعريف النوع كمرجع reference.

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

الخطأ 2: عدم فهم القيم الافتراضية للمتغيرات غير المهيأة

عند تعريف متغير من النوع قيمة value عليك إسناد قيمة له، ولا يمكن إسناد القيمة null لهذا المتغير بشكل افتراضي، فالمتغيرات غير المهيأة من النوع قيمة يجب أن تحتوي على قيمة افتراضية معينة وهي القيمة الافتراضية لنوع القيمة المسندة لها.

لذا عليك التحقق دومًا من وجود قيمة افتراضية للمتغير غير المهيَّأ قبل استخدامه، كما في المثال التالي:

class Program {
          static Point point1;
          static Pen pen1;
          static void Main(string[] args) {
              Console.WriteLine(pen1 == null);      // True
              Console.WriteLine(point1 == null);    // False (لماذا؟)
          }
      }

لاحظ أنه لا يمكن إسناد null إلى point1 لأن point من النوع قيمة والقيمة الافتراضية لها هي (0,0) وليست null، إن التعرف على هذا الخطأ في #C أمر بسيط وسهل للغاية لأن معظم الأنواع (وليس كلها) من النوع قيمة تمتلك الخاصية IsEmpty التي تمكنك من التحقق فيما إذا كان الكائن يمتلك قيمة افتراضية أم لا.

Console.WriteLine(point1.IsEmpty);        // True

عليك تهيئة أي متغير بقيمة افتراضية محددة، أو التأكد ما هي القيمة الافتراضية التي يأخذها بشكل افتراضي.

الخطأ 3: استخدام توابع مقارنة النصوص بشكل خاطئ

هناك العديد من الطرق لمقارنة النصوص في لغة #C، ويعد العامل == أقلها تفضيلًا، فعلى الرغم من استخدامه من قبل كثير من المبرمجين إلا أنه لا يحدد بشكل صريح نوع المقارنة المطلوبة في الكود ويفضل ان تستعيض عنه بالتابع Equals لاختبار تساوي النصوص كما يلي:

public bool Equals(string value);
public bool Equals(string value, StringComparison comparisonType);

في السطر الأول من الكود السابق يعمل التابع Equals بطريقة مشابهة تمامًا للمقارنة باستخدام ==، لكن تطبيقه يكون خاصًا بالسلاسل النصية فهو يجري مقارنة ترتيبية بين النصوص بناءً على المقارنة بايت بايت، وهذا مناسب في العديد من الحالات مثل مقارنة أسماء الملفات أو متغيرات البيئة.

لكن في هذه الحالات التي نحتاج فيها لإجراء مقارنة معتمدة على الترتيب الأبجدي، فإن العيب الوحيد لاستخدام التابع Equals دون المعامل comparisonType هو أن القارئ قد لا يعرف نوع المقارنة المطبقة، أما السطر الثاني الذي يتضمن المعامل comparisonType لتحديد نوع المقارنة بدقة فهو يجعل الكود أوضح، ويجبرك على التفكير في نوع المقارنة التي ترغب في إجرائها.

قد لا تتضح فائدة هذا المعامل في بعض اللغات كاللغة الإنجليزية إذ لا توجد اختلافات كبيرة عند استخدام المقارنات الترتيبية، لكن تؤدي المقارنة بدونه في لغات أخرى لحدوث أخطاء كالألمانية فقد يفسر الحرفان "ss" و"ß" على أنهما متساويين في بعض الحالات. لتوضيح ذلك، انظر المثال التالي:

  string s = "strasse";

      // outputs False:
      Console.WriteLine(s == "straße");
      Console.WriteLine(s.Equals("straße"));
      Console.WriteLine(s.Equals("straße", StringComparison.Ordinal));
      Console.WriteLine(s.Equals("Straße", StringComparison.CurrentCulture));        
      Console.WriteLine(s.Equals("straße", StringComparison.OrdinalIgnoreCase));

      // outputs True:
      Console.WriteLine(s.Equals("straße", StringComparison.CurrentCulture));
      Console.WriteLine(s.Equals("Straße", StringComparison.CurrentCultureIgnoreCase));

بالتالي الطريقة العملية الآمنة للمقارنة بين النصوص هي تزويد التابع Equals بالمعامل comparisonType دائمًا، وفيما يلي بعض الإرشادات الأساسية:

• استخدم المقارنة الحساسة للاختلافات بين اللغات عند مقارنة النصوص المدخلة من المستخدم أو التي ستعرض على المستخدم (CurrentCulture أو CurrentCultureIgnoreCase).

• استخدم المقارنة الترتيبية عند مقارنة النصوص المسندة برمجيًا (Ordinal أو OrdinalIgnoreCase).

• لا تستخدم المعاملين InvariantCulture و InvariantCultureIgnoreCase إلا في حالات محدودة جدًا لأن المقارنات الترتيبية في هذه الحالة أكثر فعالية.

ملاحظة: هناك تابع آخر لمقارنة النصوص بالإضافة إلى التابع Equals وهو التابع Compare الذي يقدم لك معلومات جيدة حول الترتيب النسبي للسلاسل النصية، وهو مناسب عند استخدام عوامل المقارنة < و=> و=<.

الخطأ 4: استخدام العبارات التكرارية بدل التصريحية لمعالجة المجموعات

لقد غيرت استعلامات LINQ من طريقة الاستعلام عن المجموعات Collections ومعالجتها بشكل جذري، ولا يجوز استخدام العبارات التكرارية ضمن لغة الاستعلام LINQ. ومع ذلك لازال هناك عدد قليل من مبرمجي #C لا يعرفون بوجود لغة الاستعلام LINQ أو يعتقدون أن استخدامها يقتصر على التعامل مع قواعد البيانات بسبب التشابه الكبير بينها وبين لغة SQL.

تعمل تعليمات LINQ على أي مجموعة قابلة للتعداد enumerable بغض النظر عن نوع الكائن أو مجموعة البيانات التي تستخدمها، فإذا كانت البيانات قابلة للتعداد -أي يمكن المرور عبر العناصر داخلها واحدًا تلو الآخر- فيمكنك استخدام LINQ للقيام بعمليات استعلام وتصفية وتحليل لهذه البيانات.

على سبيل المثال إذا كان لدينا مصفوفة تخزن حسابات مستخدمين فيمكن استعراضها من خلال التعليمة foreach كما يلي:

decimal total = 0;
foreach (Account account in myAccounts) {
if (account.Status == "active") {
          total += account.Balance;
      }
      }

يمكننا كتابة الكود التالي بدلًا من الكود السابق:

 decimal total = (from account in myAccounts
         where account.Status == "active"
         select account.Balance).Sum();

المثال السابق هو مثال بسيط جدًا لتجنب الوقوع في مثل هذه المشكلة في #C، ولكن عند الانتقال إلى أمثلة أو حالات معقدة فيمكن لعبارة واحدة من عبارات LINQ أن تحل مكان العشرات من عبارات الحلقات التكرارية أو الحلقات المتداخلة في الكود.

بالطبع عليك استخدام القرار المناسب لبرنامجك سواء استخدام عبارات لغة الاستعلام المتكاملة LINQ أو استخدام العبارات التكرارية، هذا يعتمد على أداء البرنامج لذا يمكنك إجراء مقارنة لأداء الطريقتين واختيار الأنسب.

الخطأ 5: الفشل في فهم الكائنات الأساسية في عبارة LINQ

لغة الاستعلامات التكميلية اللغوية LINQ مهمة جدًا في معالجة مجموعات البيانات سواء كانت هذه البيانات كائنات في الذاكرة، أو في جداول قاعدة البيانات، أو حتى في ملفات XML، عادة لا يهمنا معرفة الكائنات الأساسية objects التي تعالجها تعليمات هذه اللغة، ولكن عمليًا يمكن لاستعلامات LINQ المتطابقة أن ترجع نتائج مختلفة عند تطبيقها على البيانات نفسها إذا اختلف تنسيق تلك البيانات.

لاحظ الكود التالي:

decimal total = (from account in myAccounts
              where account.Status == "active"
              select account.Balance).Sum();

السؤال المطروح هنا ماذا يحدث عندما تكون قيمة account.Status لأحد الكائنات "Active" أي الحرف A كبير؟ الجواب هو كالتالي: إذا كانت المصفوفة myAccounts كائن من النوع DbSet وهو بشكل افتراضي غير حساس لحالة الأحرف فستبقى عبارة where مطابقة لحالة العنصر وتكون النتيجة النهائية صحيحة، أما إذا كانت المصفوفة myAccounts موجودة في الذاكرة فلن تتطابق مع حالة العنصر وتكون النتيجة خطأ.

قد يتبادر لذهنك سؤال آخر: ذكرنا أن العامل == يجري مقارنة حساسة لحالة الأحرف في السلاسل النصية، فلماذا قام هنا بمقارنة غير حساسة للأحرف؟ الجواب عندما تكون الكائنات التي تتعامل معها عبارات LINQ مرتبطة بجدول SQL مثل كائن DbSet في إطار عمل الكيانات Entity Framework، سيحوَّل الاستعلام إلى عبارة T-SQL وفي هذه الحالة يتبع العامل == قواعد لغة SQL وهي غير حساسة لحالة الأحرف، ولن يتبع قواعد #C. لذلك تصبح المقارنة غير حساسة لحالة الأحرف.

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

الخطأ 6: الغموض عند استخدام توابع التمديد

كما ذكرنا سابقًا، تعمل لغة الاستعلام LINQ على أي كائن من النوع IEnumerable‎ فعند استخدام استعلامات LINQ أو توابعها على كائن من النوع IEnumerable‎، فقد يبدو  أن هذه التوابع جزء من تعريف الواجهة IEnumerable‎ نفسها.

على سبيل المثال ستعمل الدالة البسيطة Sum في الكود التالي على إضافة الأرصدة إلى مجموعة من الحسابات كما يلي:

  public decimal SumAccounts(IEnumerable<Account> myAccounts) {
        return myAccounts.Sum(a => a.Balance);
      }

وسيط الدالة myAccounts في هذا الكود من النوع <IEnumerable<Account، وبما أن myAccounts يشير للتابع ()Sum فقد تتوقع أن التابع معرف ضمن الواجهة <IEnumerable<T، لكن تعريف الواجهة <IEnumerable<T لا يتضمن التابع Sum ويبدو كما يلي:

public interface IEnumerable<out T> : IEnumerable {
     IEnumerator<T> GetEnumerator();
      }

فالسؤال المطروح هنا أين يتواجد تعريف التابع ()Sum؟ فكما شرحنا في فقرات سابقة لغة #C هي لغة صارمة في تحديد الأنواع، وإذا كانت الإشارة للتابع Sum غير صحيحة فإن مصرّف لغة #C سيعلن عن وجود الخطأ ولن ينفذ الكود، لكن هذه الفرضية خاطئة والتابع موجود ولكن أين؟ أين توجد تعريفات جميع التوابع الأخرى التي تزودها لغة LINQ؟

الجواب هو أن التابع ()Sum غير معرف ضمن الواجهة <IEnumerable<T وإنما هو تابع ثابت يدعى تابع التمديد Extension Method وهو معرّف ضمن الصنف System.Linq.Enumerable كما هو موضح تاليًا:

 namespace System.Linq {
        public static class Enumerable {
          ...
          // الإشارة إلى this IEnumerable<TSource> source
          //  هي التي توفر الوصول إلى تابع التمديد Sum
          public static decimal Sum<TSource>(this IEnumerable<TSource> source,
                                             Func<TSource, decimal> selector);
          ...
        }
      }

السؤال الآن: لماذا يختلف تابع التمديد عن أي تابع ثابت آخر، وكيف يمكن الوصول إليه من أصناف أخرى؟ الجواب هو أن أهم ما يميز تابع التمديد هو وجود المتغير this ضمن المعامل الأول للتعريف، فهو بمثابة المفتاح السحري الذي يخبر مصرّف اللغة أن هذا التابع هو تابع تمديد، ويشير هذا النوع من المعاملات إلى الصنف أو الواجهة وهي في حالتنا IEnumerable<TSource>‎ وبهذا، يمكن الوصول إلى التابع وكأنه جزء من الكائن نفسه، رغم تعريفه في الواقع في مكان آخر.

ملاحظة: التشابه بين اسم الواجهة IEnumerable واسم الصنف Enumerable الذي يحتوي على تابع التمديد هو مجرد تشابه في الأسماء فقط ولا علاقة مباشرة بينهما.

يمكننا وباعتماد هذا الفهم أن نكتب التابع sumAccounts كما يلي:

public decimal SumAccounts(IEnumerable<Account> myAccounts) {
          return Enumerable.Sum(myAccounts, a => a.Balance);
      }

في الحقيقة كان بإمكاننا تطبيق هذه الطريقة بدلًا من الطريقة السابقة مما يدفعنا إلى سؤال جديد عن سبب وجود تابع التمديد والفائدة منه؟ الإجابة هي أن تابع التمديد مناسب بشكل كبير للغة البرمجة #C ويسمح بإضافة توابع إلى أنواع موجودة مسبقًا دون الحاجة إلى تعديل تلك الأنواع أو إنشاء أنواع جديدة.

يمكن تضمين تابع التمديد في نطاق الكود عن طريق إضافة العبارة using [namespace]⁢‎ في بداية الملف. ومن السهل معرفة المجالات التي تحتوي على توابع التمديد التي تحتاجها في #C. فعندما يستدعي مصرف #C تابعًا لم يتم تعريفه في الكائن، سيبحث في توابع التمديد ضمن المجالات المستوردة. وإذا وجد التابع، يستخدمه ويمرر الكائن كمعامل أول ثم يمرر المعطيات الأخرى. وإذا لم يجد التابع، سيعطي خطأ.

تعد توابع التمديد ميزة في #C لكونها تساعد في كتابة كود أسهل وأوضح وتحقق جمالية الصياغة syntactic sugar وتجعل الكود أسهل في القراءة والفهم. ولكن، إذا لم تكن معتادًا على استخدامها قد تشعر بالارتباك في البداية. لكن مع الوقت والخبرة ستعتاد استخدامها والتعامل معها فقد أصبح استخدام توابع التمديد شائعًا في مكتبات #C البرمجية، مثل مكتبة LINQ، ومحرك الألعاب Unity، وإطار Web API، وغيرها من المكتبات. وكلما كان الإطار البرمجي حديثًا، زادت احتمالية استخدامه لهذه التوابع.

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

يمكنك أيضًا كتابة توابع التمديد الخاصة بك، ولكن انتبه جيدًا لأنه وبالرغم من أن توابع التمديد تُستدعى بنفس طريقة استدعاء التوابع العادية، إلا أن هناك اختلافًا في التنفيذ، فلا يمكن لتوابع التمديد على سبيل المثال الوصول إلى العناصر الخاصة private أو المحمية protected في الصنف. لذا لا يمكن لتوابع التمديد أن تحل محل الأصناف الأساسية التقليدية التي تستخدم الوراثة.

الخطأ 7: اختيار نوع المجموعة غير المناسب للمهمة المطلوبة

توفر لغة البرمجة #C الكثير من المجموعات collection وفيما يلي بعض منها:

• المصفوفة Array
• المصفوفة الديناميكية ArrayList
• جدول التعمية HashTable
• القاموس <Dictionary<K,V
• القائمة <List<T
• المكدس Stack
• الرتل Queue
• القائمة المرتبة SortedList
• القاموس النصي StringDictionary

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

ولتجنب الأخطاء وضمان أمان الكود، استخدم المجموعات المعممة Generic Interfaces في #C التي تستلزم تعيين نوع العناصر التي ستتعامل معها المجموعة عند التصريح عنها وتتعامل مع نوع محدّد بدلاً من المجموعات غير المعممة Non-generic Interfaces التي  لا تحدد نوع العناصر وتجعل عملية التحقق من صحة الأنواع صعبة على مصرف #C.

فعند التعامل مع أنواع البيانات الأساسية مثل السلاسل النصية أو الأعداد الصحيحة أو الأعداد الحقيقية، سيؤدي استخدام مجموعة غير معممة إلى عدم تحديد نوع البيانات التي ستحتفظ بها المجموعة.وبالتالي عندما تضيف أو تسترجع العناصر، سيحول مصرف اللغة البيانات إلى نوع الكائن العام، وهذا يسمى التعليب boxing وإلغاء التعليب unboxing. ويمكن أن تؤثر هذه العمليات على أداء البرنامج بشكل كبير مقارنة باستخدام مجموعة معممة تحتوي على نوع البيانات المناسب.

ولا تحاول كتابة كود خاص لإنشاء كائنات المجموعات بنفسك، فإطار العمل .NET يوفر بالفعل العديد من المجموعات الجاهزة التي توفر الكثير من الوقت والجهد كما تقدم مكتبة C5 في #C مجموعة من الأدوات وهياكل البيانات المتقدمة التي تسهل التعامل مع مجموعات البيانات مثل الأشجار الدائمة persistent trees وارتال الأولوية priority queues والقوائم المرتبطة linked lists وغيرها.. فهذه المجموعات تساعد في تنظيم البيانات وتسهل التعامل مع إضافتها وحذفها واسترجاعها.

الخطأ 8: إهمال تحرير الموارد غير المستخدمة

تستخدم بيئة تنفيذ CLR أداة كنس المهملات Garbage Collector لإدارة الذاكرة تلقائيًا، فلست بحاجة لتحرير الذاكرة التي حجزتها عند إنشاء الكائنات. وعلى عكس لغات البرمجة مثل لغة ++C التي تحتوي على العامل delete أو لغة C التي تستخدم التابع free لتحرير الذاكرة، لا تتضمن لغة #C شيئًا مشابهًا.

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

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

يحتوي إطار العمل .NET على واجهة باسم IDisposable تتضمن تابعًا واحدًا فقط يسمى Dispose()‎. وأي كائن ينفذ هذه الواجهة سينفذ تابع Dispose()‎ الذي يساعد في تحرير الموارد بفعالية. فعندما تريد إنشاء وتحرير كائن object في كتلة الكود نفسها استخدم التابع ()Dispose بشكل أساسي، ويمكنك استخدام العبارة using للتأكد من استدعاء ()Dispose بغض النظر عن الطريقة التي ستخرج فيها من الكود سواء بسبب وقوع استثناء أو بسبب عبارة return أو إغلاق كتلة الكود، والعبارة using المذكورة هنا هي نفس تلك المستخدمة لتضمين فضاء الأسماء namespace أعلى ملف #C، وتجدر الإشارة هنا بأن للعبارة using استخدامًا آخر لا يعرفه الكثير من المطورين وهو ضمان استدعاء التابع ()Dispose للكائن عند الخروج من كتلة الكود كما في المثال التالي:

using (FileStream myFile = File.OpenRead("foo.txt")) {
       myFile.Read(buffer, 0, 100);
      }

في المثال السابق وبعد إنشاء العبارة using، سيتأكد المطور أنه التابع ()myFile.Dispose سيستدعى بمجرد انتهاء العمل بالملف سواء أصدر التابع ()Read استثناء أو لم يصدر.

الخطأ 9: تجنب الاستثناءات

تطبق لغة البرمجة #C مبدأ يسمى أمان النو ع Type safety أثناء تشغيل البرنامج، وهو يساعد المطورين على اكتشاف الأخطاء بسرعة أكبر مقارنة ببعض اللغات الأخرى مثل ++C التي قد يؤدي التحويل الخاطئ بين أنواع البيانات فيها إلى إسناد قيم غير صحيحة أو عشوائية للمتغيرات.

لكن مبرمجي #C لا يستفيدون بشكل كامل من هذه الميزة، مما يؤدي إلى بعض الأخطاء في الكود. فلغة #C تقدم طريقتين لمعالجة الأخطاء: الأولى تعتمد على إصدار استثناءات try/catch`، والثانية لا تستخدم الاستثناءات لإدارة الأخطاء وتتعامل معها بطريقة أخرى مثل التحقق من القيم أو التأكد من صحة المدخلات قبل إجراء العمليات عليها. فبعض المبرمجين يتجنبون استخدام الاستثناءات معتقدين أن ذلك يقلل من حجم الكود، لكن هذا قد يؤدي إلى تجاهل الأخطاء المهمة.

على سبيل المثال، هناك طريقتان مختلفتان للتحويل القسري بين أنواع البيانات أي لتحويل الكائنات بين أنواع البيانات المختلفة كما في الكود التالي:

// طريقة1:
      // سيرمى استثناء إذا لم نتمكن من تحويل account إلى  SavingsAccount
      SavingsAccount savingsAccount = (SavingsAccount)account;

// طريقة2:
      // لن يرمى استثناء في حال لم نتمكن من التحويل
      // سيتم تعيين savingsAccount إلى null بدلاً من ذلك
      SavingsAccount savingsAccount = account as SavingsAccount;

الخطأ الأكبر الذي قد يحدث عند استخدام الطريقة الثانية في الكود السابق هو نسيان التحقق من القيمة المرجعة. إذا كانت القيمة null، ولم تتحقق منها، فقد يؤدي ذلك إلى حدوث استثناء من النوع NullReferenceException في وقت لاحق، مما يصعب عليك تحديد السبب الفعلي للمشكلة. أما في الطريقة الأولى، فسيطلق استثناء مباشر من نوع InvalidCastException إذا كان التحويل غير ممكن ممل يساعدك على تحديد مكان المشكلة ومعرفتها بسرعة.

بالنسبة للطريقة الثانية، حتى إذا قام المبرمج بالتحقق من القيمة المرجعة، فإن المشكلة تبقى إذا كانت القيمة فارغة null. فماذا يفعل المبرمج في هذه الحالة؟ هل من الأفضل له معالجة هذه الأخطاء داخل التابع؟ وهل هناك طريقة أخرى للتعامل مع فشل عملية التحويل؟

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

لاحظ المثال التالي حيث ستصدر الطريقة الأولى استثناء أما الطريقة الثانية فلا تصدره:

int.Parse();     // يرمي استثناء إذا لم يكن بالإمكان تحويل الوسيط
int.TryParse();  // يعيد قيمة من نوع bool للدلالة على ما إذا كان التحويل قد نجح

IEnumerable.First();     // يرمي استثناء إذا كانت السلسلة فارغة

IEnumerable.FirstOrDefault();     // يعيد null أو القيمة الافتراضية إذا كانت السلسلة فارغة

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

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

if (int.TryParse(myString, out myInt)) {
        // استعمل myInt
      } else {
        // استعمل القيمة الافتراضية
      }

بدلًا من الكود التالي الذي يطلق استثناء:

 try {
        myInt = int.Parse(myString);
        // استعمل myInt
      } catch (FormatException) {
        // استعمل القيمة الافتراضية
      }

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

الخطأ 10: السماح بتراكم تحذيرات المصرّف

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

من أبسط الأمثلة على هذا النوع من الأخطاء هو نسيان حذف السطر الذي عرفت فيه متغير بعد تعديل خوارزمية ما وتوقفها عن استخدام هذا المتغير. في هذه الحالة، سيعمل البرنامج بشكل طبيعي، لكن سيصدر المترجم تحذيرًا بأن هذا المتغير غير مستخدم في الكود وغالبًا ما يتجاهل المبرمجون هذا التحذير ولا يعالجونه، كما يخفي معظم المبرمجين التحذيرات في النافذة Error List الموجودة في بيئة التطوير Visual Studio ويهتمون فقط بمعالجة الأخطاء مما يؤدي إلى تراكم هذه التحذيرات وهذا هو الخطأ بعينه. في حال تجاهل التحذيرات فإننا سنرى في القريب العاجل شيء يشبه الكود التالي:

class Account {

          int myId;
          int Id;   // يطلق المصرف تحذير هنا لكنك لم تنتبه له

          // الباني
          Account(int id) {
          this.myId = Id;     //  خطأ
          }

      }

يوجد خطأ كبير في الكود السابق بالرغم من أن مصرف اللغة وضعه كتحذير فقط وهو تعيين قيمة المتغير Id للمتغير myId باستخدام الأمر this.myId=Id والذي يجب أن يكون this.myId=id، إذا تجاهلت التحذير ستضيع الكثير من الوقت في تتبع مثل هذا الخطأ حسب درجة تعقيد البرنامج، أما إذا عالجته من البداية فستكتشف الخطأ بوقت قصير.

فيجب عليك كمبرمج عدم تجاهل التحذيرات التي تستغرق بضع ثوانٍ لحلها في بداية ظهورها، في حين ستحتاج مع تقدمك في البرنامج إلى ساعات لمعرفة سبب التحذيرات وحلها، تأكد اولًا بأول من أن النافذة Error List الموجودة في بيئة التطوير Visual Studio لا تحتوي أي أخطاء أو تحذيرات وعالجها على الفور.

من المعروف أن لكل قاعدة استثناءات، ففي بعض الأحيان قد تحتاج إلى كتابة كود يصدر تحذير ولكنك ستتجاهل هذا التحذير ليتنفيذ البرنامج بالطريقة التي تريدها. في هذه الحالات النادرة، يمكنك استخدام الأمر [pragma warning disable [warning id# في الكود نفسه الذي يصدر التحذير ليتوقف عن تشغيل التحذير المحدد، مع إمكانية تنبيهك لأي تحذيرات جديدة إذا كانت هناك حاجة لذلك.

الخلاصة

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

ترجمة وبتصرف للمقال Buggy C# Code: The 10 Most Common Mistakes in C# Programming لكاتبه Patrick Ryder.

اقرأ أيضًا

• الاستثناءات ومعالجة الأخطاء في لغة سي شارب #C
• كيفية التعامل مع الأخطاء البرمجية
• الأخطاء العشرة الأكثر شيوعًا في شيفرة بايثون Python البرمجية
• الأخطاء العشرة الأكثر شيوعًا في شيفرة PHP

لغة C# هي لغة برمجة أنيقة، كائنيّة التوجه Object-oriented بأنواع بيانات سليمة Type-safe تمكّن المطورين من بناء تطبيقات آمنة ومتينة تعمل على إطار العمل NET.

// تبدأ التعليقات وحيدة السطر بشريطين مائلين هكذا //

/*
توضع التعليقات متعدّدة الأسطر بين العلامة أعلاه والعلامة أسفله
*/

هذا تعليق xml يُستخدَم لتوليد توثيق خارجي
أو لتقديم مساعدة حسب السياق في بيئة تطوير مندمجة IDE.

/// <param name="firstParam"> لتوثيق الدالة Parameter الذي هو معامل firstParam هذا تعليق</param>

/// <returns>معلومات عن القيمة المُرجَعة للدالة/returns>

//public void MethodOrClassOrOtherWithParsableHelp(string firstParam) {}

يحدّد فضاءات اﻷسماء Namespaces التي ستستخدمها هذه الشفرة
فضاءات الأسماء أدناه هي كلّها جزء من مكتبة الأصناف Classes المعيارية في إطار العمل NET.

Framework Class Library
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using System.IO;

فضاء الأسماء هذا ليس مُتضمّنا في المكتبة المعيارية:

using System.Data.Entity;

لكي تتمكّن من استخدام المكتبة أعلاه فستحتاج لإضافة مرجع إلى ملف dll وهو ما يمكن لمدير الحزم NuGet فعلُه: Install-Package EntityFramework
تعرّف فضاءات الأسماء مجالات لتنظيم الشفرات ضمن حزم Packages أو وِحْدات Modules لاستخدام فضاء الأسماء المُعرّف أدناه في شفرة أخرى نضيف العبارة Learning.CSharp إلى فضاءات الأسماء المستخدمة

namespace Learning.CSharp
{

يجب أن يحوي كل ملف cs. على الأقل على صنف Class له نفس اسم الملف. يمكنك لك عدم التقيّد بهذا الشرط، إلا أنه أفضل لصحة الشفرة المصدرية

public class LearnCSharp
{

صياغة أساسية: يمكنك التجاوز إلى “ميزات مثيرة للاهتمام” إن سبق لك كتابة شفرات بجافا أو سي++

public static void Syntax()
{
    // للكتابة في سطر جديد Console.WriteLine استخدم
    Console.WriteLine("Hello World");
    Console.WriteLine(
        "Integer: " + 10 +
        " Double: " + 3.14 +
        " Boolean: " + true);

        // لكتابة عبارات على نفس السطر Console.Write استخدم 
        Console.Write("Hello ");
        Console.Write("World");

أنواع البيانات Types والمتغيّرات Variables

دورة تطوير التطبيقات باستخدام لغة Python

احترف تطوير التطبيقات مع أكاديمية حسوب والتحق بسوق العمل فور انتهائك من الدورة

اشترك الآن

عرّف المتغيّرات على النحو التالي <type> <name>

Sbyte - عدد صحيح (سالب أو موجب) على 8 بتات (محصور بين 128- و127)

sbyte fooSbyte = 100;

Byte - عدد طبيعي (موجب فقط) على 8 بتات (محصور بين 0 و255)

byte fooByte = 100;

Short - عدد صحيح أو طبيعي طوله 16 بتات
صحيح short محصور بين -32,768 و32,767
طبيعي ushort محصور بين 0 و65,535

short fooShort = 10000;
ushort fooUshort = 10000;

عدد صحيح fooInt أو طبيعي fooUint طوله 32 بت

int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
uint fooUint = 1; // (0 <= uint <= 4,294,967,295)

Long عدد صحيح fooLong أو طبيعي fooUlong طوله 64 بت

long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)

النوع المبدئي default للأعداد هو int أو uint حسب طول العدد. والحرف L وراء العدد يشير إلى أن نوع العدد هو long أو ulong

Double - فاصلة عائمة مزدوجة الدقة حسب المعيار 64-bit IEEE 754

double fooDouble = 123.4; // الدقة: 15-16 رقما

Float - فاصلة عائمة وحيدة الدقة 32-bit IEEE 754 Floating Point

float fooFloat = 234.5f; // الدقة: 7 أرقام

يشير الحرف f وراء العدد إلى أن نوع العدد هو Float

Decimal - نوع بيانات بطول 128 بت، ودقّة أعلى من بقية أنواع البيانات ذات الفاصلة العائمة مناسب للحسابات المالية والنقدية

decimal fooDecimal = 150.3m;
// Boolean - true & false
bool fooBoolean = true; // or false

Char - نوع بيانات بطول 16 بت يرمز لمحرف يونيكود

`char fooChar = 'A';

Strings – على النقيض من جميع أنواع البيانات السابقة التي هي أنواع لقيم البيانات
فإن النوع String - سلسلة محارف - هو نوع لمرجع Reference بمعنى أنه يمكنه أخذ القيمة null

string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
Console.WriteLine(fooString);

يمكن الوصول إلى كل محرف من سلسلة المحارف عن طريق ترتيبه في السلسلة

char charFromString = fooString[1]; // => 'e'

لا يمكن التعديل على سلاسل المحارف؛ التعليمة fooString[1] = X خاطئة مقارنة سلاسل محارف مع قيمة الخاصيّة CurrentCulture المعرّفة في المكتبة المعيارية لتمثيل اللغة المستخدمة في النظام، مع تجاهل حالة الأحرف IgnoreCase

string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);

تهيئة سلسلة المحارف اعتمادا على sprintf

string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);

التاريخ والتهيئة

DateTime fooDate = DateTime.Now;
Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));

سلاسل المحارف الأصلية Verbatim String
يمكنك استخدام العلامة @ أمام سلسلة محارف لتخليص جميع المحارف الموجودة في السلسلة

string path = "C:\\Users\\User\\Desktop";
string verbatimPath = @"C:\Users\User\Desktop";
Console.WriteLine(path == verbatimPath);  // => true

يمكنك توزيع سلسلة محارف على أكثر من سطر بالرمز @ لتخليص العلامة " ضع مكانها "" (" مرتين)

string bazString = @"Here's some stuff
on a new line! ""Wow!"", the masses cried";

استخدم الكلمة المفتاحية const لجعل المتغيّر ثابتًا غير قابل للتعديل وتُحسب القيم الثابتة أثناء تصريف البرنامج compile time

const int HoursWorkPerWeek = 9001;

بنى البيانات

المصفوفات - يبدأ العنصر الأول عند الترتيب 0 ويجب تحديد قياس المصفوفة عند تعريفها صيغة تعريف المصفوفة هي كالتالي:

;<datatype>[] <var name> = new <datatype>[<array size>]

المصفوفة intArray في المثال التالي تحوي 10 أعداد

int[] intArray = new int[10];

طريقة أخرى لتعريف مصفوفة وتهيئتها

int[] y = { 9000, 1000, 1337 };

ترتيب عناصر المصفوفة - الوصول إلى عنصر

Console.WriteLine("intArray @ 0: " + intArray[0]);

المصفوفات قابلة للتعديل.

intArray[1] = 1;

القوائم

تُستخدَم القوائم أكثر من المصفوفات لما توفّره من مرونة وصيغة تعريف قائمة هي على النحو التالي:

;List<datatype> <var name> = new List<datatype>()

List<int> intList = new List<int>();
List<string> stringList = new List<string>();
List<int> z = new List<int> { 9000, 1000, 1337 }; // تحديد القيم الابتدائية لعناصر القائمة

تُستخدَم الإشارتان <> للأنواع العميمة Generics - راجع فقرة ميزات رائعة

ليست للقوائم قيم مبدئية ويجب أولا إضافة قيمة قبل إمكانية الوصول إلى العنصر

intList.Add(1);
Console.WriteLine("intList @ 0: " + intList[0]);

بنى تحتية أخرى يجدر بك مراجعتها:

قوائم الانتظار Queues/ الرصوص Stacks
القواميس Dictionaries
HashSet
تجميعاـ القراءة فقط Read-only collections
الأزواج المُرتّبة Tuples (الإصدار 4 من .NET. فما فوق)

العوامل

Console.WriteLine("\n→Operators");


int i1 = 1, i2 = 2; // اختصار لتعريف متغيّرات عدة في آن واحد

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

Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3

المقياس Modulo

Console.WriteLine("11%3 = " + (11 % 3)); // => 2

عوامل المقارنة

Console.WriteLine("3 == 2? " + (3 == 2)); // => false
Console.WriteLine("3 != 2? " + (3 != 2)); // => true
Console.WriteLine("3 > 2? " + (3 > 2)); // => true
Console.WriteLine("3 < 2? " + (3 < 2)); // => false
Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true

عوامل المقارنة البتّية Bitwise

~ عامل التكملة الأحادي (إن كان البت يحوي 0 يحوله إلى 1، وإن كان يحوي واحد يحوّله إلى صفر)
>> إزاحة البتات إلى اليسار
<< إزاحة البتات إلى اليمين
& عامل “و” المنطقي
^ عامل “أو” المنطقي غير الشامل exclusive OR
| عامل “أو” المنطقي الشامل inclusive OR

التزايد Incrementation

int i = 0;
Console.WriteLine("\n->Inc/Dec-rementation");
Console.WriteLine(i++); //Prints "0", i = 1. تزاد بعدي
Console.WriteLine(++i); //Prints "2", i = 2. تزايد قبلي
Console.WriteLine(i--); //Prints "2", i = 1. تناقص بعدي
Console.WriteLine(--i); //Prints "0", i = 0. تناقص قبلي

بنى التحكّم

Console.WriteLine("\n->Control Structures");

تتبع بنية التحكم if else طريقة كتابة بنى التحكم في C

int j = 10;
if (j == 10)
{
    Console.WriteLine("I get printed");
}
else if (j > 10)
{
    Console.WriteLine("I don't");
}
else
{
    Console.WriteLine("I also don't");
}

العوامل الثلاثية

بنية تحكّم if else بسيطة تمكن كتابتها على النحو التالي:

<condition> ? <true> : <false>

int toCompare = 17;
string isTrue = toCompare == 17 ? "True" : "False";

حلقة While التكرارية

int fooWhile = 0;
while (fooWhile < 100)
{
    //تتكرّر الحلقة مئة مرة، من القيمة 0 إلى القيمة 99
    fooWhile++;
}

حلقة Do.. While التكرارية

int fooDoWhile = 0;
do
{

الحلقة معدّة للتكرار مئة مرة، من القيمة 0 إلى القيمة 99

Start iteration 100 times, fooDoWhile 0->99
if (false)
    continue; // تجاوز التكريرة الحالية

fooDoWhile++;

if (fooDoWhile == 50)
    break; // توقيف الحلقة تماما، والخروج منها
} while (fooDoWhile < 100);

حلقة for التكرارية ذات الصيغة:

(<for(<start_statement>; <conditional>; <step

for (int fooFor = 0; fooFor < 10; fooFor++)
{
    // تتكرّر الحلقة عشر مرات،  من القيمة 0 إلى القيمة 9
}

حلقة For Each

يمكن استخدام حلقة التكرار foreach للمرور عبر أي كائن Object يُنفّذ الصنف IEnumerable أو <IEnumerable<T
تنفّذ جميع الأنواع التجميعية (المصفوفات، القوائم، القواميس…) في إطار العمل .Net واجهة أو أكثر من الأصناف المذكورة
(يمكن حذف ()ToCharArray من التعليمة أدناه، لأن String تنفّذ الواجهة IEnumerable)

foreach (char character in "Hello World".ToCharArray())
{
    // تمرّ على جميع المحارف في السلسلة
}

تعليمة Switch

تعمل Switch مع أنواع البيانات byte, short, char, وint تعمل كذلك مع أنواع البيانات Enum (نتعرّض لها أدناه)، الصنف String وبضعة أصناف خاصّة تغلّف أنواع بيانات أساسية: Character,Byte,Short, و Integer.

int month = 3;
string monthString;
switch (month)
{
    case 1:
        monthString = "January";
        break;
    case 2:
        monthString = "February";
        break;
    case 3:
        monthString = "March";
        break;

يمكن تنفيذ أكثر من إجراء في كل حالة case، إلا أنه لا يمكن إضافة إجراء ضمن حالة دون إضافة تعليمة توقيف break; قبل الحالة الموالية (إن أردت فعل هذا الأمر، فستحتاج لإضافة تعليمة goto case x بعد الإجراء)

case 6:
case 7:
case 8:
    monthString = "Summer time!!";
        break;
    default:
        monthString = "Some other month";
        break;
    }

التحويل بين أنواع البيانات وجبْر الأنواع Typecasting

تحويل البيانات

تحويل سلسلة محارف String إلى عدد Integer
سيظهر استثناء Exception في حالة إخفاق عملية التحويل

int.Parse("123");// نحصُل على النسخة العددية من سلسلة المحارف "123"

عند استخدام الدالة TryParse لتحويل نوع البيانات فإن قيمة التحويل ستكون القيمة المبدئية لنوع البيانات وفي حالة الأعداد فإن القيمة المبدئية هي 0

int tryInt;
if (int.TryParse("123", out tryInt)) // ترجع الدالة قيمة منطقية
    Console.WriteLine(tryInt);       // 123

تحويل الأعداد إلى سلاسل محارف String
يتضمّن الصنف Convert عددا من التوابع Methods لتسهيل التحويل

Convert.ToString(123);

أو

tryInt.ToString();

جبر أنواع البيانات

جبر العدد العشري 15 للحصول على قيمة من النوع int
ثم جبر القيمة المُتحصَّل عليها ضمنيا لنحصُل على النوع long

long x = (int) 15M;
}

الأصناف

راجع التعريفات في آخر الملف

public static void Classes()
{

انظر تعريف الكائنات في آخر الملف

استخدم الكلمة المفتاحية new لاستهلال صنف

Bicycle trek = new Bicycle();

استدعاء توابع الكائن

trek.SpeedUp(3); // يجب دائما المرور عبر المعدّلات والمسترجعات Setter and getter methods
trek.Cadence = 100;

يُستخدم التابع ToString لعرض قيمة الكائن

Console.WriteLine("trek info: " + trek.ToString());

استهلال كائن جديد من الصنف PennyFarthing

PennyFarthing funbike = new PennyFarthing(1, 10);
Console.WriteLine("funbike info: " + funbike.ToString());

Console.Read();
} // نهاية التابع الرئيس Main method

مَدخل الكونسول Console entry. التطبيقات التي تعمل عبر الطرفية يجب أن يكون لديها مدخل عبارة عن تابع رئيس

public static void Main(string[] args)
{
    OtherInterestingFeatures();
}

ميزات مثيرة للاهتمام

التوقيعات المبدئية للتوابع

public // مجال الرؤية
static // يسمح بالاستدعاء المباشر من الصنف دون المرور بكائنات
int // نوع البيانات المُرجَعة,
MethodSignatures(
    int maxCount, // المتغيّر الأول عددي
    int count = 0, // القيمة المبدئية هي 0، تُستخدَم  إن لم يُمرَّر متغير إلى التابع 
    int another = 3,
    params string[] otherParams // يستقبل بقية المتغيّرات المُمررة إلى التابع جميعا 
    )
    {
        return -1;
    }

يمكن أن تكون أسماء التوابع متطابقة، ما دامت التوقيعات مختلفة وكل تابع لا يختلف عن آخر سوى في نوع البيانات المُرجَع ليس وحيدا

public static void MethodSignatures(
    ref int maxCount, // تمرير المعاملات حسب المرجع، وليس القيمة
    out int count)
{

المعامل المُمرر في المتغيّر count سيحوي القيمة 15 خارج هذه الدالة

count = 15; // معامل الخروج out يجب أن يُسنَد قبل الانتهاء من التابع
}

أنواع البيانات العميمة Generics

الأصناف TKey وTValue يحدّدها المستخدم الذي يستدعي هذه الدالة ويحاكي هذا التابع عمل SetDefault في بايثون

public static TValue SetDefault<TKey, TValue>(
    IDictionary<TKey, TValue> dictionary,
    TKey key,
    TValue defaultItem)
{
    TValue result;
    if (!dictionary.TryGetValue(key, out result))
        return dictionary[key] = defaultItem;
    return result;
}

يمكنك تقييد الكائنات التي يمكن تمريرها إلى الدالة

public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
{

بما أن الصنف T ينفّذ IEnumerable فإنه يمكننا المرور على عناصره باستخدام foreach

foreach (var item in toPrint)
    // العنصر هو من النوع int
    Console.WriteLine(item.ToString());
}

الكلمة المفتاحية “yield”

يدلّ استخدام yield أن التابع الذي تظهر فيه هذه الكلمة المفتاحية لديه خاصيّة التكرار (أي أنه يمكن استخدام التابع مع الحلقة foreach)

public static IEnumerable<int> YieldCounter(int limit = 10)
{
    for (var i = 0; i < limit; i++)
        yield return i;
}

نستطيع استدعاء التابع أعلاه على النحو التالي

public static void PrintYieldCounterToConsole()
{
    foreach (var counter in YieldCounter())
        Console.WriteLine(counter);
}

يمكن استخدام yield return أكثر من مرّة في نفس التابع

public static IEnumerable<int> ManyYieldCounter()
{
    yield return 0;
    yield return 1;
    yield return 2;
    yield return 3;
}

كما يمكنك استخدام “yield break” لتوقيف التكرار
التابع التالي يُرجِع نصف القيم الموجودة بين 0 وlimit

public static IEnumerable<int> YieldCounterWithBreak(int limit = 10)
{
    for (var i = 0; i < limit; i++)
    {
        if (i > limit/2) yield break;
        yield return i;
    }
}

public static void OtherInterestingFeatures()
{

المعاملات الاختيارية

MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
MethodSignatures(3, another: 3); // تعيين قيمة المعامل مباشرة، مع تجاوز المعاملات الاختيارية

تمرير المعاملات بالمرجع By reference، والقيمة المُرجعة Out parameter

BY REF AND OUT PARAMETERS
int maxCount = 0, count; // المعاملات المُمررة بالمرجع يجب أن تحوي قيمة
MethodSignatures(ref maxCount, out count);

توابع التمديد Extension methods

int i = 3;
i.Print(); // مُعرَّفة أدناه

الأنواع التي تقبل قيمة فارغة Nullable types، مناسبة للتخاطب مع قواعد البيانات والقيم المُرجَعة وأي نوع بيانات قيمي (أي ليس صنفا) يمكن جعله يقبل قيما فارغة بكتابة ? بعده

<type>? <var name> = <value>

int? nullable = null; // اختصار لـ Nullable<int>
Console.WriteLine("Nullable variable: " + nullable);
bool hasValue = nullable.HasValue; // قيمة منطقية صحيحة true إن لم يكن يساوي null

علامتا الاستفهام المتلاصقتان ?? هما اختصار لتحدد قيمة مبدئية في حال كان المتغيّر فارغا نعطيه 0 قيمة مبدئية

int notNullable = nullable ?? 0; // 0

?. هذه العلامة عي عامل للتحقّق من القيمة الفارغة null

nullable?.Print(); // استخدم تابع التمديد Print() إذا كان المتغيّر nullable مختلفا عن null

المتغيّرات ضمنية النوع - يمكنك ترك المُصرّف Compiler يحدّد نوع المتغيّر:

var magic = "magic is a string, at compile time, so you still get type safety";

;magic = 9 لن تُسنَد القيمة 9 إلى المتغيّر magic لأنه يحوي سلسلة محارف

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

var phonebook = new Dictionary<string, string>() {
    {"Sarah", "212 555 5555"} // إضافة عنوان إلى دفتر العناوين
};

استدعاء الدالة SetDefault المُعرَّفة أعلاه

Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone

يمكنك عدم تحديد TKey و TValue بما أنه يمكن استنتاجهما تلقائيا

Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555

الدوال مجهولة الاسم Lambda expressions - تتيح كتابة شفرات على نفس السطر

Func<int, int> square = (x) => x * x; // آخر عنصر من T هو القيمة المُرجعة
    Console.WriteLine(square(3)); // 9

التعامل مع الأخطاء

try
{
    var funBike = PennyFarthing.CreateWithGears(6);

لن تُنفَّذ لأن CreateWithGears تتسبّب في استثناء Exception

string some = "";
if (true) some = null;
some.ToLower(); // تتسبّب في الاستثناء NullReferenceException
}
catch (NotSupportedException)
{
    Console.WriteLine("Not so much fun now!");
}
catch (Exception ex) // التقاط جميع الاستثناءات الأخرى
{
    throw new ApplicationException("It hit the fan", ex);
    // throw; // التقاط آخر يحافظ على ركام النداء callstack
}
    // catch { } // التقاط كل شيء دون التعامل مع الاستثناءات
    finally
{
    // try أو catch تُنفّذ بعد
}

إدارة الموارد

يمكنك إدارة الموارد المتوفّرة بسهولة حيث تنفّذ أغلب الكائنات التي تستعمل الموارد غير المستغلة (الملفات، سياق الأجهزة الطرفية، …إلخ) تُنفّذ الواجهة IDisposable
تتولّى التعليمة using التخلّص من كائنات IDisposable

using (StreamWriter writer = new StreamWriter("log.txt"))
{
    writer.WriteLine("Nothing suspicious here");
}

يُتخلَّص من جميع الموارد بعد الانتهاء من تنفيذ هذه الشفرة حتى ولو تسبّبت في استثناء

البرمجة المتوازية

var words = new List<string> {"dog", "cat", "horse", "pony"};

Parallel.ForEach(words,
    new ParallelOptions() { MaxDegreeOfParallelism = 4 },
    word =>
    {
        Console.WriteLine(word);
    }
);

تشغيل هذه الشفرة سينتُج عنه مُخرجات متعدّدة لأن كلّ تشعّب thread يُكمل في وقت مختلف عن الآخر. أدناه أمثلة على المُخرجات

cat dog horse pony
dog horse pony cat

الكائنات الديناميكية (رائعة للعمل مع لغات برمجة أخرى)

dynamic student = new ExpandoObject();
student.FirstName = "First Name";  

لا تحتاج لتعريف صنف أولا بل إنه يمكنك إضافة توابع (يُرجع التابع أدناه سلسلة محارف ويتلقّى سلسلة محارف)

student.Introduce = new Func<string, string>(
    (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
Console.WriteLine(student.Introduce("Beth"));

تنفّذ أغلب التجميعات Collections الواجهة <IQUERYABLE<T التي توفّر الكثير من التوابع المفيدة

var bikes = new List<Bicycle>(); // دراجات هوائية
bikes.Sort(); // يرتّب القائمة
bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // يرتّب القائمة بناءً على عدد العجلات
var result = bikes
        .Where(b => b.Wheels > 3) // الترشيج والفلترة
        .Where(b => b.IsBroken && b.HasTassles)
        .Select(b => b.ToString()); //

var sum = bikes.Sum(b => b.Wheels); 

يجمع عدد العجلات في كامل القائمة وينشئ قائمة من الكائنات الضمنية Implicit objects بالاعتماد على بعض خواص الدراجة الهوائية

var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });

من الصعب توضيح الأمر هنا، إلا أنك تحصُل على نوع البيانات قبل الانتهاء من التعليمات، إذ أن المصرّف يمكنه العمل ضمنا على الأنواع أعلاه

foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
    Console.WriteLine(bikeSummary.Name);

التوازي مع ASPARALLEL

نخلط عمليّات LINQ والعمليّات المتوازية

var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);

سيحدث الأمر بالتوازي. تُنشَأ التشعبات تلقائيا وستُقسَّم النتائج بينها
طريقة رائعة للعمل مع مجموعة بيانات ضخمة إن كانت لديك الكثير من الأنوية Cores

LINQ

تربط بين مخزن بيانات وكائنات من الصنف <IQueryable<T
مثلا: LinqToSql تربط الكائنات مع قاعدة بيانات، LinqToXml تربط الكائنات مع مستند XML

var db = new BikeRepository();

يؤجَّل التنفيذ، وهو أمر جيّد عند التعامل مع قواعد البيانات

var filter = db.Bikes.Where(b => b.HasTassles); // no query run
if (42 > 6) // يمكنك الاستمرار في إضافة المرشحات، حتى تلك المشروطة؛ مناسبة لميزة "البحث المتقدّم"
    filter = filter.Where(b => b.IsBroken); // no query run

    var query = filter
        .OrderBy(b => b.Wheels)
        .ThenBy(b => b.Name)
        .Select(b => b.Name); // still no query run

يعمل الاستعلام الآن، إلا أنك لا تحصُل على نتائج الاستعلام إلا عند المرور عليها

foreach (string bike in query)
    Console.WriteLine(result);
    }
} // نهاية الصنف LearnCSharp

يمكنك إضافة أصناف أخرى في ملف cs.

public static class Extensions
{

توابع الصنف Extensions

public static void Print(this object obj)
    {
        Console.WriteLine(obj.ToString());
    }
}

التفويض والأحداث

public class DelegateTest
{
    public static int count = 0;
    public static int Increment()
    {
        // زيادة العدّاد ثم إرجاع النتيجة
        return ++count;
    }

التفويض delegate هو مرجع لتابع
لجعل مرجع على التابع Increment نبدأ بتعريف تفويض بنفس التوقيع أي أنه لا يأخذ أية معطيات ويُرجع عددا من النوع int

public delegate int IncrementDelegate();

يمكن أيضا استخدام حدث Event لتحريك التفويض
أنشئ حدثا بنوع التفويض

public static event IncrementDelegate MyEvent;

static void Main(string[] args)
{

نحيل إلى التابع Increment باستهلال التفويض وتمرير معطى هو التابع نفسه

IncrementDelegate inc = new IncrementDelegate(Increment);
Console.WriteLine(inc());  // => 1

يمكن تركيب التفويضات بالعامل +

IncrementDelegate composedInc = inc;
composedInc += inc;
composedInc += inc;

سينفّذ التفويض composedInc التابع Increment ثلاث مرات

Console.WriteLine(composedInc());  // => 4

الاشتراك في الحدث باستخدام التفويض

MyEvent += new IncrementDelegate(Increment);
MyEvent += new IncrementDelegate(Increment);

تحريك الحدث، أي تنفيذ كل التفويضات المشترِكة في هذا الحدث

Console.WriteLine(MyEvent());  // => 6
    }
}

صيغة تعريف صنف:

<public/private/protected/internal> class <class name>{`
    // حقول البيانات، المشيّدات، الدوالّ.. كلّها في الداخل
    //تُستدعى الدوال بنفس طريقة استدعاء التوابع في جافا
}

public class Bicycle
{
    // حقول/متغيّرات صنف الدراجات الهوائية Bicycle
    public int Cadence // عمومي public : يمكن استدعاء من أي مكان
    {
        get //  مسترجع - نعرّف تابعا للوصول إلى قيمة خاصيّة من الكائن
        {
            return _cadence;
        }
        set // معدّل - نعرّف تابعا لتعيين قيمة خاصيّة
        {
            _cadence = value; // القيمة value هي المعطى المُمرّر إلى المعدّل
        }
    }
private int _cadence;

protected virtual int Gear // يمكن استدعاءه فقط من هذا الصنف أو الأصناف المتفرّعة منه Protected:محميّ 
    {
        get; // تُنشأ خاصيّة تلقائية بحيث لا تحتاج لإضافة حقل بيانات
        set;
    }

internal int Wheels // داخليّ Internal: يُمكن الوصول إليه من نفس الملف التنفيذي 
        {
            get;
            private set; // يمكن تغيير مجال المسترجعات والمعدّلات
        }

int _speed; // ولا يمكن الوصول إليها إلا من داخل الصنف Private كل الخاصيّات هي مبدئيا خاصّة 
        // يمكن أيضا استخدام الكلمة المفتاحية private
public string Name { get; set; }

للخاصيّات صياغة استثنائية عندما نريد خاصية متاحة للقراءة فقط بمعنى أنها تعيد فقط نتيجة عبارة

public string LongName => Name + " " + _speed + " speed"; 

النوع enum هو نوع بيانات قيمية يتمثّل في مجموعة من المتغيّرات ثابتة القيمة
هذا النوع هو في الواقع مجرّد ربط اسم بقيمة (عددية، إن لم يحدد نوع آخر)
أنواع البيانات الموثوقة في قيم الثوابت هي byte, sbyte, short, ushort, int, uint, long, و ulong ولا يمكن أن توجد نفس القيمة مرتين في متغيّر من النوع enum

public enum BikeBrand
{
    AIST,
    BMC,
    Electra = 42, // مباشرة enum يمكن تعيين قيمة المتغيّر في 
    Gitane // 43
}

عرّفنا هذا النوع داخل الصنف Bicycle لذا فهو نوع داخلي وعندما نريد استخدامه خارج الصنف فسيتوجّب أن نكتُب Bicycle.Brand

public BikeBrand Brand; 

بعد تعريف نوع enum يصبح بإمكاننا تعريف متغيّر من هذا النوع

تستطيع التعليم على وجود قيم عدّة يمكن الاختيار بينها بإضافة الصنف FlagsAttribute قبل تعريف النوع enum
يمكن استخدام أي صنف متفرّع عن الصنف Attribute لتعليم أنواع البيانات، التوابع والمعاملات…إلخ
يمكن استخدام العوامل المنطقية & و | لإجراء عمليّات منطقية داخل القيمة

[Flags]
public enum BikeAccessories
{
    None = 0,
    Bell = 1,
    MudGuards = 2, // نحتاج لتعيين القيم يدويا
    Racks = 4,
    Lights = 8,
    FullPackage = Bell | MudGuards | Racks | Lights
}

الاستخدام: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell)
في الإصدارات السابقة على الإصدار الرابع من إطار العمل NET
 

(aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell

public BikeAccessories Accessories { get; set; }

تنتمي الخاصيّات المُعلمة بالكلمة المفتاحية static للصنف نفسه، وليس لكائن عكس بقية الخاصيّات
يمكن الوصول إلى هذه الخاصيّات دون الرجوع إلى كائن محدّد
 

;Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated)

public static int BicyclesCreated { get; set; }

عيّن القيم غير القابلة للتعديل أثناء التشغيل ولا يمكن إسناده إلا عند تعريفها أو داخل مشيّد

readonly bool _hasCardsInSpokes = false; // خاصيّة خاصّة وللقراءة فقط

المشيّدات Constructors هي طريقة لإنشاء الأصناف
أدناه المشيّد المبدئي

public Bicycle()
{
    this.Gear = 1; // يمكن الوصول إلى خاصيّات الصنف بالكلمة المفتاحية this
    Cadence = 50;  // إلا أنك لا تحتاجها في كل الحالات
    _speed = 5;
    Name = "Bontrager";
    Brand = BikeBrand.AIST;
    BicyclesCreated++;
}

هذا مشيّد مُعيّن (يحوي معطيات)

public Bicycle(int startCadence, int startSpeed, int startGear,
                       string name, bool hasCardsInSpokes, BikeBrand brand)
    : base() // أولا  base يستدعي 
    {
        Gear = startGear;
        Cadence = startCadence;
        _speed = startSpeed;
        Name = name;
        _hasCardsInSpokes = hasCardsInSpokes;
        Brand = brand;
    }

يمكن وضع المشيّدات بالتسلسل

public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
            this(startCadence, startSpeed, 0, "big wheels", true, brand)
    {
    }

صيغة كتابة الدوال

(<public/private/protected> <return type> <function name> <args>)

يمكن للأصناف أن تعيّن مسترجعات ومعدّلات لحقولها كما يمكنها تنفيذ الخاصيّات عبر دوال (وهي الطريقة المفضّلة في Csharp) ويمكن لمعاملات التابع أن تحوي قيما مبدئية، في هذه الحالة، يمكن استدعاء التوابع بدون تمرير معطيات عن هذه العوامل

public void SpeedUp(int increment = 1)
{
    _speed += increment;
}

public void SlowDown(int decrement = 1)
{
    _speed -= decrement;
}

تعيّن الخاصيّات القيم وتسترجعها. إن كان غرضك الوصول إلى البيانات فقط دون تعديلها فالخاصيّات أنسب. يمكن أن يكون للخاصيّة مسترجع أو معدّل أو كلاهما

private bool _hasTassles; // متغيّر خاص
public bool HasTassles // مسترجع عام
{
    get { return _hasTassles; }
    set { _hasTassles = value; }
}

كما يمكنك تعريف خاصيّة تلقائية في سطر واحد
ستُنشئ هذه الصيغة حقلا داعما تلقائيا
يمكنك الحد من مجال الرؤية على المسترجع أو المعدّل أو كليهما

public bool IsBroken { get; private set; }

يمكن للخاصيّات أن تكون تلقائية التنفيذ

public int FrameSize
{
    get;
        // يمكنك الحد من مجال الرؤية على المسترجع أو المعدّل
        //Framesize يمكنه استدعاء معدّل Bicycle  يعني هذا أن الصنف
    private set;
}

يمكن تعريف فهرس على الكائنات
يمكنك مثلا كتابة bicycle[0] التي ترجع القيمة “chris” للحصول على أول راكب
أو كتابة “bicycle[1] = "lisa لتعيين الراكب الثاني (دراجة رباعية المقاعد!)

private string[] passengers = { "chris", "phil", "darren", "regina" };

public string this[int i]
{
    get {
        return passengers[i];
    }

    set {
        passengers[i] = value;
    }
}

تابع لعرض قيم حقول الكائن

public virtual string Info()
{
    return "Gear: " + Gear +
        " Cadence: " + Cadence +
        " Speed: " + _speed +
        " Name: " + Name +
        " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
        "\n------------------------------\n"
        ;
}

يمكن للتوابع أن تكون ثابتة (الكلمة المفتاحية static). مناسبة للدوال المساعدة

public static bool DidWeCreateEnoughBicycles()
{

داخل التابع الثابت لا يمكن إجراء عمليات سوى على الحقول الثابتة

return BicyclesCreated > 9000;
} 

إن كان الصنف لا يحتاج إلا إلى حقول ثابتة فربما يكون من الأفضل أن يكون الصنف نفسه ثابتا

} // نهاية الصنف Bicycle

PennyFarthing هو صنف متفرّع من الصنف Bicycle

class PennyFarthing : Bicycle
{

(يمثّل هذا الصنف تلك الدراجات الهوائية التي لديها عجلة أمامية كبيرة جدا، وليست لديها مسنّنات Gears لتعديل السرعة) . نستدعي مشيّد الصنف الأب

public PennyFarthing(int startCadence, int startSpeed) :
    base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
    {
    }

    protected override int Gear
    {
        get
        {
            return 0;
        }
        set
        {
            throw new InvalidOperationException("You can't change gears on a PennyFarthing");
        }
    }

    public static PennyFarthing CreateWithGears(int gears)
    {
        var penny = new PennyFarthing(1, 1);
        // عمليا لا توجد دراجة من نوع PennyFarthing بمسنّنات
        penny.Gear = gears;
        return penny;
    }

    public override string Info()
    {
        string result = "PennyFarthing bicycle ";
        result += base.ToString(); // نستدعي التابع الأصلي الموجود في الصنف الأب
        return result;
    }
}

تحتوي الواجهات على التوقيعات فقط

interface IJumpable
{
    void Jump(int meters); // جميع الأعضاء في الواجهة هي مبدئيا عمومية
}

interface IBreakable
{
    bool Broken { get; } // يمكن للواجهات أن تحوي خاصيّات كما يمكنها أن تتضمّن واجهات وأحداثا
}

يمكن للأصناف أن ترث Inherit من صنف واحد آخر على الأكثر، إلا أنه يمكنها تنفيذ أي عدد من الواجهات ويجب أن يكون الصنف الأب الأول في لائحة الأصناف تليه الواجهات كلّها

class MountainBike : Bicycle, IJumpable, IBreakable
{
    int damage = 0;

    public void Jump(int meters)
    {
        damage += meters;
    }

    public bool Broken
    {
        get
        {
            return damage > 100;
        }
    }
}

صنف للاتصال بقاعدة البيانات، نستخدمه مثالا لعمل LinqToSql
يعمل إطار العمل EntityFramework Code First لربط الكائنات بسجلات جداول البيانات (بنفس طريقة ActiveRecord في روبي، إلا أنه ثنائي الاتجاه)

public class BikeRepository : DbContext
{
    public BikeRepository()
        : base()
    {
    }

    public DbSet<Bicycle> Bikes { get; set; }
}

يمكن تقسيم الأصناف على ملفات cs. عدّة
 

A1.cs

public partial class A
{
    public static void A1()
    {
        Console.WriteLine("Method A1 in class A");
    }
}

A2.cs

public partial class A
{
    public static void A2()
    {
        Console.WriteLine("Method A2 in class A");
    }
}

يستخدم الصنف Program أدناه الصنف A المُقسّم على ملفي cs.

Program using the partial class "A"
public class Program
{
    static void Main()
    {
        A.A1();
        A.A2();
    }
}

يمكن الإداراج في سلاسل المحارف String interpolation بكتابة $ أمام السلسلة ثم إحاطة المتغيّر المُدرج بقوسين معكوفين { }. يمكنك أيضا تجميع السلسلتين، الأصلية والمُعدّلة، بالعلامة @

public class Rectangle
{
    public int Length { get; set; }
    public int Width { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        Rectangle rect = new Rectangle { Length = 5, Width = 3 };
        Console.WriteLine($"The length is {rect.Length} and the width is {rect.Width}");

        string username = "User";
        Console.WriteLine([email protected]"C:\Users\{username}\Desktop");
    }
}

ميزات جديدة في الإصدار C# 6

class GlassBall : IJumpable, IBreakable
{

تمهيد الخاصيّات التلقائية

public int Damage { get; private set; } = 0;

تمهيد الخاصيّات التلقائية المقتصرة على المسترجعات

public string Name { get; } = "Glass ball";

تمهيد الخاصيّات التلقائية المقتصرة على المسترجعات في المشيّد

public string GenieName { get; }

public GlassBall(string genieName = null)
{
    GenieName = genieName;
}

    public void Jump(int meters)
    {
        if (meters < 0)

العبارة nameof() مستحدثة وينتُج عنها التحقّق من وجود المعرّف
 

"nameof(x) == "x

تحول على سبيل المثال دون بقاء أسماء المتغيّرات القديمة في رسائل الخطأ بعد تحديثها

    throw new ArgumentException("Cannot jump negative amount!", nameof(meters));

    Damage += meters;
}

الخاصيّات المعرَّفة ضمن هيكل العبارة

public bool Broken
=> Damage > 100;

نفس الشيء بالنسبة للتوابع

public override string ToString()
            // سلسلة محارف تُدرج ضمنها متغيّرات
            => $"{Name}. Damage taken: {Damage}";

        public string SummonGenie()

العوامل المشترطة بالقيمة الفارغة null
ترجع العبارة x?.y القيمة null بمجرد كون x مساوية ل null، بدون تقييم y

=> GenieName?.ToUpper();
}

static class MagicService
{
    private static bool LogException(Exception ex)
    {
        /* سجّل الاستثناءات في مكان ما */
        log exception somewhere */
        return false;
    }

    public static bool CastSpell(string spell)
    {
        try
        {
            // API نفترض هنا أننا نستدعي واجهة تطبيقات برمجية 
            throw new MagicServiceException("Spell failed", 42);

            // نجح الاستدعاء
            return true;
        }

يلتقط استثناء في حالة إخفاق استدعاء واجهة التطبيقات، أي أن قيمة Code تساوي 42

Only catch if Code is 42 i.e. spell failed
catch(MagicServiceException ex) when (ex.Code == 42)
{
    // أخفق الاستدعاء
    return false;
}

استثماءات أخرى أو الاستثناء MagicServiceException عندما تكون قيمة المتغير Code مختلفة عن 42

catch(Exception ex) when (LogException(ex))
{
    // لا يصل التنفيذ إلى هذه الكتلة
}
    return false;
}

لاحظ أن التقاط الاستثناء MagicServiceException وإعادة إطلاقه عندما يكون المتغير Code لا يساوي القيمة 42 أو 117 هو أمر مختلف، إذ أن كتلة catch-all الأخيرة لن تلتقط الاستثناء المُعاد

public class MagicServiceException : Exception
{
    public int Code { get; }

    public MagicServiceException(string message, int code) : base(message)
    {
        Code = code;
    }
}

الخاصية Obsolete

public static class PragmaWarning {

[Obsolete("Use NewMethod instead", false)]
public static void ObsoleteMethod()
{
    /*شفرة برمجية قديمة هنا */
}

public static void NewMethod()
{
    /* شفرة برمجية جديدة */
}

public static void Main()
{
    ObsoleteMethod(); 

تحذير يظهر عند استخدام شفرة برمجية قديمة، ناتج عن الوسم Obsolete أعلاه
 

CS0618: 'ObsoleteMethod is obsolete: Use NewMethod instead'

تعطّل التعليمة التالية إظهار التحذير السابق

#pragma warning disable CS0618
    ObsoleteMethod(); // لا تحذير
#pragma warning restore CS0618
    ObsoleteMethod(); // CS0618: 'ObsoleteMethod is obsolete: Use NewMethod instead'
        }
    }
} // نهاية فضاء الأسماء

using System;

ميزة في C# 6: إمكانية استخدام static مع using

using static System.Math;

namespace Learning.More.CSharp
{
    class StaticUsing
    {
        static void Main()
        {
            // using مع static بدون استخدام 
            Console.WriteLine("The square root of 4 is {}.", Math.Sqrt(4));
            // using مع static باستخدام 
            Console.WriteLine("The square root of 4 is {}.", Sqrt(4));
        }
    }
}

ميزة جديدة في C# 7
ثبّت آخر إصدار من Microsoft.Net.Compilers باستخدام Nuget
ثبّت آخر إصدار من System.ValueTuple باستخدام Nuget

using System;
namespace Csharp7
{

الأزواج المرتبة Tuples، التفكيك DECONSTRUCTION والإلغاءات Discards

class TuplesTest
{
    public (string, string) GetName()
    {
    // Item1، Item2 .... تُسمى الحقول في الأزواج المرتبة مبدئيا بـ 
    var names1 = ("Peter", "Parker");
    Console.WriteLine(names1.Item2);  // => Parker

يمكن تخصيص أسماء الحقول
تعريف النوع الأول

(string FirstName, string LastName) names2 = ("Peter", "Parker");

تعريف النوع الثاني

var names3 = (First:"Peter", Last:"Parker");

    Console.WriteLine(names2.FirstName);  // => Peter
    Console.WriteLine(names3.Last);  // => Parker

        return names3;
}

public string GetLastName() {
var fullName = GetName();

يمكن تفكيك الأزواج المرتبة

(string firstName, string lastName) = fullName;

يمكن إلغاء حقول من الزوج المرتب بعد تفكيكه بالعلامة _

Fields in a deconstructed tuple can be discarded by using _
var (_, last) = fullName;
return last;
}

يمكن تفكيك أي نوع بيانات على نفس المنوال باستخدام التابع Deconstruct

public int randomNumber = 4;
public int anotherRandomNumber = 10;

public void Deconstruct(out int randomNumber, out int anotherRandomNumber)
{
    randomNumber = this.randomNumber;
    anotherRandomNumber = this.anotherRandomNumber;
}

static void Main(string[] args)
{
    var tt = new TuplesTest();
    (int num1, int num2) = tt;
    Console.WriteLine($"num1: {num1}, num2: {num2}");  // => num1: 4, num2: 10

    Console.WriteLine(tt.GetLastName());
    }
}

مطابقة الأنماط Pattern matching

class PatternMatchingTest
{
public static (string, int)? CreateLogMessage(object data)
{
    switch(data)
    {
    // when  ترشيح إضافي باستخدام 
        case System.Net.Http.HttpRequestException h when h.Message.Contains("404"):
        return (h.Message, 404);
    case System.Net.Http.HttpRequestException h when h.Message.Contains("400"):
        return (h.Message, 400);
    case Exception e:
         return (e.Message, 500);
    case string s:
        return (s, s.Contains("Error") ? 500 : 200);
    case null:
        return null;
    default:
        return (data.ToString(), 500);
        }
    }
}

الإحالة إلى الموارد المحلية Reference locals
تعطيك إمكانية إرجاع مرجع Reference كائن بدلا من قيمته

class RefLocalsTest
{

لاحظ الكلمة المفتاحية ref في تعليمة الإرجاع return

public static ref string FindItem(string[] arr, string el)
{
    for(int i=0; i<arr.Length; i++)
    {
        if(arr[i] == el) {
        // إرجاع المرجع
        return ref arr[i];
        }
    }
    throw new Exception("Item not found");
}

public static void SomeMethod()
{
    string[] arr = {"this", "is", "an", "array"};

    //في كل مكان ref لاحظ 
    ref string item = ref FindItem(arr, "array");
    item = "apple";
    Console.WriteLine(arr[3]);  // => apple
    }
}

الدوال المحليّة Local functions

class LocalFunctionTest
{
    private static int _id = 0;
    public int id;
    public LocalFunctionTest()
    {
        id = generateId();

لا يمكن الوصول إلى الدالة المحلية خارج هذا المجال

int generateId()
    {
        return _id++;
    }
}

public static void AnotherMethod()
{
    var lf1 = new LocalFunctionTest();
    var lf2 = new LocalFunctionTest();
    Console.WriteLine($"{lf1.id}, {lf2.id}");  // => 0, 1

    int id = generateId();
    // خطأ
    // error CS0103: The name 'generateId' does not exist in the current context
        }
    }
}

ترجمة -وبتصرّف- للمقال Learn C# in Y Minutes

لا تخلو أيّ لغة برمجة محترمة من وسيلة لمعالجة الأخطاء. تحتوي لغة سي شارب على آليّة قويّة لمعالجة الأخطاء. تشبه هذه الآلية إلى حدّ ما تلك المستخدمة في لغة Java.

هناك نوعان أساسيّان من الأخطاء التي قد تنتج عن البرنامج: النوع الأوّل هي أخطاء أثناء التصميم، أي أثناء كتابة الشيفرة، وهي أخطاء يمكن اكتشافها بسهولة من خلال مترجم سي شارب الذي يتعرّف عليها ويعطيك وصفًا عنها، وقد يزوّدك أيضًا ببعض المقترحات للتخلّص منها. بالنسبة للنوع الثاني من الأخطاء فهي التي تنتج أثناء تنفيذ البرنامج runtime errors. توجد الكثير من الأسباب لحدوث مثل هذه الأخطاء. فمن القسمة على صفر إلى القراءة من ملف غير موجود أو حتى استخدام متغيّر مصرّح على أنّه من نوع مرجعيّ ولكن لم تتم تهيئته بعد بمرجع إلى كائن. عند حدوث مثل هذه الأخطاء ترمي بيئة التنفيذ المشتركة CLR استثناءً exception يحتوي على معلومات بخصوص الخطأ الذي حدث، فإذا كنت مستعدًّا لالتقاط هذا الاستثناء فستنجو، وإلّا سيتوقّف برنامجك عن العمل بصورة مفاجئة.

التقاط استثناء من خلال عبارة try-catch

إذا صادفتك عبارة برمجيّة تحتوي على عمليّة حسابيّة أو على استدعاء لتابع آخر، أو أيّ شيء قد يثير الريبة في نفسك، فمن الممكن مراقبتها أثناء تنفيذ البرنامج باستخدام عبارة try-catch. تتألّف هذه العبارة من قسمين: القسم الأوّل هو قسم المراقبة try، والقسم الثاني هو قسم الالتقاط catch. الشكل "الأبسط" لهذه العبارة هو التالي:

try
{
	//عبارة برمجيّة مريبة
}
catch(Exception exp)
{
	//هنا يُلتقط الاستثناء وتتمّ معالجته
}

يمكن أن يحوي قسم try على عبارات برمجيّة بقدر ما ترغب. عندما يصادف البرنامج أثناء التنفيذ خطأً ما، سيتوقّف التنفيذ عند العبارة التي سبّبت الخطأ، ثم ينتقل فورًا إلى قسم الالتقاط catch. لاحظ معي أنّ قسم catch سيُمرَّر إليه وسيط من الصنف Exception. الصنف Exception موجود ضمن نطاق الاسم System، وهو الصنف الأب لجميع الاستثناءات. إذ أنّ أي استثناء مهما كانت صفته (بما فيها الاستثناءات التي يمكنك أن تكتبها أنت) يجب أن ترث من هذا الصنف.

بعد حدوث الاستثناء والانتقال إلى قسم catch، سيحتوي الوسيط exp على معلومات حول مكان حدوث الاستثناء وسبب حدوثه، وغيرها من المعلومات التي قد تكون مفيدة لمستخدم البرنامج. تجدر الملاحظة بأنّ البرنامج لن يدخل إلى القسم catch أبدًا ما لم يحدث استثناء ضمن القسم try.

لنرى الآن البرنامج Lesson16_01 الذي سيعرّفنا على الاستثناءات بشكل عمليّ. يحتوي هذا البرنامج البسيط على عبارة try-catch وحيدة سنعمل من خلالها على توليد خطأ بشكل مقصود أثناء التنفيذ، وسنتعلّم كيفيّة المعالجة.

1	using System;
2
3	namespace Lesson16_01
4	{
5	    class Program
6	    {
7	        static void Main(string[] args)
8	        {
9	            int x = 5;
10	            int y = 0;
11	            int result;
12
13	            try
14	            {
15	                result = x / y;
16	            }
17	            catch(Exception exp)
18	            {
19	                Console.WriteLine("The following error has occurred:");
20	                Console.WriteLine(exp.Message);
21	            }
22
23	            Console.WriteLine("Good Bye!");
24	        }
25	    }
26	}

من الواضح أنّ هذا البرنامج يتجّه لأن يجري عمليّة قسمة على صفر في السطر 15 ضمن القسم try. عند وصول البرنامج إلى السطر 15 وإجراء عمليّة القسمة هذه، سيتولّد استثناء يؤدّي إلى انتقال التنفيذ مباشرةً إلى قسم catch في السطر 17. في قسم catch يعرض البرنامج معلومات عن هذا الخطأ باستخدام الخاصيّة Message لكائن الحدث exp. في النهاية يعرض البرنامج في السطر 23 رسالة توديعيّة للمستخدم.

نفّذ البرنامج لتحصل على الخرج التالي:

The following error has occurred:
Attempted to divide by zero.
Good Bye!

جرّب الآن تغيير قيمة المتغيّر y لتصبح 1 مثلًا وأعد تنفيذ البرنامج. ستلاحظ ظهور الرسالة التوديعيّة فقط على الشاشة، أي أنّه لم يحدث أي استثناء هذه المرّة. على كلّ الأحوال لا ينصح باستخدام معالجة الاستثناءات من أجل حالة القسمة على صفر في البرنامج السابق.

ملاحظة: في الواقع يمكن الاستغناء عن الوسيط الذي يمرّر إلى قسم catch بشكل كامل، وفي هذه الحالة لن يكون بإمكانك الحصول على معلومات حول الاستثناء المُلتقط. سيبدو شكل عبارة try-catch على الشكل التالي:

try
{
	//عبارة برمجيّة مريبة
}
catch
{
	//هنا يُلتقط الاستثناء وتتمّ معالجته
}

من الممكن استخدام هذا الأسلوب إذا كنّا على يقين حول طبيعة الخطأ الذي سيحدث.

عبارة try-catch أكثر تطورا

تصادفنا في بعض الأحيان حالات يكون من الضروري معها مراقبة أكثر من عبارة برمجيّة مريبة ضمن قسم try. لقد اتفقنا أنّه عند حدوث أيّ استثناء ضمن قسم try سينتقل التنفيذ إلى قسم catch. ولكن كيف سنميّز العبارة التي سبّبت هذا الاستثناء في قسم try؟

توجد العديد من الأصناف التي ترث من الصنف Exception والتي يُعتبر كلّ منها استثناءً مخصّصًا أكثر للمشكلة التي قد تحدث. فمثًلا كان من الممكن في البرنامج Lesson16_01 السابق أن نستخدم الصنف DivideByZeroException بدلًا من الصنف Exception في عبارة catch، وذلك لأنّه يرث (بشكل غير مباشر) من الصنف Exception، وسيعمل البرنامج كما هو متوقّع. ولكن في هذه الحالة لن تستطيع catch التقاط سوى الاستثناءات التي تنتج عن القسمة على صفر.

في كثير من الحالات قد تتسبّب العبارات البرمجيّة الموجودة في قسم try باستثناءات متنوّعة لا توجد علاقة فيما بينها. مما يفرض علينا استخدام الصنف Exception لكي نلتقط بشكل مؤكّد أي استثناء قد يصدر عنها، أو أن تساعدنا سي شارب في هذا الخصوص! في الحقيقة الخيار الثاني هو الأفضل وهو جاهز. يمكننا في الواقع إضافة أقسام catch أخرى بقدر ما نرغب بعد قسم try. سيوضّح البرنامج Lesson16_02 هذه الفكرة من خلال فتح ملف نصي ومحاولة قراءة محتوياته. لاحظ أنّنا سنستخدم هنا نطاق الاسم System.IO.

1	using System;
2	using System.IO;
3
4	namespace Lesson16_02
5	{
6	    class Program
7	    {
8	        static void Main(string[] args)
9	        {
10	            string contents;
11
12	            Try
13	            {
14	                using (StreamReader sr = new StreamReader("myfile.txt"))
15	                {
16	                    contents = sr.ReadLine();
17	                }
18
19	                Console.WriteLine("This file contains {0} characters.", contents.Length);
20	            }
21	            catch(NullReferenceException nullExp)
22	            {
23	                Console.WriteLine("The file does not contain any data.");
24	            }
25	            catch(FileNotFoundException notFoundExp)
26	            {
27	                Console.WriteLine("File: {0} not found!", notFoundExp.FileName);
28	            }
29	        }
30	    }
31	}

يستخدم هذا البرنامج قسميّ catch. القسم الأوّل (الأسطر من 21 إلى 24) يلتقط استثناءً من النوع NullReferenceException وهذا يحدث عند محاولة استدعاء تابع أو خاصيّة من متغيّر يحتوي على null بدلًا من مرجع لكائن حقيقي. أمّا القسم الثاني (الأسطر من 25 إلى 28) فهو يلتقط استثناءً من النوع FileNotFoundException والذي يحدث عند محاولة القراءة من ملف غير موجود. نفّذ البرنامج السابق وستحصل على الرسالة التالية في الخرج:

File: C:\\Users\Husam\documents\visual studio 2015\Projects\Lesson16_02\Lesson16_02\bin\Debug\myfile.txt not found!

وهذا طبيعي تمامًا لأنّني لم أنشئ الملف myFile.txt في هذا المسار. لاحظ كيف يضيف الصنف FileNotFoundException خاصيّة جديدة له وهي FileName (السطر 27) من النوع string التي تحوي مسار الملف مع اسمه.

أنشئ الآن الملف myFile.txt واتركه فارغًا، ثمّ ضعه ضمن نفس المجلّد الذي يحوي الملف التنفيذي للبرنامج (موجود ضمن bin\Debug\).

أعد تنفيذ البرنامج وستحصل على الرسالة التالي:

The file does not contain any data.

السبب في ظهور هذه الرسالة هو الاستثناء NullReferenceException وذلك لأنّنا حاولنا الوصول إلى الخاصيّة Length (تعطينا عدد المحارف الموجودة ضمن متغيّر نصي) من المتغيّر النصي contents رغم أنّه يحتوي على null (تذكّر بأنّنا تركنا الملف myFile.txt فارغًا).

اذهب إلى الملف myFile.txt الذي أنشأناه قبل قليل، واكتب بعض الكلمات ضمنه واحفظ الملف، ثمّ أعد تنفيذ البرنامج Lesson16_02 من جديد. يجب الآن أن تحصل على رسالة تخبرك بعدد الأحرف التي كتبتها ضمن الملف.

ملاحظة: يجب الانتباه إلى ترتيب أقسام catch. فلو كان مثلًا أوّل قسم catch موجود بعد قسم try يلتقط استثناءً من النوع Exception فعندها لن يستطيع أي قسم لاحق التقاط أي استثناء، لأنّ جميع الاستثناءات سيلتقطها هذا القسم الأوّل. السبب في ذلك أنّ الصنف Exception هو الأب العام لجميع أصناف الاستثناءات الأخرى، فيمكن له التقاطها.

عبارة try-catch-final

يمكن إضافة قسم أخير لعبارة try-catch اسمه final. وكما يوحي اسمه، فهذا القسم يمكن له أن يحتوي على عبارات برمجيّة سيتمّ تنفيذها بعد أن يدخل البرنامج إلى القسم try العائد له. وذلك سواءً أحدث استثناء ضمن try أم لم يحدث. تكمن فائدة وجود هذا القسم، في أنّه قد نواجه أحيانًا بعض الحالات التي تتطلّب إجراء بعض المهام عندما نفرغ من قسم try مثل إغلاق بعض المصادر المفتوحة، أو تحرير الذاكرة بشكل فوري وغيرها. الشرط الوحيد لاستخدام هذا القسم الاختياري هو أن يكون آخر قسم في عبارة try-catch. سنعدّل البرنامج Lesson16_02 ليدعم القسم final. انظر البرنامج Lesson16_03.

1	using System;
2	using System.IO;
3
4	namespace Lesson16_03
5	{
6		class Program
7		{
8			static void Main(string[] args)
9			{
10				string contents;
11		
12				try
13				{
14					using (StreamReader sr = new StreamReader("myfile.txt"))
15					{
16						contents = sr.ReadLine();
17					}
18					Console.WriteLine("This file contains {0} characters.", contents.Length);
19				}
20				catch(NullReferenceException nullExp)
21				{
22					Console.WriteLine("The file does not contain any data.");
23				}
24				catch(FileNotFoundException notFoundExp)
25				{
26					Console.WriteLine("File: {0} not found!", notFoundExp.FileName);
27				}
28				finally
29				{
30					Console.WriteLine("Good Bye!");
31				}
32			}
33		}
34	}

سواءً كان الملف myFile.txt موجودًا أم غير موجود، أو كان يحتوي على بيانات أم فارغاً، ستظهر العبارة !Good Bye على الشاشة.

ملاحظة: من الأفضل دومًا أن تحاول عدم استخدام عبارة try-catch وأن تستخدم عبارة if لاختبار الحالات التي تواجهك قبل تنفيذها. استخدم try-catch إذا كان ذلك ضروريًّا. والسبب في ذلك أنّ عمليّة معالجة الأخطاء بشكل عام تتطلّب المزيد من الموارد المخصّصة للبرنامج، مما قد يؤثّر على أداء البرنامج في حال تمّ استخدامها بشكل غير مدروس.

تمارين داعمة

تمرين 1

عدّل البرنامج Lesson16_02 بحيث يمكن الاستغناء عن عبارة try-catch تمامًا.

(تلميح: ستحتاج إلى استخدام عبارتيّ if في هذه الحالة).

تمرين 2

لتكن لدينا الشيفرة التالية:

string input = Console.ReadLine();

int t = int.Parse(input);

تطلب الشيفرة السابقة من المستخدم أن يدخل عددًا على شكل نص لتعمل على تحويله إلى قيمة عدديّة باستخدام التابع int.Parse.

المطلوب هو إضافة عبارة try-catch إلى الشيفرة السابقة لمعالجة استثناء ممكن الحدوث في حال أدخل المستخدم قيمة مثل "u" وهي لا يمكن تحويلها إلى قيمة عدديّة كما هو واضح.

(تلميح: استخدام الاستثناء FormatException الذي يُعبّر عن هذه الحالة).

الخلاصة

تعرّفنا في هذا الدرس على كيفيّة معالجة الأخطاء التي تظهر أثناء تنفيذ البرنامج. في الحقيقة هذا الموضوع ذو شجون! وهناك الكثير ليقال، ولكن يكفي الآن أن تتعرّف على المبادئ الأساسيّة لالتقاط الاستثناءات، وكيفيّة معالجتها.

يمكنك استخدام هذا الأسلوب في جميع التطبيقات التي تُنشئها باستخدام سي شارب، مثل تطبيقات الويب بأنواعها، وتطبيقات سطح المكتب، وحتى تطبيقات الأجهزة الذكيّة باستخدام تقنيّة Xamarin.

تعتبر تقنيّة Linq من التقنيّات الجديدة نسبيًّا في سي شارب ولغات دوت نت عمومًا. تسمح هذه التقنيّة بإجراء عمليّات استعلام معقّدة لاستخلاص البيانات بشكل سلس وسهل بسبب شكلها المألوف كما سنرى لاحقًا في هذا الدرس.

لتقنيّة Linq أشكال متعدّدة:

• Linq to Objects: للتعامل مع البيانات الموجودة في ذاكرة البرنامج.
• Linq To XML: للتعامل مع البيانات النصيّة الموجودة بتنسيق XML.
• Linq To SQL: وهي تقنيّة خاصّة بالحصول على البيانات من خادم SQL Server. في الحقيقة تمّ التخلّي عن هذه التقنيّة رغم حداثتها، وذلك لصالح تقنيّة أحدث وأكثر تطوّرًا وهي Entity Framework.

كما يتحدّث هذا الدرس عن تعابير Lambda وهي من المزايا المفيدة والتي تسهّل عمل المبرمجين إلى حدٍّ كبير. ستناول في هذا الدرس الشكل الأوّل من Linq، وهو استخدام Linq مع الكائنات Objects. ولكن قبل ذلك لنتحدّث قليلًا عن تعابير Lambda.

تعابير Lambda

تستطيع تخيّل تعابير Lambda على أنّها دوال functions صغيرة ليس لها اسم، تعمل على إجراء عمليّات حسابيّة بسيطة، ومن الممكن أن ترجع نتيجة. في الواقع يمكن للنوّاب Delegates أن تغلّف تعابير Lambda ضمن شروط محدّدة. سنتناول مثالًا بسيطًا يوضّح كيفيّة التعامل معها. انظر إلى الشيفرة التالية:

class Program
{
	delegate int Square(int x);

	static void Main(string[] args)
	{
		Square square = (x) => x * x;
		int result = square(5);
	}
}

صرّحنا في الشيفرة السابقة عن النائب Square الذي يتطلّب وسيطًا واحدًا من النوع int ويُرجع قيمة من نفس النوع. يُفترض بهذا النائب بأن يُغلّف التوابع التي تعمل على إيجاد مربّع عدد صحيح. إذا نظرت الآن إلى التابع Main ستجد أنّنا في السطر الأوّل منه نصرّح عن المتغيّر square من نوع النائب Square، حيث نُسند إليه ما يلي:

(x) => x * x

التعبير السابق هو تعبير Lambda بسبب وجود السهم <= ضمنه. فهم هذا التعبير بسيط، فهو يطلب وسيطًا وحيدًا (x) على يسار السهم، ويضرب قيمة هذا الوسيط بنفسها: x * x على يمين السهم، سيُرجع هذا التعبير قيمة x مضروبةً بنفسها. ولكن الملفت في الأمر أنّنا قد أسندنا هذا التعبير إلى متغيّر من نوع النائب Square. السبب في ذلك أنّ تعبير Lambda السابق يتوافق مع النائب Square في أنّه يحتاج إلى وسيط وحيد من النوع int ويُرجع قيمة من نفس النوع. ولكنّنا لم نوضّح في تعبير Lambda نوع الوسيط أو نوع القيمة المُعادة! لا مشكلة في ذلك، فسيتم استخلاص النوع من الوسيط المُمرّر وذلك بشكل تلقائي.

كمثال آخر على استخدام تعبير Lambda يمكن كتابة تعبير يتطلّب وسيطين ولكن لا يُرجع أي قيمة. انظر إلى الشيفرة التالية:

class Program
{
	delegate void SumAndPrinting(int a, int b);

	static void Main(string[] args)
	{
		SumAndPrinting sumAndPrnt = (a, b) => Console.WriteLine(a + b);
		sumAndPrnt(3, 4);
	}
}

النائب SumAndPrinting يقبل الآن وسيطين من النوع int لكنّه لا يُرجع أي قيمة (void). انظر إلى تعبير Lambda كيف أصبح:

(a, b) => Console.WriteLine(a + b)

لاحظ كيف أنّ الوسائط الموجودة بين قوسين تفصل بينها فواصل عاديّة دون تحديد الأنواع. كما يمكنك أن تلاحظ أيضًا بأنّ هذا التعبير مهمّته جمع قيمتي الوسيطين والطبع إلى الشاشة دون إرجاع أيّ قيمة.

ملاحظة: يمكننا الاستغناء عن القوسين في تعبير Lambda، إذا أردنا تمرير وسيط واحد فقط. مثل:

x => x * x

استعلاماتLinq

للاستفادة من Linq يجب إضافة نطاق الاسم System.Linq باستخدام الكلمة المحجوزة using. أفضل وسيلة لفهم Linq هي من خلال مثال تطبيقي بسيط، في البرنامج Lesson15_01 سنستخدم الصنف Student الذي استخدمناه في درس سابق ولكن سنجري فيه بعض التعديلات البسيطة، حيث أصبحنا نفصل اسم الطالب FirstName عن كنيته LastName، بالإضافة إلى إضافة حقل جديد اسمه Id من النوع int، والذي يُعبّر عن رقم الطالب:

class Student
{
	public int Id { get; set; }
	public string FirstName { get; set; }
	public string LastName { get; set; }
	public int Mark { get; set; }
}

سننشئ 10 كائنات من الصنف Student ونخزّنها ضمن مجموعة عموميّة <List<Student ثم نُجري على هذه المجموعة بعض "الحيل" باستخدام Linq. الهدف من هذا البرنامج هو إجراء عمليّة تصفية على هؤلاء الطلّاب بحيث نحصل على الطلّاب الذين تكون درجاتهم أكبر تمامًا من 60. سيحتوي البرنامج Lesson15_01 على أفكار جديدة ولكن مفيدة فكن مستعدًّا:

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4
5	namespace Lesson15_01
6	{
7	    class Student
8	    {
9	        public int Id { get; set; }
10	        public string FirstName { get; set; }
11	        public string LastName { get; set; }
12	        public int Mark { get; set; }
13	    }
14
15	    class Program
16	    {
17	        static void Main(string[] args)
18	        {
19	            List<Student> studentsList = new List<Student>()
20	            {
21	                new Student {Id = 1, FirstName = "Ahmad", LastName = "Morad" , Mark = 80},
22	                new Student {Id = 2, FirstName = "Husam", LastName = "Sayed" , Mark = 75},
23	                new Student {Id = 3, FirstName = "Nour", LastName = "Hasan" , Mark = 65},
24	                new Student {Id = 4, FirstName = "Bssel", LastName = "Shamma" , Mark = 30},
25	                new Student {Id = 5, FirstName = "Ahmad", LastName = "Khatib" , Mark = 90},
26	                new Student {Id = 6, FirstName = "Maryam", LastName = "Burhan" , Mark = 95},
27	                new Student {Id = 7, FirstName = "Sarah", LastName = "Burhan" , Mark = 100},
28	                new Student {Id = 8, FirstName = "Mansour", LastName = "Khalid" , Mark = 50},
29	                new Student {Id = 9, FirstName = "Omran", LastName = "Barrak" , Mark = 45},
30	                new Student {Id = 10, FirstName = "Hasan", LastName = "Anis" , Mark = 56},
31	            };
32
33	            Console.WriteLine("Full List:");
34	            Console.WriteLine("----------");
35	            PrintList(studentsList);
36
37
38	            IEnumerable<Student> students = from student in studentsList
39	                                            where student.Mark > 60
40	                                            select student;
41
42	            Console.WriteLine();
43	            Console.WriteLine("After applying Linq:");
44	            Console.WriteLine("----------");
45	            PrintList(students);
46	        }
47	
48	        private static void PrintList(IEnumerable<Student> students)
49	        {
50	            Console.WriteLine("{0,-5}{1,-15}{2,-15}{3,-10}", "Id", "First Name", "Last Name", "Mark");
51
52	            foreach (Student s in students)
53	            {
54	                Console.WriteLine("{0,-5}{1,-15}{2,-15}{3,-10}", s.Id, s.FirstName, s.LastName, s.Mark);
55	            }
56	        }
57	    }
58	}

نفّذ البرنامج السابق لتحصل على شكل شبيه بما يلي:

لاحظ كيف استثنى البرنامج في القائمة الثانية الطلاب الذين تقل درجاتهم عن 60 أو تساويها. قارن بين القائمتين واكتشف العناصر المستثناة.

يبدأ البرنامج في التابع Main بإنشاء 10 كائنات من النوع Student تمثّل بيانات عشرة طلّاب وإسناد هذه الكائنات فورًا إلى المجموعة القائمة studentsList بشكل مختصر (الأسطر من 19 إلى 31). الملفت هنا هو طريقة إنشاء كل من هذه الكائنات. انظر إلى السطر 21 مثلًا:

new Student {Id = 1, FirstName = "Ahmad", LastName = "Morad" , Mark = 80}

هذا شكل مختصر لإنشاء كائن من النوع Student حيث استخدمنا حاضنة {} بعد اسم الصنف Student مباشرةً وكتبنا أسماء الخصائص التي نريد تهيئتها ضمن هذه الحاضنة. بالنسبة لبانيّة الصنف Student فستُستدعى بكلّ تأكيد. يعتبر هذا الشكل من الإنشاء والإسناد المباشر للخصائص مفيدًا للغاية (أستخدمه بكثرة في برامجي الخاصّة) حيث يقلّل من أسطر الشيفرة البرمجيّة إلى حدٍّ كبير.

سيطبع البرنامج بعد ذلك القائمة التي أنشأناها قبل قليل من باب التوضيح، وذلك من خلال استدعاء التابع الساكن PrintList (السطر 35) بالشكل التالي:

PrintList(studentsList);

مرّرنا لهذا التابع القائمة الكاملة studentsList. التصريح عن التابع الساكن موجود في الأسطر بين 48 و 56 وسنتكلّم عنه بعد قليل.

يحتوي السطر 38 على عبارة برمجيّة تستخدم استعلام Linq:

IEnumerable<Student> students = from student in studentsList
where student.Mark > 60
select student;

يقع استعلام Linq على يمين عامل الإسناد (=)، وفي الحقيقة إذا كان لديك اطّلاع على لغة SQL فسيكون هذا الاستعلام مألوفًا بالنسبة إليك. لنركّز الآن على هذا الاستعلام فحسب:

from student in studentsList
where student.Mark > 60
select student

يبدأ الاستعلام بالكلمة المحجوزة from يتبعه اسم متغيّر جديد يمكنك تسميّته بأيّ اسم ترغبه. اخترت الاسم student لأنّني وجدتّه معبّرًا. بعد اسم المتغيّر الجديد نجد الكلمة المحجوزة in وبعدها اسم المجموعة التي نريد تطبيق الاستعلام عليها. إذًا أصبح بإمكاننا قراءة السطر الأوّل من الاستعلام على الشكل التالي:

اقتباس

"من أجل كل عنصر student موجود ضمن المجموعة studentsList".

يبدأ السطر الثاني بالكلمة المحجوزة where وهي اختياريّة ومن الممكن عدم كتابتها، وهي تسمح بكتابة شرط من ممكن تطبيقه على عناصر المجموعة studentsList. بالنسبة لمثالنا هذا، اخترت تطبيق الشرط:

where student.Mark > 60

أي أنّني أريد أن تكون درجة كل طالب (student) أكبر تمامًا من 60.

أمّا السطر الثالث select student فهو يخبر Linq عن شكل البيانات التي نريد الحصول عليها بنتيجة تنفيذ الاستعلام. في مثالنا هذا نريد الحصول على مجموعة كل عنصر من عناصرها هو كائن من النوع Student.

بنتيجة تنفيذ الاستعلام السابق سيحتوي المتغيّر students على مرجع لكائن مجموعة يحقّق الواجهة <IEnumerable<Student ولا يهمّك في الحقيقة ما هو النوع الفعليّ لهذه المجموعة.

يمكن لاستعلام Linq أن يُنتج مرجعًا لكائن مجموعة يحقّق الواجهة <IQueryable<Student ولكنّ الحديث عن هذا الموضوع هو خارج مجال الدرس.

في الواقع يمكن استخدام شروط أكثر تعقيدًا كأن نرغب بالحصول على جميع الطلّاب الذين تتراوح درجاتهم بين 60 و90 ضمنًا على سبيل المثال، وذلك باستخدام العامل && بالشكل التالي:

from student in studentsList
where student.Mark >= 60 && student.Mark <= 90
select student

كما من الممكن أنّ نرتّب البيانات حسب رقم الطالب id، أو بحسب اسمه FirstName أو كنيته LastName أو بمزيج منها، وذلك باستخدام الكلمة المحجوزة orderby الخاصّة بـ Linq:

from student in studentsList
where student.Mark >= 60 && student.Mark <= 90
orderby student.FirstName, student.LastName
select student

سيقوم الاستعلام السابق بترتيب العناصر التي توافق الشرط الموجود في القسم where حسب الاسم ثمّ حسب الكنيّة. توجد في الحقيقة الكثير من المزايا القويّة التي تتمتّع بها استعلامات Linq والتي لا يتّسع هذا الدرس لذكرها.

بالنسبة للتابع PrintList (الأسطر من 50 حتى 58) فيقتصر دوره على طباعة جدول للقائمة التي نمرّرها كوسيط إليه. لاحظ أنّ الوسيط الوحيد الذي يقبله يحقّق الواجهة <IEnumerable<Student لذلك فيمكننا تمرير أي وسيط إليه يحمل مرجعًا إلى كائن من أيّ صنف يحقّق هذه الواجهة بما فيه بالطبع الصنف <List<Student. الأمر الوحيد الجديد في هذا التابع هو استخدامه لتنسيق مختلف في إظهار البيانات بشكل جدوليّ. انظر السطر 52. ستجد النص التنسيقي: "{0,-5}{1,-15}{2,-15}{3,-10}" يسمح هذا النص التنسيقي بعرض البيانات بشكل جدوليّ أنيق على الشاشة، حيث يسمح التنسيق التالي {0, -5} بعرض الوسيط ذو الموقع 0 (من التابع WriteLine) ضمن حقل عرضه 5 فراغات بحيث تكون المحاذاة نحو اليسار. أمّا التنسيق {1, -15} فيسمح بعرض الوسيط ذو الموقع 1 ضمن حقل عرضه 15 فراغ بحيث تكون المحاذاة نحو اليسار أيضًا. بإزالة إشارة السالب (-) من التنسيقين السابقين ستصبح المحاذاة نحو اليمين.

هل تريد المزيد من الإثارة؟ أضف السطر التالي إلى السطر 43 من البرنامج السابق (أي بعد العبارة التي تستخدم استعلام Linq):

double average = students.Average(s => s.Mark);

تستخدم هذه العبارة التابع Average من المتغيّر students الذي يحتوي على قائمة الطلّاب بعد التصفيّة كما نعلم. وكما يُوحي اسمه يعمل هذا التابع على حساب معدّل الطلاب (كائنات Student) الموجودين ضمن students. ولكن كيف سيعرف التابع Average الحقل الذي سيتمّ بموجبه حساب المعدّل؟ يتمثّل الحل في استخدام تعبير Lambda يتطلّب وسيطًا واحدًا (الوسيط s) الذي سيمثّل كائن Student، ويُرجع قيمة الخاصيّة Mark له:

s => s.Mark

سيستخدم التابع هذا التعبير للمرور على جميع العناصر الموجودة ضمن المجموعة students ليحصل على درجة كلّ منها باستخدام تعبير Lambda السابق ثمّ يحسب المعدّل، ليعمل البرنامج على إسناده إلى المتغيّر average وهو من النوع double كما هو واضح. بعد تنفيذ العبارة السابقة وعلى فرض أنّ نسخة البرنامج Lesson15_01 الأساسيّة هي التي استُخدمت، ستكون قيمة average تساوي 77.5، ويمثّل هذا الرقم معدّل الطلاب الذين تكون درجاتهم أكبر تمامًا من 60.

قد يبدو كلّ ما قدّمناه جميلًا وممتعًا، لكنّك لن تستمتع بشكل فعليّ بهذه المزايا الرائعة التي توفّرها Linq و تعابير Lambda ما لم تستخدمها في برامجك الخاصّة. أستخدم مثل هذه المزايا في برامجي التي أطوّرها، ولن تتصوّر مدى سعادتي عندما أستخلص بيانات من قاعدة بيانات أو من خدمة ويب web service قد تحتوي على المئات أو الآلاف من البيانات الخام، ثمّ أُطبّق عليها وصفات Linq السحريّة فأحصل على ما أريده بكتابة عبارة برمجيّة واحدة فقط!

تمارين داعمة

تمرين 1

أجرِ تعديلًا على البرنامج Lesson15_01 بحيث نحصل على جميع الطلّاب الذين تكون درجاتهم أقل تمامًا من 50.

تمرين 2

أجرِ تعديلًا آخرًا على البرنامج Lesson15_01 بحيث نحصل على جميع الطلّاب الذين يكون الحرف الأوّل من اسمهم هو "A".

(تلميح: أحد الحلول المقترحة هو استخدام التابع StartWith من الخاصيّة النصية FirstName للكائن student أي على الشكل التالي:

student.FirstName.StartsWith("A")

وذلك بعد الكلمة where في استعلام Linq ).

الخلاصة

تعرّفنا في هذا الدرس على تعابير Lambda واستعلامات Linq. حيث صمّمنا عدّة برامج توضّح هاتين التقنيّتين المهمّتين في البرمجة باستخدام سي شارب. ستصادف كلًّا منهما كثيرًا في حياتك البرمجيّة، وستكون سعيدًا باستخدامها نظرًا للاختصار الكبير الذي ستحصل عليه في الشيفرة البرمجيّة، هذا فضلًا عن الأداء عالي المستوى الذي لن تستطيع مجاراته باستخدامك للشيفرة التقليديّة.

عندما تعمل على حاسوبك الشخصي، أو حتى على هاتفك الذكيّ، أو ربّما ساعتك الذكيّة. فأنت تستخدم الأحداث آلاف المرّات. الحدث هو وسيلة جميلة للتعبير عن أمر طارئ حدث لكائن برمجيّ. قد يكون هذا الأمر الطارئ عبارة عن نقرة زر فأرة، أو عن لمسة على شاشة جهازك الذكي. أو ضغطة مفتاح من لوحة المفاتيح الخاصّة بي وأنا أكتب هذا المقال، أو أن يكون أمرًا طارئًا يُعبّر عن حالة داخليّة ضمن نظام التشغيل. باختصار، هناك عدد كبير جدًّا من المصادر المختلفة أو المحتملة للأحداث.

العلاقة بين الأحداث Events والنوّاب Delegates

تعتمد الأحداث بشكل كليّ على النوّاب. وفي الحقيقة هي وسيلة لتهذيبها! لنستعير الصنف Car من البرنامج Lesson13_02 من الدرس السابق:

1	public class Car
2	{
3		public delegate void SpeedNotificatoinDelegate(string message);
4
5		private SpeedNotificatoinDelegate speedNotificationHandler;
6
7		public void RegisterWithSpeedNotification(SpeedNotificatoinDelegate handler)
8		{
9			this.speedNotificationHandler = handler;
10		}
11
12		public int CurrentSpeed { get; set; }
13		public int MaxSpeed { get; set; }
14
15		public Car()
16		{
17			CurrentSpeed = 0;
18			MaxSpeed = 100;
19		}
20
21		public Car(int maxSpeed, int currentSpeed)
22		{
23			CurrentSpeed = currentSpeed;
24			MaxSpeed = maxSpeed;
25		}
26
27		public void Accelerate(int delta)
28		{
29			CurrentSpeed += delta;
30
31			if (CurrentSpeed > MaxSpeed)
32			{
33				if(this.speedNotificationHandler != null)
34				{
35					string msg = string.Format("You exceed the maximum speed! (Current = {0}, Max = {1})",
36												CurrentSpeed, MaxSpeed);
37
38					speedNotificationHandler(msg);
39				}
40			}
41		}
42	}

كنت قد طلبت منك في التمرين الداعم رقم 2 من الدرس السابق أن تجري تعديلًا على الصنف Car بحيث تستغني عن التابع RegisterWithSpeedNotification، ولمّحت بأن تجعل الحقل speedNotificationHandler ذي محدّد وصول public. بعد إجراء هذا التعديل سيصبح الصنف Car على الشكل التالي:

public class Car
{
	public delegate void SpeedNotificatoinDelegate(string message);

	public SpeedNotificatoinDelegate speedNotificationHandler;

	public int CurrentSpeed { get; set; }

	public int MaxSpeed { get; set; }

	public Car()
	{
		CurrentSpeed = 0;
		MaxSpeed = 100;
	}

	public Car(int maxSpeed, int currentSpeed)
	{
		CurrentSpeed = currentSpeed;
		MaxSpeed = maxSpeed;
	}

	public void Accelerate(int delta)
	{
		CurrentSpeed += delta;
      
		if (CurrentSpeed > MaxSpeed)
		{
			if (this.speedNotificationHandler != null)
			{
				string msg = string.Format("You exceed the maximum speed! (Current = {0}, Max = {1})",
											CurrentSpeed, MaxSpeed);

				speedNotificationHandler(msg);
			}
		}
	}
}

سيعمل هذا الصنف بشكل ممتاز، حيث من الممكن أن نُسند نائبًا للحقل speedNotificationHandler من خارج الصنف Car بالشكل التالي:

Car car = new Car(100, 0);
car.speedNotificationHandler = new Car.SpeedNotificatoinDelegate(OnExceedMaxSpeedHandler);

المشكلة هنا أنّ الحقل speedNotificationHandler أصبح مكشوفًا تمامًا، حتى أنّه من الممكن استدعاء التابع الذي يغلّفه هذا النائب، من خارج الصنف Car، وهذا يعدّ خرقًا لمبدأ مهم في البرمجة كائنيّة التوجّه ألا وهو التغليف Encapsulation. لا ينبغي أن يتمكّن أيّ أحدٍ من استدعاء التابع الذي يغلّفه الحقل السابق إلّا من داخل الصنف Car حصرًا، لأنّ النائب المُسند لذلك الحقل يُعبّر عن حالة داخليّة ضمن الصنف Car وهي تجاوز السرعة القصوى.

توفّر لنا سي شارب حلًا عمليًّا وأنيقًا لهذه المشكلة تتمثّل في استخدام الأحداث. بالنسبة للصنف Car السابق (بعد التعديل) يكفيك أن تَسِم الحقل speedNotificationHandler بالكلمة المحجوزة event ليتحوّل إلى حدث لا يمكن استدعاؤه إلّا من داخل الصنف Car. لكن سيكون هناك اختلاف صغير في طريقة إسناد النوّاب إلى هذا الحقل. يحتوي البرنامج Lesson14_01 على النسخة الجديدة للصنف Car مع تعديل بسيط ضمن التابع Main لندعم استخدام الأحداث:

1	using System;
2
3	namespace Lesson14_01
4	{
5	    public class Car
6	    {
7	        public delegate void SpeedNotificatoinDelegate(string message);
8	
9	        public event SpeedNotificatoinDelegate speedNotificationHandler;
10
11	        public int CurrentSpeed { get; set; }
12	        public int MaxSpeed { get; set; }
13
14	        public Car()
15	        {
16	            CurrentSpeed = 0;
17	            MaxSpeed = 100;
18	        }
19
20	        public Car(int maxSpeed, int currentSpeed)
21	        {
22	            CurrentSpeed = currentSpeed;
23	            MaxSpeed = maxSpeed;
24	        }
25
26	        public void Accelerate(int delta)
27	        {
28	            CurrentSpeed += delta;
29	
30	            if (CurrentSpeed > MaxSpeed)
31	            {
32	                if (this.speedNotificationHandler != null)
33	                {
34	                    string msg = string.Format("You exceed the maximum speed! (Current = {0}, Max = {1})",
35	                        CurrentSpeed, MaxSpeed);
36
37	                    speedNotificationHandler(msg);
38	                }
39	            }
40	        }
41	    }
42
43	    class Program
44	    {
45	        static void Main(string[] args)
46	        {
47	            Car car = new Car(100, 0);
48
49	            car.speedNotificationHandler += new Car.SpeedNotificatoinDelegate(OnExceedMaxSpeedHandler);
50	
51	            for (int i = 0; i < 5; i++)
52	            {
53	                Console.WriteLine("Increasing speed by 30");
54	                car.Accelerate(30);
55	            }
56	        }
57
58	        static void OnExceedMaxSpeedHandler(string message)
59	        {
60	            Console.WriteLine(message);
61	        }
62	    }
63	}

انظر كيف وضعنا الكلمة المحجوزة event بعد كلمة public في التصريح عن الحقل speedNotificationHandler في السطر 9. كما أرجو أن تلاحظ أيضًا التعديل الذي طرأ في السطر 49 على كيفيّة إسناد النائب الجديد إلى الحقل speedNotificationHandler:

car.speedNotificationHandler += new Car.SpeedNotificatoinDelegate(OnExceedMaxSpeedHandler);

لاحظ كيف استخدمنا العامل (=+) بدلًا من العامل (=). في الحقيقة سيؤدي استخدام العامل (=) في هذه الحالة إلى حدوث خطأ أثناء ترجمة البرنامج.

ولكن ماهي الفائدة من العامل (=+)؟ لهذا العمل فائدة كبيرة، فمن خلاله يمكن تسجيل عدّة نوّاب (وبالتالي عدّة توابع) ضمن الحدث speedNotificationHandler بنفس الوقت. مما يعني أنّ عبارة مثل تلك الموجودة في السطر 37:

speedNotificationHandler(msg);

ستؤدّي إلى استدعاء أي نائب (وبالتالي أي تابع) مسجّل في الحدث speedNotificationHandler بشكل متسلسل يراعي الترتيب الذي سُجّلت ضمنه هذه النوّاب ضمن الحدث speedNotificationHandler باستخدام العامل =+. نسمّي التابع OnExceedMaxSpeedHandler اصطلاحًا بمعالج الحدث.

الآن سنذهب أبعد من ذلك ونجري تغييرًا على عبارة التسجيل في الحدث في السطر 49 لتصبح على الشكل التالي:

car.speedNotificationHandler += OnExceedMaxSpeedHandler;

لاحظ هنا أنّنا قد أزلنا التعبير الذي ينشئ كائن من النائب SpeedNotificatoinDelegate، ووضعنا بدلًا من ذلك اسم التابع OnExceedMaxSpeedHandler مباشرةً بعد العامل (=+). في الحقيقة إنّ مترجم سي شارب ذكيّ كفاية ليعرف أنّه ينبغي عليه أن يُنشئ كائنًا جديدًا من النائب SpeedNotificatoinDelegate بشكل تلقائيّ يغلّف التابع OnExceedMaxSpeedHandler. إذا نفّذت البرنامج ستحصل على نفس الخرج المتوقّع.

ملاحظة: تتمتّع النوّاب أيضًا بميّزة التسجيل المتعدّد باستخدام العامل =+. ولكن هذه الميّزة تُستخدم مع الأحداث بشكل أكبر.

التوابع مجهولة الاسم Anonymous Methods

التوابع مجهولة الاسم هي من المزايا التي تسمح باختصار الشيفرة إلى حدٍّ كبير. فمن اسمها، يظهر أنَّه لا يوجد لمثل هذه التوابع اسم، وإنّما جسم فقط يحوي الشيفرة المطلوب تنفيذها. كمثال بسيط على التوابع مجهولة الاسم سنجري تعديلًا على البرنامج Lesson14_01 السابق ليستخدم تابعًا عديم الاسم بدلًا من التابع OnExceedMaxSpeedHandler. سيكون هذا التعديل في السطر 49 ليصبح على الشكل التالي:

car.speedNotificationHandler += delegate(string message)
{
	Console.WriteLine(message);
};

لاحظ هنا أنّنا قد استخدمنا الكلمة المحجوزة delegate بعد العامل =+ بعد ذلك الوسائط التي يقبلها هذا التابع ثم جسم التابع المحاط بالحاضنة. الشيء الوحيد الناقص هو اسم التابع. من الواضح أنّ تعريف هذا التابع عديم الاسم يجب أن يتطابق مع تعريف النائب الذي صُرّح الحدث speedNotificationHandler بناءً عليه. الآن يمكن التخلّص من التابع OnExceedMaxSpeedHandler. انظر إلى البرنامج Lesson14_02 الكامل:

1	using System;
2
3	namespace Lesson14_02
4	{
5	    public class Car
6	    {
7	        public delegate void SpeedNotificatoinDelegate(string message);
8
9	        public event SpeedNotificatoinDelegate speedNotificationHandler;
10
11	        public int CurrentSpeed { get; set; }
12	        public int MaxSpeed { get; set; }
13
14	        public Car()
15	        {
16	            CurrentSpeed = 0;
17	            MaxSpeed = 100;
18	        }
19
20	        public Car(int maxSpeed, int currentSpeed)
21	        {
22	            CurrentSpeed = currentSpeed;
23	            MaxSpeed = maxSpeed;
24	        }
25
26	        public void Accelerate(int delta)
27	        {
28	            CurrentSpeed += delta;
29
30	            if (CurrentSpeed > MaxSpeed)
31	            {
32	                if (this.speedNotificationHandler != null)
33	                {
34	                    string msg = string.Format("You exceed the maximum speed! (Current = {0}, Max = {1})",
35	                        CurrentSpeed, MaxSpeed);
36	
37	                    speedNotificationHandler(msg);
38	                }
39	            }
40	        }
41	    }
42
43	    class Program
44	    {
45	        static void Main(string[] args)
46	        {
47	            Car car = new Car(100, 0);
48
49	            car.speedNotificationHandler += delegate(string message)
50	            {
51	                Console.WriteLine(message);
52	            };
53	
54	            for (int i = 0; i < 5; i++)
55	            {
56	                Console.WriteLine("Increasing speed by 30");
57	                car.Accelerate(30);
58	            }
59	        }
60	    }
61	}

ملاحظة: يوجد نائب جاهز موجود ضمن مكتبة FCL اسمه EventHandler وظيفته توفير الدعم للأحداث الجديدة التي نعرّفها، بحيث لا نضطّر إلى التصريح عن نائب جديد في كلّ مرّة نريد فيها التصريح عن حدث جديد. يغلّف النائب EventHandler أي تابع يتطلّب وسيطين الأوّل من النوع object والذي يمثّل الكائن الذي أصدر الحدث، والثاني من النوع EventArgs وهو كائن يحتوي على بعض المعلومات الإضافيّة عن الحدث.

تمارين داعمة

تمرين 1

ليكن لدينا الصنف التالي:

class Counter
{
	private int currentValue = 0;

	public void Increase()
	{
		currentValue++;
	}

	public void Decrease()
	{
		currentValue--;
	}
}

أجرِ تعديلًا على هذا الصنف بحيث تصرّح عن الحدث Notification الذي يُفعَّل عندما تصبح قيمة الحقل currentValue من مضاعفات العدد 5 فقط.

(تلميح: الأعداد السالبة ليست من مضاعفات 5. والعدد 5 هو مضاعف لنفسه).

تمرين 2

أجرِ تعديلًا على البرنامج Lesson14_02 السابق لتستغني عن النائب SpeedNotificatoinDelegate تمامًا، بحيث تستخدم النائب الجاهز EventHandler عوضًا عنه.

(تلميح: سيتطلّب الأمر تعديل الوسائط الممرّرة إلى معالج الحدث لتتطابق مع الوسائط التي يحتاجها النائب EventHandler)

الخلاصة

تعرّفنا في هذا الدرس على الأحداث Events. تلك التقنيّة المهمّة التي تعتمد عليها تطبيقات سطح المكتب desktop applications بشكل أساسيّ، فضلًا عن باقي أنواع التطبيقات مثل تطبيقات الويب، وتطبيقات الأجهزة المحمولة، وأي نوع من أنواع التطبيقات التي تتطلّب التفاعل الداخلي مع نظام التشغيل أو الخارجيّ مع المستخدم.

يُعتبر مفهوم النوّاب من المفاهيم الأساسيّة في سي شارب، وستستخدمه بشكل أو بآخر في أيّ برنامج حقيقي مكتوب بهذه اللغة. سنتحدّث في هذا الدرس عن هذا الموضوع المهمّ، وسنتعرّض في درس لاحق إلى مفهوم مهم آخر مرتبط به، ألا وهو مفهوم الأحداث Events.

في جميع البرامج التي صادفناها في هذه السلسلة كنّا نعمل على استدعاء توابع وخصائص من كائنات ننشئها من الأصناف المختلفة. في البرمجة العمليّة، يحتاج الكائن في الكثير من الأحيان إلى وسيلة يفعل فيها العكس. أي يحتاج الكائن إلى أسلوب يستطيع من خلاله استدعاء تابع ما لا ينتمي إليه وذلك من تابع أو خاصيّة موجودة داخل الكائن. تُسمّى هذه الظاهرة بالردود callbacks، وهي تقنيّة مهمّة جدًّا مستخدمة حتى في أنظمة التشغيل على نحو واسع.

ربما قد تتساءل لماذا يحتاج الكائن لأن يستخدم مثل هذه التقنيّة (الردود). الجواب على ذلك بسيط، فقد يحتاج الكائن إلى التعبير عن حالته الداخليّة، أو عن أمر طارئ قد حدث له، ففي تطبيقات سطح المكتب desktop applications مثلًا، يُعتبر أيّ زر موجود على نافذة البرنامج عبارة عن كائن. فعندما ينقر مستخدم البرنامج هذا الزر، فمن الطبيعي أن يبلّغنا الزر عن "حدث" النقر عليه. فكيف يفعل ذلك؟ يفعل ذلك ببساطة عن الطريق الردود التي نسمّيها في سي شارب بالنوّاب (ستعرف سبب التسمية بعد قليل).

التصريح عن نائب

يمكنك اعتبار النائب كصنف مستقل بحد ذاته، مع أنّ التصريح عنه يختلف عن التصريح عن الأصناف. تُصرّح الشيفرة التالية عن النائب SumDelegate:

public delegate int SumDelegate(int a, int b);

النوّاب -وعلى سبيل التبسيط- عبارة عن مغلّفات للتوابع. فالنائب SumDelegate السابق يمكنه أن يغلّف أو يشير إلى أيّ تابع آخر بشرط أن يقبل وسيطين من نوع int ويُرجع قيمة من نوع int أيضًا (لاحظ الشيفرة السابقة). فإذا أزلنا الكلمة المحجوزة delegate من الشيفرة السابقة، سيبدو الأمر "كما لو أنّنا" نصرّح عن التابع SumDelegate الذي يقبل وسيطين من النوع int ويُرجع قيمة من النوع int، وهو بمحدّد وصول public.

لفهم الموضوع بشكل أفضل دعنا نستخدم النائب السابق في البرنامج Lesson13_01:

1	using System;
2
3	namespace Lesson13_01
4	{
5	    public delegate int SumDelegate(int a, int b);
6
7	    class Program
8	    {
9	        static void Main(string[] args)
10	        {
11	            SumDelegate handler = new SumDelegate(Sum);
12
13	            int result = handler(5, 6);
14
15	            Console.WriteLine(result);
16	        }
17
18	        static int Sum(int a, int b)
19	        {
20	            return a + b;
21	        }
22	    }
23	}

لاحظ أولًا أنّنا وضعنا التصريح عن النائب SumDelegate في السطر 5 خارج أي صنف، مع أنّه كان ممكنًا أن نصرّح عنه ضمن الصنف Program. صرّحنا في الأسطر من 18 إلى 21 عن تابع ساكن static ضمن الصنف Program اسمه Sum يقبل وسيطين من النوع int ويُرجع قيمة من النوع int أيضًا. العمليّة التي يقوم بها هذا التابع بسيطة، فهو يجمع قيمتي الوسيطين الممرّرين إليه ويُرجع الناتج بسطرٍ واحد.

انظر الآن إلى السطر 11 ضمن التابع Main. ستلاحظ أنّنا نصرّح عن المتغيّر handler من النوع (النائب) SumDelegate، ونُسند إليه كائنًا من نفس النوع باستخدام التعبير (new SumDelegate(Sum حيث مرّرنا إلى بانيته الوسيط Sum. ولكن أليس الوسيط Sum هو نفسه اسم التابع الساكن المصرّح عنه ضمن الصنف Main!

في الواقع تتطلّب بانية النائب SumDelegate (على اعتباره صنفًا) وسيطًا عبارة عن تابع يقبل وسيطين من النوع int ويرُجع قيمة من النوع int، أي بشكل مماثل لتصريح النائب SumDelegate في السطر 5.

انظر إلى العبارة البرمجيّة التالية في السطر 13:

int result = handler(5, 6);

أصبح بإمكاننا الآن أن نستدعي النائب handler بوسيطين من النوع int، وسيُرجع بالتأكيد قيمة من النوع int أيضًا. إذًا أصبح handler "ينوب" عن التابع Sum في عمليّة الاستدعاء، رغم أنّه في حقيقة الأمر سيستدعي التابع Sum ولكن من وراء الكواليس!

يمكن باستخدام هذه التقنيّة وبإجراء بعض التعديلات الطفيفة (كما سنرى في الأحداث Events)، أن ينوب handler عن أكثر من تابع بنفس الوقت بشرط أن يقبل كلّ منها وسيطين من نوع int ويُرجع كلّ منها قيمة من النوع int.

استخدام النواب بشكل عملي

لنتناول برنامجًا يوضّح استخدام النوّاب بشكل عمليّ أكثر. انظر البرنامج Lesson13_02:

1	using System;
2
3	namespace Lesson13_02
4	{
5	    public class Car
6	    {
7	        public delegate void SpeedNotificatoinDelegate(string message);
8
9	        private SpeedNotificatoinDelegate speedNotificationHandler;
10
11	        public void RegisterWithSpeedNotification(SpeedNotificatoinDelegate handler)
12	        {
13	            this.speedNotificationHandler = handler;
14	        }
15
16	        public int CurrentSpeed { get; set; }
17	        public int MaxSpeed { get; set; }
18
19	        public Car()
20	        {
21	            CurrentSpeed = 0;
22	            MaxSpeed = 100;
23	        }
24
25	        public Car(int maxSpeed, int currentSpeed)
26	        {
27	            CurrentSpeed = currentSpeed;
28	            MaxSpeed = maxSpeed;
29	        }
30
31	        public void Accelerate(int delta)
32	        {
33	            CurrentSpeed += delta;
34
35	            if (CurrentSpeed > MaxSpeed)
36	            {
37	                if(this.speedNotificationHandler != null)
38	                {
39	                    string msg = string.Format("You exceed the maximum speed! (Current = {0}, Max = {1})",
40	                        CurrentSpeed, MaxSpeed);
41
42	                    speedNotificationHandler(msg);
43	                }
44	            }
45	        }
46	    }
47
48	    class Program
49	    {
50	        static void Main(string[] args)
51	        {
52	            Car car = new Car(100, 0);
53
54	            car.RegisterWithSpeedNotification(new Car.SpeedNotificatoinDelegate(OnExceedMaxSpeedHandler));
55
56	            for(int i = 0; i < 5; i++)
57	            {
58	                Console.WriteLine("Increasing speed by 30");
59	                car.Accelerate(30);
60	            }
61	        }
62
63	        static void OnExceedMaxSpeedHandler(string message)
64	        {
65	            Console.WriteLine(message);
66	        }
67	    }
68	}

نفّذ هذا البرنامج لتحصل في الخرج على ما يلي:

Increasing speed by 30
Increasing speed by 30
Increasing speed by 30
Increasing speed by 30
You exceed the maximum speed! (Current = 120, Max = 100)

Increasing speed by 30
You exceed the maximum speed! (Current = 150, Max = 100)

خذ نفسًا عميقًا، وجهّز كوبًا من الشاي (شرابي المفضّل) لندخل في تفاصيل البرنامج.

ينقسم هذا البرنامج إلى صنفين: الصنف Car (من السطر 5 حتى السطر 46) والصنف Program (من السطر 48 حتى السطر 67).

يمثّل الصنف Car القالب العام لسيّارة، ويحتوي على خاصيّتين CurrentSpeed و MaxSpeed وتعبّران عن السرعة الحالية والسرعة القصوى على الترتيب. كما يحتوي على بانيتين، إحداهما عديمة الوسائط، والثانية ذات وسيطين من نوع int لسهولة الإنشاء والإسناد للخصائص. يضم الصنف Car أيضًا النائب SpeedNotificatoinDelegate (السطر 7). تذكّر أنّه من الممكن أن تكون النوّاب ضمن الأصناف. يمكن لهذا النائب أن يغلّف أي تابع يقبل وسيطًا واحدًا من النوع string ولا يرجع أي قيمة (void). نعرّف أيضًا ضمن الصنف Car الحقل speedNotificationHandler (السطر 9) من النوع SpeedNotificatoinDelegate وذو محدّد وصول private، وأخيرًا يحتوي الصنف Car على التابعين Accelerate الذي يعبّر عن إكساب السيّارة المزيد من السرعة، وهو يتطلّب وسيطًا واحدًا من النوع int ويمثّل مقدار الزيادة في السرعة. والتابع RegisterWithSpeedNotification الذي يتطلّب وسيطًا واحدًا من النوع SpeedNotificatoinDelegate. وظيفة هذا التابع هو استقبال وسيط من النوع (النائب) SpeedNotificatoinDelegate وإسناده إلى الحقل الخاص speedNotificationHandler. سيغلّف النائب الممرّر لهذا التابع تابعًا آخر يقبل وسيطًا واحدًا من النوع string ولا يُرجع أي قيمة (void).

يحتوي الصنف Program على تابعين: الأوّل هو Main (من السطر 50 حتى السطر 61) وهو غنيّ عن التعريف. والثاني هو OnExceedMaxSpeedHandler (من السطر 63 حتى السطر 66) الذي يحتاج إلى وسيط نصي واحد، ولا يرجع شيء (void)، وهو يحتوي على عبارة برمجيّة وحيدة وظيفتها عرض قيمة الوسيط النصيّ msg على الشّاشة.

يبدأ البرنامج في التابع Main بالتصريح عن المتغيّر car وإسناد كائن جديد إليه من النوع Car، حيث نمرّر 100 كسرعة قصوى، والقيمة 0 كسرعة حاليّة إلى بانية الصنف Car. بعد ذلك سيعمل البرنامج على إنشاء كائن نائب يغلّف التابع OnExceedMaxSpeedHandler من خلال التعبير:

new Car.SpeedNotificatoinDelegate(OnExceedMaxSpeedHandler)

سيمرَّر هذا الكائن الجديد إلى التابع RegisterWithSpeedNotification كما هو واضح من السطر 54.

يدخل البرنامج بعد ذلك في حلقة for (الأسطر من 56 حتى 60) التي ستتكرّر 5 مرّات، وبعد أن يتم استدعاء التابع Accelerate أربعة مرّات (السطر 59)، تصبح عندها السرعة الحالية تساوي 120 وهي أكبر من السرعة القصوى، لذلك يُستدعى التابع الذي يغلّفه النائب speedNotificationHandler (السطر 42) بالشكل:

speedNotificationHandler(msg);

والذي هو في حالتنا التابع OnExceedMaxSpeedHandler ليمرّر إليه رسالة نصيّة ضمن المتغيّر msg توضّح بأنّه قد تمّ تجاوز السرعة القصوى المحدّدة. وستتكرّر نفس العمليّة من أجل الدورة الخامسة والأخيرة للحلقة for.

لاحظ الاختبار الذي أجريناه في السطر 37 من التابع Accelerate. يتأكّد هذا السطر من أنّ الحقل speedNotificationHandler ليس فارغًا (يحوي null). لأنّه إذا كان يحوي null فلا ينبغي تنفيذ عبارة الاستدعاء في السطر 42.

أنصح بأن تستخدم تطبيق Visual Studio من أجل هذا البرنامج، حيث يمكن أن تستفيد من المنقّح Debugger الخاص به لتنفيذ البرنامج خطوة بخطوة (استخدم المفتاح F11 لتنفيذ البرنامج بشكل خُطَويّ) لفهم أفضل له.

ملاحظة: أيّ حقل مصرّح عنه ضمن صنف ما ويكون من نوع مرجعيّ reference type تكون القيمة الافتراضيّة له هي null في حال لم نُسند إليه أي قيمة عند التصريح عنه. وتعني null أنّ هذا الحقل لا يحتوي على مرجع لأيّ كائن. ويسري نفس الأمر على المتغيّرات المحليّة التي نصرّح عنها ضمن التوابع والتي تكون أيضًا من أنواع مرجعيّة.

ملاحظة: يمكن لأي نائب أن يغلّف توابع عاديّة أو توابع ساكنة static.

تمارين داعمة

تمرين 1

أجرِ تعديلًا على البرنامج Lesson13_02 بحيث يستخدم البرنامج النائب speedNotificationHandler لإرسال تنبيه إلى التابع الذي يُغلّفه هذا النائب، في حال وصلت السرعة الحالية إلى منتصف السرعة القصوى أو تجاوزتها (التنبيه يجب أن يصدر لمرّة واحدة).

(تلميح: ستحتاج إلى التصريح عن حقل خاص ضمن الصنف Car من نوع bool مثلًا لكي يعرف البرنامج أنّه قد أصدر التنبيه الخاص بالوصول إلى منتصف السرعة القصوى، لكيلا يعيد إصدار مثل هذا التنبيه مرّة أخرى).

تمرين 2

أجرِ تعديلًا آخرًا على البرنامج Lesson13_02 بحيث تستغني فيه عن استخدام التابع RegisterWithSpeedNotification. دون التغيير في أسلوب عمل البرنامج.

(تلميح: ستحتاج إلى جعل الحقل speedNotificationHandler ذو محدّد وصول public بدلًا من private، ثم تتعامل مع هذا الحقل مباشرةً من الصنف Main).

الخلاصة

تعرّفنا في هذا الدرس على مفهوم جديد لكنّه أساسيّ وهو النوّاب Delegates. حيث اكتشفنا كيف أنّ النوّاب هي وسائل لتحقيق مبدأ الردود callbacks المهم في عالم البرمجة، والمستخدم على نطاق واسع في أنظمة التشغيل في تبادل الرسائل بين الكائنات المختلفة. تعلّمنا كيف يُغلّف النائب تابعًا يوافق معايير معيّنة تكون محدّدة عند التصريح عن النائب. في الحقيقة تُعتبر النوّاب الركن الأساسيّ للأحداث Events، ذلك المفهوم المهم في البرمجة كائنيّة التوجّه، والذي سنتحدّث عنه في الدرس التالي.

تشبه البنية structure الصنف class إلى حدٍّ كبير باستثناء أنّها تُعتبر نوع قيمة value type وليس نوعًا مرجعيًّا كما هو الحال بالنسبة للأصناف. أمّا بالنسبة للمعدودة enum فهي تقنيّة تسمح لنا بتعيين مجموعة من الثوابت الرقميّة التي يمكن تسميّتها، وينحصر دورها في تنظيم البرنامج وجعل الشيفرة أكثر قابليّة للفهم والتعديل.

البنى Structures

تستطيع اعتبار البنية على أنّها نسخة مخفّفة من الصنف class. يكمن الفرق الأساسي بينهما في أنّ البنية هي نوع قيمة كما ذكرنا، فعند إنشاء بنية سيتم حجز المكان المخصّص لها في المكدّس stack وليس في الكومة heap كما هو الحال مع الأنواع المرجعيّة reference types.

ستُنشئ الشيفرة التالية بنية اسمها Student على الشكل التالي:

struct Student
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Mark { get; set; }

    public override string ToString()
    {
        return string.Format("{0} {1} ({2})",FirstName,LastName,Mark);
    }
}

لاحظ مدى الشبه بينها وبين الأصناف. الآن إذا أردنا استخدام هذه البنية في الشيفرة يمكننا ذلك من خلال العبارة التالية:

Student student = new Student();

علينا أن نتذكّر دائمًا أنّ الكائن الذي يقوم العامل new بإنشائه سيكون في المكدّس stack.

يمكننا أن نتابع ونستخدم المتغيّر student من نوع البنية Student كما كنّا نفعل من قبل مع متغيّرات الأصناف:

student.FirstName = "Maher";
student.LastName = "Rajab";
student.Mark = 100;

Console.WriteLine(student.ToString());

بعد تنفيذ الشيفرة السابقة ستحصل على الخرج:

Maher Rajab (100)

توجد الكثير من البنى المهمّة والمفيدة. فمثلًا هناك البنية DateTime التي تسمح لنا بالتعامل مع الزمن والتاريخ، وهي بنية مهمّة للغاية. انظر إلى البرنامج Lesson17_01 الذي يوضّح بعض المزايا التي توفّرها.

1	using System;
2	using System.Globalization;
3
4	namespace Lesson17_01
5	{
6	    class Program
7	    {
8	        static void Main(string[] args)
9	        {
10	            DateTime myBirthDate = new DateTime(1979, 12, 25);
11	
12	            //display birth date in simple form:
13	            Console.WriteLine(myBirthDate.ToString("dd/MM/yyyy"));
14	
15	            //display birth date in more elegent way:
16	            Console.WriteLine(myBirthDate.ToString("D", CultureInfo.InvariantCulture));
17	
18	            //add time info:
19	            myBirthDate = myBirthDate.AddHours(4);
20	            myBirthDate = myBirthDate.AddMinutes(30);
21	
22	            //display completed birth date info:
23	            Console.WriteLine(myBirthDate.ToString("dddd, dd MMMM yyyy - hh:mm:ss tt", CultureInfo.InvariantCulture));
24	        }
25	    }
26	}

بعد تنفيذ البرنامج السابق ستحصل على الخرج التالي:

أنشأنا في السطر 10 كائنًا جديدًا من البنية DateTime حيث مرّرنا ثلاثة وسائط للبانية هي على الترتيب من اليسار إلى اليمين: العام والشهر واليوم (الميلادي). في الحقيقة تمتلك بانية البنية DateTime اثنا عشرة شكلًا مختلفًا، نستطيع من خلال بعض هذه الأشكال ضبط الوقت أيضًا.

يؤدّي الاستدعاء في السطر 13:

myBirthDate.ToString("dd/MM/yyyy")

إلى الحصول على تمثيل نصّي مختصر من التاريخ الذي مرّرناه إلى البانية قبل قليل. حيث ترمز dd إلى اليوم، و MM (حرف كبير) إلى الشهر، وyyyy إلى العام، ويمكنك بالتأكيد تغيير هذا الترتيب إذا أحببت (انظر إلى السطر الأوّل من الخرج في الشكل السابق).

أمّا الاستدعاء في السطر 16:

myBirthDate.ToString("D", CultureInfo.InvariantCulture)

فيؤدّي إلى الحصول على نفس التاريخ ولكن بشكل أنيق. حيث سنحصل على القيم الكتابيّة للتاريخ (انظر السطر الثاني من الخرج في الشكل السابق). ولكن لاحظ أنّنا نمرّر إلى التابع ToString وسيطين: الأوّل هو النص التنسيقي "D" الذي يُخبر التابع ToString أنّنا نريد التنسيق على شكل تاريخ ولكن بصورة تفصيليّة أنيقة، أمّا الوسيط الثاني CultureInfo.InvariantCulture فهو يُرجع كائن من النوع CultureInfo. الهدف منه هو اعتماد الإعدادات الإقليميّة العالميّة في تنسيق التاريخ. وسبب ذلك أنّ كل بلد أو ثقافة culture لها أسلوب معيّن في تنسيق التاريخ (وكذلك الأمر بالنسبة للأرقام والعملات). لقد اخترت التنسيق العالميّ InvariantCulture لأنّني لا أريد من البرنامج استخدام الإعدادات الإقليميّة الخاصّة بنظام التشغيل في حاسوبي الشخصي الذي يعمل عليه البرنامج، لأنّ الخرج سيظهر مشوّهًا نتيجة لذلك. يكمن السبب في أنّ نافذة موجّه الأوامر console window لا تدعم اللغة العربية بشكل افتراضيّ، لذلك آثرت استخدام الإعدادات العالميّة (تشبه إلى حدٍّ كبير الإعدادات الخاصّة بالولايات المتحدّة).

أخيرًا الاستدعاء في السطر 23:

Console.WriteLine(myBirthDate.ToString("dddd, dd MMMM yyyy - hh:mm:ss tt", CultureInfo.InvariantCulture));

سيؤدّي هذا الاستدعاء إلى الحصول على النص الذي يظهر في السطر الثالث من الخرج، وهو مزيج بين التاريخ والوقت. لاحظ أنّنا قد أسبقنا هذا الاستدعاء باستدعاءين في السطرين 19 و20 للتابعين AddHours وAddMinutes على الترتيب. أتصوّر أنّ وظيفتهما واضحة، وهي إضافة قيمة ساعات ودقائق محدّدة إلى المتغيّر myBirthDate، مع الانتباه إلى أنّ كل منهما ستُرجع كائن DateTime جديد يمثّل التعديل الذي حصل. أي أنّ المتغيّر myBirthDate الأصلي لن يُمس في كلتا الحالتين. إلّا أنّنا أعدنا إسناد القيم المُعادة إلى المتغيّر myBirthDate لتجنّب إنشاء متغيّرات جديدة كما هو واضح من السطرين 19 و20. بقي أن أخبرك ما يلي:

• ترمز dddd إلى اليوم ولكن بصيغة كتابيّة.
• ترمز dd إلى اليوم ولكن بصيغة رقميّة.
• ترمز MMMM إلى الشهر ولكن بصيغة كتابيّة.
• ترمز yyyy إلى العام بصيغة رقميّة.
• ترمز hh إلى الساعات.
• ترمز mm (أحرف صغيرة) إلى الدقائق.
• ترمز ss إلى الثواني.
• ترمز tt إلى AM أو PM.

ملاحظة

هناك العديد من التوابع الأخرى التي لم نتناولها بالنسبة للبنية DateTime. كما أنّ هناك بنية أخرى اسمها TimeSpan متعلّقة بالبنية DateTime ويمكن من خلالها تمثيل فترة زمنيّة بدلًا من تاريخ محدّد.

ملاحظة

توجد خاصيّة ضمن البنية DateTime مفيدة كثيرًا وهي الخاصيّة Now. تُرجع هذه الخاصيّة التوقيت الحالي الذي يمثّل التاريخ والوقت الحاليين من ساعة الحاسوب. طريقة استخدامها بسيطة:

DateTime current = DateTime.Now;

المعدودات Enums

المعدودة هي نوع قيمة value type خاص يسمح لنا بتعيين مجموعة من الثوابت الرقميّة ذات تسميّة. انظر مثلًا إلى تصريح المعدودة BorderSide التالي:

public enum BorderSide { Left, Right, Top, Bottom }

يمكن لهذا التصريح أن يوضع ضمن صنف ما، أو خارج أيّ صنف. عندها من الممكن استخدام هذه المعدودة بالشكل التالي:

BorderSide topSide = BorderSide.Top;

في الحقيقة إنّ لكلّ ثابت من ثوابت المعدودة (مثل Left أو Right أو غيرها) قيمة رقميّة ضمنيّة. تأخذ هذه الثوابت القيم الرقميّة الافتراضيّة 0، 1، 2، ... الخ بنفس الترتيب الذي تكون فيه هذه الثوابت ضمن تصريح المعدودة. فمثلًا في المعدودة BorderSide السابقة، يأخذ الثابت Left القيمة 0، والثابت Rigth القيمة 1، وهكذا. كما ويمكننا أيضًا أن نسند لثوابت المعدودة قيمًا رقميّة مباشرةً أثناء التصريح عنها. انظر إلى المعدودة BorderSide بشكلها المعدّل:

public enum BorderSide { Left = 1, Right = 5, Top = 7, Bottom = 8 }

أي ليس من الضروري أن تكون القيم الرقميّة متسلسلة أو تبدأ من الصفر. المهم فقط أن تكون صحيحة (بدون فاصلة عشريّة).

يمكن الحصول على القيمة الرقميّة المُسندة إلى أيّ ثابت ضمن المعدودة بالشكل البسيط التالي:

int i = (int)BorderSide.Left;

بعد تنفيذ العبارة السابقة ستصبح قيمة المتغيّر i تساوي 1.

تمارين داعمة

تمرين 1

عرّف متغيّرين من البنية DateTime، سمّ الأوّل first وأسند إليه التاريخ 01/01/2016، وسمّ الثاني second وأسند إليه التاريخ 13/05/2016. وبعد ذلك نفّذ العبارة التالية وحاول تفسير الخرج:

Console.WriteLine(second - first);

تمرين 2

أنشئ برنامجًا يستخدم معدودةً اسمها LevelEnum تحتوي على الثوابت: Weak، Middle، Good، VeryGood. أضف هذه المعدودة إلى الصنف Student التالي:

class Student

{

	public string FirstName { get; set; }

	public string LastName { get; set; }

	public int Mark { get; set; }

}

ثمّ أضف لنفس الصنف السابق الخاصيّة Level من نوع المعدودة LevelEnum، حيث تُعبّر هذه الخاصيّة عن مستوى الطالب Student.

الخلاصة

تعرّفنا في هذا الدرس على البنى Structures والمعدودات Enums وكيفيّة استخدامهما. ستصادف في برامجك المستقبليّة هاتين التقنيّتين بشكل متكرّر. فإمّا أن تنشئهما بنفسك أو أن تفرض عليك أصناف دوت نت أو غيرها استخدامهما. تُعتبر البنى خفيفة، حيث أنّها سريعة في الإنشاء والمعالجة أكثر من الأصناف، كونها تتوضّح في مكدّس البرنامج كما أسلفنا. وتُعتبر المعدودات أداةً رائعة لتنظيم برامجك في حال كانت تتطلّب تعريف ثوابت عدديّة ضمن مجموعات منطقيّة.

يمكن القراءة والكتابة من وإلى الملفات النصيّة في سي شارب بعدّة طرق. سنتناول أسلوبًا بسيطًا وذلك من خلال الصنفين StreamWriter و StreamReader.

يسمح الصنف StreamWriter بالكتابة فقط، أمّا الصنف StreamReader فهو يسمح بالقراءة فقط. كما يمكن استخدام كلا الصنفين في نفس البرنامج. وكلّ منهما موجود ضمن نطاق الاسم System.IO.

يرث الصنف StreamWriter من الصنف TextWriter في حين يرث الصنف StreamReader من الصنف TextReader.

الكتابة إلى ملف نصي

سنعمل في البرنامج Lesson12_01 على إنشاء الملف data.txt وكتابة بعض الأسطر ضمنه:

1	using System;
2	using System.IO;
3
4	namespace Lesson12_01
5	{
6	    class Program
7	    {
8	        static void Main(string[] args)
9	        {
10	            string[] lines = { "First Line", "Second Line", "Third Line" };
11
12	            StreamWriter fileWriter = new StreamWriter("data.txt");
13
14	            foreach (string line in lines)
15	            {
16	                fileWriter.WriteLine(line);
17	            }
18
19	            fileWriter.Close();
20	        }
21	    }
22	}

صرّحنا في السطر 10 عن المصفوفة lines التي عناصرها نصوص، لاحظ أنّنا استخدمنا الطريقة المختصرة لإنشاء كائن مصفوفة وإسناد العناصر الموجودة ضمن الحاضنة {} إلى عناصره مباشرةً.

نصرّح في السطر 12 عن المتغيّر fileWriter حيث نسند إليه كائن من الصنف StreamWriter. عند إنشاء هذا الكائن، مرّرنا اسم الملف "data.txt" إلى بانية الصنف StreamWriter. في الحقيقة تخضع هذه البانية إلى زيادة التحميل overloading، حيث تمتلك ثمانية أشكال مختلفة اخترنا أبسطها، وهو مسار واسم الملف المراد إنشاؤه. وبما أنّنا مرّرنا الاسم فقط دون المسار، فسيتم إنشاء هذا الملف في نفس المجلّد الموجود ضمنه الملف التنفيذي للبرنامج.

بعد ذلك نستخدم التابع WriteLine من المتغيّر fileWriter لكتابة عناصر المصفوفة lines على أسطر منفصلة ضمن الملف data.txt. العبارة البرمجيّة في السطر 19 ضرورية لإغلاق الملف باستدعاء التابع Close وتحرير المصدر الذي يحجزه في نظام التشغيل. جرّب تنفيذ البرنامج، لن تحصل على شيء على الشاشة، ولكن إذا فتحت الملف data.txt (ستجده غالبًا ضمن bin\debug ضمن مجلّد المشروع) ستجد الأسطر الثلاثة موجودةً ضمنه.

ملاحظة: يوجد شكل آخر لبانية الصنف StreamWriter يقبل بالإضافة إلى اسم الملف ومساره قيمة منطقيّة (من نوع bool) تُدعى append. إذا مرّرت true مكانها فسيعمل البرنامج إلى الإضافة إلى محتويات الملف data.txt، أمّا إذا مرّرت false فسيعمل على الكتابة عليه. أمّا إذا أهملت هذا الشكل تمامًا كما هو الحال في مثالنا فسيعمل البرنامج على الكتابة على الملف، أي استبدال محتوياته، في كلّ مرّة ننفّذ فيها البرنامج.

في الحقيقة ليس هذا هو الاستخدام الأمثل للصنف StreamWriter والسبب في ذلك أنّ مصادر نظام التشغيل محدودة، حيث يؤدّي التعامل مع الملفات إلى حجز بعض من هذه المصادر، لذلك ينبغي تحرير هذه المصادر فورًا عندما تنتفي الحاجة إليها. قد يبدو أنّنا قد فعلنا ذلك باستخدام التابع Close وهذا صحيح تمامًا، ولكن ليس بالسرعة القصوى الممكنة! هناك أسلوب آخر يسمح بتحرير المصادر بشكل أكثر فعاليّة وسرعة باستخدام الكلمة المحجوزة using. سأعدّل البرنامج Lesson12_01 ليستخدم هذا الأسلوب الجديد. انظر البرنامج Lesson12_02 بعد التعديل:

1	using System;
2	using System.IO;
3
4	namespace Lesson12_02
5	{
6	    class Program
7	    {
8	        static void Main(string[] args)
9	        {
10	            string[] lines = { "First Line", "Second Line", "Third Line" };
11
12	            using (StreamWriter fileWriter = new StreamWriter("data.txt"))
13	            {
14	                foreach (string line in lines)
15	                {
16	                    fileWriter.WriteLine(line);
17	                }
18	            }
19	        }
20	    }
21	}

لاحظ السطر 12 كيف وضعنا عبارة التصريح عن المتغيّر fileWriter والإسناد إليه ضمن عبارة using. في الواقع لن يكون المتغيّر fileWriter مرئيًّا خارج حاضنة using (من السطر 13 حتى السطر 18)، وبمجرّد وصول تنفيذ البرنامج إلى السطر 19 سيتم إغلاق الملف فورًا وتحرير المصدر الذي يحجزه. يظهر من البرنامج السابق أنّنا لم نعد نحتاج إلى استخدام التابع Close.

القراءة من ملف نصي

سنستخدم الصنف StreamReader لهذا الغرض. سيعمل البرنامج Lesson12_03 على قراءة محتويات الملف data.txt السابق وعرضها على الشاشة:

1	using System;
2	using System.IO;
3
4	namespace Lesson12_03
5	{
6	    class Program
7	    {
8	        static void Main(string[] args)
9	        {
10	            using (StreamReader fileReader = new StreamReader("data.txt"))
11	            {
12	                while(!fileReader.EndOfStream)
13	                {
14	                    string line = fileReader.ReadLine();
15	                    Console.WriteLine(line);
16	                }
17	            }
18	        }
19	    }
20	}

تخضع بانية الصنف StringReader أيضًا لزيادة التحميل، حيث تمتلك 11 شكلًا مختلفًا تسمح للمبرمج بالتحكّم الكامل بكيفيّة القراءة من الملف. أبسط هذه الأشكال هو الشكل الذي استخدمناه في البرنامج Lesson12_03 حيث سنمرّر لهذه البانية اسم الملف data.txt الذي أنشأناه في البرنامج Lesson12_02 السابق. استخدمنا في هذا البرنامج أيضًا العبارة using (من السطر 10 حتى السطر 17) لتحرير المصدر الذي يحجزه الملف عند الانتهاء من القراءة. ننشئ كائن من الصنف StreamReader ونسنده إلى المتغيّر fileReader ضمن عبارة using في السطر 10. ثمّ نستخدم حلقة while لقراءة محتويات الملف، وذلك لأنّنا من الناحية النظريّة لا نعلم بالتحديد كم سطرًا يحوي الملف. لاحظ شرط استمرار حلقة while حيث تُرجع الخاصيّة EndOfStream للمتغيّر fileReader القيمة true إذا وصلنا إلى نهاية الملف أثناء عمليّة القراءة، وإلّا فإنّها تُرجع false. إذًا، في حال لم نصل بعد إلى نهاية الملف ستُرجع الخاصيّة القيمة EndOfStream القيمة false وبسبب وجود عامل النفي المنطقي (!) قبل هذه الخاصيّة مباشرةً، ستكون القيمة النهائيّة لهذا التعبير هو true مما يسمح لحلقة while بالاستمرار. أمّا عند الوصول إلى نهاية الملف سيحدث العكس تماماً مما يجعل شرط استمرار الحلقة false وينتهي تنفيذ الحلقة.

نقرأ في السطر 14 سطرًا من الملف data.txt ونسنده إلى المتغيّر النصي line في كل دورة، ثمّ نطبع محتويات هذا المتغيّر إلى الشاشة في السطر 15. استخدمنا في عمليّة قراءة سطر من الملف data.txt التابع ReadLine من المتغيّر fileReader الذي يعمل على قراءة سطر واحد في كلّ مرّة من الملف data.txt.

تمارين داعمة

تمرين 1

اكتب برنامجًا يطلب من المستخدم إدخال خمس جُمل، ثم يعمل على تخزين هذه الجُمل على اعتبار أنّ كل جملة يُدخلها المستخدم تمثّل سطرًا نصيًّا. تخزّن كل جملة مع رقم سطرها بحيث يفصل بينهما محرف الجدولة (\t).

تمرين 2

استفد من الصنف Student التالي:

class Student
{
	public string Name { get; set; }
	public int Mark { get; set; }
}

في كتابة برنامج يطلب من المستخدم إدخال بيانات خمسة طلّاب (اسم الطالب Name، والدرجة Mark) مستخدمًا المجموعة العموميّة <List<Student في تخزين بيانات هؤلاء الطلّاب (ستحتاج إلى استخدام نطاق الاسم System.Collections.Generic في بداية البرنامج). بعد الانتهاء من الإدخال، يجب على البرنامج حفظ بيانات هؤلاء الطلّاب ضمن الملف students.txt على شكل جدول بسيط، بحيث تصبح محتويات الملف مشابهة للشكل التالي:

Amjad		50
Mohammad	80
Mazen		90
Nour		88
Anwar		40

الخلاصة

تعرّفنا في هذا الدرس على المبادئ الأساسيّة في التعامل مع الملفات النصيّة. حيث تعلّمنا كيفيّة القراءة من الملف النصيّ وكيفيّة الكتابة إليه. وتعلّمنا أساليب مهمّة عند فتح الملف للقراءة أو الكتابة تتمثّل في استخدام العبارة using لكي نحرّر المصدر الذي يحجزه الملف فور الانتهاء من التعامل معه.

يُعتبر التعامل مع النصوص من المواضيع المهمّة التي يحتاجها أيّ مبرمج. توفّر سي شارب أساليب متقدّمة للتعامل مع النصوص، سنتحدّث في هذا الدرس عن بعض هذه الأساليب. حيث سنتعلّم كيفيّة البحث عن نص محدّد ضمن نص آخر، واستبدال نص بآخر، واستخلاص جزء محدّد من نص، وضمّ النصوص.

النص في سي شارب هو سلسلة من المحارف char الواقعة بين علامتي الاقتباس المزدوج " ". لقد تعاملنا في العديد من المرّات مع النصوص في الدروس السابقة، وتعلّمنا كيف أنّ النوع string هو الذي يمثّل أي نص في سي شارب.

البحث والاستبدال ضمن نص

البحث ضمن نص

للمحارف في أيّ نص ترتيب رقمي يبدأ من الصفر ويسمى الدليل index. إذا أردنا أن نبحث عن نص محدّد ضمن نص آخر فيمكن ذلك باستخدام التابع IndexOf الذي نستدعيه من النص المراد البحث ضمنه، ونمرّر إليه النص المراد البحث عنه، فيُرجع دليل أوّل محرف للنص المطابق في حال وجوده وإلّا فيرجع 1-. كمثال على ذلك انظر الشيفرة التالية:

string text = "My friend Mohammad is a developer, Mohammad likes C#.";
int pos = text.IndexOf("Mohammad");

بعد تنفيذ الشيفرة السابقة سيحمل المتغيّر pos القيمة 10 والتي تمثّل دليل الحرف M ضمن النص text. ربما تكون قد لاحظت أنّ النص Mohammad موجود في النص text مرّتين، فأيّ دليل أعاد التابع IndexOf؟

تجري عملية البحث باستخدام التابع IndexOf حسب ترتيب إدخال المحارف في النص text، لذلك فأوّل كلمة Mohammad مطابقة يصادفها تُنهي عمليّة البحث. ففي مثالنا السابق حدثت المطابقة عند كلمة Mohammad الموجودة بعد "My friend".

أمّا إذا استخدمنا كلمة غير موجودة فسنحصل على القيمة 1- كما أسلفنا. انظر الشيفرة التالية:

string text = "My friend Mohammad is a developer, Mohammad likes C#.";
int pos = text.IndexOf("Amjad");

سيحمل المتغيّر pos القيمة 1- لأنّ النص الذي نبحث عنه غير موجود في النص text.

يخضع التابع IndexOf في الواقع لزيادة التحميل، حيث أنّ هناك 9 أشكال مختلفة له. تؤمّن هذه الأشكال المزيد من مزايا البحث، حيث يمكننا مثلًا البحث عن نص ضمن جزء محدّد من النص الموجود في text، أو ابتداءً من دليل محدّد حتى آخر النص، وهكذا.

هناك تابع آخر يسمح لنا بأن نبحث بشكل معكوس، وهو التابع LastIndexOf لفهم عمله بشكل جيّد سأعيد كتابة الشيفرة السابقة ولكن باستخدام التابع LastIndexOf:

string text = "My friend Mohammad is a developer, Mohammad likes C#.";
int pos = text.LastIndexOf("Mohammad");

بعد التنفيذ سيحمل المتغيّر pos القيمة 35، وذلك لأنّ المطابقة حدثت هذه المرّة مع كلمة Mohammad الثانية (تأتي قبل كلمة likes). حيث تمثّل القيمة 35 دليل الحرف M لهذه الكلمة بالنسبة للنص text.

ملاحظة

يمكنك أن تستخدم التابع ToUpper من أي متغيّر نصي والذي يعيد حالة الأحرف الطباعية الكبيرة للنص الموجود ضمن المتغيّر النصي دون أن يؤثّر ذلك على محتوى النص الأساسي ضمن المتغيّر. ونفس الأمر ينطبق على التابع ToLower والذي يعيد الحالة الطباعية الصغيرة. يفيد كل من التابعين السابقين أحيانًا في البحث إذا أردنا عدم التمييز بين الأحرف الطباعية الكبيرة والصغيرة عند عملية المطابقة بين الكلمات. انظر لكيفيّة استخدام هذين التابعين:

string text = "Hello!";

string upper = text.ToUpper(); //upper will contains "HELLO!"
string lower = text.ToLower(); //lower will contains "hello!"

مع الانتباه إلى أنّ قيمة المتغيّر text تبقى كما هي.

الاستبدال ضمن نص

بالنسبة للاستبدال فالأمر يسير أيضًا، حيث يمكن استخدام التابع Replace لهذا الغرض. يُستدعى هذا التابع من النص الذي نريد إجراء عمليّة الاستبدال ضمنه، حيث يتطلّب هذا التابع وسيطين: الأوّل oldValue والذي يمثّل القيمة النصيّة المراد استبدالها، والوسيط الثاني newValue الذي يمثّل القيمة النصيّة الجديدة. يُرجع هذا التابع قيمة نصيّة تمثّل النص الجديد بعد إجراء عمليّة الاستبدال ضمنه، أي أنّ النص الأساسي يبقى دون تغيير. انظر الشيفرة التالية:

string text = "My friend Mohammad is a developer, Mohammad likes C#.";
string newText = text.Replace("Mohammad", "Amjad");

بعد التنفيذ سيحمل المتغيّر newText القيمة النصيّة التالية:

"My friend Amjad is a developer, Amjad likes C#."

وسيبقى النص الأصلي text على حاله دون تغيير.

استخلاص النصوص وضمها

استخلاص النصوص

يمكننا استخلاص جزء من نص باستخدام التابع SubString والذي يعني نصًّا فرعيًّا أو جزئيًّا. لهذا التابع شكلان. يسمح الشكل الأوّل باستخلاص نص جزئي ابتداءً من دليل محدّد حتى آخر النص. أمّا الشكل الثاني فيسمح أيضًا باستخلاص نص جزئي ابتداءً من دليل محدّد ولكن بطول محدّد أيضًا. للتمييز بين هاتين الحالتين لنكتب بعض الشيفرة:

string text = "My friend Mohammad is a developer, Mohammad likes C#.";

string text1 = text.Substring(24);

بعد التنفيذ سيحتوي المتغيّر text1 على النص: ".#developer, Mohammad likes C". أمّا إذا استخدمنا الشيفرة التالية:

string text = "My friend Mohammad is a developer, Mohammad likes C#.";

string text1 = text.Substring(24, 9);

فسيحتوي المتغيّر text1 على النص: "developer" فقط. والسبب في ذلك أنّنا بدأنا عمليّة الاستخلاص من الدليل 24 (دليل الحرف d) وبطول 9 محارف فقط مما يعني استخلاص الكلمة developer فحسب.

ضم النصوص

يمكن ضمّ النصوص اعتبارًا من نصوص أصغر باستخدام عامل الضم + حيث أنّ استخدامه بسيط. انظر الشيفرة البسيطة التالية:

string text = "My name is " + "Husam";

بعد تنفيذ هذه العبارة سيحتوي المتغيّر text على النص:

"My name is Husam"

هناك أمرٌ بسيط لكنّه مهم جرى وراء الكواليس! لقد أنشأ مترجم سي شارب كائنًا نصيًّا جديدًا ليستوعب النص الجديد، ثم وضع مرجعًا لهذا الكائن ضمن المتغيّر text. قد لا يبدو الأمر مقلقًا في حالة مثالنا البسيط هذا، ولكن تخيّل معي ماذا سيحدث في برنامج يتطلّب ضمّ مئات من النصوص مع بعضها (وهذا أمر وارد جدًّا)؟

ستحدث بالتأكيد مشاكل في الأداة، وستغص الذاكرة بمئات الكائنات النصيّة التي لا لزوم لها، والتي تنتظر دورها في التنظيف من قبل جامع النفايات GC الذي يعمل على تحرير ذاكرة تطبيقات دون نت من الكائنات غير المستخدمة في البرنامج.

الحل الأمثل في هذه الحالة هو تجنّب استخدام عامل الضم (+)، واستخدام الصنف StringBuilder الموجود ضمن نطاق الاسم System.Text الذي يحل هذه المشكلة بكفاءة عالية. لنستعرض البرنامج Lesson11_01 لهذا الغرض:

1	using System;
2	using System.Text;
3
4	namespace Lesson11_01
5	{
6	    class Program
7	    {
8	        static void Main(string[] args)
9	        {
10	            StringBuilder sb = new StringBuilder();
11	            string[] arrText = {
12	                                "C# is a powerful language.",
13	                                "It contains advanced features.",
14	                                "It makes programming tasks more easier.",
15	                                "C# is the main programming language in .NET world."
16	                                };
17
18	            foreach(string text in arrText)
19	            {
20	                sb.Append(text);
21	            }
22
23	            Console.WriteLine(sb.ToString());
24	        }
25	    }
26	}

أنشأنا المتغيّر sb من النوع StringBuilder وأسندنا إليه كائنًا من هذا النوع في السطر 10. بعد ذلك أنشأنا المصفوفة arrText بطريقة مختصرة في السطر 11. ثمّ استخدمنا حلقة foreach للمرور على جميع عناصر المصفوفة arrText وإضافتها واحدًا تلو الآخر إلى المتغيّر sb من خلال التابع Append الذي يتطلّب وسيطًا نصيًّا واحدًا (السطر 20). أخيرًا يعمل التابع WriteLine في السطر 23 على طباعة المحتوى النصيّ الناتج من ضمّ جميع النصوص التي أضفناها باستخدام التابع Append وذلك من خلال استدعاء التابع ToString من المتغيّر sb، ستلاحظ بعد تنفيذ البرنامج أنّ النص المعروض سيكون مضمومًا كما لو استخدمنا عامل الضم (+) على الشكل التالي:

C# is a powerful language.It contains advanced features.It makes programming tasks more easier.C# is the main programming language in .NET world.

كان من الممكن استخدام تابع آخر من المتغيّر sb في السطر 20 وهو التابع AppendLine. يشبه هذا التابع Append تمامًا باستثناء أنّه يضيف محرف سطر جديد n\ تلقائيًّا إلى كلّ نص جديد تتم إضافته.

ملاحظة

استخدمنا في السطر 11 أسلوبًا مختصرًا في إنشاء المصفوفات. يمكن استخدام هذا الأسلوب عندما تكون عناصر المصفوفة معروفة ومحدّدة. للأسلوب المختصر الشكل التالي بالنسبة للمصفوفات النصيّة:

string[] arrText = {"Text_1", "Text_2", "Text_3", … , "Text_n"};

ويمكن بالطبع استخدام هذا الأسلوب المختصر مع أيّ نوع مصفوفة آخر.

تمارين داعمة

تمرين 1

ليكن لدينا النص التالي:

"black cat and white dog are friends. black cat always brings food to dog, and white dog thanks it."

المطلوب كتابة برنامج يحسب عدد الكلمات black وعدد الكلمات dog الموجودة في النص. ثمّ يستبدل كل كلمة white في النص بكلمة brown ويعرض النص المعدّل على الشاشة.

تمرين 2

هذا التمرين هو تحدٍّ من نوع آخر!

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

(تلميح: ربما تحتاج إلى شكل مختلف للتابع IndexOf يتطلّب وسيطين: الأوّل هو النص المراد البحث عنه، والثاني هو دليل المحرف الذي سيبدأ البحث اعتبارًا منه. في أمثلتنا السابقة كنّا نبحث افتراضيًّا من المحرف ذو الدليل 0).

الخلاصة

تعرّفنا في هذا الدرس على الخطوات الأساسيّة في التعامل مع النصوص. حيث تعلّمنا كيف نبحث عن نص محدّد ضمن نص آخر وذلك بأسلوبين مختلفين، بالإضافة إلى إجراء عمليّات استبدال داخل نص. كما تعلّمنا كيف نستخلص جزءًا محدّدًا من نص، وكيف نضمّ النصوص باستخدام الصنف StringBuilder. يُعتبر العمل مع النصوص أساسيًّا ومهمًّا لكلّ مبرمج وخصوصًا في مثل هذه الأيّام، فالبيانات التي يتمّ تبادلها بين التطبيقات المختلفة عبر شبكة الإنترنت تكون على شكل نصوص. سنتناول في الدرس القادم كيفيّة التعامل مع الملفات النصيّة من خلال القراءة والكتابة منها وإليها.

يتحدّث هذا الدرس عن موضوعين مهمّين في سي شارب ألا وهما الواجهات Interfaces والمجموعات Collections. تُعتبر المجموعات collections من المزايا القويّة والمهمّة في سي شارب، وهي وسيلة لتخزين العناصر ضمن بنية قابلة للتوسّع تلقائيًّا وسهلة التعامل. إذًا فهي تشبه المصفوفات، باستثناء أنّ المصفوفات ذات حجم ثابت وهي تبقى كذلك منذ لحظة إنشائها، أمّا المجموعات فهي على النقيض من ذلك، فهي بنية قابلة للتوسّع بقدر ما نرغب. بالإضافة إلى أنّ للمجموعات أشكال عديدة مفيدة جدًّا، فهناك المكدّس stack والرتل queue والقاموس dictionary وغيرها من البنى المهمّة.

سنتناول في هذا الدرس المجموعات العاديّة، والمجموعات العموميّة generics collections. سنبدأ هذا الدرس بالحديث المختصر عن الواجهات، وهي تشبه الأصناف ولكن بصورة مجرّدة، حيث تصف سمات عامّة ينبغي أن تتحلّى بها الأصناف التي تحقّقها.

كلمة عن الواجهات

ليست فكرة الواجهات Interfaces محصورةً بسي شارب، فهي موجودة أيضًا في لغات برمجة أخرى مثل جافا Java. تشبه الواجهة Interface الصنف Class بشكل كبير، فهي تضم خصائص وتوابع، ولكن كتصاريح فقط، بدون شيفرة تحوي عبارات برمجيّة، وبدون محدّدات وصول. كما لا تحتوي على حقول fields ولا على بواني. تستطيع القول أنّ الواجهة تعرّف الهيكل العام بشكل مجرّد فحسب. يمكن الاستفادة من الواجهة عندما نحقّقها implement. فعندما يرث صنف ما من واجهة، فيجب عليه أن يعيد التصريح عن جميع الخصائص والتوابع الموجودة ضمن هذه الواجهة ولكن مع تزويدها بحواضن تحوي الشيفرة المطلوب تنفيذها.

فكأنّ الواجهة تحقّق مبدأ التعدديّة الشكليّة بشكل ممتاز، فهي تصرّح عن تابع أو خاصيّة، وتترك للصنف الذي يحقّقها (يرث منها) حريّة التعبير عن هذا التابع أو هذه الخاصيّة بالشكل الملائم.

تُستخدم الواجهات على نحو واسع جدًّا في سي شارب، وتتبع تسميتها لنفس أسلوب تسمية الأصناف، مع الاصطلاح على أن يكون الحرف الأوّل من اسم أيّ واجهة هو الحرف الطباعي الكبير I وهو الحرف الأوّل من كلمة Interface. في الحقيقة لقد حلّت الواجهات مشكلة الوراثة المتعدّدة (الوراثة من أكثر من صنف بنفس الوقت) والتي كانت تتمتّع بها لغة C++ فقط. الآن أصبح بإمكان أي صنف أن يرث من صنف آخر واحد فقط، بالإضافة إلى تحقيقه لأي عدد يرغبه من الواجهات.

يُصرّح عن الواجهة بالكلمة المحجوزة interface. انظر البرنامج Lesson10_1 الذي يوضّح استخدام الواجهات.

هل تذكر الأصناف Animal و Bird و Frog و Fish؟ لقد استعرت الصنفين Animal و Frog لتوضيح فكرة استخدام الواجهات، تذكّر أنّ الصنف Frog كان يرث من الصنف Animal. في الحقيقة لقد استفدت من فكرة أنّ الكائنات الحيّة تتنفّس Breathing. لذلك أنشئت واجهة اسمها IBreathing لتعبّر عن عمليّة التنفّس، وبما أنّ الضفدع Frog هو كائن حيّ، فمن الطبيعي أن يحقّق هذه الواجهة. تحتوي الواجهة IBreathing على تابع وحيد اسمه TakeBreath (السطر 9) يقبل وسيطًا واحدًا من النوع double يُعبّر عن كميّة الأكسجين التي سيحصل عليها الكائن الحيّ عند التنفّس، كما يُرجع هذا التابع قيمة من النوع double أيضًا تمثّل كميّة الأكسجين التي بقيت بعد عمليّة التنفّس.

يرث الصنف Frog هذه الواجهة في السطر 20، ويحقّقها من خلال إعادة تعريف التابع TakeBreath في الأسطر من 27 حتى 30 حيث يُعبّر عن عمليّة التنفّس بالشكل الذي يناسبه (سيستهلك في مثالنا هذا 20% من كميّة الأكسجين التي يحصل عليها). في الحقيقة يمكن استخدام الواجهة IBreathing مع أيّ "كائن حيّ" بصرف النظر عن كونه يرث من الصنف Animal (الذي يمثّل الصنف الحيواني) أو من الصنف Mammal (الثديّيات) مثلًا أو غيره، وذلك لأنّ جميع الكائنات الحيّة تشترك معًا بخاصيّة التنفّس، وهنا تمكن قوّة الواجهات.

1	using System;
2
3	namespace Lesson10_01
4	{
5	    class Program
6	    {
7	        interface IBreathing
8	        {
9	            double TakeBreath(double oxygen_amount);
10	        }
11
12	        class Animal
13	        {
14	            public virtual void Move()
15	            {
16	                Console.WriteLine("Animal: Move General Method");
17	            }
18	        }
19
20	        class Frog : Animal,  IBreathing
21	        {
22	            public override void Move()
23	            {
24	                Console.WriteLine("Frog - Move: jumping 20 cm");
25	            }
26
27	            public double TakeBreath(double oxygen_amount)
28	            {
29	                return oxygen_amount * 0.8;
30	            }
31	
32	        }
33
34	        static void Main(string[] args)
35	        {
36	            double oxygent_to_breath = 10;
37
38	            IBreathing frog = new Frog();
39
40	            Console.WriteLine("Oxygen amount before breath: {0}", oxygent_to_breath);
41	            Console.WriteLine("Oxygen amount after breath: {0}", frog.TakeBreath(oxygent_to_breath));
42	        }
43	    }
44	}

هناك أمر آخر جدير بالملاحظة. انظر إلى السطر 38 ستجد أنّنا قد صرّحنا عن المتغيّر frog من النوع IBreathing ثمّ أسندنا إليه مرجعًا لكائن من النوع Frog، وهذا أمر صحيح تمامًا وشائع جدًّا لأنّ الصنف Frog يرث من الواجهة IBreathing.

عند تنفيذ البرنامج ستحصل على الخرج التالي:

Oxygen amount before breath: 10
Oxygen amount after breath: 8

المجموعات في سي شارب

المجموعات العادية

توجد الأصناف المعبّرة عن هذه المجموعات ضمن نطاق الاسم System.Collection. تلعب نطاقات الأسماء دورًا تنظيميًّا للأصناف، وسنتحدّث عنها بشكل أكبر في درس لاحق. من أبرز المجموعات في نطاق الاسم هذا هو الصنف ArrayList. يحقّق الصنف ArrayList كلّ من الواجهات IList و ICollection و IEnumerable و ICloneable. جميع هذه الواجهات تقع في مكتبة FCL في إطار عمل دوت نت، حيث تعرّف هذه الواجهات العمليّات الأساسيّة التي ينبغي أن يتمتّع بها الصنف ArrayList.

تسمح الكائنات من هذه المجموعة بإضافة أي نوع من العناصر لها، حيث من الممكن أن نضيف عناصر من النوع object. يمكن إضافة العناصر إلى هذه المجموعة باستخدام التابع Add الذي يقبل وسيطًا من النوع object. أي أنّنا فعليًّا نستطيع أن نضيف عناصر من أنواع مختلفة لنفس المجموعة. أيّ عنصر تتمّ إضافته سيوضع آخر المجموعة التي هي ذات حجم مرن، فمن الممكن إضافة أي عدد نرغبه من العناصر. أمّا إذا أردنا إضافة عنصر إلى مكان محدّد ضمن القائمة، فعلينا استخدام التابع Insert الذي يحتاج إلى وسيطين، الأوّل هو الدليل المراد إدراج العنصر الجديد ضمنه، والثاني هو العنصر نفسه.

انظر البرنامج Lesson10_02 البسيط التالي:

1	using System;
2	using System.Collections;
3
4	namespace Lesson10_02
5	{
6	    class Program
7	    {
8	        static void Main(string[] args)
9	        {
10	            ArrayList values = new ArrayList();
11
12	            values.Add("My ");
13	            values.Add("age: ");
14	            values.Add(36);
15
16	            foreach(object item in values)
17	            {
18	                Console.Write(item);
19	            }
20
21	            Console.WriteLine();
22	        }
23	    }
24	}

استطعنا الحصول على عناصر هذه المجموعة باستخدام حلقة foreach. ولكن إذا أردنا الوصول إلى عنصر محدّد فحسب، ولنقل أنّه العنصر الثالث (القيمة 36) في مثالنا السابق، فيمكن ذلك من خلال الشكل التالي:

values[2]

تذكّر دومًا أنّ دليل العنصر الأوّل هو 0. في الواقع ستكون القيمة التي سنحصل عليها من [values[2 هي قيمة من نوع object رغم أنّها في حقيقة الأمر تحوي القيمة 36 وهي قيمة من نوع int بطبيعة الحال. السبب في ذلك منطقيّ وهو أنّنا عندما أضفنا القيمة 36 إلى المجموعة كان ذلك باستخدام التابع Add الذي يقبل وسيطًا من النوع object. إذا أردنا الاستفادة من القيمة الفعليّة المخزّنة ضمن [values[2 فعلينا هنا أن نستخدم عامل التحويل (int) على الشكل التالي:

int age = (int) values[2];

ملاحظة: عند تمرير القيمة 36 في المثال السابق إلى التابع Add الذي يتوقّع وسيط من نوع object تحدث ظاهرة نسميها التعليب boxing. حيث تُعلَّب القيمة 36 ليصبح بالإمكان تمريرها مكان وسيط يتطلّب النوع object (يبقى هذا الأمر صحيحًا من أجل أي قيمة value type). أمّا عندما نريد استرجاع القيمة الفعليّة فإنّنا نقوم بعمليّة معاكسة تدعى بإلغاء التعليب unboxing باستخدام عامل التحويل بين الأنواع كما فعلنا بالعبارة البرمجيّة الأخيرة:

int age = (int) values[2];

هناك العديد من المجموعات الأخرى الموجودة ضمن نطاق الاسم System.Collection، ولكن لن أتحدّث عنها هنا. في الحقيقة إذا أردت نصيحتي حاول ألّا تستخدم المجموعات العاديّة أبدًا! يكمن السبب في ذلك في الفقرة التالية عندما نتحدّث عن المجموعات العموميّة generic collection، حيث سنطّلع على مجموعات تشبه إلى حدٍّ بعيد المجموعات العاديّة الموجودة هنا، ولكنّها عمليّة وأكثر أمانًا.

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

تشبه المجموعات العموميّة generic collections من حيث المبدأ المجموعات العاديّة باستثناء أنّها أكثر أمنًا وأفضل أداءً. حيث ينبغي تعيين نوع العناصر التي ستتعامل معها المجموعة عند التصريح عنها، فتتعامل المجموعة في هذه الحالة مع نوع مُحدّد. من أشهر المجموعات العموميّة هي المجموعة <List<T وهي تعبّر عن القائمة list. قد يبدو الشكل السابق غريبًا قليلًا، ولكنّه في الحقيقة بسيط. استبدل الحرف T بأيّ نوع (صنف) ترغبه وستقبل المجموعة نتيجة لذلك أن يكون عناصرها من هذا النوع. تقع المجموعات العموميّة في نطاق الاسم System.Collections.Generic.

سنعدّل البرنامج Lesson09_02 من الدرس السابق الذي كان يسمح بإدخال أسماء ودرجات خمسة طلاب فقط، ويخزّنها على شكل كائنات Student ضمن مصفوفة من النوع []Student وذلك لإيجاد مجموع الدرجات والمعدّل. سنجعل هذا البرنامج يستخدم المجموعة العموميّة <List<Student (مجموعة يمكن لعناصرها تخزين مراجع لكائنات من النوع Student)، سننشئ البرنامج Lesson10_03 لهذا الغرض.

1	using System;
2	using System.Collections.Generic;
3
4	namespace Lesson10_03
5	{
6	    class Student
7	    {
8	        public string Name { get; set; }
9	        public int Mark { get; set; }
10	    }
11
12	    class Program
13	    {
14	        static void Main(string[] args)
15	        {
16	            List<Student> listStudents = new List<Student>();
17	            int sum = 0;
18	            bool continueCondition = true;
19	            int counter = 0;
20	            string response;
21            
22	            Console.WriteLine("Input Students Marks");
23	            Console.WriteLine("=====================");
24
25	            //input loop.
26	            while(continueCondition)
27	            {
28	                Student student = new Student();
29
30	                Console.Write("Input student {0} th name: ", counter + 1);
31	                student.Name = Console.ReadLine();
32
33	                Console.Write("Input student {0} th mark: ", counter + 1);
34	                string tmpMark = Console.ReadLine();
35	                student.Mark = int.Parse(tmpMark);
36
37	                listStudents.Add(student);
38
39	                Console.WriteLine();
40	                Console.Write("Add another student? (y/n) : ");
41	                response = Console.ReadLine();
42                
43	                if(response=="n" || response == "N")
44	                {
45	                    continueCondition = false;
46	                }
47	
48	                counter++;
49	            }
50            
51	            Console.WriteLine();
52	            Console.WriteLine("Students Marks Table");
53	            Console.WriteLine("====================");
54	            Console.WriteLine("No\tName\tMark");
55
56	            //calculating sum and display output loop.
57	            for (int i = 0; i < listStudents.Count; i++)
58	            {
59	                sum += listStudents[i].Mark;
60	                Console.WriteLine("{0}\t{1}\t{2}", i + 1, listStudents[i].Name, listStudents[i].Mark);
61	            }
62
63	            Console.WriteLine("-------------------");
64	            Console.WriteLine("Sum\t\t{0}", sum);
65	            Console.WriteLine("Average\t\t{0}", sum / (double)listStudents.Count);
66	        }
67	    }
68	}