UNIT-II VISUAL BASIC.

NET

Lecture-9 SIMILARITES BETWEEN VB AND VB.NET Both languages support the creation of windows form application with the help of Graphical User Interface. Both languages support event driven programming. DIFFERENCE BETWEEN VB AND VB.NET VB
1. Integer Data type has changed. Short (Int16), Integer (Int32), Long (Int64). e.g.; Dim Age As Integer Dim ID As Long 2. Defining user defined types (UDT) has a new syntax. Type Customer CustomerNumber as Long CustomerName As String End Type 3. Public Property Get CustomerName() As String CustomerName = m_CustName End Property Public Property Let CustomerName(sCustName As String) m_CustName = sCustName End Property 4. Option Base can start from 1 or 0. 5. It supports Unstructured exception handling. 6. VB is object based. It doesn't support Inheritance and polymorphism. It supports interfaces in an awkward way. 7. VB doesnt supports multithreading. 8. By default the variable is variant. 9. VB is interpreted language. 10. It does not support concept of Partial classes. 11. 'If Not X Is Y' 12. VB is an Unmanaged Language. It is not supported by the feature of CLR. 13. VB has the drawback of DLL hell. 14. Dim x, y as Integer. VB will consider x as Variant and y as Integer. 15. ByRef is default. 16. It does not support feature of Garbage Collection. 17. It supports recordset and ADO for database connectivity. 18. It does not support interoperability. Structure Customer Public CustomerNumber as Integer Public CustomerName As String End Structure 3. Public Property CustomerName() As String Get CustomerName = m_CustName End Get Set m_CustName = Value End Set End Property 4. All arrays have Base 0. 5. It supports Structured as well as Unstructured exception handling. 6. VB.Net is object oriented. It supports Inheritance and polymorphism. It fully supports interface-based programming. 7. VB.Net supports multithreading. 8. By default the variable is object. 9. VB.Net is compiled language 10. It supports concept of Partial classes. 11. It supports IsNot operator. If X IsNot Y' 12. VB.Net is a Managed Language. It has a support of CLR feature. 13. It do not have DLL hell drawback. 14. Dim x, y as Integer. VB.Net will declare x and y both as Integer 15. ByVal is the default. 16. It supports feature of Garbage Collection. 17. It supports ADO.NET for database connectivity. 18. It supports interoperability.

VB.NET

Dim Age As Short Dim ID As Integer

Lecture-10 2.1 DECLARATION AND INITIALIZATION OF VARIABLES The Dim statement is used for declaring the variable using any data type. It can also be used for declaring the variable of type enumeration, structure, class, or interface. We can specify different data types for different variables by using a separate As clause for each variable we declare. Alternatively, we can declare several variables to be of the same type by using a common As clause. Each variable takes the data type specified in the first As clause encountered after its variablename part. Dim A As Integer Public A As Integer 2.1.1 How to declare multiple variables in a single line Dim A, B As Integer, STR As String Dim A As Integer : Dim B As Double Note: We can specify each variable's data type in the Dim statement. We can also specify an initial value. If we do not, Visual Basic uses default settings. We can use Dim only at module or procedure level. Undeclared variables and variables declared without data types are assigned the Object data type but it can cause slow execution. 2.1.2 Initialization Dim A As Integer = 1 Dim A As Integer = 1, B As Double = 2 Dim A As Integer = 1 : Dim B As Double = 2 Dim STR As String = "HELLO" Dim STR As String = "THIS IS A LONG SENTENCE" _ & "WHICH WE WANT TO PRINT" Dim a As Integer = 1 _ &2 2.1.3 How to Declare Constant We use the Const statement to declare a constant and set its value. By declaring a constant, we assign a meaningful name to a value. Once a constant is declared, it cannot be modified or assigned a new value. If we have a value that never changes in our application, we can define a named constant and use it in place of a literal value. A name is easier to remember than a value. We can define the constant just once and use it in many places in our code. If in a later version we need to redefine the value, the Const statement is the only place we need to make a change. Dim Const DaysInYear = 365 Private Const Days = 7 Public Const Funday As String = "Sunday" 2.1.4 How to declare multiple constants in a single line Public Const Four As Integer = 4, Five As Integer = 5, Six As Integer = 44

2.2 DATA TYPES The data type of a programming element refers to what kind of data it can hold and how it stores that data. Following are the data type in Visual Basic:TYPE Boolean Byte Char (single character) Date Decimal CLR TYPE STRUCTURE Boolean Byte Char STORAGE ALLOCATION Depends on platform 1 byte 2 bytes VALUE RANGE True or False 0 through 255 (unsigned) 0 through 65535 (unsigned)

DateTime Decimal

8 bytes 16 bytes

0:00:00 (midnight) on January 1, 0001 through 11:59:59 PM on December 31, 9999 0 through +/79,228,162,514,264,337,593,543,950,335 (+/7.9...E+28) with no decimal point; 0 through +/7.9228162514264337593543950335 with 28 places to the right of the decimal; smallest nonzero number is +/0.0000000000000000000000000001 (+/-1E-28) -1.79769313486231570E+308 through -4.94065645841246544E-324 for negative values; 4.94065645841246544E-324 through 1.79769313486231570E+308 for positive values -2,147,483,648 through 2,147,483,647 (signed) -9,223,372,036,854,775,808 through 9,223,372,036,854,775,807 (9.2...E+18 ) (signed) Any type can be stored in a variable of type Object

Double (doubleprecision floatingpoint) Integer Long (long integer) Object

Double

8 bytes

Int32 Int64

4 bytes 8 bytes

Object (class)

4 bytes on 32-bit platform 8 bytes on 64-bit platform 1 byte 2 bytes

SByte Short (short integer) Single (singleprecision floatingpoint) String (variablelength) UInteger ULong

SByte Int16

-128 through 127 (signed) -32,768 through 32,767 (signed)

Single

4 bytes

-3.4028235E+38 through -1.401298E-45 for negative values; 1.401298E-45 through 3.4028235E+38 for positive values 0 to approximately 2 billion Unicode characters

String (class)

Depends on implementing platform 4 bytes 8 bytes

UInt32 UInt64

0 through 4,294,967,295 (unsigned) 0 through 18,446,744,073,709,551,615 (1.8...E+19

UserDefined (structure) UShort Note:

(inherits from ValueType) UInt16

Depends on implementing platform 2 bytes

) (unsigned) Each member of the structure has a range determined by its data type and independent of the ranges of the other members 0 through 65,535 (unsigned)

The Object Data Type is the root type in the .NET Framework and in Visual Basic which means that all other data types and object types are derived from it. It also means that any other data type can be converted to Object.

2.2.1 Boolean Data Type 1. It holds values that can be only True or False. The keywords True and False correspond to the two states of Boolean variables. 2. We can use the Boolean data type to contain two-state values such as true/false, yes/no, or on/off. 3. The default value of Boolean is False. 4. The corresponding type in the .NET Framework is the System.Boolean structure. Dim A As Boolean If A = false Then System.Console.write("default value of boolean is false") End If Note: When Visual Basic converts numeric data type values to Boolean, 0 becomes False and all other values become True. When Visual Basic converts Boolean values to numeric types, False becomes 0 and True becomes -1. 2.2.2 Byte Data Type 1. Holds unsigned 8-bit (1-byte) integers that range in value from 0 through 255. 2. Use the Byte data type to contain binary data. 3. The default value of Byte is 0. Note:

