Visual Basic .NET

Материал из Национальной библиотеки им. Н. Э. Баумана
Последнее изменение этой страницы: 20:18, 1 июня 2016.
Visual Basic .NET
Visual Basic Express icon.png
Парадигма Объектно-ориентированный, Императивный, Структурный, Декларативный
Спроектировано Microsoft Corporation
Первый   появившийся 2001
Стабильная версия Visual Basic 2013 / 5 октября 2013
Печать дисциплины Динамическая типизация, Строгая типизация
Портал: Visual Basic .NET
Главная реализация
.NET Framework, Mono
Диалект
.NET, .NET 2003, 2005, 2008, 2010, 2012, 2013
Под влиянием
Visual Basic 6.0

Visual Basic .NET (VB.NET) — это объектно-ориентированный язык программирования, рассматриваемый как очередной виток эволюции Visual Basic (VB). Реализован на платформе Microsoft .NET. Нет обратной совместимости с более ранней версией (Visual Basic 6.0). Развитие проектов старых версий (*.vbp) возможно только после предварительной конвертации их в формат VB.NET специальным мастером (Migration Wizard), но после конвертации требуется ручная доработка текстов.

Изменения по сравнению с VB 6.0

Важнейшие изменения в VB.NET следующие.

  1. Поддержка концепций объектно-ориентированного программирования с конструкторами и деструкторами, наследованием, перекрытием методов (Overrides) и др. Есть даже переопределение знаков операций.
  2. Компиляция в байт-код (intermediate language, IL), исполняемый с помощью виртуальной машины common language runtime (CLR).
  3. Использование всего набора объектных библиотек, входящих в .NET Framework, включающих мощные средства по работе с формами (Windows Forms), базами данных (ADO.NET), графикой (GDI+), средствами обеспечения безопасности, веб-страницами (ASP.NET) и т. п.
  4. Поддержка свободной многопоточности.
  5. Поддержка структурной обработки исключений (structured exception handling, SEH).

С переходом на платформу .NET, изменилась сама парадигма программирования (и это наиболее важное изменение).

Программная структура

  • Группа Interface — прототипы классов, Implements — их реализация.
  • Аппарат Namespaces для предотвращения конфликтов имён.

Данные

  • Режим жёсткой проверки типов (Option Strict).
  • Новые или изменённые типы данных:
    • Char (беззнаковое слово, содержащее Unicode-символ).
    • String теперь всегда содержит двухбайтовые Unicode-символы.
    • Short (вместо прежнего Integer), 16 битов.(от -32768 до 32767)
    • Integer (вместо прежнего Long), 32 бита.(от -2147483648 до 2147483647)
    • Long (целое, 64 бита, от -9223372036854775808 до 9223372036854775807).
    • Их беззнаковые варианты:
      • UShort (от 0 до 65535),
      • UInteger (от 0 до 4294967295),
      • ULong (от 0 до 18446744073709551615).
    • Байт со знаком: SByte.
    • Decimal (96-битовое целое, масштабированное требуемой степенью 10), примерно до .
    • Структура данных Structure вместо Type, причём она, подобно классу, допускает методы.
    • Тип Variant переименован в Object. Типы Currency, String*длина упразднены.
  • При описании можно указать начальное значение.

Новые средства языка

  • Структурная обработка исключений: операторы Try/Catch/Finally/Throw, объект Exception.
  • Новые виды оператора присваивания: +=, -=, >>= и др.
  • С версии [2005] появился оператор Continue {For|Do|While} — новый оборот цикла.
  • Оператор Return возвращает значение для функций.
  • Операции сдвига для целых.
  • Новые логические операции AndAlso, OrElse — для них лишние вычисления операндов блокируются. Логические операции Eqv, Imp упразднены.

Типы данных и переменные

