تطبيق وصل wassll لمتابعة مخصصات المحروقات

المصفوفات في سي شارب C#

تُستخدم المصفوفات Arrays لتخزين مجموعة من القيم من نفس النوع. يمكن أن تكون المصفوفة ثنائية الأبعاد أو متعددة الأبعاد أيضًا. إليك بعض الأمثلة على كيفية استخدام المصفوفات في C#:

لإنشاء مصفوفة جديدة، يمكنك استخدام البناء التالي:

// إنشاء مصفوفة من النوع int بحجم 5
int[] myArray = new int[5];

يمكنك أيضًا تعيين القيم المبدئية للمصفوفة عند إنشائها:

// إنشاء مصفوفة وتعيين القيم المبدئية
int[] myArray = new int[] { 1, 2, 3, 4, 5 };

يمكنك الوصول إلى العناصر في المصفوفة باستخدام الفهرس (الفهارس) الخاصة بها:

// الوصول إلى العناصر في المصفوفة
int firstElement = myArray[0];
int secondElement = myArray[1];

يمكنك تعيين قيمة جديدة لعنصر في المصفوفة بنفس الطريقة:

// تعيين قيمة جديدة لعنصر في المصفوفة
myArray[0] = 10;

يمكنك أيضًا استخدام الحلقات للانتقال عبر عناصر المصفوفة:

// استخدام حلقة للانتقال عبر المصفوفة
for (int i = 0; i < myArray.Length; i++)
{
    Console.WriteLine(myArray[i]);
}

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

انواع المصفوفات في لغة سي شارب C#

في لغة C#، يمكن تصنيف المصفوفات إلى عدة أنواع بناءً على عدد الأبعاد ونوع العنصر الذي تحتويه. هنا هي بعض أنواع المصفوفات الشائعة في C#:

المصفوفات ذات الأبعاد الواحدة (One-Dimensional Arrays): 

• مصفوفة من الأعداد الصحيحة: int[] 
• مصفوفة من الأعداد العشرية: double[] 
• مصفوفة من النصوص: string[] 
• مصفوفة من الأحرف: char[]

المصفوفات ذات الأبعاد المتعددة (Multidimensional Arrays): 

• مصفوفة ثنائية الأبعاد: int[,] 
• مصفوفة ثلاثية الأبعاد: double[,,]

المصفوفات الجاجزة (Jagged Arrays): 

• مصفوفة جاجزة ذات الأبعاد الواحدة: int[][]
•  مصفوفة جاجزة ذات الأبعاد المتعددة: double[][][]

تُعرف المصفوفات باستخدام نوع العنصر المطلوب يليها قوسين مربعين تحدد أبعاد المصفوفة. على سبيل المثال، int[] هو نوع مصفوفة واحدة البعد من الأعداد الصحيحة، بينما int[,] هو نوع مصفوفة ثنائية الأبعاد من الأعداد الصحيحة.

ما هي الطريقة المثلى لتعريف مصفوفة ثلاثية الأبعاد في C#؟

لتعريف مصفوفة ثلاثية الأبعاد في لغة C#، يمكنك استخدام البناء التالي:

// تعريف مصفوفة ثلاثية الأبعاد بنوع العنصر المحدد
dataType[,,] arrayName = new dataType[length1, length2, length3];

حيث:

1. dataType هو نوع العنصر الذي ترغب في تخزينه في المصفوفة (مثل int أو double أو string وما إلى ذلك).
2. arrayName هو اسم المصفوفة التي ترغب في تعريفها.
3. length1 و length2 و length3 هي أطوال الأبعاد الثلاثة للمصفوفة.

على سبيل المثال، إليك كيفية تعريف مصفوفة ثلاثية الأبعاد لتخزين الأعداد الصحيحة:

int[,,] myArray = new int[3, 4, 5];

في هذا المثال، تم تعريف مصفوفة ثلاثية الأبعاد تحمل 3 أبعاد، حيث تحتوي الأبعدة الأولى على 3 عناصر، والأبعدة الثانية على 4 عناصر، والأبعدة الثالثة على 5 عناصر.

