Objects and Classes - Visual Basic (2023)

AObjectis a combination of code and data that can be treated as a unit. An object can be part of an application, like a control or a form. A complete application can also be an object.

When you create an application in Visual Basic, you work with objects all the time. You can use objects provided by Visual Basic such as B. Controls, forms, and data access objects. You can also use objects from other applications in your Visual Basic application. You can even create your own objects and define additional properties and methods for them. Objects act like ready-made building blocks for programs - you can write a piece of code once and use it again and again.

This topic describes objects in detail.

objects and classes

Every object in Visual Basic is represented by aClassAre defined. A class describes an object's variables, properties, procedures, and events. Objects are instances of classes. You can create as many objects as you need once you have defined a class.

To understand the relationship between an object and its class, imagine cookie cutters and cookies. The cookie cutter is the class. It defines the characteristics of each biscuit, e.g. the size and shape. The class is used to create objects. The objects are the cookies.

You must create an object before you can access its members, except for elementsSharedwhich can be accessed without an object of the class.

Creating an object from a class

1. Determine which class you want to create an object from, or define your own class. Example:

   Public Class Customer Public Property AccountNumber As IntegerEnd Class

2. Write adim statementto create a variable to which you can assign a class instance. The variable should be of the type of the desired class.

   Dim nextCustomer As Customer

3. Add the keywordNew operatorto initialize the variable for a new instance of the class.

   Dim nextCustomer As New Customer

4. You can now access the members of the class through the object variable.

   nextCustomer.AccountNumber = lastAccountNumber + 1

Multiple Instances

Newly created objects from a class are often identical. However, once they exist as individual objects, their variables and properties can be modified independently of the other instances. For example, if you add three check boxes to a form, each check box object is an instance of the classCheckBox. The single onesCheckBox-Objects share a common set of characteristics and functions (properties, variables, procedures, and events) defined by class. However, each has its own name, can be turned on and off separately, and placed elsewhere on the form.

object member

An object is an element of an application, the oneinstancerepresents a class. Fields, properties, methods, and events are the building blocks of objects and make up theirsMember.

member access

You access a member of an object by sequentially specifying the object variable name, a period (.) and specify the name of the member. In the following example, theText-Property of aLabel-Object set.

warningLabel.Text = "Data not saved"

IntelliSense collection of members

IntelliSense lists the members of a class when you invoke the List Members option, such as when you type a period (.) as the member access operator. If you type the period after the name of a variable that was declared as an instance of that class, IntelliSense lists all instance members and none of the shared members. If you type the period after the class name itself, IntelliSense lists all shared members and none of the instance members. For more information, seeUsing IntelliSense.

fields and properties

FelderandCharacteristicsrepresent the information contained in an object. You get their values ​​and set them with assignment statements just as you get and set local variables in a procedure. The following example calls theWidthproperty and sets theForeColor-Property of aLabel-object.

Dim warningWidth As Integer = warningLabel.WidthwarningLabel.ForeColor = System.Drawing.Color.Red

Note that a field can also be used as aMembervariablereferred to as.

Use property procedures in the following cases:

• You must control when and how a value is set or retrieved.

• The property has a well-defined set of values ​​that need to be validated.

• Setting the value results in a perceptible change in the object's state, e.gIsVisible-Characteristic.

• Setting the property results in changes to other internal variables or the values ​​of other properties.

• A number of steps must be performed before the property can be set or retrieved.

Use fields in the following cases:

• The value is that of a self-checking type. Example: An error or automatic data conversion occurs if a value other thanTrueorFalseoneBooleanvariable is assigned.

• Any value in the range supported by the data type is invalid. This applies to many properties of typeSingleorDouble.

• The property is aString- Data type, and there is no constraint on the size or value of the string.

• For more information, seeProperty Procedures(property procedures).

methods

OneMethodis an action that can be performed by an object. For example, isAdda method ofComboBoxobject that adds a new entry to a combo box.

The following example demonstrates the use of theStart-Method oneTimer-object shown.

Dim safetyTimer As New System.Windows.Forms.TimersafetyTimer.Start()

Note that a method is simply aProcedureis provided by an object.

For more information, seeprocedures.

Events

An event is an action recognized by an object, such as a mouse click or key press, and for which you can write code in response. Events can occur as a result of user action, program code, or be caused by the system. Code that signals an event is said to be the eventtrigger, and code that responds to it shouldtransact.

You can also develop your own custom events to be raised by your objects and handled by other objects. For more information, seeevents.

When you create an object from a class, the result is an instance of that class. Members that don't match the keywordApprovedare declaredinstance members, which belong exclusively to this entity in question. An instance member in one instance is independent of the same member in another instance of the same class. For example, an instance member variable can have different values ​​in different instances.

Items tagged with the keywordSharedare declaredshared membersthat belong to a class as a whole and not to a specific instance. A shared member exists only once, regardless of how many instances you create of its class, or whether you create no instances. For example, a shared member variable contains only one value that is available to all code that can access the class.

1. Make sure the object is created from its class and assigned to an object variable.

   Dim secondForm As New System.Windows.Forms.Form

2. In the statement that accesses the element, follow the object variable name with theMemberzugriffsoperator(.) and then the member name.

   secondForm.Show()

• Follow the class name with theMemberzugriffsoperator(.) and then the member name. You should have oneShared-Always call the member of the object directly via the class name.

  Console.WriteLine("This computer is called " & Environment.MachineName)