Все данные, используемые в Visual Basic.NET, описываются целой системой типов данных. Эта система определяет следующие примитивные типы данных:

  • Boolean: представляет логическое значение. Может принимать True или False. Представлен системным типом System.Boolean
  • Byte: представляет 8-ми битное число от 0 до 255 и занимает 1 байт. Представлен системным типом System.Byte
  • Short: представляет число от -32768 до 32767 и занимает 2 байта. Представлен системным типом System.Int16
  • Integer: представляет целое число от –2 147 483 648 до 2 147 483 647 и занимает 4 байта. Представлен системным типом System.Int32
  • Long: представляет целое число от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 и занимает 8 байт. Представлен системным типом System.Int64
  • SByte: представляет значение от -128 до 127 и занимает 1 байт. Представлен системным типом System.SByte
  • UShort: представляет целое число от 0 до 65 535 и занимает 2 байта. Представлен системным типом System.UInt16
  • UInteger: представляет целое число от 0 до 4 294 967 295 и занимает 4 байта. Представлен системным типом System.UInt32
  • ULong: представляет целое число от 0 до 18 446 744 073 709 551 615 и занимает 8 байт. Представлен системным типом System.UInt64
  • Single: представляет число с плавающей точкой и может принимать следующие значения: для отрицательных чисел от –3,4028235E+38 до –1,401298E–45; для положительных чисел от 1,401298E–45 до 3,4028235E+38. Представлен системным типом System.Single
  • Double: представляет числа с плавающей запятой двойной точности. Может принимать следующие значения: для отрицательных чисел от –1,79769313486231570E+308 до –4.94065645841246544E–324; для положительных чисел от 4,94065645841246544E–324 до 1,79769313486231570E+308. В памяти занимает 8 байт. Представлен системным типом System.Double
  • Decimal: хранит десятичное число с фиксированной запятой. Если употребляется без десятичной запятой, имеет значение от 0 до +/–79 228 162 514 264 337 593 543 950 335; если с запятой, то от 0 до +/–7,9228162514264337593543950335 с 28 разрядами после запятой и занимает 16 байт. Представлен системным типом System.Decimal
  • Date: представляет дату от 0:00:00 1 января 0001 года до 23:59:59 31 декабря 9999 года и занимает 8 байт. Представлен системным типом System.DateTime
  • Char: хранит одиночный символ в кодировке Unicode и занимает 2 байта. Представлен системным типом System.Char
  • String: хранит набор символов Unicode. Представлен системным типом System.String
  • Object: может хранить значение любого типа данных и занимает 4 байта на 32-разрядной платформе и 8 байт на 64-разрядной платформе. Представлен системным типом System.Object, который является базовым для всех других типов и классов .NET.

Объявление переменных

Для объявления переменных мы используем ключевое слово Dim, либо один из модификаторов доступа - Private, Friend, Protected, Public или Static. О модификаторах доступа мы поговорим чуть попозже, а пока ограничимся употреблением оператора Dim. Далее мы должны указать имя переменной. Требования к имени переменной следующие:

  • имя должно содержать не более 255 символов
  • имя может содержать любые буквы, цифры и символ подчеркивания, при этом первый символ в имени должен быть буквой или символом подчеркивания
  • в имени должны отсутствовать пробелы и знаки пунктуации
  • имя не должно быть ключевым словом

После имени переменной указывается ключевое слово As и затем идет тип данных переменной. После указания типа данных мы можем указать также и значение переменной с помощью знака равно. Ниже даны примеры объявления переменных:

Dim x As Integer
Dim y As Double = 4.0
Dim s As String = "Hello"

Это были примеры явного указания переменных, то есть мы явно указывали их тип данных. Однако возможен и другой способ, когда компилятор выводит тип данных из ее значения, то есть неявный способ определения переменных. Поэтому уместны и следующие объявления:

Dim x = 6 
Dim y = 4.0
Dim s = "Hello"

Если однажды объявив переменную, мы можем многократно изменять ее значение, то значение констант мы изменять не можем и можем указать его лишь однажды. Объявление константы похоже на объявление переменной, только вместо слова Dim используется ключевое слово Const:

Const x As Integer = 6 
Const y = 4.0

Использование системных типов

При перечислении всех базовых типов данных, упоминалось, что каждому примитивному типу данных соответствует какой-то системный тип. Потому что название встроенного типа по сути представляет собой сокращенное обозначение системного типа. Например, следующие переменные будут эквивалентны по типу:

Dim a As Integer = 5

Операции языка Visual Basic.NET

