Снова о свойствах


Принципиальное различие в работе свойств VB6 и VB .NET заключается в том, что секции Get и Set теперь должны обладать одинаковым уровнем доступа. Определять свойства с секциями Public Get и Private Set в VB .NET не разрешается.
Это ограничение легко обходится. Чтобы процедура Set фактически стала закрытой, объявите свойство с атрибутами Public Readonly и одновременно объявите другое, внутреннее закрытое свойство для Set.
Кроме того, в VB6 свойство не могло изменяться в процедуре, даже если оно было передано по ссылке (то есть с ключевым словом ByRef). В VB .NET свойства, переданные по ссылке, могут изменяться.
Но самое принципиальное изменение относится к свойствам по умолчанию. В прежних версиях VB существовала концепция свойств по умолчанию, которая на первый взгляд казалась очень удобной. На практике свойства по умолчанию часто становились причиной ошибок в программах. Например, что означает следующая команда?
Me.Text1 = Text2
Отслеживая ошибки, возникающие в подобных командах, опытные пользователи VB выясняли, что эта команда задает свойству Text текстового поля с именем Textl значение переменной Text2. Свойства по умолчанию не только становились источником ошибок в программах, но и требовали, чтобы при присваивании объектов использовалось ключевое слово Set, поскольку присваивание объектам нужно было отличать от присваивания свойствам. В VB .NET проблема свойств по умолчанию решается просто — они разрешены только там, где это действительно оправдано, а именно при использовании параметров. Допустим, у вас имеется кэш-таблица aTable; при выборке значений было бы удобно использовать синтаксис вида aTable("theKey"), но это возможно лишь в том случае, если Item является свойством по умолчанию для класса HashTable. Свойства по умолчанию объявляются в классе с ключевым словом Default, причем это допускается лишь для свойств, получающих минимум один параметр. Если свойство по умолчанию перегружается, все перегруженные версии также помечаются ключевым словом Default. Свойства по умолчанию чаще всего используются в ситуации, когда у объекта имеется свойство, значение которого возвращается в виде массива или другого объекта, способного вмещать несколько величин (например, хэш-таблицы). Предположим, у вас имеется класс Sal es и свойство InYear, которое по полученному индексу возвращает число (объем продаж):
Public Class Sales
Private m_Sales() As
Decimal = {100, 200. 300}
Default Public Property InYear(ByVal theYear As Integer) As Decimal
Get
Return m_Sales(theYear)
End Get
Set(ByVa1 Value As Decimal)
m_Sales(theYear)=Value
End Set
End Property
' Остальной код класса End Class
Свойство по умолчанию позволяет использовать конструкции вида
Dim ourSales As New Sales()
Console.WriteLine(ourSa1es(1))
вместо
Dim ourSales As New Sales()
Console.WriteLi ne(ourSales.InYear(1))
Или, например, вы можете написать
ourSales (2) = 3000
вместо
ourSales.InYear(2) = 3000
Ключевое слово Set используется в процедурах свойств VB NET.
 
Свойства и инкапсуляция
На первый взгляд кажется, что свойства очень похожи на открытые поля экземпляров. Если объявить в классе А открытое поле с именем evil, на него можно сослаться при помощи конструкции A.evil; ничто не указывает на то, что свойство реализовано в виде открытой переменной. Может, определить открытое поле и избавиться от хлопот по определению процедур Get и Set?
Не поддавайтесь соблазну. Инкапсуляцию данных не стоит нарушать без веских причин (а еще лучше —те нарушать никогда!).
Но инкапсуляцию можно случайно нарушить и другими способами — например, если не следить за возвращаемыми значениями свойств. Каким образом? Если поле представляет собой изменяемый объект (например, массив), возвращение его в виде значения свойства приведет к нарушению инкапсуляции, поскольку внешний код сможет изменить состояние поля экземпляра через полученную объектную переменную. В таких ситуациях следует создать клон поля (клонирование объектов рассматривается в главе 5). Мораль:
Свойства не должны возвращать изменяемые объекты, которые представляют собой переменные классов.
 
Область видимости переменных
Переменные класса (в том числе и закрытые поля), объявленные за пределами его методов или свойств, доступны для всех членов класса. Переменные, объявленные в методе или свойстве, являются локальными по отношению к этому методу или свойству.
Переменные, объявленные на уровне модуля, доступны для всех классов, определенных в этом модуле, и для всего кода, обладающего доступом к этому модулю.
Таким образом, переменные уровня модуля являются глобальными по отношению к экземплярам классов. Пример:
Module Modulel
Dim aGlobal As Integer = 37
Sub Main()
Dim anA As New А()
Dim aB As New B()
Console. ReadLine()
End Sub
Public Class A Sub New()
aGlobal =aGlobal +17 Console.WriteLine(aGlobal)
End Sub
End Class
Public Class В Sub New()
Console.WriteLine(aGlobal)
End Sub
End Class
End Module
В данном случае целая переменная aGlobal определяется на уровне модуля, поэтому изменения, вносимые в aGlobal классом А, будут восприняты классом В. Использовать переменные уровня модуля не рекомендуется — все взаимодействие между классами должно быть реализовано на уровне обмена сообщениями!
В прежних версиях VB широко практиковалось хранение общих данных классов в глобальных переменных. В VB .NET надобность в этом небезопасном приеме отпала. За дополнительной информацией обращайтесь к разделу «Общие данные в классах» этой главы.
 
