重拾VB6（15）：Data-Aware Classes, Class Naming Conventions, Polymorphism

来自MSDN-2001-OCT: Visual Tools and Languages/Visual Studio 6.0 Documentation/Visual Basic Documentation/Using Visual Basic/Programmer’s Guide/Part 2: What Can You Do With Visual Basic/Programming with Objects/Creating Data-Aware Classes及之后的章节

 

1. Creating Data-Aware Classes

(1) In order to work with external sources of data, you need to make your class data-aware.

Data-aware classes can be divided into two categories — data consumers and data sources.

Class modules have two design-time properties, DataBindingBehavior and DataSourceBehavior, that determine how a class will interact with external data.

The BindingCollection object is used to bind data-aware classes to controls or to each other.

(2) A data source is a class that provides data from an external source to be consumed by other objects.

The DataSourceBehavior property determines whether or not a class can act as a data source. By setting the DataSourceBehavior to 1 (vbDataSource), your class can act as a source of data for other objects.

(3) A data consumer is a class that can be bound to an external source of data. The DataBindingBehavior property allows a class to bind to external data.

By setting this property to 1 (vbSimpleBound), an object created from your class will be bound to a single data field in an external data source. By setting the DataBindingBehavior to 2 (vbComplexBound), your class will be bound to a row of data in an external data source.

(4) The BindingCollection is a collection of bindings between a data source and one or more data consumers.

Once the BindingCollection has been instantiated and its DataSource set, you can use the Add method to define the binding relationships. The Add method takes three required arguments: the name of the consumer object, the property of that object to be bound to the source, and the field from the source that will be bound to the property. You can add multiple bindings to the BindingCollection by repeating the Add method; you can use the Remove method to delete a binding.

1.1 Creating a Data Source

(1) When DataSourceBehavior is set to vbDataSource, a new Sub procedure GetDataMember is added to the class module.

(2) The GetDataMember procedure sets the source of the data for the class. Your data source class can provide multiple data sources by adding a Select Case statement to the GetDataMember procedure and passing in a source name in the DataMember argument.

1.2 Creating a Data Consumer

Option Explicit
Private objSource As MySource
Private objBindingCollection As BindingCollection
Private objConsumer As MyConsumer

Private Sub Form_Load()
   Set objSource = New MySource
   Set objBindingCollection = New BindingCollection
   Set objConsumer = New MyConsumer

   ' Assign the source class to the Binding
   ' Collection’s DataSource property.
   Set objBindingCollection.DataSource = objSource
   ' Add a binding.
   objBindingCollection.Add txtConsumer, "Text", "Directory"
   objBindingCollection.Add objConsumer, "DirName", "Directory"
end sub

 

2. Naming Properties, Methods, and Events

(1) Use entire words whenever possible. If whole words are too long, use complete first syllables.

(2) Use mixed case for your identifiers, capitalizing each word or syllable, as for example ShortcutMenus or AsyncReadComplete.

(3) Use the correct plural for collection class names, as for example Worksheets, Forms, or Widgets. If the collection holds objects with a name that ends in "s," append the word "Collection," as for example SeriesCollection.

(4) Use either verb/object or object/verb order consistently for your method names.

(5) Best to avoid the underscore character altogether when naming properties, methods, and events.

 

3. Polymorphism

3.1 How Visual Basic Provides Polymorphism

Polymorphism becomes a powerful mechanism for evolving systems of software components.

(1) Visual Basic doesn't use inheritance to provide polymorphism. Visual Basic provides polymorphism through multiple ActiveX interfaces. An interface is a set of related properties and methods.

(2) Polymorphism is important for performance reasons.

Public Sub GetFood(ByVal Critter As Object, _
ByVal Food As Object)
   Dim dblDistance As Double
   ' Code to calculate distance to food (omitted).
   Critter.Move dblDistance   ' Late bound
   Critter.Bite Food            ' Late bound
End Sub

The Move and Bite methods are late bound to Critter. Because it can't tell what the object will be, Visual Basic compiles some extra code to ask the object if it supports the method you've called. If the object supports the method, this extra code invokes it; if not, the extra code raises an error. Every method or property call incurs this additional overhead.