Visual Basic.NET поддерживает большинство стандартных операций, принятых и в других языках программирования. Рассмотрим все виды операций.

Арифметические операции

  • + сложение двух чисел
  • - вычитание двух чисел
  • звезда умножение
  • ^ возведение в степень
  • / обычное деление
  • \ целочисленное деление двух чисел
  • Mod Получение остатка от деления двух чисел

Примеры:

Dim x1 As Integer = 6 + 7 'Результат равен 13 
Dim x2 As Integer = 6 - 7 'Результат равен -1
Dim x3 As Integer = 6 * 7 'Результат равен 42
Dim x4 As Integer = 12 / 6 'Результат равен 2
Dim x5 As Integer = 13 \ 6 'Результат равен 2, а остаток отбрасывается
Dim x6 As Integer = 13 Mod 6 'Результат (он же остаток от деления 13 на 6) равен 1
Dim x7 As Integer = 6 ^ 2 'Результат равен 36

Операции сравнения и логические операции

В Visual Basic.NET также имеются операторы сравнения:

  • > Больше
  • >= Больше или равно
  • < Меньше
  • <= Меньше или равно
  • = Равно (в данном случае используется как знак сравнения на равенство двух значений)
  • <> Не равно

Также в языке определены логические операторы, которые возвращают в отличие от арифметических операций значение типа Boolean:

  • And Логическое умножение (логическое И)
  • Or Логическое сложение (логическое ИЛИ)
  • Xor Умножение
  • Not Возведение в степень
  • AndAlso Сокращенный оператор And
  • OrAlso Сокращенный оператор Or

Оператор And возвращает результат True только в том случае, если все выражения истинны. В остальных случаях он возвращает False. Оператор Or возвращает True, если хотя бы одно из выражений истинно. Он возвращает False тогда, когда неверны все выражения. Оператор Xor возвращает True, если одно из выражений истинно, а другое ложно. В остальных случаях, если оба выражения либо истинны, либо ложны, возвращается False. Оператор Not возвращает True, если выражение ложно, и False, если выражение истинно. Примеры использования:

Dim x As Boolean = 6 > 2 And 2 < 4 'Результат True, так как и первое выражение и второе выражение истинны
Dim y As Boolean = 6 > 2 And 2 > 4 'Результат False, так как только одно выражение истинно
     
Dim x1 As Boolean = 6 > 2 Or 2 < 4 'Результат True, так как хотя бы одно выражение истинно
Dim y1 As Boolean = 6 > 2 Or 2 > 4 'Результат True, так как опять же одно выражение истинно
Dim y2 As Boolean = 6 < 2 Or 2 > 4 'Результат False, так как оба выражения ложны
     
Dim x2 As Boolean = 6 > 2 Xor 2 < 4 'Результат False, так как оба выражения истинны
Dim y2 As Boolean = 6 > 2 Xor 2 > 4 'Результат True, так как одно выражение истинно, а другое ложно
     
Dim x3 As Boolean = Not 2 < 4 'Результат False, так как выражение истинно
Dim y3 As Boolean = Not 2 > 4 'Результат True, так как выражение ложно

Операторы AndAlso и OrAlso хотя возвращают тот же самый результат, что и And и Or, но все же между ними есть отличия. Так допустим у нас есть следующие два выражения, возвращающие идентичный результат :

Dim x As Boolean = 6 > 2 And 2 < 4 
Dim x As Boolean = 6 > 2 AndAlso 2 < 4

В первом случае (в случае с And) программа сначала проверяет истинность первого выражения - 6 > 2 и не зависимости от результата проверки затем проверяет истинность второго выражения - 2 < 4. Что у нас происходит в случае с AndAlso? Сначала также проверяется истинность первого выражения, и если оно истинно, тогда уже проверяется истинность второго. В случае если первое выражение ложно, тогда нету смысла проверять истинность второго выражения, так как в любом случае итоговый результат будет False.

Все сказанное в отношении пары And/AndAlso характерно и для пары Or/OrAlso: если оператор Or проверяет истинность правого и левого выражения, то оператор OrElse проверяет сначала истинность первого выражения, и только если оно False, проверяет на истинность второе выражение.