يمكنك الوصول إلى العناصر في المصفوفة وتعديلها باستخدام الفهرس (الفهارس) الخاصة بها، على غرار المصفوفات ذات الأبعاد الأقل.

كيف يمكنني الوصول إلى عناصر محددة في مصفوفة ثلاثية الأبعاد في C#؟

للوصول إلى عناصر محددة في مصفوفة ثلاثية الأبعاد في لغة C#، يمكنك استخدام الفهرس (الفهارس) المناسبة لكل بُعد. يتم تمرير قيمة الفهرس لكل بُعد كوسيطة في الأقواس المربعة المتعددة.

هنا بعض الأمثلة لكيفية الوصول إلى عناصر محددة في مصفوفة ثلاثية الأبعاد:

int[,,] myArray = new int[3, 4, 5];

// تعيين قيمة لعنصر في المصفوفة
myArray[0, 1, 2] = 10;

// الوصول إلى قيمة عنصر في المصفوفة
int value = myArray[0, 1, 2];

في هذا المثال، تم تعيين قيمة 10 لعنصر في الموقع (0, 1, 2) في المصفوفة، وتم الوصول إلى قيمة هذا العنصر باستخدام نفس الفهرس (0, 1, 2).

يجب أن يتم تحديد قيم الفهارس لكل بعد في النطاق الصحيح. على سبيل المثال، إذا كانت المصفوفة ثلاثية الأبعاد هي int[3, 4, 5]، فإن الفهارس يجب أن تكون بين 0 و 2 للبعد الأول، وبين 0 و 3 للبعد الثاني، وبين 0 و 4 للبعد الثالث.

يمكنك استخدام حلقتي for متداخلتين للانتقال عبر جميع العناصر في المصفوفة ثلاثية الأبعاد:

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 4; j++)
    {
        for (int k = 0; k < 5; k++)
        {
            // الوصول إلى العنصر في الفهرس (i, j, k)
            int element = myArray[i, j, k];
            Console.WriteLine(element);
        }
    }
}

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

هل يمكنني استخدام قيم سالبة كفهارس في المصفوفة ثلاثية الأبعاد؟

نعم، يمكنك استخدام قيم سالبة كفهارس في المصفوفة ثلاثية الأبعاد في لغة C#. تُعتبر الفهارس السالبة بمثابة إزاحة من نهاية المصفوفة نحو البداية.

على سبيل المثال، إذا كانت المصفوفة ثلاثية الأبعاد هي int[3, 4, 5]، فإذا استخدمت الفهرس -1 في أي بُعد، فسيتم الوصول إلى العنصر الذي يسبق أول عنصر في ذلك البُعد. وعلى النحو نفسه، فإن استخدام الفهرس -2 سيتيح الوصول إلى العنصر الذي يسبق العنصر الثاني في ذلك البُعد، وهكذا.

هنا بعض الأمثلة لتوضيح الفهارس السالبة في مصفوفة ثلاثية الأبعاد:

int[,,] myArray = new int[3, 4, 5];

// تعيين قيمة لعنصر في المصفوفة باستخدام فهرس سالب
myArray[0, -1, 2] = 10;

// الوصول إلى قيمة عنصر في المصفوفة باستخدام فهرس سالب
int value = myArray[0, -1, 2];

في هذا المثال، تم تعيين قيمة 10 لعنصر في الموقع (0, -1, 2) في المصفوفة، وتم الوصول إلى قيمة هذا العنصر باستخدام نفس الفهرس (0, -1, 2).

ومع ذلك، يجب أن تتأكد من عدم تجاوز الحد الأدنى لكل بُعد عند استخدام الفهارس السالبة. على سبيل المثال، إذا كانت المصفوفة ثلاثية الأبعاد هي int[3, 4, 5]، فإذا استخدمت الفهرس -4 في البُعد الثاني، فسيؤدي ذلك إلى خطأ في وقت التشغيل (IndexOutOfRangeException)، لأن الحد الأدنى للبُعد الثاني هو -3.

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