Вложенные классы
В программах VB .NET нередко встречаются ситуации, когда у вас имеются два класса: «внешний» и «внутренний», фактически принадлежащий первому. Вложенные (nested) классы обычно выполняют вспомогательные функции, и их код имеет смысл лишь в контексте внешнего класса. Существует хорошее эмпирическое правило: если при просмотре внешнего класса код вложенного класса можно свернуть в окне программы и это не затруднит понимания логики внешнего класса, значит, работа вложенного класса организована правильно. Конечно, использование вложенных классов всегда приводит к некоторому нарушению инкапсуляции — вложенный класс может обращаться к закрытым членам внешнего класса (но не наоборот!). Если это обстоятельство учитывается в архитектуре вашего приложения, не стоит уделять ему особого внимания, поскольку внутренний класс всего лишь является специализированным членом внешнего класса.
VB .NET не позволяет расширять область видимости вложенного класса посредством функций. Например, открытый член внешнего класса не может вернуть экземпляр закрытого или дружественного (Friend) вложенного класса.
 
Практическое использование вложенных классов на примере связанного списка
Вложенные классы чаще всего применяются в реализациях различных структур данных. К числу самых распространенных структур данных принадлежит связанный список. Он представляет собой цепочку ссылок, которая позволяет легко переходить от текущего объекта к следующему, однако поиск всегда начинается с конкретной ссылки. Применение вложенных классов в реализации связанного списка выглядит вполне естественно, поскольку код объектов-ссылок не представляет интереса для пользователей класса LinkedList, а объекты Link не могут существовать независимо от содержащего их объекта LinkedList.
Ниже приведена очень простая реализация класса для работы со связанными списками. Просмотрите ее, а затем мы подробно проанализируем листинг. Обратите внимание на важную строку, выделенную жирным шрифтом (строка 49); в ней используется нетривиальная особенность объектно-ориентированного программирования, о которой будет рассказано ниже.
1 Option Strict On
2 Module Modulel 3 Sub Main()
4 Dim aLinkedList As New LinkedlistC'first link")
5 Dim aALink As LinkedList.Link
6 aLink = aLinkedList.MakeLink(aLinkedList.GetFirstLink,"second link")
7 aLink = aLinkedList.MakeLink(aLink,"third link")
8 Console.WriteLine(aLinkedList.GetFirstLink.MyData)
9 aLink = aLinkedList.GetNextLink(aLinkedList.GetFirstLink)
10 Console.WriteLine(aLink.MyData)
11 Console.WriteLine(aLink.NextLink.MyData)
12 Console. ReadLine()
13 End Sub
14 Public Class LinkedList
15 Private m_CurrentLink As Link
16 Private m_FirstLink As Link
17 Sub New(ByVal theData As String)
18 m_CurrentLink = New Link(theData)
19 m_FirstLink = in_CurrentLink
20 End Sub
21 Public Function MakeLink(ByVal currentLink As Link.ByVal
22 theData As String) As Link
23 m_CurrentLink =New Link(currentLink.theData)
24 Return m_CurrentLink
25 End Function
26 Public Readonly Property GetNextLink(ByVal aLink As Link)_
27 As Link
28 Get
29 Return aLink.NextLink()
30 End Get
31 End Property
32 Public Readonly Property GetCurrentLink()As Link
33 Get
34 Return m_CurrentLink
35 End Get
36 End Property
37 Public Readonly Property GetFirstUnkOAs Link
38 Get
39 Return m_FirstLink
40 End Get
41 End Property
42
43 ' Вложенный класс для ссылок
44 Friend Class Link
45 Private m_MyData As String
46 Private m_NextLink As Link
47 Friend Sub New(ByVal myParent As Link.ByVal theData As String)
48 m_MyData - theData
49 myParent.m_NextLink = Me
50 ' End Sub
51 Friend Sub New(ByVal theData As String)
52 m_MyData =theData
53 End Sub
54 Friend Readonly Property MyData()As String
55 Get
56 Return m_MyData
57 End Get
58 End Property
59 Friend Readonly Property NextLink()As Link
60 Get
61 Return m_NextLink
62 End Get
63 End Property
64 End Class
65 End Class
66 End Module
Строка 4 создает новый экземпляр связанного списка. В строке 5 определяется объектная переменная типа Link. Поскольку класс Link является вложенным по отношению к LinkedList, его тип записывается в виде «полного имени» LinkedList.Link. Строки 6-12 содержат небольшую тестовую программу.
В строках 17-20 определяется конструктор класса LinkedList, в котором вызывается второй конструктор класса Link (строки 51-53). Последний объявлен с атрибутом Friend и потому доступен для внешнего класса Li nkedLi st. Если бы конструктор Link был объявлен с атрибутом Private, то он стал б"ы недоступным для внешнего класса.
Также стоит обратить внимание на то, как в первом конструкторе класса Link (строки 47-50) организуется ссылка на только что созданный элемент списка из предыдущего элемента. Для этого используется ключевое слово Me — это очень принципиальный момент, поэтому строка 49 выделена в листинге жирным шрифтом. На первый взгляд команда myParent.m_NextLink = Me выглядит недопустимой, поскольку мы обращаемся к закрытому полю родительского класса myParent. Однако программа все-таки работает! Итак, запомните очень важное правило:
Для экземпляра класса всегда доступны закрытые поля других экземпляров этого класса.
При написании подобных классов в VB .NET можно обойтись и без использования этой нетривиальной особенности классов. Например, в класс Link можно включить специальный метод для создания ссылки на следующий элемент списка. В конечном счете выбор зависит только от вашего стиля программирования. Тем не менее сама возможность обращения к закрытым членам класса может преподнести неприятные сюрпризы, и об этом необходимо знать. По этой причине в нашем примере продемонстрирован именно такой подход.
 