Поэтому в целях ускорения работы программы рекомендуется использовать AndAlso и OrAlso. Однако иногда сокращенные логические операторы не могу употребляться: в поразрядных операциях. В таких операциях необязательно возвращается значение типа Boolean, оно может представлять и другой тип данных. Например:

Dim i As Integer
i = 4 And 5

Здесь числа 4 и 5 рассматриваются как двоичные:

число 4 в двоичной форме имеет представление 100,

а число 5 в двоичной форме имеет представление 101

Здесь действует та же логика, что и в логических операциях, только теперь сравниваются разряды чисел. В итоге это выражение возвращает нам число 4, потому что результат операции в двоичной форме будет иметь форму 100.

С помощью поразрядной операции Xor удобно применять примитивное шифрование:

Dim x As Byte = 102 'Пусть это будет ключ - в двоичной форме 1100110
Dim y As Byte = 45  'Значение, которое надо зашифровать - в двоичной форме 101101
Dim z As Byte = y Xor x
Console.WriteLine(z) 'Результатом будет число 1001011 или 75
'Обратная операция - расшифровка
y = z Xor x
Console.WriteLine(y) 'Результатом будет исходное число 45

Операции сдвига

Еще один класс операций представляют операции поразрядного сдвига << и >>. Они имеют следующий синтаксис:

результат = число << (или >>) число разрядов

Сдвинем число 64 на два разряда влево и мы получим 256

Console.WriteLine(64 << 2)

Теперь сдвинем число 64 вправо также на два разряда и мы получим 16:

Dim num1  = 64 >> 2
Console.WriteLine(num1)

Несмотря на то, что с первого взгляда кажется, что данные операторы редко используются. нельзя не отметить их практическую ценность. Поскольку каждый сдвиг на один разряд вправо приравнивается к делению на 2, а сдвиг влево - к умножению на 2, то операции сдвига можно использовать вместо деления/умножения на степени двойки, тем более с точки зрения архитектуры компьютера операции сдвига будут отрабатывать быстрее, чем операции умножения и деления на 2.

Операции присваивания

Операции присваивания.

  • = Присваивание
  • ^= Присваивание после возведения в степень
  • *= Присваивание после умножения
  • /= Присваивание после деления
  • \= Присваивание после целочисленного деления
  • += Присваивание после сложения
  • -= Присваивание после вычитания
  • >>= Присваивание после сдвига вправо
  • <<= Присваивание после сдвига влево
  • &= Присваивание после конкатенации двух значений

Большинство операций присваивания представляют сокращенную форму других операций.

Массивы

Массив представляет собой набор данных одного типа. Например, объявим массив элементов типа Integer:

Dim nums(5) As Integer
nums(0) = 0
nums(1) = 1
nums(2) = 2
nums(3) = 3
Console.WriteLine(nums(3))

Здесь мы объявили массив из 6 элементов типа Integer. По умолчанию всем шести элементам в массиве присваивается 0. Затем первым четырем элементам массива мы присваиваем некоторые значения. Обратите внимание, что индексация в массиве начинается с нуля. При этом мы не можем выйти за рамки установленной длины массива в 6 элементов. А следующий код вызовет исключение ArrayIndexOutOfRange, поскольку восьмого элемента в массиве не существует, в нем определено только 6 элементов:

Dim nums(5) As Integer
nums(7) = 7

В вышеприведенном примере мы уже неявно инициализировали члены массива, задав для не него размер в шесть элементов. Однако можно объявить массив, а количество элементов указать потом:

Dim nums() As Integer

В таком случае нам его еще предстоит инициализировать. Мы это можем сделать так:

Dim nums() As Integer
nums = New Integer(5) {}
nums(0) = 0
nums(1) = 1
nums(2) = 2
nums(3) = 3

В данном примере мы c помощью ключевого слова New указываем, что хотим создать новый объект. Также указываем размер массива. А фигурные скобки служат для инициализации массива. Однако нам необязательно присваивать все значения массива после объявления. Мы можем все сделать уже при объявлении массива:

Dim nums2 As Integer() = New Integer(5) {0, 1, 2, 3, 4, 5}