Byte is an unsigned type so it cannot represent a negative number. If we use the unary minus (-) operator on an expression that evaluates to type Byte, Visual Basic converts the expression to Short first. The Byte data type widens to Short, UShort, Integer, UInteger, Long, ULong, Decimal, Single, or Double. This means we can convert Byte to any of these types without encountering a System.OverflowException error. The corresponding type in the .NET Framework is the System.Byte structure.

2.2.3 Char Data Type

1. Holds unsigned 2-byte code points ranging in value from 0 through 65535. Each code point, or character code, represents a single Unicode character. 2. Use the Char data type when we need to hold only a single character and do not need the overhead of String. In some cases we can use Char(), an array of Char elements, to hold multiple characters. 3. The default value of Char is the character with a code point of 0. 4. Visual Basic does not convert directly between Char and the numeric types. We can use the Asc, AscW Functions to convert a Char value to an Integer. We can use the Chr, ChrW Functions to convert an Integer value to a Char. 5. The first 128 code points (0127) of Unicode correspond to the letters and symbols on a standard U.S. keyboard. These first 128 code points are the same as those the ASCII character set defines. The second 128 code points (128255) represent special characters, such as Latin-based alphabet letters, accents, currency symbols, and fractions. Unicode uses the remaining code points (256-65535) for a wide variety of symbols, including worldwide textual characters, diacritics, and mathematical and technical symbols. Note:

Char is an unsigned type and cannot represent a negative value. In any case, we should not use Char to hold numeric values. The Char data type widens to String. This means we can convert Char to String and will not encounter a System.OverflowException error. Appending the literal type character C to a single-character string literal forces it to the Char data type. The corresponding type in the .NET Framework is the System.Char structure. You can use methods like IsDigit and IsPunctuation on a Char variable to determine its Unicode classification.

2.2.4 Date Data Type

1. 2. 3.

It holds 8-byte values that represent dates ranging from January 1 of the year 0001 through December 31 of the year 9999, and times from 12:00:00 AM (midnight) through 11:59:59.9999999 PM. The default value of Date is 0:00:00 (midnight) on January 1, 0001.