Общие данные в классах
Вернемся к классу Еmploуее. Допустим, каждому работнику необходимо присвоить уникальный номер. В старых версиях VB задача решалась при помощи глобальных переменных, что приводило к нарушению инкапсуляции и создавало потенциальную угрозу случайного изменения номеров внешним кодом. Логика подсказывает, что номер должен увеличиваться только при создании нового объекта Empl оуее.
В VB .NET наконец-то появились средства для достижения этой цели. Идея проста: в классе определяются данные, совместно используемые всеми экземплярами данного класса, однако внешний доступ к этим данным находится под вашим полным контролем (например, через обращение к свойству). Не стоит и говорить, что эти поля никогда не должны объявляться открытыми...
Такие поля называются общими (shared). Они идеально подходят для таких ситуаций, как в нашем призере с присвоением последовательных номеров. В классах также могут определяться общие свойства и методы. Недостаток заключается в том, что общие члены классов не могут работать с обычными полями, свойствами или методами. Иначе говоря, общие члены работают только с другими общими членами. Дело в том, что общие данные существуют еще до создания объекта, поэтому было бы нелогично разрешать общим членам доступ к конкретным объектам.
Ниже приведен фрагмент новой версии класса Employee с использованием общих данных для присвоения номеров. В классе определяется закрытая общая переменная типа Integer, которая:

  • имеет начальное значение 1;
  • ассоциируется со ReadOnly-свойством, возвращающим ее текущее значение;
  • изменяется (увеличивается) только в конструкторе класса.

В совокупности это означает, что работнику никогда не будет присвоен номер 0 и что новый номер выделяется только при создании нового объекта Empl oyee — именно это нам и требовалось:
Public Class Employee
Private m_Name As String
Private m_Salary As Decimal
Private Shared m_EmployeeID As Integer = 1
Public Sub New(ByVal theName As String. ByVal curSalary As Decimal)
m_Name = thename
m_Salary = curSalary
m_EmployeeID = m_EmployeeID + 1
End Sub
Readonly
Property Employeeld() As Integer
Get
Employeeld = m_EmployeeID
End Get
End Property
End Class
Ниже приведена небольшая программа для тестирования класса Empl oyee, а также полный код класса с общим полем:
Option Strict On Module Modulel
Sub Main()
Dim Tom As New Employee("Tom". 100000)
System.Console.WriteLine(Tom.TheName & "is employee! " & _
Tom. Employee ID & "with salary " & Tom.SalaryO)
Dim Sally As New Employee("Sally". 150000)
System.Console.WriteLine(Sally.TheName & "is employee!" & _
Sally.EmployeeID &"with salary "SSally.Salary())
System.Console.WriteLine("Please press the Enter key")
System.Console.Read()
End Sub
End Module
Public Class Employee
Private m_Name As 'String
Private m_Salary As Decimal
Private Shared m_EmployeeID As Integer = 1
Public Sub New(ByVal theName As String.ByVal curSalary As Decimal)
m_Name = thename
m_Salary = curSalary
m_EmployeeID = m_EmployeeID + 1
End Sub Readonly Property Employeeld()As Integer
Get
Employeeld = m_EmployeeID
End Get End Property Readonly
Property TheName() As String
Get
TheName = m_Name
End Get . End Property Readonly
Property Salary () As Decimal
Get
Salary = m_Sa1ary
End Get
End Property
End Class
Обращения к константам в классах не отличаются от обращений к общим полям, но при объявлении констант вместо Shared используется ключевое слово Const. Конечно, объявление открытых констант не приводит к нарушению инкапсуляции.
Не путайте общие данные со статическими. Общие данные существуют в одной копии для всех экземпляров класса, поэтому с точки зрения экземпляров они неявно обладают глобальной видимостью. Статическими называются переменные, состояние которых просто запоминается для повторного использования. Статическими могут быть объявлены как общие, так и обычные поля класса.
 