Таким образом, все элементы массива у нас уже будут иметь значение. При этом мы можем использовать сокращенный синтаксис при инициализации массива без ключевого слова New, либо не задавать явным образом размер массива:

'Не указываем размер массива
Dim nums1 As Integer() = New Integer() {0, 1, 2, 3, 4, 5}
'Сокращенный синтаксис инициализации
Dim nums2 As Integer() = {0, 1, 2, 3, 4, 5}

В первой главе мы уже говорили, что тип переменной может выводиться компилятором автоматически. То же самое применимо и к массиву. Например:

Dim nums = {0, 1, 2, 3, 4, 5}

Кроме размера массив характеризуется таким понятием как размерность (dimension). В предыдущих примерах мы использовали одномерные массивы. Но массивы бывают и многомерными. Например:

'Одномерный массив
Dim nums1 As Integer() = {0, 1, 2, 3, 4, 5}
'Двухмерный массив
Dim nums2 As Integer(,) = {{0, 1, 2}, {3, 4, 5}}
Console.WriteLine(nums2(1, 1))

Здесь мы создали двухмерный массив, который можно представить в виде таблицы.

Изменение размера массива

При инициализации массива нам надо указать его размер, либо размер выводится из количества элементов. Однако иногда бывают ситуации, когда надо по ходу программы добавить еще один элемент в массив. Это можно сделать с помощью ключевого слова ReDim.

Dim nums1 As Integer() = {0, 1, 2, 3, 4, 5}
ReDim nums1(8)

ReDim пересоздает массив с новым размером. Чтобы сохранить все прежние элементы, нам надо также использовать ключевое слово Preserve.

Dim nums1 As Integer() = {0, 1, 2, 3, 4, 5} ReDim Preserve nums1(8)

Некоторые методы и свойства массивов

  • Свойство Length позволяет получить количество элементов массива
  • Свойство Rank позволяет получить размерность массива
  • Метод Reverse изменяет порядок следования элементов массива на обратный
  • Метод Sort сортирует элементы массива

Примеры использования:

Dim nums1 As Integer() = {8, 1, 5, 3, 4, 2}
Dim lenght As Integer = nums1.Length()
Console.WriteLine("количество элементов: {0}", lenght)
Dim rank As Integer = nums1.Rank()
Console.WriteLine("размерность массива: {0}", rank)
nums1.Reverse()
Array.Sort(nums1)
Console.WriteLine(nums1(1))

Условные конструкции

Конструкция If...Then

Конструкция If ... Then проверяет истинность некоторого условия и зависимости от результатов проверки выполняет определенный код:

Dim num1 As Integer = 10
Dim num2 As Integer = 9
If (num1 > num2) Then
    Console.WriteLine("Число {0} больше числа {1}", num1, num2)
End If

Здесь проверяем, больше ли число num1 числа num2, и если num1 больше чем num2. то выводим сообщение.

Конструкция Select Case

Конструкция Select Case подобна в конструкции If...Then, так как позволяет обрабатывать сразу несколько условий. После слов Select Case указывается сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после оператора Case. И в случае если значения совпали, то выполняется блок команд, помещенных после данного оператора Case. Конструкция завершается словами End Select. Если мы хотим определить действия, которые будут выполняться, если совпадений не выявлено, то мы можем использовать оператор Case Else, после которого помещаем блок действий по умолчанию. Блок Case Else необязателен и может не употребляться Так, мы можем переписать предыдущий пример с помощью Select Case:

Dim R As New Random()
Dim num1 As Integer = R.Next(100)
Select Case num1
    Case 1
        Console.WriteLine("Число num1 равно 1")
    Case 2
        Console.WriteLine("Число num1 равно 2")
    Case 3 To 25
        Console.WriteLine("Число num1 находится на отрезке от 3 до 25")
    Case Else
        Console.WriteLine("Число num1 больше 25")
End Select

Здесь мы также генерируем случайное число и последовательно сравниваем его значения.

Конструкция GoTo

Ну и в конце говоря об условных конструкций нельзя не упомянуть и оператор GoTo. Этот оператор требует после себя указание метки, на которую осуществляется переход. Например:

        Dim time As String = "day"
        If time = "day" Then
            GoTo M1
        Else
            GoTo M2
        End If