By contrast, interfaces allow early binding. When Visual Basic knows at compile time what interface is being called, it can check the type library to see if that interface supports the method. Visual Basic can then compile in a direct jump to the method, using a virtual function table (vtable). This is many times faster than late binding.  

Public Sub GetFood(ByVal Critter As Animal, _
ByVal Food As Object)
   Dim dblDistance As Double
   ' Code to calculate distance to food (omitted).
   Critter.Move dblDistance   ' Early bound (vtable).
   Critter.Bite Food            ' Early bound (vtable).
End Sub

3.2  Creating and Implementing an Interface for an abstract class

(1) An abstract class contains no implementation code. 里面的interface声明为public, 而对应的implements声明为private. Note all these are done automatically.

(2) An interface is like a contract. By implementing the interface, a class agrees to respond when any property or method of the interface is invoked. Therefore, you must implement all the properties and methods of an interface.

(3) 模板类里的public variable会对应implements里的读写变量。也可以直接在模板类里写成只读变量：

Public Property Get Age() As Double

End Property

3.3  About Objects and Interfaces

(1) An object may have multiple interfaces, but it's still the same object underneath.

Private Sub Command1_Click()
   Dim ty As Tyrannosaur
   Dim anim As Animal

   Set ty = New Tyrannosaur
   Set anim = ty
   MsgBox TypeName(anim)
End Sub

You might expect the message box to display "Animal," but in fact it displays "Tyrannosaur."

(2) In Visual Basic, each class has a default interface that has almost the same name as the class. By convention, an underscore is prefixed to the class name. The underscore indicates that this interface is hidden in the type library.

Thus the Tyrannosaur class has a default interface called _Tyrannosaur. Because Tyrannosaur also implements Animal, the class has a second interface named Animal.

(3) Querying for Interfaces：When you assign a Tyrannosaur object to variable of type Animal, Visual Basic asks the Tyrannosaur object if it supports the Animal interface. (The method used for this is called QueryInterface, or QI for short; you may sometimes hear QI used as a verb.) If the answer is no, an error occurs.

If the answer is yes, the object is assigned to the variable. Only the methods and properties of the Animal interface can be accessed through this variable.

(4) The interface the variable will access is the last interface assigned. For example: add the following method to the Tyrannosaur class:  

Public Sub Growl()
   Debug.Print "Rrrrrr"
End Sub

The Growl method belongs to the Tyrannosaur object's default interface.

Private Sub Command1_Click()
   Dim ty As Tyrannosaur
   Dim anim As Animal
   Dim obj As Object

   Set ty = New Tyrannosaur
   Set anim = ty
   Set obj = anim
   obj.Move 42      ' Succeeds
   obj.Growl      ' Fails

   Set obj = ty
   obj.Move 42      ' Fails
   obj.Growl      ' Succeeds
End Sub

3.4 Implement the interface of a fully functional class

(1) There are two main forms of code reuse — binary and source. Binary code reuse is accomplished by creating and using an object, while source code reuse is achieved by inheritance, which isn't supported by Visual Basic.

(2) Implement the interface of a fully functional class: You can create the inner object (that is, the implemented object) in the Initialize event of the outer object (that is, the one that implements the inner object's interface).

(3) You must implement all the members of the inner object's interface in the outer object's class module. However, you can be very selective in the way you delegate to the properties and methods of the inner object. In one method you might delegate directly to the inner object, passing the arguments unchanged, while in another method you might execute some code of your own before calling the inner object — and in a third method you might execute only your own code, ignoring the inner object altogether!

(4) Writing delegation code can indeed become tedious, especially if most of the outer object's properties and methods simply delegate directly to the corresponding properties and methods of the inner object. You can use the Visual Basic Extensibility model to create your own delegation wizard to automate the task.

(5)Visual Basic class modules are not your only source of interfaces to implement. You can implement any interface contained in a type library, as long as that interface supports Automation. You can create your own type libraries of abstract classes.