2. أساسيات لغة VB.NET
2.1. مقدمة
سنعامل VB.NET أولاً كلغة برمجة تقليدية. وسنتناول الكائنات لاحقاً.
في البرنامج، هناك أمران
- البيانات
- التعليمات التي تتعامل معها
نسعى عمومًا إلى فصل البيانات عن التعليمات:
 |
2.2. بيانات VB.NET
يستخدم VB.NET أنواع البيانات التالية:
- الأعداد الصحيحة، والأعداد الحقيقية، والأعداد العشرية
- الأحرف والسلاسل
- القيم المنطقية
- التواريخ
- الكائنات
2.2.1. أنواع البيانات المحددة مسبقًا
نوع VB | نوع .NET المكافئ | الحجم | نطاق القيمة |
منطقية | System.Boolean | 2 بايت | صحيح أو خطأ. |
بايت | System.Byte | 1 بايت | من 0 إلى 255 (غير موقّع). |
Char | System.Char | 2 بايت | من 0 إلى 65,535 (بدون علامة). |
Date | System.DateTime | 8 بايت | من 0:00:00 في 1 يناير 0001 إلى 23:59:59 في 31 ديسمبر 9999. |
عشري | System.Decimal | 16 بايت | من 0 إلى +/-79,228,162,514,264,337,593,543,950,335 بدون أرقام عشرية؛ من 0 إلى +/-7.9228162514264337593543950335 مع 28 رقمًا عشريًا؛ أصغر رقم غير صفر هو +/-0.0000000000000000000000000001 (+/-1E-28). |
Double | نظام.Double | 8 بايت | -1.79769313486231E+308 إلى -4.94065645841247E-324 للقيم السالبة؛ 4.94065645841247E-324 إلى 1.79769313486231E+308 للقيم الموجبة. |
عدد صحيح | System.Int32 | 4 بايت | من -2,147,483,648 إلى 2,147,483,647. |
طويل | System.Int64 | 8 بايت | من -9,223,372,036,854,775,808 إلى 9,223,372,036,854,775,807. |
كائن | System.Object | 4 بايت | يمكن تخزين أي نوع في متغير من نوع Object. |
Short | System.Int16 | 2 بايت | من -32,768 إلى 32,767. |
Single | System.Single | 4 بايت | من -3.402823E+38 إلى -1.401298E-45 للقيم السالبة؛ ومن 1.401298E-45 إلى 3.402823E+38 للقيم الموجبة. |
String | System.String (فئة) | من 0 إلى حوالي 2 مليار حرف Unicode. |
في الجدول أعلاه، نرى أن هناك نوعين ممكنين لعدد صحيح 32 بت: Integer و System.Int32. هذان النوعان قابلان للتبادل. وينطبق الأمر نفسه على أنواع VB الأخرى وما يعادلها في منصة .NET. فيما يلي برنامج نموذجي:
Module types
Sub Main()
' whole numbers
Dim var1 As Integer = 100
Dim var2 As Long = 10000000000L
Dim var3 As Byte = 100
Dim var4 As Short = 4
' real numbers
Dim var5 As Decimal = 4.56789D
Dim var6 As Double = 3.4
Dim var7 As Single = -0.000103F
' date
Dim var8 As Date = New Date(2003, 1, 1, 12, 8, 4)
' boolean
Dim var9 As Boolean = True
' character
Dim var10 As Char = "A"c
' character string
Dim var11 As String = "abcde"
' object
Dim var12 As Object = New Object
' displays
Console.Out.WriteLine("var1=" + var1.ToString)
Console.Out.WriteLine("var2=" + var2.ToString)
Console.Out.WriteLine("var3=" + var3.ToString)
Console.Out.WriteLine("var4=" + var4.ToString)
Console.Out.WriteLine("var5=" + var5.ToString)
Console.Out.WriteLine("var6=" + var6.ToString)
Console.Out.WriteLine("var7=" + var7.ToString)
Console.Out.WriteLine("var8=" + var8.ToString)
Console.Out.WriteLine("var9=" + var9.ToString)
Console.Out.WriteLine("var10=" + var10)
Console.Out.WriteLine("var11=" + var11)
Console.Out.WriteLine("var12=" + var12.ToString)
End Sub
End Module
ينتج عن التنفيذ النتائج التالية:
var1=100
var2=10000000000
var3=100
var4=4
var5=4,56789
var6=3,4
var7=-0,000103
var8=01/01/2003 12:08:04
var9=True
var10=A
var11=abcde
var12=System.Object
2.2.2. ترميز البيانات الحرفية
145، -7، &FF (سداسي عشري) | |
100000L | |
134.789، -45E-18 (-45 × 10⁻¹⁸) | |
134.789F، -45E-18F (-45 × 10⁻¹⁸) | |
100000D | |
"A"c | |
"اليوم" | |
صحيح، خطأ | |
تاريخ جديد (2003، 1، 1) لـ 01/01/2003 |
لاحظ النقاط التالية:
- 100000L، حيث تشير L إلى أن الرقم يُعامل كعدد صحيح طويل
- 134.789F، حيث تشير F إلى أن الرقم يُعامل كرقم عائم أحادي الدقة
- 100000D، حيث تشير D إلى أن الرقم يُعامل كرقم حقيقي عشري
- "A"c، لتحويل سلسلة الأحرف "A" إلى الحرف 'A'
- يتم وضع السلسلة بين الحرفين ". إذا كان يجب أن تحتوي السلسلة على الحرف "، يتم تكراره، كما في "abcd""e" لتمثيل السلسلة [abcd"e].
2.2.3. إعلان البيانات
2.2.3.1. دور الإعلانات
يعالج البرنامج البيانات التي تتميز باسم ونوع. يتم تخزين هذه البيانات في الذاكرة. عند ترجمة البرنامج، يقوم المترجم بتعيين موقع ذاكرة لكل جزء من البيانات يتميز بعنوان وحجم. ويقوم بذلك باستخدام الإعلانات التي وضعها المبرمج. علاوة على ذلك، تسمح هذه الإعلانات للمترجم باكتشاف أخطاء البرمجة. وبالتالي، سيتم إعلان العملية x = x \* 2 كخطأ إذا كان x سلسلة، على سبيل المثال.
2.2.3.2. إعلان الثوابت
صيغة إعلان الثابت هي كما يلي:
const identifier as type=value
على سبيل المثال، [const PI as double=3.141592]. لماذا نعلن الثوابت؟
- سيكون البرنامج أسهل في القراءة إذا أعطيت الثابت اسمًا ذي معنى: [const VAT_rate as single=0.186F]
- سيكون تعديل البرنامج أسهل إذا احتاجت "الثابتة" إلى التغيير. وبالتالي، في الحالة السابقة، إذا تغير معدل ضريبة القيمة المضافة إلى 33٪، فإن التعديل الوحيد المطلوب سيكون تغيير العبارة التي تحدد قيمتها: [const vatrate as single=0.336F]. إذا تم استخدام 0.186 بشكل صريح في البرنامج، فسيكون من الضروري تعديل العديد من العبارات.
2.2.3.3. إعلان المتغيرات
يتم تحديد المتغير بواسطة اسم ويشير إلى نوع البيانات. لا يميز VB.NET بين الأحرف الكبيرة والصغيرة. وبالتالي، فإن المتغيرين FIN و fin متطابقان. يمكن تهيئة المتغيرات عند إعلانها. صيغة إعلان متغير واحد أو أكثر هي:
dim variable1,variable2,...,variablen as type_identifier
حيث type_identifier هو نوع محدد مسبقًا أو نوع محدد من قبل المبرمج.
2.2.4. التحويلات بين الأرقام والسلاسل
number.ToString أو "" & number أو CType(number, String) | |
كائن.ToString | |
عدد صحيح.Parse(سلسلة) أو Int32.Parse | |
Long.Parse(سلسلة) أو Int64.Parse | |
Double.Parse(string) | |
Single.Parse(string) |
قد يفشل تحويل سلسلة إلى رقم إذا كانت السلسلة لا تمثل رقمًا صحيحًا. ويؤدي ذلك إلى حدوث خطأ فادح، يُعرف باسم «استثناء» في VB.NET. ويمكن معالجة هذا الخطأ باستخدام كتلة try/catch التالية:
try
appel de la fonction susceptible de générer l'exception
catch e as Exception
traiter l'exception e
end try
instruction suivante
إذا لم تولد الدالة استثناءً، ننتقل إلى الجملة التالية؛ وإلا، ندخل إلى نص جملة catch ثم ننتقل إلى الجملة التالية. سنعود إلى معالجة الاستثناءات لاحقًا. فيما يلي برنامج يوضح التقنيات الرئيسية للتحويل بين الأرقام والسلاسل. في هذا المثال، تقوم الدالة display بطباعة قيمة معلمتها على الشاشة. وبالتالي، فإن display(S) تطبع قيمة S على الشاشة.
' guidelines
Option Strict On
' imported namespaces
Imports System
' the test module
Module Module1
Sub Main()
' main proceedings
' local data
Dim S As String
Const i As Integer = 10
Const l As Long = 100000
Const f As Single = 45.78F
Dim d As Double = -14.98
' number --> string
affiche(CType(i, String))
affiche(CType(l, String))
affiche(CType(f, String))
affiche(CType(d, String))
'boolean --> string
Const b As Boolean = False
affiche(b.ToString)
' string --> int
Dim i1 As Integer = Integer.Parse("10")
affiche(i1.ToString)
Try
i1 = Integer.Parse("10.67")
affiche(i1.ToString)
Catch e As Exception
affiche("Erreur [10.67] : " + e.Message)
End Try
' chain --> long
Dim l1 As Long = Long.Parse("100")
affiche("" + l1.ToString)
Try
l1 = Long.Parse("10.675")
affiche("" & l1)
Catch e As Exception
affiche("Erreur [10.675] : " + e.Message)
End Try
' chain --> double
Dim d1 As Double = Double.Parse("100,87")
affiche(d1.ToString)
Try
d1 = Double.Parse("abcd")
affiche("" & d1)
Catch e As Exception
affiche("Erreur [abcd] : " + e.Message)
End Try
' chain --> single
Dim f1 As Single = Single.Parse("100,87")
affiche(f1.ToString)
Try
d1 = Single.Parse("abcd")
affiche(f1.ToString)
Catch e As Exception
affiche("Erreur [abcd] : " + e.Message)
End Try
End Sub
' poster
Public Sub affiche(ByVal S As String)
Console.Out.WriteLine("S=" + S)
End Sub
End Module
النتائج هي كما يلي:
S=10
S=100000
S=45,78
S=-14,98
S=False
S=10
S=Erreur [10.67] : Le format de la chaîne d'entrée est incorrect.
S=100
S=Erreur [10.675] : Le format de la chaîne d'entrée est incorrect.
S=100,87
S=Erreur [abcd] : Le format de la chaîne d'entrée est incorrect.
S=100,87
S=Erreur [abcd] : Le format de la chaîne d'entrée est incorrect.
لاحظ أن الأعداد الحقيقية في شكل سلسلة يجب أن تستخدم فاصلة، وليس نقطة عشرية. وبالتالي، نكتب Dim d As Double = -14.98 ولكن Dim d1 As Double = Double.Parse("100.87")
2.2.5. مصفوفات البيانات
مصفوفة VB.NET هي كائن يسمح بتجميع البيانات من نفس النوع تحت معرف واحد. يتم إعلانها على النحو التالي:
Dim Array(n) As Type أو Dim Array() As Type = New Type(n) {}
حيث n هو مؤشر عنصر المصفوفة الأخير. تشير صيغة Array(i) إلى البيانات الموجودة في المؤشر i، حيث ينتمي i إلى النطاق [0,n]. أي إشارة إلى البيانات Array(i) حيث لا ينتمي i إلى النطاق [0,n] ستؤدي إلى حدوث استثناء. يمكن تهيئة المصفوفة في نفس الوقت الذي يتم فيه تعريفها. في هذه الحالة، لا توجد حاجة لتحديد مؤشر العنصر الأخير.
Dim entiers() As Integer = {0, 10, 20, 30}
تحتوي المصفوفات على خاصية Length، وهي عدد العناصر الموجودة في المصفوفة. فيما يلي مثال على برنامج:
Module tab0
Sub Main()
' a first picture
Dim tab0(5) As Integer
For i As Integer = 0 To UBound(tab0)
tab0(i) = i
Next
For i As Integer = 0 To UBound(tab0)
Console.Out.WriteLine("tab0(" + i.ToString + ")=" + tab0(i).tostring)
Next
' a second panel
Dim tab1() As Integer = New Integer(5) {}
For i As Integer = 0 To tab1.Length - 1
tab1(i) = i * 10
Next
For i As Integer = 0 To tab1.Length - 1
Console.Out.WriteLine("tab1(" + i.ToString + ")=" + tab1(i).tostring)
Next
End Sub
End Module
وتنفيذه:
tab0(0)=0
tab0(1)=1
tab0(2)=2
tab0(3)=3
tab0(4)=4
tab0(5)=5
tab1(0)=0
tab1(1)=10
tab1(2)=20
tab1(3)=30
tab1(4)=40
tab1(5)=50
يمكن تعريف مصفوفة ثنائية الأبعاد على النحو التالي:
Dim Array(n, m) as Type أو Dim Array(,) as Type = New Type(n, m) {}
حيث n+1 هو عدد الصفوف، و m+1 هو عدد الأعمدة. تشير صيغة Array(i,j) إلى العنصر j في الصف i من Array. يمكن أيضًا تهيئة المصفوفة ثنائية الأبعاد في نفس وقت إعلانها:
Dim réels(,) As Double = {{0.5, 1.7}, {8.4, -6}}
يمكن الحصول على عدد العناصر في كل بُعد باستخدام طريقة GetLength(i)، حيث يمثل i=0 البُعد المقابل للمؤشر الأول، وi=1 البُعد المقابل للمؤشر الثاني، ... وإليك مثال على برنامج:
Module Module2
Sub Main()
' a first picture
Dim tab0(2, 1) As Integer
For i As Integer = 0 To UBound(tab0)
For j As Integer = 0 To tab0.GetLength(1) - 1
tab0(i, j) = i * 10 + j
Next
Next
For i As Integer = 0 To UBound(tab0)
For j As Integer = 0 To tab0.GetLength(1) - 1
Console.Out.WriteLine("tab0(" + i.ToString + "," + j.ToString + ")=" + tab0(i, j).tostring)
Next
Next
' a second panel
Dim tab1(,) As Integer = New Integer(2, 1) {}
For i As Integer = 0 To tab1.GetLength(0) - 1
For j As Integer = 0 To tab1.GetLength(1) - 1
tab1(i, j) = i * 100 + j
Next
Next
For i As Integer = 0 To tab1.GetLength(0) - 1
For j As Integer = 0 To tab1.GetLength(1) - 1
Console.Out.WriteLine("tab1(" + i.ToString + "," + j.ToString + ")=" + tab1(i, j).tostring)
Next
Next
End Sub
End Module
ونتيجة تنفيذها:
tab0(0)=0
tab0(1)=1
tab0(2)=2
tab0(3)=3
tab0(4)=4
tab0(5)=5
tab1(0)=0
tab1(1)=10
tab1(2)=20
tab1(3)=30
tab1(4)=40
tab1(5)=50
يتم إعلان مصفوفة المصفوفات على النحو التالي:
Dim Array(n)() As Type أو Dim Array()() As Type = New Type(n)()
يؤدي الإعلان أعلاه إلى إنشاء مصفوفة مكونة من n+1 صفًا. كل عنصر Array(i) هو مرجع مصفوفة أحادية البعد. لا يتم إنشاء هذه المصفوفات أثناء الإعلان أعلاه. يوضح المثال أدناه كيفية إنشاء مصفوفة من المصفوفات:
' a table of tables
Dim noms()() As String = New String(3)() {}
' initialization
For i = 0 To noms.Length - 1
noms(i) = New String(i) {}
For j = 0 To noms(i).Length - 1
noms(i)(j) = "nom" & i & j
Next
Next
هنا، names(i) عبارة عن مصفوفة مكونة من i+1 عنصر. وبما أن names(i) مصفوفة، فإن names(i).Length يمثل عدد العناصر التي تحتوي عليها. فيما يلي مثال يجمع بين أنواع المصفوفات الثلاثة التي ناقشناها للتو:
' guidelines
Option Strict On
Option Explicit On
' imports
Imports System
' test class
Module test
Sub main()
' an initialized 1-dimensional array
Dim entiers() As Integer = {0, 10, 20, 30}
Dim i As Integer
For i = 0 To entiers.Length - 1
Console.Out.WriteLine("entiers[" & i & "]=" & entiers(i))
Next
' an initialized 2-dimensional array
Dim réels(,) As Double = {{0.5, 1.7}, {8.4, -6}}
Dim j As Integer
For i = 0 To réels.GetLength(0) - 1
For j = 0 To réels.GetLength(1) - 1
Console.Out.WriteLine("réels[" & i & "," & j & "]=" & réels(i, j))
Next
Next
' an array°of arrays
Dim noms()() As String = New String(3)() {}
' initialization
For i = 0 To noms.Length°- 1
noms(i) =°New String(i) {}
For j = 0 To noms(i).Length - 1
noms(i)(j) = "nom" & i & j
Next
Next
' display
For i = 0 To noms.Length°- 1
For j = 0 To noms(i).Length - 1
Console.Out.WriteLine("noms[" & i & "][" & j & "]=" & noms(i)(j))
Next
Next
End Sub
End Module
عند التنفيذ، نحصل على النتائج التالية:
entiers[0]=0
entiers[1]=10
entiers[2]=20
entiers[3]=30
réels[0,0]=0,5
réels[0,1]=1,7
réels[1,0]=8,4
réels[1,1]=-6
noms[0][0]=nom00
noms[1][0]=nom10
noms[1][1]=nom11
noms[2][0]=nom20
noms[2][1]=nom21
noms[2][2]=nom22
noms[3][0]=nom30
noms[3][1]=nom31
noms[3][2]=nom32
noms[3][3]=nom33
2.3. عبارات VB.NET الأساسية
نحن نميز بين
1 الأوامر الأساسية التي ينفذها الكمبيوتر.
2 الأوامر التي تتحكم في تدفق البرنامج.
تتضح التعليمات الأساسية عند النظر إلى بنية الحاسوب الصغير وأجهزته الطرفية.
 |
-
قراءة المعلومات من لوحة المفاتيح
-
معالجة المعلومات
-
كتابة المعلومات على الشاشة
-
قراءة المعلومات من ملف على القرص
-
كتابة المعلومات إلى ملف على القرص
2.3.1. الكتابة على الشاشة
هناك تعليمات متنوعة للكتابة على الشاشة:
Console.Out.WriteLine(expression)
Console.WriteLine(expression)
Console.Error.WriteLine (expression)
حيث التعبير هو أي نوع بيانات يمكن تحويله إلى سلسلة ليتم عرضه على الشاشة. في الأمثلة التي رأيناها حتى الآن، لم نستخدم سوى عبارة Console.Out.WriteLine(expression).
توفر فئة System.Console إمكانية الوصول إلى عمليات الكتابة على الشاشة (Write، WriteLine). تحتوي فئة Console على خاصيتين، هما Out و Error، وهما تياران للكتابة من نوع StreamWriter:
- Console.WriteLine() تعادل Console.Out.WriteLine() وتكتب إلى تيار Out، الذي يرتبط عادةً بالشاشة.
- تكتب Console.Error.WriteLine() إلى تيار Error، الذي يرتبط عادةً بالشاشة أيضًا.
يرتبط تيارا Out و Error بالشاشة بشكل افتراضي. ومع ذلك، يمكن إعادة توجيههما إلى ملفات نصية أثناء وقت التشغيل، كما سنرى بعد قليل.
2.3.2. قراءة البيانات المكتوبة على لوحة المفاتيح
يتم تمثيل دفق البيانات من لوحة المفاتيح بواسطة كائن Console.In من النوع StreamReader. يتيح لك هذا النوع من الكائنات قراءة سطر من النص باستخدام الأسلوب ReadLine:
Dim ligne As String = Console.In.ReadLine()
يتم تخزين السطر الذي تمت كتابته على لوحة المفاتيح في المتغير line* ويمكن بعد ذلك استخدامه بواسطة البرنامج. يمكن إعادة توجيه دفق In إلى ملف، تمامًا مثل دفقَي Out وError*.
2.3.3. مثال على الإدخال/الإخراج
فيما يلي برنامج قصير يوضح عمليات الإدخال/الإخراج عبر لوحة المفاتيح/الشاشة:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
' module
Module io1
Sub Main()
' write to Out feed
Dim obj As New Object
Console.Out.WriteLine(("" & obj.ToString))
' write to the Error stream
Dim i As Integer = 10
Console.Error.WriteLine(("i=" & i))
' reading a line entered on the keyboard
Console.Out.Write("Tapez une ligne : ")
Dim ligne As String = Console.In.ReadLine()
Console.Out.WriteLine(("ligne=" + ligne))
End Sub
End Module
ونتيجة التنفيذ:
التعليمات
Dim obj As New Object
Console.Out.WriteLine(obj.ToString)
موجودة فقط لإظهار أنه يمكن عرض أي كائن. لن نحاول هنا شرح معنى ما يتم عرضه.
2.3.4. إعادة توجيه الإدخال/الإخراج
في DOS/Windows، توجد ثلاثة أجهزة إدخال قياسية تسمى:
- جهاز الإدخال القياسي — يشير افتراضيًا إلى لوحة المفاتيح ويحمل الرقم 0
- جهاز الإخراج القياسي — يشير افتراضيًا إلى الشاشة ويحمل الرقم 1
- جهاز الخطأ القياسي — يشير افتراضيًا إلى الشاشة ويحمل الرقم 2
في VB.NET، يكتب دفق الإخراج Console.Out إلى الجهاز 1، ويكتب دفق الإخراج Console.Error إلى الجهاز 2، ويقرأ دفق الإدخال Console.In البيانات من الجهاز 0. عند تشغيل برنامج في نافذة DOS ضمن Windows، يمكنك تحديد الأجهزة التي ستكون 0 و1 و2 للبرنامج قيد التشغيل. انظر إلى سطر الأوامر التالي:
بعد الحجج argi لبرنامج pg، يمكنك إعادة توجيه أجهزة الإدخال/الإخراج القياسية إلى ملفات:
يتم إعادة توجيه دفق الإدخال القياسي رقم 0 إلى الملف in.txt. وبالتالي، سيقوم دفق Console.In في البرنامج بقراءة بياناته من الملف in.txt. | ||||
يعيد توجيه تيار الإخراج رقم 1 إلى الملف out.txt. وهذا يعني أنه في البرنامج، سيقوم تيار Console.Out بكتابة بياناته إلى الملف out.txt | ||||
مثل ما سبق، لكن البيانات المكتوبة تُلحق بالمحتويات الحالية لملف out.txt. | ||||
يعيد توجيه المخرج رقم 2 إلى ملف error.txt. وهذا يعني أنه في البرنامج، سيقوم تيار Console.Error بكتابة بياناته إلى ملف error.txt | ||||
مثل ما سبق، لكن البيانات المكتوبة تُلحق بالمحتويات الحالية لملف error.txt. | ||||
يتم إعادة توجيه الجهازين 1 و 2 إلى الملفات | ||||
لاحظ أنه لإعادة توجيه تدفقات الإدخال/الإخراج لبرنامج pg إلى ملفات، لا يلزم تعديل برنامج pg. فنظام التشغيل هو الذي يحدد طبيعة الأجهزة 0 و1 و2. انظر البرنامج التالي:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
' redirections
Module console2
Sub Main()
' lecture flux In
Dim data As String = Console.In.ReadLine()
' write Out feed
Console.Out.WriteLine(("écriture dans flux Out : " + data))
' écriture flux Error
Console.Error.WriteLine(("écriture dans flux Error : " + data))
End Sub
End Module
دعونا نقوم بتجميع هذا البرنامج:
dos>vbc es2.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4 pour Microsoft (R) .NET Framework version 1.1.4322.573
Copyright (C) Microsoft Corporation 1987-2002. Tous droits réservés.
dos>dir
24/02/2004 15:39 416 es2.vb
11/03/2004 08:20 3 584 es2.exe
دعونا نقوم بتشغيله للمرة الأولى:
dos>es2.exe
un premier test
écriture dans flux Out : un premier test
écriture dans flux Error : un premier test
التنفيذ السابق لا يعيد توجيه أي من تدفقات الإدخال/الإخراج القياسية In أو Out أو Error. سنقوم الآن بإعادة توجيه التدفقات الثلاثة جميعها. سيتم إعادة توجيه تدفق In إلى ملف باسم in.txt، وتدفق Out إلى ملف باسم out.txt، وتدفق Error إلى ملف باسم error.txt. يتم تنفيذ إعادة التوجيه هذه على سطر الأوامر كما يلي
يؤدي التنفيذ إلى النتائج التالية:
dos>more in.txt
un second test
dos>es2.exe 0<in.txt 1>out.txt 2>error.txt
dos>more out.txt
écriture dans flux Out : un second test
dos>more error.txt
écriture dans flux Error : un second test
من الواضح أن تدفقات Out و Error لا تكتب إلى نفس الأجهزة.
2.3.5. تعيين قيمة تعبير إلى متغير
نحن مهتمون هنا بالعملية variable=expression. يمكن أن يكون التعبير من الأنواع التالية: حسابي، أو علائقي، أو منطقي، أو سلسلة.
2.3.5.1. قائمة العوامل
الإجراء | عنصر اللغة |
^، –، *، /، \، Mod، +، = | |
=, ^=, *=, /=, \=, +=, -=, &= | |
=، <>، <، >، <=، >=، Like، Is | |
&, + | |
Not، And، Or، Xor، AndAlso، OrElse | |
AddressOf، GetType |
2.3.5.2. التعبير الحسابي
المشغلات الخاصة بالتعبيرات الحسابية هي كما يلي:
^، –، *، /، \، Mod، +، = |
+: الجمع، -: الطرح، *: الضرب، /: القسمة العائمة، \: ناتج القسمة الصحيحة، Mod: باقي القسمة الصحيحة، ^: الأسي. وبالتالي، فإن البرنامج التالي:
' arithmetic operators
Module operateursarithmetiques
Sub Main()
Dim i, j As Integer
i = 4 : j = 3
Console.Out.WriteLine(i & "/" & j & "=" & (i / j))
Console.Out.WriteLine(i & "\" & j & "=" & (i \ j))
Console.Out.WriteLine(i & " mod " & j & "=" & (i Mod j))
Dim r1, r2 As Double
r1 = 4.1 : r2 = 3.6
Console.Out.WriteLine(r1 & "/" & r2 & "=" & (r1 / r2))
Console.Out.WriteLine(r1 & "^2=" & (r1 ^ 2))
Console.Out.WriteLine(Math.Cos(3))
End Sub
End Module
يعطي النتائج التالية:
هناك العديد من الدوال الرياضية. فيما يلي بعض منها:
| الجذر التربيعي |
| جيب التمام |
| جيب |
| الظل |
| x أس y (x > 0) |
| أسي |
| اللوغاريتم الطبيعي |
| القيمة المطلقة |
جميع هذه الدوال محددة في فئة .NET تسمى Math. عند استخدامها، يجب أن تسبقها باسم الفئة التي تم تعريفها فيها. وبالتالي، ستكتب:
التعريف الكامل لفئة Math هو كما يلي:
يمثل اللوغاريتم الطبيعي الذي تحدد قاعدته الثابتة e. | ||||
يمثل نسبة محيط الدائرة إلى قطرها، ويُحدد بالثابت π. | ||||
مُثقل. يُرجع القيمة المطلقة لعدد محدد. | ||||
تُرجع الزاوية التي يكون جيبها هو الرقم المحدد. | ||||
تُرجع الزاوية التي يكون جيبها هو الرقم المحدد. | ||||
تُرجع الزاوية التي يكون ظلها هو الرقم المحدد. | ||||
تُرجع الزاوية التي يكون ظلها هو حاصل قسمة عددين محددين. | ||||
يُنشئ حاصل ضرب عددين صحيحين من 32 بت. | ||||
يعيد أصغر عدد صحيح أكبر من أو يساوي العدد المحدد. | ||||
تُرجع جيب التمام للزاوية المحددة. | ||||
تُرجع جيب التمام الزائدي للزاوية المحددة. | ||||
مُثبَّت. تُرجع ناتج القسمة بين عددين، مع تمرير الباقي كمعلمة إخراج. | ||||
تُرجع e مرفوعة إلى القوة المحددة. | ||||
تُرجع أكبر عدد صحيح أقل من أو يساوي الرقم المحدد. | ||||
تُرجع باقي قسمة عدد على عدد آخر. | ||||
مُثقل. يُرجع لوغاريتم عدد محدد. | ||||
تُرجع لوغاريتم عدد محدد بأساس 10. | ||||
مُثقل. يُرجع الأكبر من بين رقمين محددين. | ||||
مُثبَّت. يُرجع الأصغر من رقمين. | ||||
تُرجع الرقم المحدد مرفوعًا إلى القوة المحددة. | ||||
مُثقل. يُرجع الرقم الأقرب إلى القيمة المحددة. | ||||
محملة. تُرجع قيمة تشير إلى إشارة الرقم. | ||||
تُرجع جيب الزاوية المحددة. | ||||
تُرجع الجيب الزائدي للزاوية المحددة. | ||||
تُرجع الجذر التربيعي لعدد محدد. | ||||
تُرجع ظل الزاوية المحددة. | ||||
تُرجع الظل الزائدي للزاوية المحددة. | ||||
عندما يتم إعلان دالة على أنها "محملة بشكل زائد"، فهذا يعني أنها موجودة لأنواع مختلفة من المعلمات. على سبيل المثال، الدالة Abs(x) موجودة لـ x من النوع Integer و Long و Decimal و Single و Float. لكل نوع من هذه الأنواع، يوجد تعريف منفصل للدالة Abs. وعندئذ يُقال إنها محملة بشكل زائد.
2.3.5.3. المُشغِّلات في تقييم التعبيرات الحسابية
أولوية العوامل عند تقييم تعبير حسابي هي كما يلي (من الأعلى إلى الأدنى):
الفئة | المُشغِّلات |
جميع التعبيرات التي لا تحتوي على عوامل: الدوال، الأقواس | |
^ | |
+، - | |
*, / | |
\ | |
Mod | |
+، - |
2.3.5.4. التعبيرات العلائقية
المعاملات هي كما يلي:
=، <>، <، >، <=، >=، Like، Is |
=: يساوي، <>: لا يساوي، <: أقل من (بشكل صارم)، >: أكبر من (بشكل صارم)، <=: أقل من أو يساوي، >=: أكبر من أو يساوي، Like: يطابق نمطًا، Is: هوية الكائن. تتمتع جميع هذه العوامل بنفس الأسبقية. ويتم تقييمها من اليسار إلى اليمين. تكون نتيجة التعبير العلائقي قيمة منطقية.
مقارنة السلاسل: انظر البرنامج التالي:
' namespaces
Imports System
Module string1
Sub main()
Dim ch1 As Char = "A"c
Dim ch2 As Char = "B"c
Dim ch3 As Char = "a"c
Console.Out.WriteLine("A<B=" & (ch1 < ch2))
Console.Out.WriteLine("A<a=" & (ch1 < ch3))
Dim chat As String = "chat"
Dim chien As String = "chien"
Dim chaton As String = "chaton"
Dim chat2 As String = "CHAT"
Console.Out.WriteLine("chat<chien=" & (chat < chien))
Console.Out.WriteLine("chat<chaton=" & (chat < chaton))
Console.Out.WriteLine("chat<CHAT=" & (chat < chat2))
Console.Out.WriteLine("chaton like chat*=" & ("chaton" Like "chat*"))
End Sub
End Module
ونتيجة تنفيذها:
لنفترض وجود حرفين C1 و C2. يمكن مقارنتهما باستخدام العوامل: <, <=, =, <>, >, >=. يتم مقارنة قيمهما في Unicode — وهي أرقام. وفقًا لترتيب Unicode، تنطبق العلاقات التالية:
مسافة < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z'
تُقارن السلاسل حرفًا حرفًا. أول عدم تساوي يُلاحظ بين حرفين يعني عدم تساوي السلاسل بنفس الإشارة. مع هذه التفسيرات، ندعو القارئ إلى فحص نتائج البرنامج السابق.
2.3.5.5. التعبيرات المنطقية
المعاملات هي كما يلي:
Not، And، Or، Xor، AndAlso، OrElse |
Not: "و" المنطقية، Or: "أو" المنطقية، Not: النفي، Xor: "أو الحصري".
op1 AndAlso op2: إذا كان op1 خطأً، لا يتم تقييم op2 وتكون النتيجة خطأً.
op1 OrElse op2: إذا كان op1 صحيحًا، لا يتم تقييم op2 وتكون النتيجة صحيحة.
أولوية هذه العوامل بالنسبة لبعضها البعض هي كما يلي:
المنطقية NOT | |
و، و"أيضًا" | |
أو، أو غير ذلك | |
XOR |
نتيجة التعبير المنطقي هي قيمة منطقية.
2.3.5.6. العمليات على البتات
من ناحية، نجد نفس العوامل مثل العوامل المنطقية بنفس الأسبقية. كما نجد عاملين للإزاحة: << و >>. لنفترض أن i و j عددان صحيحان.
يحول i بمقدار n بتات إلى اليسار. البتات الواردة هي أصفار. | |
يحول i n بتات إلى اليمين. إذا كان i عددًا صحيحًا موقّعًا (signed char، int، long)، يتم الحفاظ على بت الإشارة. | |
يقوم بإجراء عملية AND المنطقية بتية لـ i و j. | |
تقوم بإجراء عملية OR بتية على i و j. | |
يعكس i إلى 1 | |
يُجري عملية XOR بين i و j |
لننظر إلى البرنامج التالي:
Module operationsbit
Sub main()
' bit manipulation
Dim i As Short = &H123F
Dim k As Short = &H7123
Console.Out.WriteLine("i<<4=" & (i << 4).ToString("X"))
Console.Out.WriteLine("i>>4=" & (i >> 4).ToString("X"))
Console.Out.WriteLine("k>>4=" & (k >> 4).ToString("X"))
Console.Out.WriteLine("i and 4=" & (i And 4).ToString("X"))
Console.Out.WriteLine("i or 4 =" & (i Or 4).ToString("X"))
Console.Out.WriteLine("not i=" & (Not i).ToString("X"))
End Sub
End Module
يؤدي تنفيذ هذا البرنامج إلى النتائج التالية:
2.3.5.7. المُشغِّل المرتبط بالتعيين
من الممكن كتابة a+=b، مما يعني a=a+b. قائمة العوامل التي يمكن دمجها مع عملية التعيين هي كما يلي:
^=، *=، /=، \=، +=، -=، &= |
2.3.5.8. أولوية العمليات الحسابية العامة
الفئة | المُشغِّلات |
جميع التعبيرات بدون عوامل | |
^ | |
+، - | |
*، / | |
\ | |
Mod | |
+، - | |
& | |
<<، >> | |
=، <>، <، >، <=، >=، Like، Is، TypeOf...Is | |
ليس | |
و، و أيضًا | |
أو، أو غير ذلك | |
XOR |
عندما يتم وضع معامل بين عاملين لهما نفس الأسبقية، فإن ترابطية العوامل تحدد الترتيب الذي يتم فيه تنفيذ العمليات. جميع العوامل مترابطة من اليسار، مما يعني أن العمليات يتم تنفيذها من اليسار إلى اليمين. يمكن التحكم في الأسبقية والترابطية باستخدام التعبيرات الموضوعة بين قوسين.
2.3.5.9. تحويلات الأنواع
هناك عدد من الدوال المحددة مسبقًا التي تسمح لك بالتحويل من نوع بيانات إلى آخر. القائمة هي كما يلي:
تقبل هذه الوظائف تعبيرًا رقميًا أو سلسلة أحرف كحجة. ويظهر نوع النتيجة في الجدول التالي:
الدالة | النتيجة | نطاق قيمة معلمة الدالة |
منطقية | أي سلسلة أو تعبير رقمي صالح. | |
بايت | من 0 إلى 255؛ يتم تقريب الكسور. | |
Char | أي تعبير String صالح؛ يمكن أن تتراوح القيمة من 0 إلى 65,535. | |
تاريخ | أي تمثيل صالح للتاريخ والوقت. | |
Double | -1.79769313486231E+308 إلى -4.94065645841247E-324 للقيم السالبة؛ من 4.94065645841247E-324 إلى 1.79769313486231E+308 للقيم الموجبة. | |
عشري | +/-79,228,162,514,264,337,593,543,950,335 للأرقام غير العشرية. نطاق القيم للأرقام ذات 28 رقمًا عشريًا هو +/-7.9228162514264337593543950335. أصغر عدد غير صفر هو 0.0000000000000000000000000001. | |
عدد صحيح | من -2,147,483,648 إلى 2,147,483,647؛ يتم تقريب الكسور. | |
طويل | من -9,223,372,036,854,775,808 إلى 9,223,372,036,854,775,807؛ يتم تقريب الكسور. | |
كائن | أي تعبير صحيح. | |
قصير | من -32,768 إلى 32,767؛ يتم تقريب الكسور. | |
مفرد | -3.402823E+38 إلى -1.401298E-45 للقيم السالبة؛ 1.401298E-45 إلى 3.402823E+38 للقيم الموجبة. | |
سلسلة | تعتمد القيم التي ترجعها الدالة Cstr على وسيطة التعبير. |
فيما يلي مثال على برنامج:
Module conversion
Sub main()
Dim var1 As Boolean = CBool("true")
Dim var2 As Byte = CByte("100")
Dim var3 As Char = CChar("A")
Dim var4 As Date = CDate("30 janvier 2004")
Dim var5 As Double = CDbl("100,45")
Dim var6 As Decimal = CDec("1000,67")
Dim var7 As Integer = CInt("-30")
Dim var8 As Long = CLng("456")
Dim var9 As Short = CShort("-14")
Dim var10 As Single = CSng("56,78")
Console.Out.WriteLine("var1=" & var1)
Console.Out.WriteLine("var2=" & var2)
Console.Out.WriteLine("var3=" & var3)
Console.Out.WriteLine("var4=" & var4)
Console.Out.WriteLine("var5=" & var5)
Console.Out.WriteLine("var6=" & var6)
Console.Out.WriteLine("var7=" & var7)
Console.Out.WriteLine("var8=" & var8)
Console.Out.WriteLine("var9=" & var9)
Console.Out.WriteLine("var10=" & var10)
End Sub
End Module
ونتيجة تنفيذها:
var1=True
var2=100
var3=A
var4=30/01/2004
var5=100,45
var6=1000,67
var7=-30
var8=456
var9=-14
var10=56,78
يمكنك أيضًا استخدام الدالة CType(expression, type)، كما هو موضح في البرنامج التالي:
Module ctype1
Sub main()
Dim var1 As Boolean = CType("true", Boolean)
Dim var2 As Byte = CType("100", Byte)
Dim var3 As Char = CType("A", Char)
Dim var4 As Date = CType("30 janvier 2004", Date)
Dim var5 As Double = CType("100,45", Double)
Dim var6 As Decimal = CType("1000,67", Decimal)
Dim var7 As Integer = CType("-30", Integer)
Dim var8 As Long = CType("456", Long)
Dim var9 As Short = CType("-14", Short)
Dim var10 As Single = CType("56,78", Single)
Dim var11 As String = CType("47,89", String)
Dim var12 As String = 47.89.ToString
Dim var13 As String = "" & 47.89
Console.Out.WriteLine("var1=" & var1)
Console.Out.WriteLine("var2=" & var2)
Console.Out.WriteLine("var3=" & var3)
Console.Out.WriteLine("var4=" & var4)
Console.Out.WriteLine("var5=" & var5)
Console.Out.WriteLine("var6=" & var6)
Console.Out.WriteLine("var7=" & var7)
Console.Out.WriteLine("var8=" & var8)
Console.Out.WriteLine("var9=" & var9)
Console.Out.WriteLine("var10=" & var10)
Console.Out.WriteLine("var11=" & var11)
Console.Out.WriteLine("var12=" & var12)
Console.Out.WriteLine("var13=" & var13)
End Sub
End Module
مما ينتج عنه النتائج التالية:
var1=True
var2=100
var3=A
var4=30/01/2004
var5=100,45
var6=1000,67
var7=-30
var8=456
var9=-14
var10=56,78
var11=47,89
var12=47,89
var13=47,89
2.4. تعليمات للتحكم في تنفيذ البرنامج
2.4.1. إيقاف
تسمح لك طريقة Exit المحددة في فئة Environment بإيقاف تنفيذ البرنامج:
[Visual Basic]
Public Shared Sub Exit(ByVal exitCode As Integer )
توقف العملية الحالية وتُرجع قيمة exitCode إلى العملية الأم. يمكن للعملية الأم استخدام قيمة exitCode. في نظام DOS، تُرجع هذه المتغير الحالة إلى DOS في المتغير النظامي ERRORLEVEL، والذي يمكن التحقق من قيمته في ملف دفعي. في نظام Unix، يسترد المتغير $? قيمة exitCode.
سينهي البرنامج بحالة خروج تساوي 0.
2.4.2. هيكل قرار بسيط
- يكون كل إجراء في سطر منفصل
- يمكن حذف جملة else.
يمكنك تداخل هياكل القرار كما هو موضح في المثال التالي:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
Module if1
Sub main()
Dim i As Integer = 10
If i > 4 Then
Console.Out.WriteLine(i & " est > " & 4)
Else
If i = 4 Then
Console.Out.WriteLine(i & " est = " & 4)
Else
Console.Out.WriteLine(i & " est < " & 4)
End If
End If
End Sub
End Module
النتيجة التي تم الحصول عليها:
2.4.3. هيكل الحالة
الصيغة هي كما يلي:
select case expression
case liste_valeurs1
actions1
case liste_valeurs2
actions2
...
case else
actions_sinon
end select
- يجب أن يكون نوع [التعبير] أحد الأنواع التالية:
- يمكن حذف جملة [case else].
- [list_of_values] هي القيم المحتملة للتعبير. [lists_of_values] تمثل قائمة بالشروط condition1، condition2، ...، conditionx. إذا استوفى [expression] أحد الشروط، يتم تنفيذ الإجراءات التي تلي جملة [list_of_values]. يمكن أن تتخذ الشروط الشكل التالي:
- val1 إلى val2: صحيح إذا كان [expression] ينتمي إلى النطاق [val1,val2]
- val1: صحيح إذا كان [التعبير] يساوي val1
- is > val1: صحيح إذا كان [التعبير] > val1. يمكن حذف الكلمة الرئيسية [is]
- وينطبق الأمر نفسه على العوامل =، <، <=، >، >=، <>
- يتم تنفيذ الإجراءات المرتبطة بالشرط الأول الذي تم التحقق منه فقط.
لننظر إلى البرنامج التالي:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
Module selectcase1
Sub main()
Dim i As Integer = 10
Select Case i
Case 1 To 4, 7 To 8
Console.Out.WriteLine("i est dans l'intervalle [1,4] ou [7,8]")
Case Is > 12
Console.Out.WriteLine("i est > 12")
Case Is < 15
Console.Out.WriteLine("i est < 15")
Case Is < 20
Console.Out.WriteLine("i est < 20")
End Select
End Sub
End Module
وينتج عن ذلك النتائج التالية:
2.4.4. بنية الحلقة
2.4.4.1. عدد التكرارات المعروف
For counter [ As datatype ] = start To end [ Step step ]
actions
Next [ counter ]
يتم تنفيذ الإجراءات لكل قيمة تأخذها المتغير [العداد]. انظر البرنامج التالي:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
Module for1
Sub main()
Dim somme As Integer = 0
Dim résultat As String = "somme("
For i As Integer = 0 To 10 Step 2
somme += i
résultat += " " + i.ToString
Next
résultat += ")=" + somme.ToString
Console.Out.WriteLine(résultat)
End Sub
End Module
النتائج:
فيما يلي بنية تكرارية أخرى ذات عدد معروف من التكرارات:
For Each element [ As datatype ] In groupe
[ actions ]
Next [ element ]
- المجموعة هي مجموعة من الكائنات. والمجموعة التي نعرفها بالفعل هي المصفوفة
- نوع البيانات هو نوع الكائنات الموجودة في المجموعة. بالنسبة للمصفوفة، سيكون هذا هو نوع عناصر المصفوفة
- العنصر هو متغير محلي للحلقة سيتخذ تباعًا قيم المجموعة.
وبالتالي، فإن الكود التالي:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
Module foreach1
Sub main()
Dim amis() As String = {"paul", "hélène", "jacques", "sylvie"}
For Each nom As String In amis
Console.Out.WriteLine(nom)
Next
End Sub
End Module
سيعرض:
2.4.4.2. عدد التكرارات غير معروف
هناك العديد من البنى في VB.NET لهذه الحالة.
Do { While | Until } condition
[ statements ]
Loop
تستمر الحلقة طالما أن الشرط صحيح (while) أو حتى يصبح الشرط صحيحًا (until). قد لا يتم تنفيذ الحلقة أبدًا.
Do
[ statements ]
Loop { While | Until } condition
تستمر الحلقة طالما كان الشرط صحيحًا (while) أو حتى يصبح الشرط صحيحًا (until). يتم تنفيذ الحلقة دائمًا مرة واحدة على الأقل.
While condition
[ statements ]
End While
تستمر الحلقة طالما أن الشرط صحيح. قد لا يتم تنفيذ الحلقة أبدًا. تحسب جميع الحلقات التالية مجموع أول 10 أعداد صحيحة.
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
Module boucles1
Sub main()
Dim i, somme As Integer
i = 0 : somme = 0
Do While i < 11
somme += i
i += 1
Loop
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do Until i = 11
somme += i
i += 1
Loop
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do
somme += i
i += 1
Loop Until i = 11
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do
somme += i
i += 1
Loop While i < 11
Console.Out.WriteLine("somme=" + somme.ToString)
End Sub
End Module
2.4.4.3. عبارات التحكم في الحلقات
يخرج من حلقة do...loop | |
يخرج من حلقة for |
2.5. هيكل برنامج VB.NET
قد يكون لبرنامج VB.NET الذي لا يستخدم فئات أو دوال محددة من قبل المستخدم بخلاف الدالة الرئيسية Main الهيكل التالي:
' options
Option Explicit On
Option Strict On
' namespaces
Imports espace1
Imports ....
Module nomDuModule
Sub main()
....
End Sub
End Module
- تفرض التوجيهية [Option Explicit on] إعلان المتغيرات. في VB.NET، هذا ليس إلزامياً. يكون المتغير غير المعلن عندئذٍ من النوع Object.
- يحظر التوجيه [Option Strict on] أي تحويلات لأنواع البيانات التي قد تؤدي إلى فقدان البيانات وأي تحويلات بين الأنواع الرقمية والسلاسل. لذلك يجب استخدام وظائف التحويل بشكل صريح.
- يستورد البرنامج جميع مساحات الأسماء التي يحتاجها. لم نقدم هذا المفهوم بعد. في البرامج السابقة، كنا نواجه غالبًا عبارات مثل:
كان ينبغي علينا في الواقع أن نكتب:
حيث System هو مساحة الاسم التي تحتوي على فئة [Console]. من خلال استيراد مساحة الاسم [System] باستخدام عبارة Imports، سيقوم VB.NET بالبحث فيها بشكل منهجي كلما صادف فئة لا يتعرف عليها. وسيكرر البحث عبر جميع مساحات الأسماء المعلنة حتى يعثر على الفئة المعنية. لذلك نكتب:
' namespaces
Imports System
....
Console.Out.WriteLine(unechaine)
قد يبدو البرنامج النموذجي كما يلي:
' options
Option Explicit On
Option Strict On
'namespaces
Imports System
' main module
Module main1
Sub main()
Console.Out.WriteLine("main1")
End Sub
End Module
يمكن كتابة البرنامج نفسه على النحو التالي:
' options
Option Explicit On
Option Strict On
'namespaces
Imports System
' test class
Public Class main2
Public Shared Sub main()
Console.Out.WriteLine("main2")
End Sub
End Class
هنا، نستخدم مفهوم الفئة، الذي سيتم تقديمه في الفصل التالي. عندما تحتوي هذه الفئة على إجراء ثابت (مشترك) باسم main، يتم تنفيذه. ندرج هذا الرمز هنا لأن C#، اللغة الشقيقة لـ VB.NET، لا تعترف إلا بمفهوم الفئات—أي أن كل الرموز المنفذة يجب أن تنتمي إلى فئة. مفهوم الفئات هو جزء من البرمجة الموجهة للكائنات. وفرضه على تصميم كل برنامج أمر غير ملائم إلى حد ما. ونرى ذلك هنا في الإصدار 2 من البرنامج السابق، حيث نضطر إلى إدخال مفاهيم الفئات والأساليب الثابتة في أماكن لا تحتاج إليها. لذلك، من الآن فصاعدًا، لن نقدم مفهوم الفئة إلا عند الضرورة. وفي الحالات الأخرى، سنستخدم مفهوم الوحدة النمطية، كما في الإصدار 1 أعلاه.
2.6. ترجمة وتشغيل برنامج VB.NET
لا يتطلب ترجمة برنامج VB.NET سوى .NET SDK. انظر إلى البرنامج التالي:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
Module boucles1
Sub main()
Dim i, somme As Integer
i = 0 : somme = 0
Do While i < 11
somme += i
i += 1
Loop
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do Until i = 11
somme += i
i += 1
Loop
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do
somme += i
i += 1
Loop Until i = 11
Console.Out.WriteLine("somme=" + somme.ToString)
i = 0 : somme = 0
Do
somme += i
i += 1
Loop While i < 11
Console.Out.WriteLine("somme=" + somme.ToString)
End Sub
End Module
لنفترض أنه موجود في ملف يسمى [loops1.vb]. لتجميعه، نتبع الخطوات التالية:
dos>dir boucles1.vb
11/03/2004 15:55 583 boucles1.vb
dos>vbc boucles1.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4
pour Microsoft (R) .NET Framework version 1.1.4322.573
Copyright (C) Microsoft Corporation 1987-2002. Tous droits réservés.
dos>dir boucles1.*
11/03/2004 16:04 601 boucles1.vb
11/03/2004 16:04 3 584 boucles1.exe
برنامج vbc.exe هو مترجم VB.NET. هنا، كان موجودًا في مسار DOS:
dos>path
PATH=E:\Program Files\Microsoft Visual Studio .NET 2003\Common7\IDE;E:\Program Files\Microsoft Visual Studio .NET 2003\VC7\BIN;E:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools;E:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\bin\prerelease;E:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\bin;E:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\bin;E:\WINNT\Microsoft.NET\Framework\v1.1.4322;e:\winnt\system32;e:\winnt;
dos>dir E:\WINNT\Microsoft.NET\Framework\v1.1.4322\vbc.exe
21/02/2003 10:20 737 280 vbc.exe
ينتج المُجمِّع [vbc] ملف .exe يمكن تنفيذه بواسطة الآلة الافتراضية .NET:
2.7. مثال على حساب الضريبة
نقترح كتابة برنامج لحساب ضريبة دافع الضرائب. نأخذ في الاعتبار الحالة المبسطة لدافع الضرائب الذي لا يبلغ سوى عن راتبه:
- نحسب عدد شرائح الضريبة للموظف على النحو التالي: nbParts = nbEnfants / 2 + 1 إذا كان غير متزوج، و nbEnfants / 2 + 2 إذا كان متزوجًا، حيث nbEnfants هو عدد الأطفال.
- إذا كان لديه ثلاثة أطفال على الأقل، يحصل على نصف حصة إضافية
- نحسب دخله الخاضع للضريبة R = 0.72 * S، حيث S هو راتبه السنوي
- نحسب معامل الأسرة QF = R / nbParts
- نحسب ضريبته I. انظر الجدول التالي:
12620.0 | 0 | 0 |
13,190 | 0.05 | 631 |
15,640 | 0.1 | 1,290.5 |
24,740 | 0.15 | 2,072.5 |
31,810 | 0.2 | 3,309.5 |
39,970 | 0.25 | 4900 |
48,360 | 0.3 | 6,898.5 |
55,790 | 0.35 | 9,316.5 |
92,970 | 0.4 | 12,106 |
127,860 | 0.45 | 16,754.5 |
151,250 | 0.50 | 23,147.5 |
172,040 | 0.55 | 30,710 |
195,000 | 0.60 | 39,312 |
0 | 0.65 | 49062 |
يحتوي كل صف على 3 حقول. لحساب الضريبة I، ابحث عن أول صف حيث QF <= الحقل 1. على سبيل المثال، إذا كان QF = 23,000، فسيكون الصف الذي تم العثور عليه هو
الضريبة I تساوي إذن 0.15*R - 2072.5*nbParts. إذا كان QF بحيث لا تتحقق الشرط QF<=field1 أبدًا، يتم استخدام المعاملات من الصف الأخير. هنا:
مما يعطي الضريبة I = 0.65*R - 49062*nbParts. برنامج VB.NET المقابل هو كما يلي:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
Module impots
' ------------ hand
Sub Main()
' data tables required for tax calculation
Dim Limites() As Decimal = {12620D, 13190D, 15640D, 24740D, 31810D, 39970D, 48360D, 55790D, 92970D, 127860D, 151250D, 172040D, 195000D, 0D}
Dim CoeffN() As Decimal = {0D, 631D, 1290.5D, 2072.5D, 3309.5D, 4900D, 6898.5D, 9316.5D, 12106D, 16754.5D, 23147.5D, 30710D, 39312D, 49062D}
' we recover marital status
Dim OK As Boolean = False
Dim reponse As String = Nothing
While Not OK
Console.Out.Write("Etes-vous marié(e) (O/N) ? ")
reponse = Console.In.ReadLine().Trim().ToLower()
If reponse <> "o" And reponse <> "n" Then
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
Else
OK = True
End If
End While
Dim Marie As Boolean = reponse = "o"
' number of children
OK = False
Dim NbEnfants As Integer = 0
While Not OK
Console.Out.Write("Nombre d'enfants : ")
reponse = Console.In.ReadLine()
Try
NbEnfants = Integer.Parse(reponse)
If NbEnfants >= 0 Then
OK = True
Else
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
End If
Catch
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
End Try
End While
' salary
OK = False
Dim Salaire As Integer = 0
While Not OK
Console.Out.Write("Salaire annuel : ")
reponse = Console.In.ReadLine()
Try
Salaire = Integer.Parse(reponse)
If Salaire >= 0 Then
OK = True
Else
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
End If
Catch
Console.Error.WriteLine("Réponse incorrecte. Recommencez")
End Try
End While
' calculating the number of shares
Dim NbParts As Decimal
If Marie Then
NbParts = CDec(NbEnfants) / 2 + 2
Else
NbParts = CDec(NbEnfants) / 2 + 1
End If
If NbEnfants >= 3 Then
NbParts += 0.5D
End If
' taxable income
Dim Revenu As Decimal
Revenu = 0.72D * Salaire
' family quotient
Dim QF As Decimal
QF = Revenu / NbParts
' search for tax bracket corresponding to QF
Dim i As Integer
Dim NbTranches As Integer = Limites.Length
Limites((NbTranches - 1)) = QF
i = 0
While QF > Limites(i)
i += 1
End While
' tax
Dim impots As Integer = CInt(i * 0.05D * Revenu - CoeffN(i) * NbParts)
' the result is displayed
Console.Out.WriteLine(("Impôt à payer : " & impots))
End Sub
End Module
يتم ترجمة البرنامج في نافذة DOS باستخدام:
dos>vbc impots1.vb
Compilateur Microsoft (R) Visual Basic .NET version 7.10.3052.4 pour Microsoft (R) .NET Framework version 1.1.4322.573
dos>dir impots1.exe
24/02/2004 15:42 5 632 impots1.exe
ينتج عن التجميع ملف قابل للتنفيذ باسم impots.exe. لاحظ أن impots.exe لا يمكن تنفيذه مباشرة بواسطة المعالج. فهو يحتوي في الواقع على كود وسيط لا يمكن تنفيذه إلا على منصة .NET. النتائج التي تم الحصول عليها هي كما يلي:
dos>impots1
Etes-vous marié(e) (O/N) ? o
Nombre d'enfants : 3
Salaire annuel : 200000
Impôt à payer : 16400
dos>impots1
Etes-vous marié(e) (O/N) ? n
Nombre d'enfants : 2
Salaire annuel : 200000
Impôt à payer : 33388
dos>impots1
Etes-vous marié(e) (O/N) ? w
Réponse incorrecte. Recommencez
Etes-vous marié(e) (O/N) ? q
Réponse incorrecte. Recommencez
Etes-vous marié(e) (O/N) ? o
Nombre d'enfants : q
Réponse incorrecte. Recommencez
Nombre d'enfants : 2
Salaire annuel : q
Réponse incorrecte. Recommencez
Salaire annuel : 1
Impôt à payer : 0
2.8. أهم حجج البرنامج
يمكن أن تقبل الدالة الرئيسية Main مصفوفة من السلاسل كمعلمة:
Sub main(ByVal args() As String)
المعلمة args هي مصفوفة من السلاسل التي تستقبل الحجج التي تم تمريرها على سطر الأوامر عند استدعاء البرنامج.
- args.Length هو عدد العناصر في مصفوفة args
- args(i) هو العنصر i من المصفوفة
إذا قمنا بتشغيل البرنامج P باستخدام الأمر: P arg0 arg1 … argn وإذا تم تعريف الإجراء Main للبرنامج P على النحو التالي:
Sub main(ByVal args() As String)
فسيكون لدينا arg(0)="arg0"، arg(1)="arg1" … وإليك مثال على ذلك:
' guidelines
Option Strict On
Option Explicit On
' namespaces
Imports System
Module arg
Sub main(ByVal args() As String)
' number of arguments
console.out.writeline("Il y a " & args.length & " arguments")
Dim i As Integer
For i = 0 To args.Length - 1
Console.Out.WriteLine("argument n° " & i & "=" & args(i))
Next
End Sub
End Module
ينتج عن التنفيذ النتائج التالية:
2.9. التعدادات
التعداد هو نوع بيانات يكون مجال قيمته مجموعة من الثوابت الصحيحة. لنفترض أن هناك برنامجًا يحتاج إلى معالجة درجات الامتحانات. ستكون هناك خمس درجات: مقبول، مقبول، جيد، جيد جدًا، ممتاز. يمكننا عندئذٍ تعريف تعداد لهذه الثوابت الخمس:
Enum mention
Passable
AssezBien
Bien
TrésBien
Excellent
End Enum
داخليًا، يتم تمثيل هذه الثوابت الخمس بأعداد صحيحة متتالية تبدأ بـ 0 للثابت الأول، و 1 للثابت التالي، وهكذا. يمكن تعريف متغير ليتخذ هذه القيم في التعداد:
' a variable that takes its values from the enumeration mentioned
Dim maMention As mention = mention.Passable
يمكن مقارنة المتغير بالقيم المختلفة الممكنة للتعداد:
' test avec valeur de l'énumération
If (maMention = mention.Passable) Then
Console.Out.WriteLine("Peut mieux faire")
End If
يمكنك استرداد جميع قيم التعداد:
For Each m In mention.GetValues(maMention.GetType)
Console.Out.WriteLine(m)
Next
تمامًا كما أن النوع البسيط Integer يعادل البنية Int32، فإن النوع البسيط Enum يعادل البنية Enum. تحتوي هذه الفئة على طريقة GetValues ثابتة تسمح لك باسترداد جميع قيم نوع معدد تم تمريره كمعلمة. يجب أن تكون هذه المعلمة كائنًا من النوع Type، وهو فئة توفر معلومات حول نوع البيانات. يتم الحصول على نوع المتغير v عبر v.GetType(). لذا هنا، تُرجع maMention.GetType() كائن Type لتعداد mentions، وتُرجع Enum.GetValues(maMention.GetType()) قائمة القيم لتعداد mentions.
وهذا ما يوضحه البرنامج التالي:
' guidelines
Option Strict On
Option Explicit On
' namespaces
Imports System
Public Module enum2
' an enumeration
Enum mention
Passable
AssezBien
Bien
TrèsBien
Excellent
End Enum
' test pg
Sub Main()
' a variable that takes its values from the enumeration mentioned
Dim maMention As mention = mention.Passable
' variable value display
Console.Out.WriteLine("mention=" & maMention)
' test with enumeration value
If (maMention = mention.Passable) Then
Console.Out.WriteLine("Peut mieux faire")
End If
' list of literal mentions
For Each m As mention In [Enum].GetValues(maMention.GetType)
Console.Out.WriteLine(m.ToString)
Next
' list of full mentions
For Each m As Integer In [Enum].GetValues(maMention.GetType)
Console.Out.WriteLine(m)
Next
End Sub
End Module
نتائج التنفيذ هي كما يلي:
2.10. معالجة الاستثناءات
العديد من وظائف VB.NET قادرة على توليد استثناءات، أي أخطاء. عندما تكون الوظيفة قادرة على توليد استثناء، يجب على المبرمج معالجته من أجل إنشاء برامج أكثر مرونة في التعامل مع الأخطاء: يجب عليك دائمًا تجنب "تعطل" التطبيق بشكل غير متوقع.
تتبع معالجة الاستثناءات هذا النمط:
try
appel de la fonction susceptible de générer l'exception
catch e as Exception e)
traiter l'exception e
end try
instruction suivante
إذا لم ترمي الدالة استثناءً، ينتقل البرنامج إلى الجملة التالية؛ وإلا، فإنه يدخل إلى نص جملة catch ثم ينتقل إلى الجملة التالية. لاحظ النقاط التالية:
- e هو كائن مشتق من نوع Exception. يمكننا أن نكون أكثر تحديدًا باستخدام أنواع مثل IOException و SystemException وما إلى ذلك: فهناك عدة أنواع من الاستثناءات. بكتابة catch e كـ Exception، نشير إلى أننا نريد معالجة جميع أنواع الاستثناءات. إذا كان من المحتمل أن يولد الكود الموجود في كتلة try أنواعًا متعددة من الاستثناءات، فقد نرغب في أن نكون أكثر تحديدًا من خلال معالجة الاستثناء باستخدام كتل catch متعددة:
try
appel de la fonction susceptible de générer l'exception
catch e as IOException
traiter l'exception e
catch e as SystemException
traiter l'exception e
end try
instruction suivante
- يمكنك إضافة جملة finally إلى كتل try/catch:
try
appel de la fonction susceptible de générer l'exception
catch e as Exception
traiter l'exception e
finally
code exécuté après try ou catch
end try
instruction suivante
سواء حدثت استثناء أم لا، سيتم دائمًا تنفيذ الكود الموجود في جملة finally.
- في جملة catch، قد لا ترغب في استخدام كائن Exception المتاح. بدلاً من كتابة catch e as Exception، تكتب catch.
- تحتوي فئة Exception على خاصية Message التي تحتوي على رسالة توضح تفاصيل الخطأ الذي حدث. لذا، إذا أردت عرض هذه الرسالة، فستكتب:
catch e as Exception
Console.Error.WriteLine("L'erreur suivante s'est produite : "+e.Message);
...
end try
- تحتوي فئة Exception على طريقة ToString التي تُرجع سلسلة تشير إلى نوع الاستثناء وقيمة الخاصية Message. وبالتالي يمكننا كتابة:
catch ex as Exception
Console.Error.WriteLine("L'erreur suivante s'est produite : "+ex.ToString)
...
end try
يوضح المثال التالي استثناءً تم إنشاؤه باستخدام عنصر مصفوفة غير موجود:
' options
Option Explicit On
Option Strict On
' namespaces
Imports System
Module tab1
Sub Main()
' declaring & initializing an array
Dim tab() As Integer = {0, 1, 2, 3}
Dim i As Integer
' table display with for
For i = 0 To tab.Length - 1
Console.Out.WriteLine(("tab[" & i & "]=" & tab(i)))
Next i
' table display with a for each
Dim élmt As Integer
For Each élmt In tab
Console.Out.WriteLine(élmt)
Next élmt
' generating an exception
Try
tab(100) = 6
Catch e As Exception
Console.Error.WriteLine(("L'erreur suivante s'est produite : " & e.Message))
End Try
End Sub
End Module
يؤدي تشغيل البرنامج إلى النتائج التالية:
dos>exception1
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
L'erreur suivante s'est produite : L'index se trouve en dehors des limites du tableau.
فيما يلي مثال آخر نتعامل فيه مع الاستثناء الناتج عن تعيين سلسلة أحرف إلى رقم عندما لا تمثل السلسلة رقمًا:
' options
Option Strict On
Option Explicit On
'imports
Imports System
Public Module console1
Public Sub Main()
' We ask for the name
System.Console.Write("Nom : ")
' reading response
Dim nom As String = System.Console.ReadLine()
' age requested
Dim age As Integer
Dim ageOK As Boolean = False
Do While Not ageOK
' question
Console.Out.Write("âge : ")
' reading-checking response
Try
age = Int32.Parse(System.Console.ReadLine())
If age < 0 Then Throw New Exception
ageOK = True
Catch
Console.Error.WriteLine("Age incorrect, recommencez...")
End Try
Loop
' final display
Console.Out.WriteLine("Vous vous appelez [" & nom & "] et vous avez [" & age & "] ans")
End Sub
End Module
بعض نتائج التنفيذ:
dos>console1
Nom : dupont
âge : xx
Age incorrect, recommencez...
âge : 12
Vous vous appelez dupont et vous avez 12 ans
2.11. تمرير المعلمات إلى دالة
نحن مهتمون هنا بكيفية تمرير المعلمات إلى الدالة. لنفكر في الدالة:
Sub changeInt(ByVal a As Integer)
a = 30
Console.Out.WriteLine(("Paramètre formel a=" & a))
End Sub
في تعريف الدالة، يُطلق على a اسم المعلمة الشكلية. وهي موجودة فقط لغرض تعريف الدالة changeInt. وكان من الممكن بسهولة تسميتها بـ b. والآن لننظر إلى مثال على استخدام هذه الدالة:
Sub Main()
Dim age As Integer = 20
changeInt(age)
Console.Out.WriteLine(("Paramètre effectif age=" & age))
End Sub
هنا، في عبارة changeInt(age)، age هي المعلمة الفعلية التي ستمرر قيمتها إلى المعلمة الشكلية a. نحن مهتمون بكيفية استرداد المعلمة الشكلية لقيمة المعلمة الفعلية المقابلة.
2.11.1. التمرير بالقيمة
يوضح المثال التالي أن معلمات الدالة/الإجراء يتم تمريرها بالقيمة بشكل افتراضي: أي أن قيمة المعلمة الفعلية يتم نسخها إلى المعلمة الشكلية المقابلة. وهما كيانان منفصلان. إذا قامت الدالة بتعديل المعلمة الشكلية، تظل المعلمة الفعلية دون تغيير.
' options
Option Explicit On
Option Strict On
' passing parameters by value to a function
Imports System
Module param1
Sub Main()
Dim age As Integer = 20
changeInt(age)
Console.Out.WriteLine(("Paramètre effectif age=" & age))
End Sub
Sub changeInt(ByVal a As Integer)
a = 30
Console.Out.WriteLine(("Paramètre formel a=" & a))
End Sub
End Module
النتائج هي كما يلي:
تم نسخ القيمة 20 الخاصة بالمعلمة الفعلية إلى المعلمة الشكلية a. ثم تم تعديل المعلمة الشكلية. أما المعلمة الفعلية فلم تتغير. وتعد طريقة التمرير هذه مناسبة لمعلمات الإدخال في الدالة.
2.11.2. التمرير بالمرجع
في التمرير بالمرجع، تكون المعلمة الفعلية والمعلمة الشكلية كيانًا واحدًا. إذا قامت الدالة بتعديل المعلمة الشكلية، يتم تعديل المعلمة الفعلية أيضًا. في VB.NET، يجب أن تسبق المعلمة الشكلية الكلمة الرئيسية ByRef. فيما يلي مثال على ذلك:
' options
Option Explicit On
Option Strict On
' passing parameters by value to a function
Imports System
Module param2
Sub Main()
Dim age As Integer = 20
changeInt(age)
Console.Out.WriteLine(("Paramètre effectif age=" & age))
End Sub
Sub changeInt(ByRef a As Integer)
a = 30
Console.Out.WriteLine(("Paramètre formel a=" & a))
End Sub
End Module
ونتيجة التنفيذ:
تبع المعلمة الفعلية التغيير في المعلمة الشكلية. طريقة التمرير هذه مناسبة لمعلمات الإخراج للدالة.