M1:     Console.WriteLine("Hello World")
M2:     Console.WriteLine("Good Bye World")

Как показывает практика, начинающие часто злоупотребляют использованием этого оператора, что приводит к написанию некрасивого и непонятного кода. Поэтому рекомендуется использовать данный оператор как можно реже и по возможности обходиться без него.

Циклы

Цикл For...Next

В этом цикл выполняется определенное число раз, причем это число задается счетчиком:

For i As Integer = 1 To 9
    Console.WriteLine("Квадрат числа {0} равен {1}", i, i * i)
Next

Здесь переменная i выполняет роль счетчика. После слова To мы помещаем максимальное значение счетчика. При каждом цикле значение счетчика увеличивается на единицу. И это значение сравнивается со значением после To. Если эти два значения равны, то цикла прекращает свою работу.

При работе с циклами мы можем увеличивать значение счетчика при каждом проходе не только на единицу, но и вообще на любое число. Для этого нужно либо использовать ключевое слово Step и после него указать шаг цикла, на который будет увеличиваться значение счетчика, либо можно увеличивать счетчик непосредственно в цикле:

For i As Integer = 1 To -9 Step -1
    For j As Integer = 1 To 9
        Console.WriteLine("Произведение чисел i и j равно {0}", i * j)
        j += 1
    Next
Next

Обратите внимание, что в качестве шага в первом цикле выбрано отрицательное значение и значение счетчика с каждым проходом уменьшается на единицу. Во внутреннем цикле счетчик j при каждом проходе увеличивается на 2, так как он по умолчанию увеличивается на единицу, и еще мы явным образом увеличиваем его в цикле на единицу. В итоге внутренний цикл отрабатывает пять раз, а внешний девять, то есть фактически получается 45 циклов.

Цикл For Each...Next

Цикл For Each осуществляет перебор элементов в определенной группе, например, в массиве или в коллекции. Предположим у нас есть некоторый массив типа Integer и нам надо инициализировать этот массив случайными значениями и затем вывести все его элементы на экран:

'Создаем массив из пяти чисел
Dim nums(4) As Integer
Dim r As New Random()
'инициализируем массив
For i As Integer = 0 To nums.Length - 1
    nums(i) = r.Next(100)
Next
'Выводим элементы массива
For Each i As Integer In nums
    Console.Write("{0} ", i)
Next

В выражении For Each мы сначала указываем переменную, которая будет принимать значения элементов массива. А после ключевого слова In указываем группу, в которой надо перебрать все элементы.

Цикл While

В цикл While выполняется до тех пор, пока соблюдается определенное условие, указанное после слова While:

Dim j As Integer = 10
While j > 0
    Console.WriteLine(j)
    j -= 1
End While

Цикл Do

Цикл Do, также как и цикл While, выполняется, пока соблюдается определенное условие. Однако он имеет разные формы. Так, в следующем примере сначала проверяется условие, а затем выполняется блок кода, определенный в цикле:

Dim j As Integer = 10
Do While j > 0
    Console.WriteLine(j)
    j -= 1
Loop

В данном случае цикл выполняется, пока значение j больше нуля. Но есть еще одна запись, где вместо слова While используется слово Until, а цикл выполняется пока не соблюдено определенное условие, то есть пока значение j не станет меньше нуля:

Dim j As Integer = 10
Do Until j < 0
    Console.WriteLine(j)
    j -= 1
Loop

Если изначально условие, заданное в цикле, неверно, то цикл не будет работать. Но мы можем определить проверку в конце цикла, и таким образом, наш цикл как минимум один раз отработает:

Dim j As Integer = -1
Do
    Console.WriteLine(j)
     j -= 1
Loop Until j < 0
'либо
Do
    Console.WriteLine(j)
    j -= 1
Loop While j > 0

Операторы Continue и Exit

Нередко возникает необходимость не дожидаться окончания цикла, а сразу же выйти из цикла, в случае соблюдения определенного условия. Для этого используют оператор Exit, после которого указывают тип цикла, из которого осуществляется выход, например, Exit Do (Exit While):

Dim r As New Random()
Dim num As Integer = r.Next(100)For i As Integer = 0 To 100
    num -= 1
    If num < 50 Then Exit For