Общие члены классов
Закрытые общие поля классов в сочетании со ReadOnly-свойствами очень удобны, но этим область применения ключевого слова Shared не исчерпывается. В классе можно объявлять общие свойства и методы. Как было показано на примере класса Math, при обращении к общим средствам класса указывается либо имя класса, либо имя конкретного экземпляра. Допустим, в класс Employee включается общая функция Calcul ateFICA, зависящая от двух открытых констант:
Public Const FICA_LIMIT As Integer = 76200
Public Const FICA_PERCENTAGE As Decimal = 0.062D
Функция CalculateFICA выглядит так:
Public Shared Function CalculateFICA(ByVal aSalary As Decimal) As Decimal
If aSalary > FICA_LIMIT Then
Return FICA_LIMIT * FICA_PERCENTAGE
Else
Return aSalary * FICA_PERCENTAGE
End If
End Function
Общие члены класса могут использоваться без создания экземпляров Empl oyee, только по имени класса. Пример:
System.Console.WriteLine(Employee.
CalculateFICA(100000))
С другой стороны, метод мджно вызвать и для конкретного экземпляра Employee:
System.Console.WriteLine
(Tom.CalculateFICA
(Tom.GetSalary())
Конструкторы тоже можно объявлять общими, для этого в объявление метода
New включается ключевое слово Shared. Общие конструкторы:

  • не обладают атрибутами Publiс или Private;
  • вызываются без параметров;
  • могут работать только с общими полями класса. Как правило, общие конструкторы применяются только для инициализации общих данных. Код общего конструктора выполняется при создании первого экземпляра указанного класса, перед вызовом всех остальных конструкторов.

 
Жизненный цикл объекта
Итак, при создании экземпляра класса оператором New вызывается соответствующий метод-конструктор New из определения класса (также может быть вызван общий конструктор, если он есть). Версия конструктора выбирается в соответствии с типом переданных параметров. Конструктор можно рассматривать как аналог события Class_Initiall ze в VB6.
Не в каждом классе определяется открытый конструктор. Более того, в некоторых ситуациях все конструкторы класса объявляются закрытыми и экземпляры создаются только общими методами. Конструктор объявляется закрытым в одном из следующих случаев:

  • Если он должен вызываться только из класса. Например, в классе может быть определен открытый конструктор, который вызывает закрытый конструктор при определенных обстоятельствах (например, в зависимости от типа переданных параметров).
  • Если специфика класса не предусматривает создание его экземпляров. Например, класс, состоящий только из общих членов, должен содержать только закрытые конструкторы, поскольку его экземпляры не должны создаваться во внешних программах. В подобных ситуациях вы должны определить хотя бы один закрытый конструктор, в противном случае VB .NET автоматически сгенерирует открытый безаргументный конструктор.
  • Если вызов закрытого конструктора через общий метод используется для контроля над созданием экземпляров. Например, если создание объекта требует больших затрат времени и ресурсов, необходимо позаботиться о том, чтобы экземпляры создавались только в случае крайней необходимости.

После того как объект будет создан оператором New, вы не сможете изменить его состояние повторным вызовом New. Пример:
Dim Tom As New EmployeeC'Tom ", 100000)
Tom = New Employee("Tom ". 125000)
В этом фрагменте создаются два разных объекта Empl oyee, причем после присваивания во второй строке первый объект Тот теряется. Иногда это соответствует намерениям программиста, иногда — нет. Например, если идентификатор работника хранится в общей переменной Empl oyeeID, то вторая строка присвоит второму объекту Тот идентификатор на 1 больше первоначального. Так или иначе, следующий фрагмент заведомо невозможен:
Dim Tom As New Employee("Tom ", 100000)
Dim Tom As New Employee("Tom ", 125000)
Компилятор выдает следующее сообщение об ошибке:
The local variable 'Tom' is defined multiple times in the same method.
 
Уничтожение объектов
В VB .NET объекты не умирают «естественной смертью»; в каком-то смысле они постепенно «уходят в небытие» со временем. Главное отличие от предыдущих версий VB заключается в том, что вы не можете явно освободить память, занимаемую объектом. Встроенный сборщик мусора когда-нибудь заметит, что эти блоки памяти не используются в программе, и автоматически освободит их. Автоматическая сборка мусора оказывает сильное влияние на программирование в VB .NET. В частности, сборку мусора следует рассматривать как полностью автоматизированный процесс, на который вы абсолютно не можете повлиять.
Хотя в программе можно провести принудительную сборку мусора вызовом метода System. GC. Collect(), считается, что это не соответствует хорошему стилю программирования .NET. Мы рекомендуем всегда полагаться на автоматическую сборку мусора.
Вспомните, что в прежних версиях VB в каждом классе существовало событие Termi nate, которое гарантированно вызывалось в тот момент, когда количество ссылок уменьшалось до 0 (в терминологии ООП это называется детерминированным завершением). В VB .NET (как бы вы к этому ни относились) поддерживается только недетерминированное завершение, из чего следует, что вы не можете рассчитывать на то, что некий аналог события Termi nate будет вызван в определенный момент времени. Более того, не гарантировано даже то, что он вообще будет когда-нибудь вызван!
Некоторые программисты считают Finalize аналогом события Terminate в VB .NET, однако эта аналогия неверна. Метод Finalize всего лишь содержит код, который должен выполняться при освобождении памяти вашего объекта в процессе сборки мусора. Но поскольку вы не можете явно управлять тем, когда это произойдет, мы настоятельно рекомендуем использовать Finalize лишь как дополнительную меру безопасности — например, для дублирования метода Dispose, который должен вызываться пользователем класса. Метод Dispose рассматривается ниже.
Возникает вопрос: если раньше мы проводили деинициализацию класса в событии Terminate, как же это делается сейчас? Для решения этой проблемы в VB .NET существует очень важное правило:
Если ваш класс должен освобождать какие-либо внешние ресурсы, кроме обычной памяти (например, подключения к базе данных, графические контексты, файловые манипуляторы и т.. д.), он должен содержать метод с именем Di spose, вызываемый из внешнего кода.
Мы вернемся к методу Dispose при рассмотрении интерфейса IDisposabl e в главе 5. А пока достаточно сказать, что любое графическое приложение — даже самое простое, вроде продемонстрированного в главе 1, — относится к категории программ, в которых необходим метод Dispose. Это связано с тем, что графические программы захватывают так называемые графические контексты, которые должны быть освобождены для возвращения ресурсов в систему (графические контексты не являются блоками памяти, поэтому автоматическая сборка мусора в данном случае не поможет). Теперь становится ясно, почему в автоматически сгенерированный код, приведенный в главе 1, входит вызов Dispose. Недетерминированное завершение относится к числу самых неоднозначных нововведений .NET, однако автоматическая сборка мусора является неотъемлемой частью .NET. Разработчикам при всем желании не удалось бы сохранить прежний, детерминированный вариант управления памятью и обеспечить совместимость с .NET. Кроме того, механизму, использованному в старых версиях VB (подсчет ссылок), присущи проблемы с утечкой памяти, вызванной существованием циклических ссылок, когда объект А ссылается на объект В и наоборот, как показано на  8.
Такие языки, как Java, наглядно доказали, что преимущества от автоматической сборки мусора оправдывают небольшие изменения в стиле программирования, связанные с отсутствием детерминированного завершения.
 
Структурные типы
Традиционно в объектно-ориентированных языках возникало немало проблем с простейшими типами данных — такими, как обычные целые числа. Дело в том, что в объектно-ориентированном языке все данные должны быть объектами. С другой стороны, создание объекта сопряжено с определенными затратами на выполнение служебных операций (таких, как выделение блока памяти для объекта). Обработка сообщения «сложить» также уступает по скорости простой математической операции сложения и т. д. Стоит добавить, что в языках с автоматической сборкой мусора некоторое время расходуется на уничтожение неиспользуемых объектов.
Ранние объектно-ориентированные языки пошли по самому прямолинейному пути. Скажем, в Smalltalk все данные интерпретировались как объекты. В результате такие языки работали медленнее, чем языки с разделением примитивных типов и объектов. С другой стороны, подобное разделение приводило к усложнению программ, поскольку программный код, работавший с числами, приходилось отделять от кода, работавшего с объектами. Чтобы интерпретировать число в объектном контексте, его приходилось «заворачивать» в объект. Например, в Java сохранение числа в эквиваленте динамического массива выглядело примерно так:
anArrayList.Add(Integer(5));
Число 5 «заворачивалось» в объект Integer. Такие программы плохо читались и медленно работали.
В .NET Framework были объединены лучшие стороны обоих решений. В общем случае числа интерпретируются как примитивные типы, но при "необходимости они автоматически интерпретируются как объекты. Таким образом, для обычного числового литерала можно вызвать метод или занести его в хэш-таблицу без дополнительных усилий. Это называется автоматической упаковкой (boxing); обратный процесс называется распаковкой (unboxing).
Для нас, программистов, из этого вытекает важное следствие: хотя в VB .NET все данные являются объектами, не каждая переменная в программе содержит манипулятор блока памяти и создается оператором New. Разумеется, ничто не дается даром: программисту приходится помнить о различиях между структурными и ссылочными типами. Первое, наиболее очевидное различие заключается в том, что новые экземпляры структурных типов создаются без ключевого слова New. Вам не придется (да и не удастся) использовать конструкции вида Dim a As New Integer(5).
Более серьезное различие связано с передачей переменных процедурам по значению. Как было сказано выше, при передаче изменяемого объекта по значению процедура может изменить состояние объекта. Переданные по значению структурные типы ведут себя вполне традиционно — все изменения теряются при выходе из вызванной процедуры или функции (иногда это называется структурной семантикой в отличие от ссылочной семантики).
Все числовые типы VB .NET являются структурными типами; к этой же категории относится и такой тип, как дата. Как будет показано ниже, VB .NET позволяет определить пользовательские структурные типы, если по соображениям быстродействия вы хотите свести к минимуму затраты на работу с объектами или же предпочитаете работать с объектами, обладающими структурной семантикой.
Чтобы узнать, обладает ли некий тип структурной семантикой, передайте переменную этого типа следующей функции.
Function IsValueType(ByVal foo As Object)As Boolean
If TypeOf (foo)Is System.ValueType Then
Return True Else
Return False
End If
End Function
Для объектов структурного типа оператор Equal s всегда возвращает True, если структурные объекты содержат одинаковые данные. Синтаксис вызова выглядит так:
a..Fquals(b)
Учтите, что для ссылочных типов этот принцип в общем случае не выполняется. Например, два массива могут содержать одинаковые элементы, но равными при этом они не считаются.
В VB .NET структурные типы делятся на две категории: структуры и перечисляемые типы. Мы начнем с перечисляемых типов, а затем перейдем к структурам, которые представляют собой «облегченные» варианты объектов.
 
Перечисляемые типы
Перечисляемые типы обычно используются для определения набора именованных целочисленных констант. При определении перечисляемого типа используется пара ключевых слов Enum-End Enum вместе с модификатором доступа. Перечисляемый тип может содержать только целочисленные типы вроде Integer или Long (тип Char недопустим). Например, в следующем фрагменте определяется открытый перечисляемый тип с именем BonusStructure:
Public Enum BonusStructure
None = 0
FirstLevel = 1
SecondLevel = 2
End Enum
После этого в любом месте программы можно объявить переменную типа BonusStructure: Dim bonusLevel As BonusStructure
При работе с перечисляемыми типами, как и с другими структурными типами, ключевое слово New не используется.
Если в перечисляемом типе указаны только имена без числовых значений, .NET начи-нает отсчет с 0 и увеличивает значение на 1 для каждой новой константы. Если задано только первое число, то каждое следующее значение вычисляется увеличением предыдущего на 1.
Определив в проекте перечисляемый тип, вы можете использовать конструкции вида

Bonus =Tom.Sales * bonusLevel.SecondLevel
Поскольку перечисляемые типы неявно интерпретируются как общие, в ссылках на них можно указывать имя перечисляемого типа вместо имени переменной:
Public Function Calcu1ateBonus(ByVal theSales As Decimal) As Decimal
Return theSales * BonusStructure.SecondLevel
End Function
Одним из традиционных недостатков перечисляемых типов было отсутствие удобных средств для получения имени по значению, что затрудняло отладку программ. В классе Enum, базовом для всех перечисляемых типов, определены очень полезные методы для получения подобной информации. Например, следующая команда возвращает строку FirstLevel :
BonusStructure.GetName(bonusLevel .GetType.l)
Данный фрагмент выводит все имена, входящие в перечисляемый тип:
Dim enumNames As String().s As String
enumNames = BonusStructure.GetNames(bonusLevel.GetType)
For Eachs In enumNames
System.Console.WriteLine(s) Next
Структуры
Некоторые полагают, что структуры VB .NET аналогичны пользовательским типам прежних версий VB или многих других языков программирования. Конечно, структуры VB .NET могут использоваться как пользовательские типы, но этим область их возможного применения не исчерпана. Структура может обладать всеми признаками традиционного класса, включая конструкторы и члены с атрибутами Private/Friend/Public. Единственное отличие структур от обычных объектов заключается в том, что структуры обладают структурной семантикой. Вспомните, какой смысл вкладывается в этот термин:

  • передача по значению не изменяет состояния исходной переменной;
  • структуры создаются без использования оператора New, поэтому для них всегда определено значение по умолчанию, образованное значениями по умолчанию всех полей экземпляра;
  • в структуре определен метод Equals, который возвращает True, если две структуры содержат одинаковые внутренние данные (метод Equals используется в форме А.Еquals(В)).

В текущей версии VB .NET равенство двух экземпляров структурного типа не может быть проверено при помощи знака равенства (=). Вместо этого следует использовать метод Equals. По умолчанию метод Equals выполняет так называемое поверхностное (shallow) сравнение — смысл этого термина рассматривается в разделе «Клонирование объектов» главы 5. Если вы хотите, чтобы ваша версия Equals отличалась каким-то особым поведением, метод можно переопределить в определении структуры.
Некоторые программисты используют структуры чаще, чем следует, полагая, что структура как1 облегченный объект работает эффективнее, чем объекты обычных классов. К сожалению, этот подход не лишен недостатков: два объекта, обладающие одинаковым состоянием, далеко не всегда должны считаться равными, тогда как при использовании структур это неизбежно. Кроме того, пользователи вашего кода обычно ожидают, что структуры (и структурные типы вообще) по своему поведению близки к встроенным структурным типам вроде Integer и Double.
Все стандартные числовые типы (Integer, Long, и т.д.) реализованы B.NETFramewdrke виде структур.
 
Определение структур в программе
Определение структуры начинается с модификатора уровня доступа и ключевого слова Structure:
Public Structure NameOfStructure
' Код структуры End Structure
Для каждого члена структуры должен быть указан модификатор доступа (например, Public или Private). Поля, объявленные с ключевым словом Dim вне процедур и функций, считаются открытыми. Ниже приведен простейший вариант структуры для работы с комплексными числами:
Public Structure ComplexNumber
Private m_real As Double
Private m_complex As Double
Public Property real () As Double Get
Return m_real
End Get Set(ByVal Value As Double)
m_real = Value
End Set
End Property
Public Property complex()As Double Get
Return m_complex End Get Set(ByVal Value As Double)
m_complex = Value
End Set
End Property
Public Sub New(ByVal x As Double. ByVal у As Double)
real = x complex = у
End Sub
Public Function Add(ByVal zl As ComplexNumber) As ComplexNumber
Dim z As ComplexNumber
z.real = Me.real + zl.real
Z.complex = Me.complex + zl.complex
Return z End Function
' И т.д. End Structure
Обратите внимание на возвращение структуры функцией Add. Кстати, поля структур не могут инициализироваться при объявлении:
Private m_real As Double = 0 ' Ошибка
Между структурами и ссылочными объектами существует еще одно принципиальное различие: использование открытых полей вместо свойств Get-Set в структурах широко распространено и не считается проявлением плохого стиля программирования, как для объектов. Это связано с тем, что поля экземпляров обычно относятся к базовым типам. Например, переопределение приведенной выше структуры ComplexNumber с открытыми полями Real и Imaginary не вызовет особых проблем.
Структуры создаются вызовом New или при присваивании значений их полям. Обращения к полям структур осуществляются так же, как и обращения к свойствам объектов. Ниже приведен пример использования структуры Compl exNumber:
Sub Main()
Dim Z1 As New ComplexNumber(2.3. 2.4)
Dim Z2.Z3 As ComplexNumber
Z2.real = 1.3
Z2.complex =1.4
Z3 = Zl.Add(Z2)
Console. WriteLine(Z3. real)
Console.ReadLine()
End Sub
Текущая версия VB .NET не позволяет переопределять смысл операторов (то есть про-изводить перегрузку операторов), поэтому нам пришлось определить метод Add вместо того, чтобы задать новое определение для оператора «+». Возможность перегрузки операторов должна появиться в будущих версиях VB .NET. Если вы хотите, чтобы в сегодняшней версии вашего пакета для работы с комплексными числами сложение выполнялось знаком «+», придется использовать С#.
Структуры могут содержать любые объекты VB .NET, в том числе другие структуры, перечисляемые типы, массивы и т. д. Таким образом, на VB .NET можно написать пакет для работы с матрицами, в котором основная структура данных будет определяться следующим образом:
Public Structure Matrix
Private TheOata(,) As Double
' И т.д. End Structure
 
Пространства имен для создаваемых классов
Классы, перечисляемые типы, структуры или модули включаются в пространства имен. Конечно, создать экземпляр модуля невозможно — только экземпляры классов, определяемых в модуле. В диалоговом окне Project Properties, показанном на  9, присутствуют текстовые поля для имени сборки и корневого пространства имен,
На  9 указано корневое пространство имен Apress. При объявлении пространства имен в программе можно использовать иерархию произвольной глубины, отражающую логическую структуру нашей программы. Рассмотрим пример определения класса:
Namespace Cornell.Morrison.VB.NET.CH4
Module Module1
Sub Main()
Console.filriteLine("test code goes here")
End Sub
Public Class"EmployeeExamplel
' Код класса End Class
End Module
End Namespace
В этом случае полное имя класса выглядит так:
Apress.Cornell.Morrison.VB.NET.CH4.EmployeeExamplel
Пространства имен .NET в отличие от пакетов Java не привязаны к определенной структуре каталогов. Два класса могут принадлежать одному пространству имен даже в том случае, если они определяются в разных файлах, находящихся в разных каталогах.
 
Окно классов
Теперь, когда вы знаете, как определять собственные классы, вам будет проще работать с окном классов, в котором члены классов вашего решения отображаются в виде удобного иерархического дерева. Окно классов помогает ориентироваться в коде вашего решения: при двойном щелчке в одной из строк окна классов в окне программы автоматически открывается код соответствующего члена. Окно классов открывается командой View > Class View или комбинацией клавиш Ctrl+Shift+C. На  10 показано, как выглядит окно классов для одной из версий нашего класса Employee.
В левом верхнем углу окна расположена пара кнопок. Кнопка New Folder создает новую папку, но чаще используется кнопка Class View Sort By Type. Она открывает список, в котором выбирается режим представления информации в окне.

  • Sort Alphabetically. Классы и члены упорядочиваются по алфавиту (a-z).
  • Sort By Type. Классы и члены упорядочиваются по типу. Например, в этом режиме удобно сгруппировать все свойства (базовых классов, интерфейсов, методов и т. д.).
  • Sort By Access. Классы и члены упорядочиваются по уровню доступа.
  • Group By Type. Классы и члены группируются в разных узлах в зависимости от типа. Например, все свойства объединяются в узле Properties, а все поля — в узле Fields.

 
Отладка объектно-ориентированных программ
Отладка объектно-ориентированных программ всегда начинается с анализа объектных переменных и проверки того, соответствует ли их состояние предполагаемому. Именно по этой причине в VS IDE предусмотрены средства для получения информации о закрытых полях ваших классов — окна просмотра (Watch) и локальных переменных (Locals). Применение этих средств отладки будет рассмотрено на простом примере. Допустим, мы решили перейти от связанного списка к двусвязному. Проще говоря, в каждом элементе должна храниться не одна ссылка, а две — на следующий и на предыдущий элемент списка, чтобы перебор мог осуществляться не только в прямом, но и в обратном направлении. Ниже приведен первый вариант класса двусвязного списка, содержащий ошибку. На этом примере будут продемонстрированы основные приемы отладки объектно-ориентированных программ:
1 Option Strict On
2 Module Modulel
3 Sub Main()
4 Dim alinkList As New LinkedList("first link")
5 Dim aLink As LinkedList.Link
6 aLink = aLinklist.MakeLink(aLinkList.GetFirstLink, "second link")
7 aLink = aLinkList.MakeLinktaLink, "third link")
8 Console.WriteLine(aLinkList.GetFirstLink.MyData)
9 aLink = aLinkList.GetNextLink(aLinkList.GetFirstLink)
10 Console.Wri teLine(aLi nk.MyData)
11 Console.WriteLineCaLink.NextLink.MyData)
12 Console. ReadUne()
13 End Sub
14 Public Class LinkedList
15 Private m_CurrentLink As Link
16 Private nfFirstUnk As Link
17 Sub New(ByVal theData As String)
18 m_CurrentLink = New Link(theData)
19 m_FirstLink = m CurrentLink
20 End Sub
21 Public Function MakeLinktByVal currentLink As Link. ByVal _
22 theData As String) As Link
23 m_CurrentLink = New LinkCcurrentLink.theData)
24 Return m_CurrentLink
25 End Function
26 Public Readonly Property GetNextLink(ByVal aLink As Link)_
27 As Link
28 Get
29 Return aLink.NextLink()
30 End Get
31 End Property
32 Public Readonly Property GetCurrentLink() As Link
33 Get
34 Return m_CurrentLink
35 End Get
36 End Property
37 Public Readonly Property GetFirstLink() As Link
38 Get
39 Return m_FirstLink
40 End Get
41 End Property
42
43 ' Вложенный класс для ссылок
44 Friend Class Link
45 Private m_MyData As String
46 Private m_NextLink As Link
47' Private m_ParentLink As Link
48 Friend Sub New(ByVal myParent As Link. ByVal theData As String)
49 m_MyData = theData
50 m_Parentlink = Me
51 m_NextLink = myParent
52 End Sub
53 Friend Sub New(ByVal theData As String)
54 m_MyData = theData
55 End Sub
56 Friend Readonly Property MyData() As String
57 Get
58 Return m_MyData
59 End Get
60 End Property
61 Friend Readonly Property NextLink() As Link
62 Get
63 Return m_NextLink
64 End Get
65 End Property
66 End Class
67 End Class
68 End Module
Результат работы программы показан на  11. Конечно, это совсем не то, что мы ожидали получить.
В подобных ситуациях программу приходится отлаживать. Один из способов отладки описан ниже.

  • Нажмите кнопку Break в диалоговом окне, показанном на  11.
  • Закройте окно (в данном примере — консольное), чтобы вернуться в IDE.

