Upload
satyam-gahatraj
View
129
Download
2
Tags:
Embed Size (px)
DESCRIPTION
it solved
Citation preview
SIKKIM MANIPAL UNIVERSITY
BT0082 – Visual Basic: SET 1 & SET 2
Mohd.Afnan
Roll.no:540910075
Course: BSc.IT
Semester: 4
BT0082 – Visual Basic: SET 1
1. Describe the importance and usage of .NET Framework in Visual Studio.
Ans.
The .NET Framework (pronounced “dot net framework”) defines the environment that
you use to execute Visual Basic .NET applications and the services you can use within
those applications. One of the main goals of this framework is to make it easier to
develop applications that run over the Internet. However, this framework can also be
used to develop traditional business applications that run on the Windows desktop.
To develop a Visual Basic .NET application, you use a product called Visual Studio .NET
(pronounced “Visual Studio dot net”). This is actually a suite of products that includes the
three programming languages described in table 1.1. In this book, of course, you’ll learn
how to use Visual Basic .NET, which is designed for rapid application development.
Visual Studio also includes several other components that make it an outstanding
development product. One of these is the Microsoft Development Environment, which
you’ll be introduced to in a moment. Another is the Microsoft SQL Server 2000 Desktop
Engine (or MSDE). MSDE is a database engine that runs on your own PC so you can
use Visual Studio for developing database applications that are compatible with
Microsoft SQL Server. SQL Server in turn is a database management system that can
be used to provide the data for large networks of users or for Internet applications.
The two other languages that come with Visual Studio .NET are C# and C++. C# .NET
(pronounced “C sharp dot net”) is a new language that has been developed by Microsoft
especially for the .NET Framework. Visual C++ .NET is Microsoft’s version of the C++
language that is used on many platforms besides Windows PCs.
In this figure, you can see that Visual Studio .NET can be used on any PC that runs
Windows 2000 or later. You can also see that the applications that are developed with
Visual Studio .NET can be run on any PC that runs Windows 98 or later, depending on
which .NET components are used by the application. From a practical point of view,
though, you can assume that the applications that you develop with Visual Basic .NET
will be run on PCs that are using Windows 2000 or later.
This figure also shows that Visual Basic .NET comes in an inexpensive Standard Edition
that includes only the Visual Basic language, not C# or C++. All but one of the Visual
Basic features presented in this book work with the Standard Edition as well as the full
Visual Studio .NET.
Although the three languages shown in this figure are the only three programming
languages you can use within Visual Studio .NET, other vendors are free to develop
languages for the .NET Framework. For example, Fujitsu has already developed a
version of COBOL for the .NET Framework.
2. Explain various basic data types and variables in Visual Basic.
Ans.
Basic Data Types and Their Mapping to the CTS (Common Type System)
There are two kinds of data types in VB.Net
1. Value type (implicit data types, Structure and Enumeration)
2. Reference Type (objects, delegates)
Value types are passed to methods by passing an exact copy while Reference types are
passed to methods by passing only their reference (handle). Implicit data types are
defined in the language core by the language vendor, while explicit data types are types
that are made by using or composing implicit data types.
As seen in the first unit, implicit data types in .net compliant languages are mapped to
types in Common Type System (CTS) and CLS (Common Language Specification).
Hence, each implicit data type in VB.Net has its corresponding .Net type. The implicit
data types in VB.Net are:
VB.NET
type
Corresponding
.Net type
Size in
bytes
description
Boolean
Boolean
1
Contains either
True or False
Char
Char
2
Contains any single Unicode character
enclosed in double quotation marks
followed by a c, for example "x"c
Integral types
Byte
Byte
1
May contain integers from 0-255
Short
Int16
2
Ranges from -32,768 to 32,767
Integer(def
ault)
Int32
4
Ranges from -2,147,483,648 to
2,147,483,647
Long
Int64
8
Ranges from -9,223,372,036,854,775,808 to
9,223,372,036,854,775,807
Floating point types
Single
Single
4
Ranges from ±1.5 × 10-45 to ±3.4 ×
1038 with 7 digits precision. Requires
the suffix 'f' or 'F'
Double(def
ault)
Double
8
Ranges from ±5.0 × 10-324 to ±1.7 ×
10308 with 15-16 digits precision.
Decimal
Decimal
12
Ranges from 1.0 × 10-28 to 7.9 × 1028
with 28-29 digits precision. Requires
the suffix 'm' or 'M'
Variables
During the execution of program, data is temporarily stored in memory. A variable is the
name given to a memory location holding particular type of data. So, each variable has
associated with it a data type and value. In VB.Net, a variable is declared as:
Dim <variable> as <data type>
Example:
Dim i As Integer
The above line will reserve an area of 4 bytes in memory to store integer type values,
which will be referred in the rest of program by identifier 'i'. You can initialize the variable
as you declare it (on the fly) and can also declare/initialize multiple variables of same
type in a single statement.
3. Write a VB program to find and display the greatest of three numbers. The input
should be taken through a form based application and the greatest number should
be displayed in a textbox on the form.
Ans.
If...Then...Else is also an statement, you can use it under other If...Then...Else
statements, like:
If i>5 Then ' line 1
If i=6 Then ' line 2
Console.WriteLine("Ok, 6 is also closer to 5")
Else ' line 4
Console.WriteLine("Oops! i is greater than 5 but not 6")
End If
Console.WriteLine("Thanks God, i finally becomes greater than 5")
Else ' line 8
Console.WriteLine("Missed...When will i become 5 or closed to 5?")
End If
4. Develop a form based interface to demonstrate the usage of combo box and list
box controls.
Ans.
Figure below shows you how to work with combo boxes and list boxes. In the form at the
top of this figure, a combo box lets the user select a number that represents the life of an
asset and a list box displays the depreciation amount for each year of the asset’s life. To
use this form, the user enters the initial cost of the asset and the final value of the asset
(which is often zero) in the text boxes. Then, the user selects the life of the asset from
the drop-down list of the combo box or enters the number of years into that box. Last,
the user clicks on the Calculate button to display the year and depreciation amounts in
the list box.
This figure also lists some of the properties and methods you’re likely to use as you work
with combo boxes and list boxes. To get the index value of the item that the user selects,
for example, you can use the SelectedIndex property. And to get the value of the
selected item, you can use the SelectedItem property. You’ll see coding examples that
use these properties in the next figure (figure 4.11).
One property that applies only to a combo box is the DropDownStyle property. This
property determines how the combo box functions. The default is DropDown, which
means that the user can either click on the drop-down arrow at the right side of the
combo box to display the drop-down list and select an item, or he can enter a value
directly into the text box portion of the combo box. Note that the value the user enters
doesn’t necessarily have to be a value that appears in the list.
If you want to restrict user entries to just the values in the list, you can set the
DropDownStyle property to DropDownList. Then, the user can only select a value from
the list or enter a value that appears in the list.
The third option for the DropDownStyle property is Simple. Like the DropDown setting,
this setting lets the user enter any value into the text box portion of the control. However,
instead of having to click on an arrow to display the list, the list is always visible.
When you work with the items in a list box or combo box, you should realize that you’re
actually working with the items in a collection. To refer to this collection, you use the
Items property of the control. Then, you can use the properties and methods that the
.NET Framework provides for working with collection objects to work with the items in
the collection. The most common properties and methods are summarized in this figure.
The most common event for working with combo boxes and list boxes is the
SelectedIndexChanged event. This event occurs when the value of the SelectedIndex
property changes, which is when the user selects a different item from the list. For a
combo box, you can also use the TextChanged event to detect when the user enters a
value into the text box portion of the control. Keep in mind, though, that this event will
occur each time a single character is added, changed, or deleted.
5. Explain the concept of Exceptions in .NET environment.
Ans.
.NET implements a systemwide, comprehensive approach to exception handling. As
noted in the chapter introduction, instead of an error number, there is an exception
object. This object contains information relevant to the error, exposed as properties of
the object. Later you’ll see a summary of the properties and the information they expose
in a table.
Such an object is an instance of a class that derives from a class named
System.Exception. As shown later, a variety of subclasses of System.Exception are
used for different circumstances.
Important Properties and Methods of an Exception
The Exception class has properties that contain useful information about the exception,
as shown in the following table:
Property Description
HelpLink A string indicating the link to help for this exception
InnerException Returns the exception object reference to an inner
(nested) exception
Message
A string that contains a description of the error,
suitable for displaying to users
Source
A string containing the name of an object that
generated the error
StackTrace
A read-only property that holds the stack trace as a
text string. The stack trace is a list of the pending
method calls at the point at which the exception was
detected. That is, if MethodA called MethodB, and
an exception occurred in MethodB, the stack trace
would contain both MethodA and MethodB.
TargetSite
A read-only string property that holds the method
that threw the exception
The two most important methods of the Exception class are as follows:
Method Description
GetBaseException Returns the first exception in the chain
ToString
Returns the error string, which might include as
much information as the error message, the inner
exceptions, and the stack trace, depending on the
error
6. Describe the process of compiling and running a Visual Basic application.
Ans.
Figure below shows how an application is compiled and run when using Visual Basic
.NET. To start, you use Visual Studio .NET to create a project, which is made of one or
more source files that contain Visual Basic statements. Most simple projects consist of
just one source file, but more complicated projects can have more than one source file.
A project may also contain other types of files, such as sound files, image files, or simple
text files. As the figure shows, a solution is a container for projects, which you’ll learn
more about in a moment.
Description
1.The programmer uses Visual Studio’s Integrated Development Environment to create
a project, which includes one or more Visual Basic source files. In some cases, a project
may contain other types of files, such as graphic image files or sound files.
A solution is a container that holds projects. Although a solution can contain more than
one project, the solution for most simple applications contains just one project. So you
can think of the solution and the project as essentially the same thing.
2. The Visual Basic compiler translates or builds the source code into Microsoft Inter-mediate Language (MSIL), or just Intermediate Language (IL). This language is stored
on disk in an assembly that also contains references to the classes that the application
requires. An assembly is simply an executable file that has an .exe or .dll extension.
3. The assembly is then run by the .NET Framework’s Common Language Runtime. The
CLR manages all aspects of how the assembly is run, including converting the
Intermediate Language to native code that can be run by the operating system,
managing memory for the assembly, enforcing security, and so on.
7. What do you mean by namespaces? Explain.
Ans.
Namespaces in VB.Net
A namespace is simply a logical collection of related classes in VB.Net. The application
related classes (like those related with database activity for example) can be bundled in
a named collection and hence it is called as a namespace (e.g., DataActivity).
VB.Net does not allow two classes with the same name to be used in a program. The
sole purpose of using namespaces is to prevent the name conflict, which may happen if
working with a large number of classes. It is the same case in the Framework Class
Library (FCL). For example, it is highly possible that the Connection Class in DataActivity
conflicts with the Connection Class of InternetActivity. To avoid this, these classes are
made
part of their respective namespace. The fully qualified name of these classes will be
DataActivity.Connection and InternetActivity.Connection, hence resolving any ambiguity
for the compiler.
In the second line of the code, there is a declaration classes (enclosed in
Namespace...End Namespace block) which are part of the MyHelloWorldApplication
namespace.
The VB.Net namespaces have no physical mapping. The namespace may contain
modules, classes, interfaces, events, exceptions, delegates and even other namespaces
which are known as "Internal namespace". These internal namespaces can be defined
like this:
Namespace MyHelloWorldApplication
...
End Namespace
Namespace Parent
Namespace Child
...
End Namespace
End Namespace
8. Write a VB program to print the day of the week taking the numbers 1 to 7 as input
using Select…Case statement.
Ans.
Below program is using console for inputs and output. Depending on the user Input and
Select case statements, program decides the day of the week and displays the results on
the console.
Module Module1
Sub Main()
Dim Day As Integer
Console.Clear()
Console.WriteLine(" * * * Console Application to Display Day of Week *
* * ")
Console.WriteLine("Enter Number from 1 to 7")
Day = Console.ReadLine()
Select Case Day
Case 1
Console.WriteLine("Monday")
Case 2
Console.WriteLine("Tuesday")
Case 3
Console.WriteLine("Wednesday")
Case 4
Console.WriteLine("Thursday")
Case 5
Console.WriteLine("Friday")
Case 6
Console.WriteLine("Saturday")
Case 7
Console.WriteLine("Sunday")
Case Else
Console.WriteLine("Invalid Input Detected")
End Select
Console.Read()
End Sub
End Module
9. Design a form based application using labels, text boxes, and buttons to perform
basic arithmetic operations on integers.
Ans.
This program demonstrates the basic arithmetic function. There are two text boxes to
input the 2 operands required for calculation and combo box to select the type of
arithmetic operations to be performed. The operations can be either +, -, *, / and Mod.
On click of the “=” button, program calculates and displays the result in the third textbox.
Public Class FormBT0082
Private Sub cmdEquals_Click(ByVal sender As System.Object, ByVal e As System. EventArgs)
Handles cmdEquals.Click
Select Case cboOp.Text
Case "+"
txtResults.Text Convert.ToInt16(txtNum1.Text) + Convert.ToInt16(txtNum2.Text)
Case "-"
txtResults.Text Convert.ToInt16(txtNum1.Text) - Convert.ToInt16(txtNum2.Text)
Case "*"
txtResults.Text Convert.ToInt16(txtNum1.Text) * Convert.ToInt16(txtNum2.Text)
Case "/"
txtResults.Text Convert.ToInt16(txtNum1.Text) / Convert.ToInt16(txtNum2.Text)
Case "Mod"
txtResults.Text Convert.ToInt16(txtNum1.Text) Mod Convert.ToInt16(txtNum2.Text)
End Select
End Sub
Private Sub FormBT0082_Load(ByVal sender As System.Object, ByVal e As
System. EventArgs) Handles MyBase.Load
cboOp. Items . Add ("+")
cboOp. Items . Add (" -”)
cboOp. Items . Add (" *")
cboOp. Items . Add (" /")
cboOp. Items. Add ( "Mod" )
End Sub
End Class
10. Describe the structured Exception handling keywords.
Ans.
Structured-Exception-Handling Keywords
Structured exception handling depends on several new keywords in VB 2005:
Try – Begins a section of code in which an exception might be generated from a
code error. This section of code is often called a Try block. In some respects, this
would be the equivalent of an On Error statement in VB6. However, unlike an On
Error statement, a Try statement does not indicate where a trapped exception
should be routed. Instead, the exception is automatically routed to a Catch
statement (discussed next).
Catch – Begins an exception handler for a type of exception. One or more Catch
code blocks follow a Try block, with each Catch block catching a different type of
exception. When an exception is encountered in the Try block, the first Catch
block that matches that type of exception receives control. A Catch statement is
analogous to the line label used in a VB6 On Error statement, but the ability to
route different types of exceptions to different Catch statements is a radical
improvement over VB6.
Finally – Contains code that runs when the Try block finishes normally, or when
a Catch block receives control and then finishes. That is, the code in the Finally
block always runs, regardless of whether an exception was detected. Typically,
the Finally block is used to close or dispose of any resources, such as database
connections, that might have been left unresolved by the code that had a
problem. There is no equivalent of a Finally in VB6.
Throw – Generates an exception. This is similar to Err.Raise in VB6. It’s usually
done in a Catch block when the exception should be kicked back to a calling
routine or in a routine that has itself detected an error such as a bad argument
passed in.
BT0082 – Visual Basic: SET 2
1. Describe the Data Form Wizard in Visual Studio .NET.
Ans.
Visual Studio .NET and the Data Form Wizard
VB.Net allows you many ways to connect to a database or a data source. The
technology used to interact with a database or data source is called ADO.NET. The ADO
parts stands for Active Data Objects which, admittedly, doesn’t explain much. But just
like System was a Base Class (leader of a hierarchy, if you like), so is ADO. Forming the
foundation of the ADO Base Class are five other major objects:
Connection
Command
DataReader
DataSet
DataAdapter
We’ll see just what these objects are, and how to use them, as we go along. But we can
make a start on the ADO.NET trail by creating a simple Address Book project. All we’ll
do is see how to use ADO to open up the database you downloaded, and scroll through
each entry.
What we’re going to be doing is to use a Wizard to create a program that reads the
database and allows us to scroll through it. The wizard will create a Form for us, and
allow us to add buttons to the form so that the data can be edited, updated, and deleted.
2. Describe the concept of record navigation in VB.NET.
Ans.
Record Navigation
(i) Move Back One Record at a Time
To move backwards through the DataSet, we need to decrement the inc counter. This
means is deducting 1 from whatever is currently in inc.
But we also need to check that inc doesn't go past zero, which is the first record in the
DataSet. Here's the code to add to your btnPrevious:
If inc > 0 Then
inc = inc – 1
NavigateRecords() Else MsgBox("First Record")
End If
So the If statement first checks that inc is greater than zero. If it is, inc gets 1 deducted
from. Then the NavigateRecords() subroutine gets called. If inc is zero or less, then we
display a message.
When you've finished adding the code, test your program out. Click the Previous button
first. The message box should display, even though no records have been loaded into
the textboxes. This is because the variable inc has a value of -1 when the form first
loads. It only gets moved on to zero when the Next button is clicked. You could amend
your IF Statement to this:
If inc > 0 Then
inc = inc - 1
NavigateRecords()
ElseIf inc = -1 Then
MsgBox("No Records Yet")
ElseIf inc = 0 Then
MsgBox("First Record")
End If
This new If Statement now checks to see if inc is equal to minus 1, and displays a
message if it does. It also checks if inc is equal to zero, and displays the "First Record"
message box.
(ii) Moving to the Last Record in the DataSet
To jump to the last record in the DataSet, you only need to know how many records
have been loaded into the DataSet - the MaxRows variable in our code. You can then
set the inc counter to that value, but minus 1. Here's the code to add to your btnLast:
If inc <> MaxRows - 1 Then
inc = MaxRows - 1
NavigateRecords()
End If
The reason we're saying MaxRows - 1 is that the row count might be 5, say, but the first
record in the DataSet starts at zero. So the total number of records would be zero to 4.
Inside of the If Statement, we're setting the inc counter to MaxRows - 1, then calling the
NavigateRecords() subroutine.
That's all we need to do. So run your program. Click the Last button, and you should see
the last record displayed in your textboxes.
(iii) Moving to the First Record in the DataSet
Moving to the first record is fairly straightforward. We only need to set the inc counter to
zero, if it's not already at that value. Then call the Sub:
If inc <> 0 Then
inc = 0
NavigateRecords()
End If
Add the code to your btnFirst. Run your program and test out all of your buttons. You
should be able to move through the names in the database, and jump to the first and last
records.
As yet, though, we don't have a way to add new records, to update records, or to delete
them. Let's do that next.
3. Explain the theory behind declaring arrays in VB.NET.
Ans.
Declaring Arrays in Visual Basic
Arrays occupy space in memory. The programmer specifies the array type and the
number of elements required by the array so that the compiler may reserve the
appropriate amount of memory. Arrays may be declared as Public (in a code module),
module or local. Module arrays are declared in the general declarations using keyword
Dim or Private. Local arrays are declared in a procedure using Dim or Static. Array must
be declared explicitly with keyword "As".
There are two types of arrays in Visual Basic namely:
Fixed-Size Array: The size of array always remains the same-size doesn't change
during the program execution.
Dynamic Array: The size of the array can be changed at the run time- size changes
during the program execution.
Fixed-Size Arrays
When an upper bound is specified in the declaration, a Fixed-array is created. The upper
limit should always be within the range of long data type.
Declaring a fixed-array
Dim numbers(5) As Integer
In the above illustration, numbers is the name of the array, and the number 6 included in
the parentheses is the upper limit of the array. The above declaration creates an array
with 6 elements, with index numbers running from 0 to 5.
If we want to specify the lower limit, then the parentheses should include both the lower
and upper limit along with the To keyword.
Example
Dim numbers (1 To 6) As Integer
In the above statement, an array of 10 elements is declared but with indexes running
from 1 to 6.
A public array can be declared using the keyword Public instead of Dim as shown below.
Public numbers(5) As Integer
4. Describe the mechanism of creating transparent images using ImageList Control.
Ans.
Creating Transparent Images
The ImageList control has a MaskColor property whose value determines the color that
should be considered transparent when you're performing graphical operations on
individual ListImage objects or when you're displaying images inside other controls. By
default, this is the gray color (&HC0C0C0), but you can change it both at design time in
the Color tab of the Properties dialog box and at run time via code.
When a graphical operation is performed, none of the pixels in the image that are the
color defined by MaskColor are transferred. To actually display transparent images,
however, you must ensure that the UseMaskColor property is set to True, which is its
default value. You can modify this value in the General tab of the Properties dialog box
or at run time via code:
' Make white the transparent color.
ImageList1.MaskColor = vbWhite
ImageList1.UseMaskColor = True
5. Explain the design time property settings of a ListView Control.
Ans.
Setting Design – Time Properties
While you can use the regular Properties window to set most properties of a ListView
control, it's surely preferable to use a ListView control's custom Properties dialog box,
shown in Figure.
6. Describe the concept of setting a connection string with an example.
Ans.
Setting a Connection String
There are Properties and Methods associated with the Connection Object, of course. We
want to start with the ConnectionString property. This can take many parameters.
Fortunately, we only need a few of these.
We need to pass two things to our new Connection Object: the technology we want to
use to do the connecting to our database; and where the database is. (If your database
was password and user name protected, you would add these two parameters as well.
Ours isn't, so we only need the two.)
The technology is called the Provider; and you use "Data Source" to specify where
your database is. This should be entered on the same line, and not two as it is below. So
add this to your code:
con.ConnectionString = "PROVIDER=Microsoft.Jet.OLEDB.4.0;Data Source =
C:\AddressBook.mdb"
Notice the two parts, separated by a semi-colon:
1st Part: PROVIDER=Microsoft.Jet.OLEDB.4.0 2nd Part: Data Source =
C:\AddressBook.mdb
The first part specifies which provider technology we want to use to do the connecting
(JET). The second part, typed after a semi-colon, points to where the database is. In the
above code, the database is on the C drive, in the root folder. The name of the Access
file we want to connect to is called AddressBook.mdb. (Note that "Data Source" is two
words, and not one.)
But your coding window should now look like this:
This assumes that you have copied the AddressBook database over to the root folder of
your C Drive. If you've copied it to another folder, change the "Data Source" part to
match. For example, if you copied it to a folder called "databases" you'd put this:
Data Source = C:\databases\AddressBook.mdb
In our code , though, ConnectionString is a property of the con variable. The con
variable holds our Connection Object. We're passing the Connection String the name of
a data provider, and a path to the database.
Private Sub btnLoad_Click(ByVal Sender as Object,_
ByVal e as System.EventArgs) _
Handles btnLoad.Click
Dim con as new OleDb.OleDbConnection
Con.ConnectionString = “Provider = Microsoft.Jet.OLEDB.4.0; DataSource =
C:\AddressBook.mdb”
7. Describe the process of adding, updating, and deleting records with an example.
Ans.
Add, Update and Delete Records
In the last section, you learned how to move through the records in your DataSet, and
how to display the records in Textboxes on your form. In this lesson, we'll see how to
add new records, how to delete them and how to Update a records.
Before we start the coding for these new buttons, it's important to understand that the
DataSet is disconnected from the database. What this means is that if you're adding a
new record, you're not adding it to the database: you're adding it to the DataSet!
Similarly, if you're updating or Deleting, you are doing it to the DataSet, and NOT to the
database. After you have made all of your changes, you THEN commit these changes to
the database. You do this by issuing a separate command. But we'll see how it all works.
You'll need to add a few more buttons to your form - five of them. Change the Name
properties of the new Buttons to the following:
btnAddNew
btnCommit
btnUpdate
btnDelete
btnClear
Change the Text properties of the buttons to "Add New Record ", "Commit Changes",
"Update Record ", "Delete Record", and "Clear/Cancel". Your form might look
something like this:
(i) Updating a Record
To reference a particular column (item) in a row of the DataSet, the code is this:
ds.Tables("AddressBook").Rows(2).Item(1)
That will return whatever is at Item 1 on Row 2.
As well as returning a value, you can also set a value. You do it like this:
ds.Tables("AddressBook").Rows(2).Item(1) = "Jane"
Now Item 1 Row 2 will contain the text "Jane". This won't, however, affect the database!
The changes will just get made to the DataSet. To illustrate this, add the following code
to your btnUpdate:
ds.Tables("AddressBook").Rows(inc).Item(1) = txtFirstName.Text
ds.Tables("AddressBook").Rows(inc).Item(2) = txtSurname.Text
MsgBox("Data updated")
Run your program, and click the Next Record button to move to the first record. "John"
should be displayed in your first textbox, and "Smith" in the second textbox. Click inside
the textboxes and change "John" to "Joan" and "Smith" to "Smithy". (Without the
quotes). Now click your Update Record button. Move to the next record by clicking your
Next Record button, and then move back to the first record. You should see that the first
record is now "Joan Smithy".
(ii) Add a New Record
Adding a new record is slightly more complex. First, you have to add a new Row to the
DataSet, then commit the new Row to the Database.
But the Add New Record button on our form is quite simple. The only thing it does is to
switch off other buttons, and clear the textboxes, ready for a new entry. Here's the code
for your Add New Record button:
btnCommit.Enabled = True btnAddNew.Enabled = False btnUpdate.Enabled = False
btnDelete.Enabled = False
txtFirstName.Clear() txtSurname.Clear()
So three buttons are switched off when the Add New Record button is clicked, and one
is switched on. The button that gets switched on is the Commit Changes button. The
Enabled property of btnCommit gets set to True. But, for this to work, you need to set it
to False when the form loads. So return to your Form. Click btnCommit to select it.
Then locate the Enabled Property in the Properties box. Set it to False. When the Form
starts up, the button will be switched off.
The Clear/Cancel button can be used to switch it back on again. So add this code to
your btnClear:
btnCommit.Enabled = False btnAddNew.Enabled = True btnUpdate.Enabled = True
btnDelete.Enabled = True
inc = 0 NavigateRecords()
We're switching the Commit Changes button off, and the other three back on. The other
two lines just make sure that we display the first record again, after the Cancel button is
clicked. Otherwise the textboxes will all be blank.
(iii) Delete a Record from a Database
The code to delete a record is a little easier than last time. Double click your btnDelete
and add the following:
Dim cb As New OleDb.OleDbCommandBuilder(da)
ds.Tables("AddressBook").Rows(inc).Delete() MaxRows = MaxRows - 1
inc = 0 NavigateRecords() da.Update(ds, "AddressBook")
You've met most of it before. First we set up a Command Builder. Then we have this
line:
ds.Tables("AddressBook").Rows(inc).Delete()
Just as there is an Add method of the DataSet Rows property, so there is a Delete
method. You don't need anything between the round brackets, this time. We've specified
the Row to delete with:
Rows(inc)
The inc variable is setting which particular Row we're on. When the Delete method is
called, it is this row that will be deleted.
However, it will only be deleted from the DataSet. To delete the row from the underlying
database, we have this again:
da.Update(ds, "AddressBook")
8. Explain the usage of variants in VB.NET.
Ans.
Arrays and Variants
Visual Basic lets you store arrays in Variant variables and then access the array items
using the Variant variable as if it were an array:
ReDim Names(100) As String, var As Variant ' Initialize the Names array (omitted).
var = Names() ' Copy the array into the Variant. Print var(1) ' Access array items
through the Variant.
You can even create an array of Variant elements on the fly using the Array function and
store it in a Variant variable:
' Arrays returned by the Array() function are zero-based. Factorials = Array(1, 1, 2,
6, 24, 120, 720, 5040, 40320, 362880, 3628800)
Likewise, you can pass an array to a procedure that expects a Variant parameter and
then access the elements of the array through that parameter:
' A polymorphic function that sums the values in any array Function ArraySum(arr
As Variant) As Variant Dim i As Long, result As Variant For i = LBound(arr) To
UBound(arr) result = result + arr(i) Next ArraySum = result End Function
The most interesting feature of the preceding routine is that it works correctly with any
type of numeric one-dimensional array. It even works with String arrays, but in that case
you get the concatenation of all items, not their sum.
9. Describe the process of extracting and drawing images using ImageList Control.
Ans.
Extracting and Drawing Images
If you associate an ImageList control with another common control, you usually don't
have to worry about extracting and showing individual images because everything is
done automatically for you. But if you want to manually display or print images, you have
to learn how to use a few properties and methods from the ImageList control and its
ListImage dependent objects.
Extracting Individual Images
Each ListImage object exposes a Picture property, which lets you extract the image and
assign it to another control, typically a PictureBox or Image control:
Set Picture1.Picture = ImageList1.ListImages("Cut").Picture
In general, you can use the Picture property of a ListImage object whenever you would
use the Picture property of a PictureBox or an Image control, as in the following
example:
' Save an image to a disk file.
SavePicture ImageList1.ListImages("Cut").Picture, "C:\cut.bmp"
' Display an image on the current form, zooming it by a factor
' of 4 along the X-axis, and 8 along the Y-axis.
With ImageList1
PaintPicture .ListImages("Cut").Picture, 0, 0, _
ScaleX(.ImageWidth, vbPixels) * 4, ScaleY(.ImageHeight, vbPixels) * 8
End With
Using the PaintPicture method, you can display any ListImage object on a form or in a
PictureBox control, or you can print it to the Printer object.
ListImage objects also expose an ExtractIcon method, which creates an icon out of the
image and returns it to the caller. You can therefore use this method whenever an icon is
expected, as in this code:
Form1.MouseIcon = ImageList1.ListImages("Pointer").ExtractIcon
Unlike standard collections, keys in the ListImages collection are dealt with in a case-sensitive way. In other words, "Pointer" and "pointer" are assumed to be different items.
10. Describe the runtime properties of ListView Control.
Ans.
Run-Time Operations
While you can define the appearance of a ListView control at design time, you can fill it
with data only through code. In this section, we would see how to add and manipulate
data for this control.