We must enclose a Date literal within number signs (# #). We must specify the date value in the format M/d/yyyy, for example #5/31/1993#. This requirement is independent of our locale and our computer's date and time format settings.The reason for this restriction is that the meaning of our code should never change depending on the locale in which our application is running. Suppose we hard-code a Date literal of #3/4/1998# and intend it to mean March 4, 1998. In a locale that uses mm/dd/yyyy, 3/4/1998 compiles as we intend. But suppose we deploy our application in many countries. In a locale that uses dd/mm/yyyy, our hard-coded literal would compile to April 3, 1998. In a locale that uses yyyy/mm/dd, the literal would be invalid (April 1998, 0003) and cause a compiler error. 4. The corresponding type in the .NET Framework is the System.DateTime structure. 5. If we convert a Date value to the String type, Visual Basic renders the date according to the short date format specified by the run-time locale, and it renders the time according to the time format (either 12-hour or 24hour) specified by the run-time locale. 6. If we do not include a date in a date/time literal, Visual Basic sets the date part of the value to January 1, 0001. If we do not include a time in a date/time literal, Visual Basic sets the time part of the value to the start of the day, that is, midnight (0:00:00). Syntax: Dim DateAndTime As Date = #8/13/2002 12:14 PM#

2.2.5 Double Data Type

1. 2. 3. 4.

Holds signed 8-byte double-precision floating-point. Double-precision numbers store an approximation of a real number. The Double data type provides the largest and smallest possible magnitudes for a number. The default value of Double is 0. The floating-point data types do not have any internal representation of trailing zero characters. For example, they do not distinguish between 4.2000 and 4.2. Consequently, trailing zero characters do not appear when we display or print floating-point values. Appending the literal type character R to a literal forces it to the Double data type. Appending the identifier type character # to any identifier forces it to Double. The corresponding type in the .NET Framework is the System.Double structure.

5. 6.

2.2.6 Decimal Data Type

1. 2. 3. 4.

Holds signed 16-byte values representing 96-bit (12-byte) integer numbers scaled by a variable power of 10. The scaling factor specifies the number of digits to the right of the decimal point; it ranges from 0 through 28. It is particularly suitable for calculations, such as financial, that require a large number of digits but cannot tolerate rounding errors. The default value of Decimal is 0. Decimal is not a floating-point data type. The Decimal structure holds a binary integer value, together with a sign bit and an integer scaling factor that specifies what portion of the value is a decimal fraction. Because of this, Decimal numbers have a more precise representation in memory than floating-point types (Single and Double). The Decimal data type is the slowest of all the numeric types. We should weigh the importance of precision against performance before choosing a data type. The Decimal data type widens to Single or Double. This means we can convert Decimal to either of these types without encountering a System.OverflowException error.

5. 6.

Visual Basic does not store trailing zeros in a Decimal literal. However, a Decimal variable preserves any trailing zeros acquired computationally. The following example illustrates this. 7. Appending the literal type character D to a literal forces it to the Decimal data type. Appending the identifier type character @ to any identifier forces it to Decimal. 8. The corresponding type in the .NET Framework is the System.Decimal structure. 2.2.7 Integer Data Type
1.

Holds signed 32-bit (4-byte) integers that range in value from -2,147,483,648 through 2,147,483,647. The Integer data type provides optimal performance on a 32-bit processor. The other integral types are slower to load and store from and to memory.
2.

The default value of Integer is 0. The Integer data type widens to Long, Decimal, Single, or Double. This means we can convert Integer to any one of these types without encountering a System.OverflowException error.
4. 5.

Appending the literal type character I to a literal forces it to the Integer data type. Appending the identifier type character % to any identifier forces it to Integer. The corresponding type in the .NET Framework is the System.Int32 structure.

2.2.8 Long Data Type 1. Holds signed 64-bit (8-byte) integers ranging in value from -9,223,372,036,854,775,808 through 9,223,372,036,854,775,807 (9.2...E+18) 2. Use the Long data type to contain integer numbers that are too large to fit in the Integer data type. 3. The default value of Long is 0. 4. The Long data type widens to Decimal, Single, or Double. This means we can convert Long to any one of these types without encountering a System.OverflowException error. 5. Appending the literal type character L to a literal forces it to the Long data type. Appending the identifier type character & to any identifier forces it to Long. 6. The corresponding type in the .NET Framework is the System.Int64 structure. 2.2.9 Object Data Type Holds 32-bit (4-byte) addresses that refer to objects. We can assign any reference type (string, array, class, or interface) to an Object variable. An Object variable can also refer to data of any value type (numeric, Boolean, Char, Date, structure, or enumeration). 2. The Object data type can point to data of any data type. We can use Object data type when we do not know at compile time what data type the variable might point to. Whatever data type it refers to, an Object variable does not contain the data value itself, but rather a pointer to the value. It always uses four bytes in computer memory, but this does not include the storage for the data representing the value of the variable. Because of the code that uses the pointer to locate the data, Object variables holding value types are slightly slower to access than explicitly typed variables. Performance. A variable you declare with the Object type is flexible enough to contain a reference to any object. However, when you invoke a method or property on such a variable, you always incur late binding (at run time). To force early binding (at compile time) and better performance, declare the variable with a specific class name, or cast it to the specific data type.
1.

The default value of Object is Nothing (a null reference). 4. All data types and all reference types widen to the Object data type. This means you can convert any type to Object without encountering a System.OverflowException error. However, if you convert between value types and Object, Visual Basic performs operations called boxing and unboxing, which make execution slower. 5. Object has no literal type character or identifier type character. 6. The corresponding type in the .NET Framework is the System.Object class.
3.

2.2.10 SByte Data Type 1. Holds signed 8-bit (1-byte) integers that range in value from -128 through 127.It can be used to contain integer values that do not require the full data width of Integer or even the half data width of Short to save memory consumption. 2. The default value of SByte is 0. 3. The SByte data type is not part of the Common Language Specification (CLS), so CLS-compliant code cannot consume a component that uses it. 4. The SByte data type widens to Short, Integer, Long, Decimal, Single, and Double. This means you can convert SByte to any of these types without encountering a System.OverflowException error. 5. SByte has no literal type character or identifier type character. 6. The corresponding type in the .NET Framework is the System.SByte structure.

2.2.11 Short Data Type 1. Holds signed 16-bit (2-byte) integers that range in value from -32,768 through 32,767.it can be used to contain integer values that do not require the full data width of Integer to save memory consumption. 2. The default value of Short is 0. 3. The Short data type widens to Integer, Long, Decimal, Single, or Double. This means you can convert Short to any one of these types without encountering a System.OverflowException error. 4. The literal type character S is used to the Short data type. 5. The corresponding type in the .NET Framework is the System.Int16 structure. 2.2.12 Single Data Type 1. Holds signed 4-byte single-precision floating-point numbers ranging from negative values to positive values. Single-precision numbers store an approximation of a real number. 2. It is used to contain floating-point values that do not require the full data width of Double. In some cases the common language runtime might be able to pack your Single variables closely together and save memory consumption. 3. The default value of Single is 0. 4. The Single data type widens to Double. This means you can convert Single to Double without encountering a System.OverflowException error. 5. The floating-point data types do not have any internal representation of trailing 0 characters. For example, they do not distinguish between 4.2000 and 4.2. Consequently, trailing 0 characters do not appear when you display or print floating-point values. 6. Appending the literal type character F to a literal forces it to the Single data type. Appending the identifier type character ! to any identifier forces it to Single. 7. The corresponding type in the .NET Framework is the System.Single structure. 2.2.13 String Data Type 1. Holds sequences of unsigned 2-byte code points that range in value from 0 through 65535. Each code point, or character code, represents a single Unicode character. A string can contain from 0 to approximately two billion (2 ^ 31) Unicode characters. 2. Use the String data type to hold multiple characters without the array management overhead of Char(), an array of Char elements. 3. The default value of String is Nothing (a null reference). It is not the same as the empty string (""). 4. You must enclose a String literal within quotation marks (" "). If you must include a quotation mark as one of the characters in the string, you use two contiguous quotation marks (""). The following example illustrates this. Dim h As String = "Hello" 5. Once you assign a string to a String variable, that string is immutable, which means you cannot change its length or contents. When you alter a string in any way, Visual Basic creates a new string and abandons the previous one. The String variable then points to the new string. 6. String cannot represent negative values. In any case, you should not use String to hold numeric values.

7. Appending the identifier type character $ to any identifier forces it to the String data type. String has no literal type character. However, the compiler treats literals enclosed in quotation marks (" ") as String. 8. The corresponding type in the .NET Framework is the System.String class. 2.2.14 UInteger Data Type 1. Holds unsigned 32-bit (4-byte) integers ranging in value from 0 through 4,294,967,295.The UInteger data type provides the largest unsigned value in the most efficient data width. 2. The default value of UInteger is 0. 2.2.15 ULong Data Type 1. Holds unsigned 64-bit (8-byte) integers. It can be used to contain binary data. 2. The default value of ULong is 0. 3. ULong is an unsigned type, it cannot represent a negative number. 4. The ULong data type is not part of the Common Language Specification 5. The ULong data type widens to Decimal, Single, and Double. This means you can convert ULong to any of these types without encountering a System.OverflowException error. 6. Appending the literal type characters UL to a literal forces it to the ULong data type. ULong has no identifier type character. 7. The corresponding type in the .NET Framework is the System.UInt64 structure. 2.2.16 User-Defined Data Type 1. Holds data in a format you define. The Structure statement defines the format. It is used when you need to combine various data types into a single unit, or when none of the elementary data types serve your needs. 2. The default value of a structure data type consists of the combination of the default values of each of its members. 2.2.17 UShort Data Type 1. Holds unsigned 16-bit (2-byte) integers ranging in value from 0 through 65,535. We use the UShort data type to contain binary data too large for Byte. 2. The default value of UShort is 0. 3. UShort is an unsigned type; it cannot represent a negative number. LS Compliance. 4. The UShort data type widens to Integer, UInteger, Long, ULong, Decimal, Single, and Double. This means you can convert UShort to any of these types without encountering a System.OverflowException error. 5. Appending the literal type characters US to a literal forces it to the UShort data type. UShort has no identifier type character. 6. The corresponding type in the .NET Framework is the System.UInt16 structure. Advantages of using data types Specifying data types for all our variables is known as strong typing. It has several advantages:

It takes advantage of compiler type checking. This catches statements that can fail at run time due to errors such as overflow. It also catches calls to methods on objects that do not support them. It results in faster execution of our code.

2.3. Types A data type is a value type if it holds the data within its own memory allocation. A reference type contains a pointer to another memory location that holds the data. 2.3.1 Value Types Value types include the following: All numeric data types Boolean, Char, and Date All structures, even if their members are reference types Enumerations, since their underlying type is always SByte, Short, Integer, Long, Byte, UShort, UInteger, or ULong

2.3.2 Reference Types Reference types include the following: String All arrays, even if their elements are value types Class types, such as Form

NOTE: We can assign either a reference type or a value type to a variable of the Object data type. An Object variable always holds a pointer to the data, never the data itself. However, if we assign a value type to an Object variable, it behaves as if it holds its own data. In the .NET Framework, a structure is a value type and a class is a reference type. For this reason, value types such as Char and Integer are implemented by .NET Framework structures, whereas reference types such as Object and String are supported by .NET Framework classes. Note that every array is a reference type, even if its members are value types, and that every structure is a value type, even if it has reference type members.

2.4 Type Conversion The process of changing a value from one data type to another is called Type Conversion. Conversions are either Widening or Narrowing depending on the data capacities of the types involved. It is also implicit or explicit depending on the syntax in the source code. 2.4.1 Widening and Narrowing Conversions In type conversion the result of the conversion may exist within the range of the destination data type or not. A Widening conversion changes a value to a data type that can accommodate any possible value of the original data. A narrowing conversion changes a value to a data type that might not be able to hold some of the possible values.

2.4.1.1 Widening Conversions Widening conversion changes a value to a data type that can accommodate any possible values of the original data. It always succeed at run time and never incur data loss and always performed implicitly. The table shows the standard widening conversions: DATA TYPE SByte Byte Short UShort Integer UInteger Long ULong Decimal Single Double Any enumerated type (Enum) Char Char array Any type NOTE: By definition, every data type widens to itself. Conversions from Integer, UInteger, Long, ULong, or Decimal to Single or Double might result in loss of precision, but never in loss of magnitude. In this sense they do not incur information loss. Widening conversions always succeed at run time and never incur data loss. You can always perform them implicitly, whether the Option Strict Statement sets the type checking switch to On or to Off. WIDENS TO DATA TYPES SByte, Short, Integer, Long, Decimal, Single, Double Byte, Short, UShort, Integer, UInteger, Long, ULong, Decimal, Single, Double Short, Integer, Long, Decimal, Single, Double UShort, Integer, UInteger, Long, ULong, Decimal, Single, Double Integer, Long, Decimal, Single, Double UInteger, Long, ULong, Decimal, Single, Double Long, Decimal, Single, Double ULong, Decimal, Single, Double Decimal, Single, Double Single, Double Double Its underlying integral type and any type to which the underlying type widens Char, String Char array, String Object

2.4.1.2 Narrowing Conversions Narrowing conversion changes a value to a data type that might not be able to hold some of the possible values. The standard narrowing conversions include the following:

The reverse directions of the widening conversions in the preceding table (except that every type widens to itself) Conversions in either direction between Boolean and any numeric type Conversions from any numeric type to any enumerated type (Enum) Conversions in either direction between String and any numeric type, Boolean, or Date Conversions from a data type or object type to a type derived from it

Narrowing conversions do not always succeed at run time, and can fail or incur data loss. An error occurs if the destination data type cannot receive the value being converted. For example, a numeric conversion can result in an

overflow. The compiler does not allow you to perform narrowing conversions implicitly unless the Option Strict Statement sets the type checking switch to Off. ExDim num1 As Integer =35786 Dim num2 As Short num2=num1 Narrowing conversion so compiler doesnt allow to perform implicitly. Here overflow exception occurred. NOTE: Widening conversions always succeed, they do not throw exceptions. Narrowing conversions, when they fail, most commonly throw the following exceptions:

InvalidCastException if no conversion is defined between the two types OverflowException if the converted value is too large for the target type

2.5 Implicit & Explicit Conversion 2.5.1 Implicit Conversion An implicit conversion doesnt require any special syntax in the source code. Widening Conversion is always implicit. ExDim num1 As Integer =35786 Dim num2 As double num2=num1

2.5.2 Explicit Conversion Explicit conversion uses a type conversion keyword. These keyword act like a function which accept one parameter. Following functions are used to convert a value to a specific data type:Function name CBool() CByte() CChar() CDate() CDbl() CDec() CInt() CLng() CObj() CSByte() CShort() CSng() CStr() CUInt() CULng() CUShort() Return data type Boolean Data Type Byte Data Type Char Data Type Date Data Type Double Data Type Decimal Data Type Integer Data Type Long Data Type Object Data Type SByte Data Type Short Data Type Single Data Type String Data Type UInteger Data Type ULong Data Type UShort Data Type

NOTE: If the expression passed to the function is outside the range of the data type to which it is to be converted, an OverflowException occurs. When we convert a nonintegral value to an integral type, the integer conversion functions (CByte, CInt, CLng, CSByte, CShort, CUInt, CULng, and CUShort) remove the fractional part and round the value to the closest integer. If the fractional part is exactly 0.5, the integer conversion functions round it to the nearest even integer. For example, 0.5 rounds to 0. 2.5.2.1 CType Function The CType Function is an alternative conversion function available in VB.NET which can be used for for any kind of type conversion. It takes two arguments; first argument specifies value to be converted and second argument specifies typename to which value is to be converted. Dim Number As Long = 1000 Dim NewNumber As Single = CType (Number, Single) 2.5.2.2 TryCast Function It is a type conversion function which is used for any kind of reference type conversion that does not throw an exception. If an attempted conversion fails then CType throws InvalidCastException error which can adversely affect the performance of application where as TryCast returns nothing instead of having to handle a possible exception. Dim Number As Long = 1000 Dim NewNumber As Object = CType (Number, Object) Summary:Keyword CType() TryCast() 2.6 Boxing & Unboxing Boxing is the process of converting a value type to the object type or to any reference type implemented by this value. When the CLR boxes a value type , it wraps the value inside a System.Object and store it on the managed heap. Unboxing is the reverse of boxing wherein object type is converted into value type. Note:- Boxing is performed implicitly and Unboxing is performed explicitly. ExDim num1 As Integer =432 Dim obj As Object obj=num1 Boxing Process Dim num1 As Integer Dim obj As Object=432 num1=CInt(obj) Data types Any data types Reference types only Run-time failure Throws InvalidCastException Returns Nothing

Ex-

Unboxing Process Lecture-11

2.7 Basic Operators

Visual Basic comes with many built-in operators that allow us to manipulate data. An operator performs a function on one or more operands. For example, we add two variables with the "+" addition operator and store the result in a third variable with the "=" assignment operator like this: int x + int y = int z. The two variables (x ,y) are called operands. There are different types of operators in Visual Basic and they are described below in the order of their precedence. Arithmetic Operators Arithmetic operators are used to perform arithmetic operations that involve calculation of numeric values. The table below summarizes them: Operator + * \ / MOD ^ Concatenation Operators Concatenation operators join multiple strings into a single string. There are two concatenation operators, + and & as summarized below: Operator + & String Concatenation String Concatenation Use Use Addition Subtraction Multiplication Division Integer Division Modulus Arithmetic (Return remainder) Exponentiation

Note:- When concatenating a string variable with a numeric value then dont use + operator otherwise it will give an error. Comparison Operators A comparison operator compares operands and returns a logical value based on whether the comparison is true or not. The table below summarizes them: Operator = <> < > >= <= Like Is Use Equality Inequality (i.e Not Equal) Less than Greater than Greater than or equal to Less than or equal to Matches a string to pattern & return true if string matches otherwise false Compare 2 object reference variable and return true if both refer to same object otherwise false.

Like Operator Like operator matches a string to pattern and return true if string matches a pattern otherwise return false.

Syntax: Result= String Like Pattern Note- Result will be of Boolean Type. ExDim Result as Boolean Result=Hello Like He* MsgBox(Result) Return True

Pattern matching feature allow to match string using Wildcard Characters, Character-list or character ranges, in any combinations. Character In pattern ? * # [charlist] [!charlist] Example:1. MsgBox (Bat Like B?t) MsgBox (Bit Like B?t) 2. MsgBox(John Like Jo*) MsgBox(Joan Like Jo*) MsgBox(Joann Like Jo*) 3. MsgBox(401 Like #01) MsgBox(part-301 Like *3##) 4. MsgBox(Bat Like B[a-f]t) MsgBox(Bit Like B[a-f]t) MsgBox(Bat Like B[!a-f]t) Logical / Bitwise Operators The logical operators compare Boolean expressions and return a Boolean result. In short, logical operators are expressions which return a true or false result over a conditional expression. The table below summarizes them: Operator Not And AndAlso Or OrElse Xor Assignment Operator Visual Basic .NET provides several assignment operators for abbreviating assignment statements. Negation Conjunction Conjunction Disjunction Disjunction Disjunction Use O/P True O/P True O/P- True O/P- True O/P- True O/P- True O/P- True O/P - True O/P - False O/P - True Matches in String Any single character Zero or more character Any single digit (0-9) Any single character in list Any single character not in list i.e. match is made if any character except the characters in charlist is found in string

Operator = += -+ *= /= \= MOD= ^= &= 2.8 Enumeration

Use Assignment Addition Assignment Subtraction Assignment Multiplication Assignment Division Assignment Integer Division Assignment Mod Assignment Exponentiation Assignment Concatenation Assignment

Enumeration is a distinct type consisting of a set of named constant called the Enumeration list. Enumerations provide a convenient way to work with sets of related constants and to associate constant values with names which are easier to remember than their values. This also improves the readability of code because all the related values use the same enumeration name. For example, we can declare an enumeration for a set of integer constants associated with the days of the week, and then use the names of the days rather than their integer values in your code. Every enumeration has an underlying type which can be any integral type. Integral data types are those that represent only whole number. Ex-Byte(unsigned),Short,integer,Long,SByte,Ushort,UInteger,ULong. Note:- If we dont specify data type for the enumerator then the default data type is imposed on enumeration which of Integer type. Syntax for Declaring Enumeration:Enum [Enumeration Name] [As] [Integral Data Type] Enumeration list End Enum Example:Enum days Sunday Monday Tuesday Wednesday Thursday Friday Saturday End Enum

Use of Enumeration Console.WriteLine(Days. Sunday) Note:

 Visual Basic initializes the first member with value zero if no value is given to it followed by an (n+1) progression Enumerations do not necessarily need to follow a sequential ordering. For example:Enum BoilingPoints As Byte Fahrenheit = 212 Celcius = 100 End Enum Console.WriteLine(BoilingPoints. Celcius) If the value of a member exceeds the allowable range for the underlying data type, or if you initialize any member to the maximum value allowed by the underlying data type, the compiler reports an error. Values of enumeration can repeat. For example:Enum Colors Red = 1 Brown = 2 Green = 1 End Enum 2.9 Option Statements 2.9.1 OPTION EXPLICIT Forces explicit declaration of all variables to be used in the program if it is turned on. Syntax:Option Explicit [On|Off] If used, the Option Explicit statement must appear before any other source code statements. If we try to use an undeclared variable name, an error occurs at compile time. If we do not specify Option Explicit in our code than by default Option Explicit is On.

2.9.2 OPTION STRICT

Using Option Strict On we can prevent narrowing conversion which lead to data loss and causes runtime failure.. Option Strict ensures compile-time notification if narrowing conversions occurs without an explicit

cast operator so that they can be avoided. It restricts implicit data type conversions to only widening conversions. Syntax:Option Strict [On|Off]

If used, the Option Strict statement must appear before any other source code. Because Option Strict On provides strong typing, prevents unintended type conversions with data loss and improves performance, its use is strongly recommended. The compiler default is Option Strict Off if we do not specify Option Strict in our code.

NOTE: The compiler default is Option Strict Off if we do not specify Option Strict in our code. 2.9.3 OPTION COMPARE

This is used to specify the default comparison method to be used when need to compare string datas. Option Compare Binary sets the string comparison method to Binary. If used, the Option Compare statement must appear in a file before any other source code statements. Syntax:Option Compare [Text|Binary]

The Option Compare statement specifies the string comparison method (Binary or Text) for a class, module or structure. If an Option Compare statement is not included, the default text comparison method is Binary.

2.9.4. OPTION INFER Syntax:Option Infer [On|Off] When Option Infer is set to On then we can declare variables without explicitly stating a data type. Compiler will infer the data type of a variable from the type of value it store.

2.10 IMPORTS STATEMENT IMPORTS STATEMENT is used to import any namespace. After using IMPORTS statement all named members of that namespace are available without qualification. For example:-

Imports System.Console Module module1 Sub main() Writleine("Hello") End Sub Each file can contain any number of Imports statements. Imports statements must be placed before any declarations.

2.11 SCOPE IN VB.NET The scope of a declared element is the set of all code that can refer to it without qualifying its name or making it available through an Imports Statement. An element can have scope at one of the following levels:2.11.1 BLOCK SCOPE A block is a set of statements enclosed within initiating and terminating declaration statements, such as the following: Do and Loop If and End If Select and End Select Try and End Try While and End While

For Example:If n < 1291 Then Dim cube As Integer Cube = n ^ 3 End If 2.11.2 PROCEDURE SCOPE An element declared within a procedure is not available outside that procedure. Only the procedure that contains the declaration can use it. Variables at this level are also known as local variables Sub main() Dim a As Integer Writleine(a) End Sub 2.11.3 MODULE SCOPE Module level applies to modules, classes, and structures. We can declare elements at this level by placing the declaration statement outside of any procedure or block but within the module, class, or structure. 2.11.4 NAMESPACE SCOPE If we declare an element at module level using the Friend (Visual Basic) or Public (Visual Basic) keyword, it becomes available to all procedures throughout the namespace in which the element is declared. With the following alteration to the preceding example, the string variable strMsg can be referred to by code anywhere in the namespace of its declaration. Namespace scope includes nested namespaces. An element available from within a namespace is also available from within any namespace nested inside that namespace.

If your project does not contain any Namespace Statements, everything in the project is in the same namespace. In this case, namespace scope can be thought of as project scope. Public elements in a module, class, or structure are also available to any project that references their project. Level Block scope Procedure scope Module scope Namespace scope Description Variable is available only within the code block in which it is declared Variable is available to all code within the procedure in which it is declared Variable is available to all code within the module, class, or structure in which it is declared Variable is available to all code in the namespace in which it is declared

2.12 CHECKING DATA TYPES FUNCTIONS Function IsArray() IsDate() IsDBNull() IsError () IsNothing() IsNumeric() IsReference() Description An array of values, rather than a single value A Date Data Type (Visual Basic) value, or a string that can be interpreted as a date and time value An object of type DBNull, which represents missing or nonexistent data An exception object, which derives from Exception Nothing (Visual Basic), that is, no object is currently assigned to the variable A number, or a string that can be interpreted as a number A reference type (such as a string, array, delegate, or class type)

Lecture-12

2.13 CONTROL FLOW CONTROL FLOW IN VISUAL BASIC Control structures allow regulating the flow of program's execution.

Control Flow

Decision Structures

Loop Structures

Decision Structures (A)IfThenElse If condition Then 'statements End If Dim A >=10 If A > 10 Then A = A + 1 : B = B + A : C = C + B Variation If condition Then 'statements Else 'statements End If If condition1 Then 'statements ElseIf condition2 Then 'statements ElseIf condition3 Then 'statements Else 'statements End If Example

Dim score As Integer, Result As String score = InputBox("Enter score") If score < 50 Then Result = "Failed" ElseIf score < 75 Then Result = "Pass" ElseIf score < 90 Then Result = "Very Good" Else Result = "Excellent" End If MsgBox(Result) (B) Select...Case Statement An alternative to the efficient, but difficult-to-read, code of the multiple-ElseIf structure is the Select Case structure, which compares one expression to different values. The advantage of the Select Case statement over multiple If ThenElse/ElseIf statements is that it makes the code easier to read and maintain. Select Case expression Case value1 statementblock1 Case value2 statementblock2 Case Else statementblockN End Select Example Dim message As String Select Case Now.DayOfWeek Case DayOfWeek.Monday message = "Have a nice week" Case DayOfWeek.Friday message = "Have a nice weekend" Case Else message = "Welcome back!" End Select MsgBox(message) Select Case Now.DayOfWeek Case DayOfWeek.Monday message = "Have a nice week" Case DayOfWeek.Tuesday, DayOfWeek.Wednesday, _ DayOfWeek.Thursday, DayOfWeek.Friday message = "Welcome back!" Case DayOfWeek.Friday, DayOfWeek.Saturday, DayOfWeek.Sunday message = "Have a nice weekend!" End Select MsgBox(message)

Looping Structures
(A)FORNEXT

For counter = start To end [Step increment] statements Next [counter] Example: For i = 0 To 10 Console.WriteLine(i) i=i+1 Next i (B)DoLoop To execute a block of statements while a condition is true. Do While condition Statement(s) Loop Example Dim d, e As Integer d=0 e=6 While e > 4 e -= 1 d += 1 End While System.Console.WriteLine("The Loop ran " & e & "times") To execute a block of statements until the condition becomes true. (C)Do Until.Loop Do Until Condition Statement(s) Loop Example Dim str As String Do Until str = "Cool" Console.WriteLine("What to do?") str = System.Console.ReadLine() Loop

2.14 CONTINUE STATEMENT This statement transfers control immediately to the next iteration of a loop. You can transfer from inside a Do, For, or While loop to the next iteration of that loop. Control passes immediately to the loop condition test, which is equivalent to transferring to the For or While statement, or to the Do or Loop statement that contains the Until or While clause. Module Module1 Sub Main() Dim index As Integer = -1 Dim input As Integer = 0 Dim unemp As Integer = -1 Do index += 1 Console.WriteLine("1. Enter 1 for Employed" & vbNewLine & "2. Enter 0 for Exit" & vbNewLine & "3. Enter 2 for UnEmployed") input = Val(Console.ReadLine()) If input = 1 Then Continue Do unemp += 1 Loop While input <> 0 Console.WriteLine("{0} Out of {1} people are UnEmployed", unemp, index) Console.ReadLine() End Sub End Module

2.15 WITH...END WITH It executes a series of statements making repeated reference to a single object or structure. We can use a With...End With structure to specify the object once for all of the statements.

With testObject .Height = 100 .Text = "Hello, World" .ForeColor = System.Drawing.Color.Green End With

HOW TO: ADD A COMMENT Comment character (') at the beginning or in the middle of any line ' This entire line is a comment. Dim Total As Decimal = 0 ' Sales total for today

HOW TO: BREAK AND COMBINE STATEMENTS IN CODE cmd.CommandText = _ "SELECT * FROM Titles JOIN Publishers " _ & "ON Publishers.PubId = Titles.PubID " _ & "WHERE Publishers.State = 'CA'"

SPECIAL CHARACTERS IN CODE 1. PARENTHESES 2. SEPARATORS

MEMBER ACCESS OPERATORS DOT (.) OPERATOR Dim nextForm As New ' Access Text member (property) of Form class (on nextForm object). nextForm.Text = "This is the next form" ' Access Close member (method) on nextForm nextForm.Close()

Lecture-13 2.16 Arrays

An array is a set of values that are logically related to each other, such as the number of students in each grade in a grammar school. An array allows you to refer to these related values by the same name and to use a number, called an index or subscript, to tell them apart. The individual values are called the elements of the array. They are contiguous from index 0 through the highest index value. In contrast to an array, a variable containing a single value is called a scalar variable. Dim students(6) As Integer Dim values As Double() = {1, 2, 3, 4, 5, 6} The array students in the preceding example contain 7 elements. The indexes of the elements range from 0 through 6. Having this array is simpler than declaring 7 different variables. The following illustration shows the array students. For each element of the array: The index of the element represents the grade (index 0 represents kindergarten). The value contained in the element represents the number of students in that grade. Elements of the "students" array

The following example shows how to refer to the first, second, and last element of the array students. Dim kindergarten As Integer = students(0) Dim firstGrade As Integer = students(1) Dim sixthGrade As Integer = students(6) MsgBox("Students in kindergarten = " & CStr(kindergarten)) MsgBox("Students in first grade = " & CStr(firstGrade)) MsgBox("Students in sixth grade = " & CStr(sixthGrade)) 2.16.1 Array Dimensions The array students in the preceding example uses one index and is said to be one-dimensional. An array that uses more than one index or subscript is called multidimensional.A dimension is a direction in which you can vary the specification of an array's elements. An array that holds the sales total for each day of the month has one dimension (the day of the month). An array that holds the sales total by department for each day of the month has two dimensions (the department number and the day of the month). The number of dimensions an array has is called its rank. You specify an element of an array by supplying an index or subscript for each of its dimensions. The elements are contiguous along each dimension from index 0 through the highest index for that dimension.

The following illustrations show the conceptual structure of arrays with different ranks. Each element in the illustrations shows the index values that access it. For example, you can access the first element of the second row of the two-dimensional array by specifying indexes (1, 0). One-dimensional array

Two-dimensional array

Three-dimensional array

One Dimension Many arrays have only one dimension, such as the number of people of each age. The only requirement to specify an element is the age for which that element holds the count. Therefore, such an array uses only one index. The following example declares a variable to hold a one-dimensional array of age counts for ages 0 through 120. To declare a one-dimensional array variable, add one pair of parentheses after the variable name. Dim cargoWeights() As Double Dim ageCounts(120) As UInteger Two Dimensions Some arrays have two dimensions, such as the number of offices on each floor of each building on a campus. The specification of an element requires both the building number and the floor, and each element holds the count for that combination of building and floor. Therefore, such an array uses two indexes. The following example declares a variable to hold a two-dimensional array of office counts, for buildings 0 through 40 and floors 0 through 5.

To declare a multidimensional array variable, add one pair of parentheses after the variable name and place commas inside the parentheses to separate the dimensions. Dim atmospherePressures(,,,) As Short Dim officeCounts(40, 5) As Byte NOTE: - A two-dimensional array is also called a rectangular array. Three Dimensions A few arrays have three dimensions, such as values in three-dimensional space. Such an array uses three indexes, which in this case represent the x, y, and z coordinates of physical space. The following example declares a variable to hold a three-dimensional array of air temperatures at various points in a three-dimensional volume. Dim airTemperatures(99, 99, 24) As Single More than Three Dimensions Although an array can have as many as 32 dimensions, it is rare to have more than three.Suppose you want to track sales amounts for every day of the present month. You might declare a one-dimensional array with 31 elements, one for each day of the month, as the following example shows. Dim salesAmounts(30) As Double Now suppose you want to track the same information not only for every day of a month but also for every month of the year. You might declare a two-dimensional array with 12 rows (for the months) and 31 columns (for the days), as the following example shows. Dim salesAmounts(11, 30) As Double Now suppose you decide to have your array hold information for more than one year. If you want to track sales amounts for 5 years, you could declare a three-dimensional array with 5 layers, 12 rows, and 31 columns, as the following example shows. Dim salesAmounts(4, 11, 30) As Double Note that, because each index varies from 0 to its maximum, each dimension of salesAmounts is declared as one less than the required length for that dimension. Note also that the size of the array increases with each new dimension. The three sizes in the preceding examples are 31, 372, and 1,860 elements respectively. 2.16.2 JAGGED ARRAY Another kind of array is one which holds other arrays as elements. This is known as an array of arrays or a jagged array. A jagged array can be either one-dimensional or multidimensional, and so can its elements. Sometimes the data structure in your application is two-dimensional but not rectangular. For example, you might have an array of months, each element of which is an array of days. Since different months have different numbers of days, the elements do not form a rectangular two-dimensional array. In such a case, you can use a jagged array instead of a multidimensional array. Dim colors(2)() As String Declaring an array of 3 arrays colors(0)=New String{Red,Blue,Green} Initializing the first array to 3 members and setting values colors(1)=New String(){yellow,purple,green,violet} Initializing the second array to 4 members and setting values Colors(2)=New string(){red,black,white,grey,aqua} Initializing the third array to 5 members and setting values

NOTE:- Zero-Length Arrays An array with no elements is also called a zero-length array. A variable holding a zero-length array does not have the value Nothing. To create an array that has no elements, declare one of the array's dimensions to be -1, as shown in the following example. Dim twoDimensionalStrings(-1, 3) As String You might need to create a zero-length array under the following circumstances: Your code needs to access members of the Array class, such as Length or Rank, or call a Visual Basic function such as UBound, without risking a NullReferenceException exception. You want to keep the consuming code simpler by not having to check for Nothing as a special case. Your code interacts with an application programming interface (API) that requires you to pass a zero-length array to one or more procedures, or that returns a zero-length array from one or more procedures. 2.16.3 DYNAMIC ARRAY We can change the size of an array after creating them Dim Test(10) As Integer ReDim Test(25) Reinitializing the array When using the ReDim statement all the data contained in the array is lost. If you want to preserve existing data when reinitializing an array then you should use the Preserve. Dim Test() As integer={1,3,5} ReDim Preserve Test(25) resizes the arrayn and return the data in elements 0 to 2.

Lecture-14
2.17.1 Array Class: Method and Properties All Array derived from the System.Array namespace so we must import this namespace to use the method and properties. Properties: 1.Length Return the length(total number of element) of a one-dimensional array in integer. Syntax: Arrayname.Length 2.2.Rank Return number of dimension of array. Syntax: Arrayname.Length Methods 1. Clear() Sets a range of elements to 0,NULL,False depending on the element type in one dimensional array. Syntax: Array.Clear(ArrayName, Starting index value, number of element to clear) 2.GetLength() Return the total n umber of element in the specified dimension of the array. 3.GetLowerBound() 4.GetUpperBound() 5.GetValue() 6.SetValue() 7.Sort() 7.Reverse() 2.17.2 String Class : Method and Properties String class under the System.String namespace provide several built in methods to facilitate comparison and manipulation of string. Methods 1.Compare()

2.Concat() 3.ToLower() 4.ToUpper() 5.Trim() 6.TrimEnd() 7.TrimStart() 8.SubString() 9.Replace() 10.Remove() 11.Insert()

Lecture-15
2.18 EXCEPTION HANDLING Errors Exceptions

Exception is an abnormal/unexpected/exceptional condition that encounter during runtime. Error can exceptional/unexpected or not. Error is a known workflow within application. For Example- Username not provided during authentication is an error. Exception can be used to convey an error but more generally is used to convey that something unexpected occurred. So, all Exceptions are Error but not vice-versa. TYPES OF EXCEPTION HANDLING Unstructured Exception Handling Structured Exception Handling

2.18.1 UNSTRUCTURED EXCEPTION HANDLING Unstructured exceptional handling uses On Error GoTo statement for handling the execution. Syntax: On Error {Goto [line|0|-1] Resume Next} GoToline Enables the error-handling routine that starts at the line specified in the required line argument. The line argument is any line label or line number. If a run-time error occurs, control branches to the specified line, making the error handler active. The specified line must be in the same procedure as the On Error statement, or a compile-time error will occur.

GoTo 0 Disables enabled error handler in the current procedure and resets it to Nothing. GoTo -1 Disables enabled exception in the current procedure and resets it to Nothing. Resume Next Specifies that when a run-time error occurs, control goes to the statement immediately following the statement where the error occurred, and execution continues from that point. Use this form rather than On Error GoTo when accessing objects

Example: Module Module1 Sub Main() On Error GoTo handler Dim a, b, c As Integer a=1 b=0 c=a/b Exit Sub handler: System.Console.WriteLine("Error") System.Console.ReadLine() End Sub End Module

Example: On Error Resume Next Dim a, b, c As Integer a=1 b=0 c=a/b System.Console.WriteLine("program completed") System.Console.ReadLine() Exit Sub

Example: On Error GoTo handler Dim a, b, c As Integer a=1 b=0 c=a/b Exit Sub handler: System.Console.WriteLine("Error Number(Err.Number): " & Err.Number & vbCrLf) System.Console.WriteLine("Error Description(Err.Description): " & Err.Description & vbCrLf) System.Console.WriteLine("Error Source File(Err.Source): " & Err.Source & vbCrLf) System.Console.WriteLine(Err.GetException) System.Console.ReadLine()

Example: On Error GoTo handler Dim a, b, c As Integer a=1 b=0 c=a/b handler: If TypeOf Err.GetException() Is OverflowException Then System.Console.WriteLine("overflow error") End If System.Console.ReadLine() Exit Sub

Example: Sub Main() On Error GoTo -1 Dim a, b, c As Integer a=1 b=0 c=a/b handler: If TypeOf Err.GetException() Is OverflowException Then System.Console.WriteLine("overflow error") End If System.Console.ReadLine() Exit Sub

Example: On Error GoTo handler Dim a, b, c As Integer a=1 b=0 Err.Raise(6) handler: System.Console.WriteLine(Err.Description) System.Console.ReadLine() Exit Sub

2.18.2 STRUCTURED EXCEPTION HANDLING Try [try statements] Exit Try Catch exception As Type [catch statemnets] Exit Try Catch exception2 As Type [catch statemnets] Finally [Finally statments] End Try Example: Try Dim a, b, c As Integer a=1 b=0 c=a/b Catch exception1 As Exception System.Console.WriteLine(exception1.Message & vbCrLf) System.Console.WriteLine(exception1.ToString) Exit Try End Try

Example: Try Dim a, b, c As Integer a=1

b=0 c=a/b Catch exception1 As System.OverflowException System.Console.WriteLine(exception1.Message & vbCrLf) System.Console.WriteLine(exception1.ToString) Exit Try Catch exception2 As Exception System.Console.WriteLine(exception2.Message & vbCrLf) System.Console.WriteLine(exception2.ToString) Exit Try Finally System.Console.WriteLine(vbCrLf & "program completed") End Try End Try

Example: Try Throw New OverflowException Catch exception1 As System.OverflowException System.Console.WriteLine(exception1.Message & vbCrLf) Exit Try

OBJECT ORIENTED PROGRAMMING FEATURES FOUR PILLARS OF OOPS Encapsulation Polymorphism Abstraction Inheritance

ENCAPSULATION

It can be defined as the separation between implementation and interface (i.e., data and function). It can be defined as wrapping up of data into single unit. It is also called as data hiding. Encapsulation is implemented using classes and structures. CLASSES Classes are the heart and soul of an object-oriented language. It is the user defined data type which can bind the data and function into single unit. It provides the template framework which can have data members and methods. It also consist some special procedures called as constructors and destructors. We can also create properties, procedures and classes in it. [Public Private Protected Friend Protected Friend] [MustInherit Partial NotInheritable] Classname [Inherits] classname [Implements] interfacename, interfacename Public Class Line Private ID As Integer Public Name As String Private mstrFileName As String

'NOTE: properties represents the charcterstics of an objet (Class). It uses

Set and Get method to manipulate internal values Property EMPID() As Integer Get Return ID End Get Set(ByVal Value As Integer) ID = Value End Set End Property ReadOnly Property EmpName() As String Get Return Name End Get End Property WriteOnly Property FileName() As String Set(ByVal Value As String) mstrFileName = Value End Set End Property Function display() As Integer Return mstrLine End Function Sub abc(ByVal a As Integer) Console.WriteLine(mstrLine) End Sub End Class

Sub Main() Dim oLine As Line = New Line() 'Or Dim oLine As New Line() System.Console.WriteLine(Obj.display()) End Sub DIFFERENCE BETWWEN CONSTRUCTORS AND METHODS Constructors No return type Same name as that of class. In VB.NET it is Sub New() End Sub block Called implicitly Methods May have return type Have different name Called explicitly

STRUCTURES
It is the user defined data type like classes which can bind the data and function into single unit. It provides the template framework which can have data members and methods. You cannot inherit from a structure; structures should be used only for objects that do not need to be extended. We can use structures when the object you wish to create has a small instance size.

Structure a [Public Private Protected Friend Protected Friend] [Partial] [Implements interfacename] End Structure

Structure abc Private id As Integer Public name As String Sub display(ByVal id As Integer) Console.WriteLine(id) End Sub End Structure Sub Main() Dim obj As New abc obj.name = "BCA" Console.WriteLine(obj.name) obj. display(1) End Sub SIMILARITIES BETWEEN STRUCTURES AND CLASSES

Structures and classes are similar in the following respects:

Both are container types, meaning that they contain other types as members. Both have members, which can include constructors, methods, properties, fields, constants, enumerations. Both can implement interfaces.

DIFFERENCE BETWEEN STRUCTURES AND CLASSES STRUCTURES Value type. Structures use stack allocation CLASSES Reference type. Classes use heap allocation.

Cannot have default constructors. Can have default constructors Cannot inherit any class or structures. That Can inherit any class or structures. is why structures are also called as sealed class. So it cannot override finalize method. All structure elements are Public by default class variables and constants are Private by default structure must have at least one nonshared class can be completely empty variable or nonshared, noncustom event element SHARED MEMBERS IN VISUAL BASIC Shared members are properties, procedures, and fields that are shared by all instances of a class or structure. Some programming languages refer to such items as static members.

SHARED FIELDS AND PROPERTIES Shared fields and properties are useful when you have information that is part of a class but is not specific to any one instance of a class. When you change the value of a shared field and property, you change the value associated with the class and all instances of the class. On the other hand, changing the value of a non-shared field or property associated with any one instance does not affect the value of that field or property in other instances of the class. Non-shared fields and properties exist independently for each instance of a class. In this way, shared fields and properties behave like global variables that can be accessed only from instances of a class, or with qualification of the class name. Without shared fields and properties, you would need to use modulelevel variables to achieve the same effect. However, module-level variables can make your classes difficult to understand and maintain. Furthermore, using module-level variables in this way violates the concept of encapsulation that classes represent. SHARED PROCEDURES Shared procedures are class methods that are not associated with a specific instance of a class. Shared procedures and properties do not have access to instances of the class.

Public Class Item Public Shared Count As Integer = 1 Public Shared Sub ShareMethod() MsgBox("Current value of Count: " & Count) End Sub Public Sub New(ByVal Name As String) ' Use Count to initialize SerialNumber. Me.SerialNumber = Count Me.Name = Name ' Increment the shared variable Count += 1 End Sub Public SerialNumber As Integer Public Name As String Public Sub InstanceMethod() MsgBox("Information in the first object: " & _ Me.SerialNumber & vbTab & Me.Name) End Sub End Class Sub TestShared() ' Create two instances of the class. Dim part1 As New Item("keyboard") Dim part2 As New Item("monitor") part1.InstanceMethod() part2.InstanceMethod() Item.ShareMethod() End Sub CONSTRUCTORS & DESTRUCTORS A Constructor is a special function which is called automatically when a class is created. A Destructor is a special function which is called automatically when a class is destroyed. In VB.NET, Class Dog 'The age variable Private Age As Integer Public Sub New() 'This constructor block Console.Writeline("Dog is Created With Age Zero") Age = 0 End Sub Public Sub New(ByVal val As Integer) Console.Writeline("Dog is Created With Age " + Convert.ToString(val)) Age = val End Sub

Protected Overrides Sub Finalize() 'This destructor block Console.Writeline("Dog is Destroyed") End Sub 'The Main Function End Class

ABSTRACTION
Public: Declaring a class as Public means you can "see" and instantiate this class in any other classes or subroutines within the same assembly. If you've compiled it into a DLL, referencing assemblies can see it, as well. Declaring a Public Sub / Function or Property means that when its container class is instantiated, the consumer can also see the method or property. Private: Private limits the visibility to a scope. Declaring a private class within a class means that "sub-class" can't be seen from outside of the class. This is also true for methods and properties - they can be seen within the class, but not to any consumers or inheritors. Protected: Protected members act as private members in class. This will more likely apply to methods and properties; they won't necessarily be seen outside of the class in which they're declared. However, if a class inherits the container class, that inheritor can see the protected members. Friend: This applies to classes, methods, and properties. They can be seen within the assembly, but not to any referencing assemblies or even inheritors. (This is the equivalent of "internal" in C#) Protected Friend: This is what it seems; classes, methods, and properties declared with this can be seen both within the assembly, as well as by inheritors. They cannot be seen from referencing assemblies. (This is "protected internal" in C#)

POLYMORPHISM
Public Overloads Sub Add(ByVal A As Integer, ByVal B As Integer) Console.Writeline("Adding Integers: " + Convert.ToString(a + b)) End Sub Public Overloads Sub Add(ByVal A As String, ByVal B As String) Console.Writeline("Adding Strings: " + a + b) End Sub

INHERITANCE
Inheritance is the property in which, a derived class acquires the attributes of its base class. In simple terms, you can create or 'inherit' your own class (derived class), using an existing class (base class). You can use the Inherits keyword for this.
Class Human 'This is something that all humans do Public Sub Walk() Console.Writeline("Walking") End Sub

End Class Class Programmer Inherits Human Public Sub StealCode() Console.Writeline("Stealing code") End Sub End Class

SOME IMPORTANT KEYWORDS

MustInherit
The MustInherit keyword specifies that a class cannot be instantiated and can be used only as a base class. i.e., if you declare our Human class as "MustInherit Class Human", then you can't create objects of type Human without inheriting it.

NotInheritable
The NotInheritable keyword specifies that a class cannot be inherited. I.e., if you specify 'NotInheritable Class Human', no derived classes can be made from the Human class.

The Overridable keyword is used to mark a function as overridable.

The keyword Overrides is used to mark that a function is overriding some base class function.

Class Human 'Speak() is declared Overridable Public Overridable Sub Speak() Console.Writeline("Speaking") End Sub End Class Class Indian Inherits Human Public Overrides Sub Speak() Console.Writeline("Speaking Hindi") End Sub End Class

INTERFACES
Interfaces define the properties, methods, and events that classes can implement. They also provide another way of implementing polymorphism. Through interfaces, we specify methods that a component must implement without actually specifying how the method is implemented. We just specify the methods in an interface and leave it to the class to implement those methods. Visual Basic .NET does not support multiple inheritance directly but using interfaces we can achieve multiple inheritance.

We use the Interface keyword to create an interface and implements keyword to implement the interface. Once you create an interface you need to implement all the methods specified in that interface. The following code demonstrates the use of interface. [ Public | Private | Protected | Friend | Protected Friend ] _ [ Shadows ] Interface name [ Inherits interfacename[, interfacename ]] [ [ Default ] Property proname ] [ Function memberame ] [ Sub memberame ] [ Event memberame ] End Interface

Example: Public Interface Test 'creating an Interface named Test Sub disp() Function Multiply() As Double 'specifying two methods in an interface End Interface Public Class One Implements Test 'implementing interface in class One Public i As Double = 12 Public j As Double = 12.17 Sub disp() Implements Test.disp 'implementing the method specified in interface WriteLine("sum of i+j is" & i + j) Read() End Sub Public Function multiply() As Double Implements Test.Multiply 'implementing the method specified in interface WriteLine(i * j) Read() End Function End Class

Example: Interface Interface1 Sub sub1(ByVal i As Integer) End Interface Interface Interface2 Inherits Interface1 ' Demonstrates interface inheritance. Sub M1(ByVal y As Integer) ReadOnly Property Num() As Integer End Interface Public Class ImplementationClass1 Implements Interface1

Sub Sub1(ByVal i As Integer) Implements Interface1.Sub1 ' Place code here to implement this method. End Sub End Class Public Class ImplementationClass2 Implements Interface2 Dim INum As Integer = 0 Sub sub1(ByVal i As Integer) Implements Interface2.Sub1 ' Place code here that implements this method. End Sub Sub M1(ByVal x As Integer) Implements Interface2.M1 ' Place code here to implement this method. End Sub ReadOnly Property Num() As Integer Implements _ Interface2.Num Get Num = INum End Get End Property End Class