• Alternatively, if you have already created an object from the class, you can create aShared-Call members via the object's variable.

Differences between classes and modules

The main difference between classes and modules is that classes can be instantiated as objects while standard modules cannot. Since there is only one copy of a standard module's data, when one part of your program changes a public variable in a standard module, every other part of the program gets the same value when it subsequently reads that variable. In contrast, object data exists separately for each instantiated object. Another difference is that unlike standard modules, classes can implement interfaces. If a class with theMustInherit modifieris marked, it cannot be instantiated directly. However, it is still different from a module as it can be inherited while modules cannot be inherited.

Classes and modules also use different scopes for their members. Members defined within a class are scoped to a specific instance of the class and exist only for the lifetime of the object. To access class members from outside a class, you must use fully qualified names in the formatObject.Memberuse.

On the other hand, by default, the members declared in a module can be called publicly and with any code that can call the module. This means that variables in a standard module are ultimately global variables since they are visible anywhere in the project and exist for the lifetime of the program.

Reuse of classes and objects

With objects, you can declare variables and procedures once and then reuse them whenever you need to. Example: If you want to add a spell checker to an application, you can define all the variables and support functions to provide the spell checker functionality. If you create your spell checker as a class, you can then reuse it in other applications by adding a reference to the compiled assembly. You might even be able to save yourself some work by using a spell checker class someone else has already developed.

.NET provides many examples of components that are available for use. The following example uses theTimeZone-class inSystem-Namespace.TimeZonecontains members that enable you to retrieve information about the current computer system's time zone.

Public Sub ExamineTimeZone() Dim tz As System.TimeZone = System.TimeZone.CurrentTimeZone Dim s As String = "Current time zone is " s &= CStr(tz.GetUtcOffset(Now).Hours) & " hours and " s &= CStr(tz.GetUtcOffset(Now).Minutes) & " minutes " s &= "different from UTC (coordinated universal time)" s &= vbCrLf & "and is currently " If tz.IsDaylightSavingTime(Now) = False Then s &= "not " s &= "on ""summer time""." Console.WriteLine(s)End Sub

In the previous example, declares the firstdim statementan object variable of typeTimeZoneand shows them to youTimeZone-Object added by theCurrentTimeZoneproperty was returned.

relationships between objects

Objects can be linked to each other in different ways. The basic types of relationships arehierarchicalandinclusion.

hierarchical relationship

When classes derive from more basic classes, ahierarchical relationshipspoken. Class hierarchies are useful when describing members that are a subtype of a more general class.

In the example below, let's assume you want a special kind of oneButton-Define elements that look like a normalButtonelement, but also provides a method that inverts the foreground and background colors.

Define a class that derives from an already existing class

1. Use oneclass statementto define a class from which to create the required object.

   Public Class ReversibleButton

   Make sure the last line of code in the class is aEnd Class-Instruction follows. By default, the integrated development environment (IDE) generates aClassstatement automaticallyEnd Class-Element.

2. TheClass-Instruction must be immediatelyinherits statementconsequences. Specify the class from which your new class is derived.

   Inherits System.Windows.Forms.Button

   Your new class inherits any members defined by the base class.

3. Add the code for the additional members that your derived class exposes. For example, you canReverseColorsmethod and the derived class could look like this:

   Public Class ReversibleButton Inherits System.Windows.Forms.Button Public Sub ReverseColors() Dim saveColor As System.Drawing.Color = Me.BackColor Me.BackColor = Me.ForeColor Me.ForeColor = saveColor End SubEnd Class

   If you select an object from theReversibleButtoncreate a class, it can access all members of theButtonclass, as well as the method and any other new elements thatReverseColorsyou defineReversibleButton.

Derived classes inherit members from the class on which they are based. This allows you to add complexity when navigating through a class hierarchy. For more information, seeFundamentals of Inheritance.

compiling the code

Make sure the compiler can call the class you want your new class to derive from. This can involve fully qualifying the name, as in the previous example, or identifying the namespace in aImports statement (.NET namespace and type). If the class is in another project, you may need to add a reference to the project. For more information, seeManaging references in a project.

inclusion relationship

Another way to link objects is ainclusion relationship. Container objects logically enclose other objects. For example, this containsOperatingSystem-object oneVersion-Object logical it through itsVersionproperty returns. Note that the container object does not physically contain any other object.

collections

A specific type of object containment is represented bylistings. Collections are groups of similar objects that can be listed. Visual Basic supports a specific syntax in theFor Each... Next Statementthat you to iterate through the items of a collection. In addition, collections allow the use of aItem[]-Elements to retrieve elements by their index or by mapping to a unique string. Collections are easier to use than arrays because you can use them to add or remove elements without indexes. Because of their ease of use, collections are often used to store forms and controls.

Walkthrough: Defining Classes
Provides a step-by-step description of creating a class.

Overloaded properties and methods
Overloaded properties and methods

Fundamentals of Inheritance
Describes the inheritance modifiers, method and property overrides, MyClass, and MyBase.

Object Lifetime: Creation and destruction of objects
Explains how to create and remove class instances.

Anonymous The type
Describes how to create and use anonymous types, which allow you to create objects without writing a class definition for the data type.

Object initializers: named and anonymous types
Explains object initializers used to create instances of named and anonymous types with a single expression.

How to: Infer property names and types in declarations from anonymous types
Explains how to infer property names and types in declarations from anonymous types. Provides examples of successful and failed derivations.