Установите точку прерывания (F9) в позиции, с которой должен начаться анализ состояния различных объектов программы, — в нашем примере логично установить ее в строке, предшествующей той, в которой произошло исключение (строка 9 листинга). Запустите программу командой Debug > Start (клавиша F5). Откройте окно локальных переменных и выведите его на передний план. На  12 показано, как выглядит это окно. Рядом с именами объектных переменных aLink и aLinkedList расположены значки «+», на которых так и хочется щелкнуть.
Поскольку объектная переменная aLink соответствует третьей ссылке, очевидно, ссылка на предыдущий элемент не должна быть равна Nothi ng. Это наводит на мысль, что мы должны повнимательнее присмотреться к коду, в котором присваивается значение ссылки на предыдущий элемент.
Friend Sub New(ByVal myParent As Link. ByVal theData As String)
m_MyData = theData
m_ParentLink = Me
m_NextLink = myParent End Sub
Оказывается, мы перепутали операции присваивания ссылок и забыли задать ссылки из предыдущего элемента списка на текущий. Исправленный вариант этой функции должен выглядеть так:
Friend Sub NewtByVal myParent As Link, ByVal theData As String)
m_MyData = theData
m_ParentLink = myParent
m_ParentLink.m_NextLink = Me
End Sub
Возможности отладки не ограничиваются использованием окна локальных переменных. Например, вы можете установить условную точку прерывания по условию aLink Is Nothing или воспользоваться командой Add Watch контекстного меню в окне программы, когда программа находится в режиме прерывания. Впрочем, независимо от того, какой путь будет выбран, центральное место в процессе отладки занимает анализ состояния объектов.
 
Итоги
Глава получилась очень длинной. В ней вы познакомились с некоторыми встроенными классами .NET Framework, но главной темой была специфика работы с объектами в VB .NET. По сравнению с прежними версиями VB в этой области произошло много изменений, в основном принципиальных. В частности, были рассмотрены параметризованные конструкторы, значительно повышающие надежность создания объектов и их инициализацию. Короче говоря, в этой главе был изложен базовый материал, абсолютно необходимый для дальнейшего освоения VB .NET.

 

 
На главную | Содержание | < Назад....Вперёд >
С вопросами и предложениями можно обращаться по nicivas@bk.ru. 2013 г. Яндекс.Метрика