Next
Console.WriteLine(num)

Существует и другая задача - осуществить выход не из цикла, а из текущего прохода или итерации и перейти к следующему. Для этого используют оператор Continue, после которого указывают тип цикла, из которого осуществляется выход, например, Continue While:

Dim r As New Random()
Dim num As Integer = r.Next(100)For i As Integer = 0 To 10
    num -= 7
    If num < 50 AndAlso num > 25 Then
        Continue For
    End If    Console.WriteLine(num)
Next

В данном случае мы в каждом проходе цикла вычитаем из num число 7 и затем смотрим, не принадлежит ли число num интервалу от 25 до 50. И если принадлежит, переходим к новой итерации цикла, а если нет, то выводим его на экран.

Методы и их параметры

Методы представляют собой набор операторов, предназначенных для выполнения определенного действия. Методы условно можно разделить на два типа: процедуры и функции. Если процедуры просто выполняют определенные действия, то функции возвращают некоторое значение.

Синтаксис процедуры выглядит следующим образом: сначала мы указываем модификатор доступа, затем ключевое слово Sub, после имя процедуры. После имени процедуры в скобках объявляем параметры процедуры, однако метод может и не иметь параметров - в таком случае в скобках ничего не указывается. Заканчивается объявление процедуры словами End Sub. С одной процедурой вы уже должны быть знакомы - это процедура Main, которая и вызывается при запуске модуля:

Sub Main()
    'Здесь выполняемые действия
End Sub

или

Sub Method1()
    Console.WriteLine("This is a Method1")
End Sub

Объявление функции похоже на объявление процедуры, только вместо ключевого слова Sub используется слово Function. Второе различие состоит в том, что нам надо указать тип и возвращаемое значение из функции. Чтобы указать тип, после скобок с параметрами помещается ключевое слово As, после которого пишется тип, значение которого возвращает функция. Если тип не указан, то функция по умолчанию возвращает значение типа Object. Кроме того, в конце функции мы помещаем слово Return и после него указываем возвращаемое значение:

Function Factorial() As Integer
    Return 1
End Function

или

Function Hello() As String
    Dim s As String = "Hello World"
    Return s
End Function

Структуры

Кроме простых типов данных, типа Integer, в языке VB.NET имеются и составные, которые называются структурами. Они могут, как и модули, содержать другие переменные различных типов, а также методы. Объявление структуры начинается со ключевого слова Structure. Создадим структуру Book, которая будет хранить переменные для названия, автора и года издания книги и процедуру для вывода на консоль информации о книге:

Structure Book
    'Название книги
    Dim name As String
    'Автор
    Dim author As String
    'Год издания
    Dim year As Integer    'Метод для вывода информации о книге
    Sub Information()
        Console.WriteLine("Книга '{0}' (автор {1}) была издана в {2} году", name, author, year)
    End SubEnd Structure

Классы

Visual Basic.NET является полноценным объектно-ориентированным языком, а это значит, что программа может быть представлена в виде взаимосвязанных объектов, которые взаимодействуют между собой. Описанием объекта является класс, в то время как объект - экземпляр этого класса. Класс определяется с помощью ключевого слова Class:

Class Book
End Class

Всю функциональность класса обеспечивают его члены - поля, свойства, методы, конструкторы, события. Поля представляют обычные переменные? обычным образом также определяются процедуры и функции (в этом плане классы во многом похожи на структуры):

Class Book
    'Название книги
    Dim name As String
    'Автор
    Dim author As String
    'Год издания
    Dim year As Integer    'Метод для вывода информации о книге
    Sub GetInformation()
        Console.WriteLine("Книга '{0}' (автор {1}) была издана в {2} году", name, author, year)
    End Sub
End Class

Кроме обычных методов в классах существуют специальные методы - конструкторы. Конструкторы вызываются при создании нового объекта класса. Чтобы объявить конструктор, надо использовать ключевое слово New. Зачем нужен конструктор? Обычно конструктор выполняет инициализацию членов класса. Объявим в классе конструктор, который будет инициализировать поля нашего класса Book:

Public Class Book
    'Название книги
    Dim name As String
    'Автор
    Dim author As String
    'Год издания
    Dim year As Integer    Sub New(name As String, author As String, year As Integer)
        Me.name = name
        Me.author = author
        Me.year = year
    End SubEnd Class

Здесь мы создали конструктор, который принимает три параметра - название книги, ее автора и год издания. Затем в конструкторе мы присваиваем значения параметров полям класса. Поскольку параметры и поля класса называются одинаково, то нам надо использовать ключевое слово Me, которое предоставляет ссылку на данный класс. Если бы параметры имели другие имена, то использование слова Me было бы необязательным. Если мы не создадим свой конструктор, тогда будет использоваться конструктор по умолчанию:

Sub New()End Sub

Теперь используем класс. Создайте новое консольное приложение. Затем нажмите правой кнопкой мыши на название проекта в окне Solution Explorer (Обозреватель решений) и в появившемся меню выберите пункт Add (Добавить), в другом появившемся меню выберите пункт Class (Класс). В окне создания нового класса присвойте ему имя Book и нажмите кнопку Add (Добавить). В проект будет добавлен новый класс Book, который будет находиться в файле Book.vb. Перенесите в этот класс следующий код:

Public Class Book
    'Название книги
    Dim name As String
    'Автор
    Dim author As String
    'Год издания
    Dim year As Integer    Sub New(name As String, author As String, year As Integer)
        Me.name = name
        Me.author = author
        Me.year = year
    End Sub
    'Конструктор по умолчанию
    Sub New()
        name = "Евгений Онегин"
        author = "А. С. Пушкин"
        year = 1833
    End Sub    'Метод для вывода информации о книге
    Sub GetInformation()
        Console.WriteLine("Книга '{0}' (автор {1}) была издана в {2} году", name, author, year)
    End Sub
End Class

Теперь в основной файл приложения - в модуль добавим следующий код:

Module Module1    Sub Main()        Dim b1 As Book = New Book("Война и мир", "Л. Н. Толстой", 1869)
        b1.GetInformation()
         
        'Используем конструктор по умолчанию
        Dim b2 As Book = New Book()
        b2.GetInformation()
         
        Console.ReadLine()
    End Sub
End Module

Если мы запустим код на выполнение, то консоль выведет нам информацию о книгах b1 и b2. Обратите внимание, что чтобы создать новый объект кроме конструктора нам надо использовать ключевое слово New. В первом случае мы используем свой конструктор, а во втором - конструктор по умолчанию.

Частичные классы

Частичные классы представляют возможность разделения одного класса на несколько файлов. Например, в одном файле может быть:

Partial Public Class Book
    'Название книги
    Dim name As String
     
End Class

а в другом:

Partial Public Class Book
     
    'Автор
    Dim author As String
    'Год издания
    Dim year As IntegerEnd Class

Для создания частичного класса перед его объявлением надо поставить ключевое слово Partial. В итоге в результате компиляции будет создан единый класс, который не будет отличаться от других классов.

Ключевое слово With

Предположим, что у нас есть следующий класс State:

Class State
    Public capital As String
    Public area As Integer
    Public population As Integer    Sub New(cap As String)
        capital = cap
    End Sub
End Class

При создании объекта класса мы указываем столицу, значения для остальных полей мы должны указать отдельно, например так:

Dim state1 As New State("City")
state1.area = 200
state1.population = 200

Однако таких свойств может быть множество. И чтобы сократить объем кода, мы можем использовать конструкцию With...End With. Чтобы применить эту конструкцию, после слова With указывается объект, а затем построчно свойства объекта, которые мы хотим получить или присвоить:

Dim capit As String
Dim state1 As New State("City")
         
With state1
    'Установка остальных полей
    .area = 200
    .population = 200
    'Получение значение поля capital
    capit = .capital
End With

Кроме того, мы можем использовать сокращенный синтаксис инициализации объекта с помощью ключевого слова With и одновременно указать все необходимые свойства:

Dim state2 = New With {.capital = "City2", .area = 300, .population = 300}

Ссылки

  1. Visual Basic .NET
  2. Новые возможности Visual Basic 2010
  3. Практические видео-материалы по Visual Basic