Visual Basic.Net Online Programming

Deleting Records from a Database

2011-07-29T21:24:00.000-07:00

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")

The Command Builder, in conjunction with the Data Adapter, will take care of the deleting. All you need to is call the Update method of the Data Adapter.

The MaxRows line in the code just deducts 1 from the variable. This just ensures that the number of rows in the DataSet matches the number we have in the MaxRows variable.

We also reset the inc variable to zero, and call the NavigateRecords() subroutine. This will mean that the first record is displayed, after a record has been deleted.

Try out your programme. Click the Next Record button a few times to move to a valid record. Then click the Delete Record button. The record will be deleted from the DataSet AND the database. The record that is then displayed will be the first one.

There's another problem, though: if you click the Delete Record button before the Next Record button, you'll get an error message. You can add an If Statement to check that the inc variable does not equal minus 1.

Another thing you can do is to display a message box asking users if they really want to delete this record. Here's one in action:

To get this in your own programme, add the following code to the very top of your Delete button code:

If MessageBox.Show("Do you really want to Delete this Record?", _
"Delete", MessageBoxButtons.YesNo, _
MessageBoxIcon.Warning) = DialogResult.No Then

MsgBox("Operation Cancelled")
Exit Sub

End If

The first three lines of the code are really one line. The underscore has been used to spread it out, so as to fit on this page.

But we're using the new message box function:

MessageBox.Show()

In between the round brackets, we specifying the message to display, followed by a caption for the message box. We then have this:

MessageBoxButtons.YesNo

You won't have to type all that out; you'll be able to select it from a popup list. But what it does is give you Yes and No buttons on your message box.

After typing a comma, we selected the MessageBoxIcon.Warning icon from the popup list.

But you need to check which button the user clicked. This is done with this:

= DialogResult.No

Again, you select from a popup list. We want to check if the user clicked the No button. This will mean a change of mind from the user. A value of No will then be returned, which is what we're checking for in the If Statement.

The code for the If Statement itself is this:

MsgBox("Operation Cancelled")
Exit Sub

This will display another message for the user. But most importantly, the subroutine will be exited: we don't want the rest of the Delete code to be executed, if the user clicked the No button.

And that's it for our introduction to database programming. You not only saw how to construct a database programme using the Wizard, but how to write code to do this yourself. There is an awful lot more to database programming, and we've just scratched the surface. But in a beginner's course, that's all we have time for.

The section that follows is all about Forms.

How to Add a New Record

2011-07-29T21:21:00.000-07:00

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.

To add a new record to the database, we'll use the Commit Changes button. So double click your btnCommit to access its code. Add the following:

If inc <> -1 Then

Dim cb As New OleDb.OleDbCommandBuilder(da)
Dim dsNewRow As DataRow

dsNewRow = ds.Tables("AddressBook").NewRow()

dsNewRow.Item("FirstName") = txtFirstName.Text
dsNewRow.Item("Surname") = txtSurname.Text

ds.Tables("AddressBook").Rows.Add(dsNewRow)

da.Update(ds, "AddressBook")

MsgBox("New Record added to the Database")

btnCommit.Enabled = False
btnAddNew.Enabled = True
btnUpdate.Enabled = True
btnDelete.Enabled = True

End If

The code is somewhat longer than usual, but we'll go through it.

The first line is an If Statement. We're just checking that there is a valid record to add. If there's not, the inc variable will be on minus 1.

Inside of the If Statement, we first set up a Command Builder, as before. The next line is this:

Dim dsNewRow As DataRow

If you want to add a new row to your DataSet, you need a DataRow object. This line just sets up a variable called dsNewRow. The type of variable is a DataRow.

To create the new DataRow object, this line comes next:

dsNewRow = ds.Tables("AddressBook").NewRow()

We're just saying, "Create a New Row object in the AddressBook DataSet, and store this in the variable called dsNewRow." As you can see, NewRow() is a method of ds.Tables. Use this method to add rows to your DataSet.

The actual values we want to store in the rows are coming from the textboxes. So we have these two lines:

dsNewRow.Item("FirstName") = txtFirstName.Text
dsNewRow.Item("Surname") = txtSurname.Text

The dsNewRow object we created has a Property called Item. This is like the Item property you used earlier. It represents a column in your DataSet. We could have said this instead:

dsNewRow.Item(1) = txtFirstName.Text
dsNewRow.Item(2) = txtSurname.Text

The Item property is now using the index number of the DataSet columns, rather than the names. The results is the same, though: to store new values in these properties. We're storing the text from the textboxes to our new Row.

We now only need to call the Method that actually adds the Row to the DataSet:

ds.Tables("AddressBook").Rows.Add(dsNewRow)

To add the Row, you use the Add method of the Rows property of the DataSet. In between the round brackets, you need the name of your DataRow (the variable dsNewRow, in our case).

You should know what the rest of the code does. Here's the next line:

da.Update(ds, "AddressBook")

Again, we're just using the Update method of the Data Adapter, just like last time. The rest of the code just displays a message box, and resets the button.

But to add a new Row to a DataSet, here's a recap on what to do:

Create a DataRow variable
Cretae an Object from this variable by using the NewRow() method of the DataSet Tables property
Assign values to the Items in the new Row
Use the Add method of the DataSet to add the new row

A little more complicated, but it does work! Try your programme out. Click your Add New Record button. The textboxes should go blank, and three of the buttons will be switched off. Enter a new First Name and Surname, and then click the Commit Changes button. You should see the message box telling you that a new record has been added to the database.

To see the new record, close down your programme, and run it again. The new record will be there.

In the next part, you'll learn how to delete a record from the database.

Add, Edit and Delete Records

2011-07-29T21:18:00.000-07:00

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 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 (View Image)

We'll start with the Update Record button

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, effect 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 programme, 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".

Close down your programme, then run it again. Click the Next Record button to move to the first record. It will still be "John Smith". The data you updated has been lost! So here, again, is why:

"Changes are made to the DataSet, and NOT to the Database"

To update the database, you need some extra code. Amend your code to this (the new lines are in bold, red text):

Dim cb As New OleDb.OleDbCommandBuilder(da)

ds.Tables("AddressBook").Rows(inc).Item(1) = txtFirstName.Text
ds.Tables("AddressBook").Rows(inc).Item(2) = txtSurname.Text

da.Update(ds, "AddressBook")

MsgBox("Data updated")

The first new line is this:

Dim cb As New OleDb.OleDbCommandBuilder(da)

To update the database itself, you need something called a Command Builder. The Command Builder will build a SQL string for you. In between round brackets, you type the name of your Data Adapter, da in our case. The command builder is then stored in a variable, which we have called cb.

The second new line is where the action is:

da.Update(ds, "AddressBook")

The da variable is holding our Data Adapter. One of the methods of the Data Adapter is Update. In between the round brackets, you need the name of your DataSet (ds, for us). The "AddressBook" part is optional. It's what we've called our DataSet, and is here to avoid any confusion.

But the Data Adapter will then contact the database. Because we have a Command Builder, the Data Adapter can then update your database with the values from the DataSet.

Without the Command Builder, though, the Data Adapter can't do it's job. Try this. Comment out the Command Builder line (put a single quote before the "D" of Dim). Run your programme again, and then try and update a record. You'll get this error message (View Image)

The error is because you haven't got a command builder - a Valid Update Command.
Delete the comment from your Command Builder line and the error message goes away.

You should now be able to make changes to the database itself (as long as the Access database isn't Read Only).

Try it out. Run your programme, and change one of the records. Click the Update button. Then close the programme down, and load it up again. You should see your new changes displayed in the textboxes.

Exercise

There's one slight problem with the code above, though. Try clicking the Update button before clicking the Next Record button. What happens? Do you know why you get the error message? Write code to stop this happening

In the next part, we'll see how to add a new record.

How to Move through the Database

2011-07-29T21:15:00.000-07:00

In this lesson, you'll add the code for the buttons.

How to Move Forward One Record at a Time

Double click your Next Record button to access the code. Add the following If … Else Statement:

If inc <> MaxRows - 1 Then
inc = inc + 1
NavigateRecords()
Else
MsgBox("No More Rows")
End If

We're checking to see if the value in inc does not equal the value in MaxRows - 1. If they are both equal then we know we've reached the last record in the DataSet. In which case, we just display a message box. If they are not equal, these two lines get executed:

inc = inc + 1
NavigateRecords()

First, we move the inc counter on by one. Then we call the Sub we set up:

NavigateRecords()

Our Subroutine is where the action takes place, and the values from the DataSet are placed in the textboxes. Here it is again:

Private Sub NavigateRecords()

txtFirstName.Text = ds.Tables("AddressBook").Rows(inc).Item(1)
txtSurname.Text = ds.Tables("AddressBook").Rows(inc).Item(2)

End Sub

The part that moves the record forward (and backwards soon) is this part:

Rows(inc)

Previously, we hard-coded this with:

Rows(0)

Now the value is coming from the variable called inc. Because we're incrementing this variable with code, the value will change each time the button is clicked. And so a different record will be displayed.

You can test out your Next button. Run your programme and click the button. You should now be able to move forward through the DataSet. When you get to the end, you should see the message box display "No More Rows".

None of the other button will work yet, of course. So let's move backwards.

Move Back One Record at a Time

To move backwards through the DataSet, we need to decrement the inc counter. All 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 programme 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.

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 programme. Click the Last button, and you should see the last record displayed in your textboxes.

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 programme 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.

Navigate a Database with VB .NET

2011-07-29T21:10:00.000-07:00

In this section, we're going to see a more practical example of how to do that.

To navigate through the dataset, let's change our form. By adding some navigation buttons, we can duplicate what the wizard did. We'll also need to move the code we already have. So let's start with that.

At the moment, all our code is in the Button we added to the form. We're going to delete this button, so we need to move it out of there. The variable declarations can be moved right to the top of the coding window. That way, any button can see the variables. So move your variables declarations to the top, as in the image below (don't forget to add the Dim inc As Integer line) (View Image)

We can move a few lines to the Form Load event. So, create a Form Load event, as you did in a previous section. Now move all but the textbox lines to there. Your coding window should then look like this (you can delete the message box lines, or just comment them out) (View Image)

For your button, all you should have left are these two lines:

txtFirstName.Text = ds.Tables("AddressBook").Rows(inc).Item(1)
txtSurname.Text = ds.Tables("AddressBook").Rows(inc).Item(2)

Since we're going to be deleting this button, this code can be moved. Because all the buttons need to put something into the textboxes, the two lines we have left are an ideal candidate for a Subroutine. So add the following Sub to your code:

Private Sub NavigateRecords()

txtFirstName.Text = ds.Tables("AddressBook").Rows(inc).Item(1)
txtSurname.Text = ds.Tables("AddressBook").Rows(inc).Item(2)

End Sub

When we navigate through the DataSet, we'll call this subroutine.

Now that all of your code has gone from your button, you can delete the button code altogether. Return to you form, click on the button to select it, then press the delete key on your keyboard. This will remove the button itself from your form. (You can also right click on the button, and then select Delete from the menu.)

Here's what your coding window should like (View Image)

Now you can re-design the form. Add four new buttons, and change the Name properties to: btnNext, btnPrevious, btnFirst, and btnLast. Change the Text properties to >, <, <<, and >>. Your form will then look like this (View Image)

Just a couple of more things to set up before we get started. Add a new variable declaration to the top of your code, just under the Dim inc As Integer line. Add this:

Dim MaxRows As Integer

We can store how many rows are in the DataSet with this variable. You can get how many rows are in the DataSet with this:

MaxRows = ds.Tables("AddressBook").Rows.Count

So the Rows property has a Count Method. This simply counts how many rows are in the DataSet. We're passing that number to a variable called MaxRows. You can then test what is in the variable, and see if the inc counter doesn't go past it. You need to do this because VB throws up an error message if try to go past the last row in the DataSet. (Previous versions of VB had some called an EOF and BOF properties. These checked the End of File and Before End of File. These properties have now gone.)

Add the following two lines of code to the Form Load Event of Form1:

MaxRows = ds.Tables("AddressBook").Rows.Count
inc = - 1

Your code should then look like this (View Image)

Notice the other line of code for the Form Load event:

inc = - 1

This line sets the inc variable to minus one when the form loads. When the Buttons are clicked, this will ensure that we're moving the counter on by the correct amount.

In the next Part, we'll see how the Buttons on the form work.

Source: homeandlearn

Displaying the Data in the DataSet

2011-07-29T21:06:00.000-07:00

What we want to do now is to display the records on a Form, so that people can see them. So so this:

Add two textboxes to your form
Change the Name properties of your textboxes to txtFirstName and txtSurname
Go back to your code window
Add the following two lines:

txtFirstName.Text = ds.Tables("AddressBook").Rows(0).Item(1)
txtSurname.Text = ds.Tables("AddressBook").Rows(0).Item(2)

You can add them after the line that closes the connection to the database. Once the DataSet has been filled, a connection to a database can be closed.

Your code should now look like this (View Image)

Before the code is explained, run your programme and click the button. You should see "John Smith" displayed in your two textboxes.

So let's examine the code that assigns the data from the DataSet to the textboxes. The first line was this:

txtFirstName.Text = ds.Tables("AddressBook").Rows(0).Item(1)

It's rather a long line! But after the equals sign, you type the name of your DataSet (ds for us). After a full stop, select Tables from the popup list. The Tables property needs something in between round brackets. Quite bizarrely, this is NOT the name of your database table! It's that identifier you used with the Data Adapter Fill. We used the identifier "AddressBook". If we had used "Bacon Sandwich" then we'd put this:

ds.Tables("Bacon Sandwich")

But we didn't, so our code is:

ds.Tables("AddressBook")

Type a full stop and you'll see another list popping up at you. Select Rows from the list. In between round brackets, you need a number. This is a Row number from the DataSet. We want the first row, which is row zero in the DataSet:

ds.Tables("AddressBook").Rows(0)

Type full stop after Rows(0) and the popup list appears again. To identify a Column from the DataSet, you use Item. In between round brackets, you type which column you want:

ds.Tables("AddressBook").Rows(0).Item(1)

In our Access database, column zero is used for an ID field. The FirstName column is the second column in our Access database. Because the Item collection is zero based, this is item 1 in the DataSet.

You can also refer to the column name itself for the Item property, rather than a number. So you can do this:

ds.Tables("AddressBook").Rows(0).Item("FirstName")
ds.Tables("AddressBook").Rows(0).Item("Surname")

If you get the name of the column wrong, then VB throws up an error. But an image might clear things up. The image below shows what the items and rows are in the database (View Image)

The image shows which are the Rows and which are the Items in the Access database Table. So the Items go down and the Rows go across.

However, we want to be able to scroll through the table. We want to be able to click a button and see the next record. Or click another button and see the previous record. You can do this by incrementing the Row number.

To see the next record, we'd want this:

txtFirstName.Text = ds.Tables("AddressBook").Rows(1).Item(1)
txtSurname.Text = ds.Tables("AddressBook").Rows(1).Item(2)

The record after that would then be:

txtFirstName.Text = ds.Tables("AddressBook").Rows(2).Item(1)
txtSurname.Text = ds.Tables("AddressBook").Rows(2).Item(2)

So by incrementing and decrementing the Row number, you can navigate through the records. Let's see how that's done.

Source: homeandlearn

Data Sets and Data Adapters

2011-07-29T20:59:00.000-07:00

In the previous part, you learned how to set up a Connection Object. This was so that you could open a connection to the database itself. But that's not the end of it. The data from the database needs to be stored somewhere, so that we can manipulate it.

ADO.NET uses something called a DataSet to hold all of your information from the database (you can also use a DataTable, if all you want to do is read information, and not have people write to your database.). But the DataSet (and Data Table) will hold a copy of the information from the database.

The DataSet is not something you can draw on your form, like a Button or a Textbox. The DataSet is something that is hidden from you, and just stored in memory. Imagine a grid with rows and columns. Each imaginary row of the DataSet represents a Row of information in your Access database. And each imaginary column represents a Column of information in your Access database (called a Field in Access).

This, then, is a DataSet. But what's a Data Adapter?

The Connection Object and the DataSet can't see each other. They need a go-between so that they can communicate. This go-between is called a Data Adapter. The Data Adapter contacts your Connection Object, and then executes a query that you set up. The results of that query are then stored in the DataSet.

The Data Adapter and DataSet are objects. You set them up like this:

Dim ds As New DataSet
Dim da As OleDb.OleDbDataAdapter

da = New OleDb.OleDbDataAdapter(sql, con)

The code needs a little explaining, though. First, the Data Adapter.

The Data Adapter

The Data Adapter is a property of the OLEDB object, hence the full stop between the two:

OleDb.OleDbDataAdapter

We're passing this object to the variable called da. This variable will then hold a reference to the Data Adapter.

While the second line in the code above sets up a reference to the Data Adapter, the third line creates a new Data Adapter object. You need to put two things in the round brackets of the Object declaration: Your SQL string (which we'll get to shortly), and your connection object. Our Connection Object is stored in the variable which we've called con. (Like all variable you can call it practically anything you like. We've gone for something short and memorable.)

You then pass the New Data Adapter to your variable (da for us):

da = New OleDb.OleDbDataAdapter(sql, con)

We need something else, though. The sql in between the round brackets is the name of a variable. We haven't yet set this up. We'll have a look at SQL in a moment. But bear in mind what the Data Adaptor is doing: Acting as a go-between for the Connection Object and the Data Set

Structured Query Language

SQL (pronounced SeeKwel), is short for Structured Query Language, and is a way to query and write to databases (not just Access). The basics are quite easy to learn. If you want to grab all of the records from a table in a database, you use the SELECT word. Like this:

SELECT * FROM Table_Name

SQL is not case sensitive, so the above line could be written:

Select * from Table_Name

But your SQL statements are easier to read if you type the keywords in uppercase letters. The keywords in the lines above are SELECT and FROM. The asterisk means "All Records". Table_Name is the name of a table in your database. So the whole line reads:

"SELECT all the records FROM the table called Table_Name"

You don't need to select all (*) the records from your database. You can just select the columns that you need. The name of the table in our database is tblContacts. If we wanted to select just the first name and surname columns from this table, we can specify that in our SQL String:

SELECT tblContacts.FirstName, tblContacts.Surname FROM tblContacts

When this SQL statement is executed, only the FirstName and Surname columns from the database will be returned.

There are a lot more SQL commands, but for our purposes this is enough.

Because we want to SELECT all (*) the records from the table called tblContacts, we pass this string to the string variable we have called sql:

sql = "SELECT * FROM tblContacts"

Your code window should now look like this (though the file path to your database might be different) (View Image)

Now that the Data Adapter has selected all of the records from the table in our database, we need somewhere to put those records - in the DataSet.

Filling the DataSet

The Data Adapter can Fill a DataSet with records from a Table. You only need a single line of code to do this:

da.Fill(ds, "AddressBook")

As soon as you type the name of your Data Adapter (da for us), you'll get a pop up box of properties and methods. Select Fill from the list, then type a pair of round brackets. In between the round brackets, you need two things: the Name of your DataSet (ds, in our case), and an identifying name. This identifying name can be anything you like. But it is just used to identify this particular Data Adapter Fill. We could have called it "Bacon Sandwich", if we wanted:

da.Fill(ds, "Bacon Sandwich ")

The code above still works. But it's better to stick to something a little more descriptive than "Bacon Sandwich"!

Add the new line after the creation of the Data Adaptor:

da = New OleDb.OleDbDataAdapter(sql, con)
da.Fill(ds, "AddressBook")

And that's it. The DataSet (ds) will now be filled with the records we selected from the table called tblContact. There's only one slight problem - nobody can see the data yet! We'll tackle that in the next part.

Source: homeandlearn

Write your own Database code in VB .NET

2011-07-29T20:45:00.000-07:00

In this next section, we'll take a look at the objects that you can use to open and read data from a Database. We'll stick with our Access database, the AddressBook.mdb one, and recreate what the Wizard has done. That way, you'll see for yourself just what is going on behind the scenes.

So close any open projects, and create a new one. Give it whatever name you like, and let's begin. If you haven't yet downloaded the Address Book database, you can get it here:

Download the Address Book Database

The Connection Object

The Connection Object is what you need if you want to connect to a database. There are a number of different connection objects, and the one you use depends largely on the type of database you're connecting to. Because we're connecting to an Access database, we'll need something called the OLE DB connection object.

OLE stands for Object Linking and Embedding, and its basically a lot of objects (COM objects) bundled together that allow you to connect to data sources in general, and not just databases. You can use it, for example, to connect to text files, SQL Server, email, and a whole lot more.

There are a number of different OLE DB objects (called data providers), but the one we'll use is called "Jet". Others are SQL Server and Oracle.

So place a button on your form. Change the Name property to btnLoad. Double click your button to open up the code window. Add the following line:

Dim con As New OleDb.OleDbConnection

The variable con will now hold the Connection Object. Notice that there is a full stop after the OleDB part. You'll then get a pop up box from where you can select OleDbConnection. We're also creating a New object on this line.This is the object that you use to connect to an Access database.

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. So add this to your code:

Dim dbProvider As String
Dim dbSource As String

dbProvider = "PROVIDER=Microsoft.Jet.OLEDB.4.0;"
dbSource = "Data Source = C:/AddressBook.mdb"

con.ConnectionString = dbProvider & dbSource

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.)

If you prefer, you can have the provider and source on one line, as below (it's on two here because it won't all fit on one line):

con.ConnectionString = "PROVIDER=Microsoft.Jet.OLEDB.4.0;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 (View Image)

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

You can also specify a folder such as MyDocuments (or Documents in Vista and Windows 7). You do it like this:

dbSource = "Data Source = C:\Users\Owner\Documents\AddressBook.mdb"

Another way to specify a file path is this:

Dim fldr As String
fldr = Environment.GetFolderPath( Environment.SpecialFolder.MyDocuments ) & "/AddressBook.mdb"

dbSource = "Data Source = " & fldr

On the second line, spread over two lines in the code above, we have this:

Environment.GetFolderPath( )

The folder path you're getting goes between the round brackets of GetFolderPath:

Environment.SpecialFolder.MyDocuments

The Special Folder in this case is the MyDocuments folder.

But back to our connection code. 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.

Opening the Connection

Now that we have a ConnectionString, we can go ahead and open the datatbase. This is quite easy - just use the Open method of the Connection Object:

con.Open( )

Once open, the connection has to be closed again. This time, just use the Close method:

con.Close( )

Add the following four lines to your code:

con.Open()

MsgBox("Database is now open")

con.Close()

MsgBox("Database is now Closed")

Your coding window will then look like this (use the file path below, if you have Vista or Windows 7, after moving the database to your Documents folder) (View Image)

Test out your new code by running your programme. Click your button and the two message boxes should display. If they don't, make sure your Data Source path is correct. If it isn't, you might see this error message (View Image)

The error message is a bit on the vague and mysterious side. But what it's saying is that it can't find the path to the database, so it can't Open the connection. The line con.Open in your code will then be highlighted in green. You need to specify the correct path to your database. When you do, you'll see the message boxes from our code, and not the big one above.

Now that we've opened a connection to the database, we need to read the information from it. This is where the DataSet and the DataAdapter come in.

Source: homeandlearn

The Database Wizard in VB NET Express

2011-07-29T20:28:00.000-07:00

Let's make a start on our Database project. So, once you have your VB software open, do the following:

Click File > New Project from the menu bar
Select Windows Application, and then give it the Name AddressBook. Click OK
Locate the Solution Explorer on the right hand side (If you can't see it, click View > Solution Explorer from the menu bar, or View > Other Windows > Solution Explorer in version 2010.) (View Image)

We need to select a Data Source. So click on Data Sources at the bottom of the Solution Explorer in version 2008 (View Image)

If you have VB NET 2010 then the Data Source tab is on the left, just below the Toolbox (View Image)

To Add a New Data Source, click on the link. When you do, you'll see a screen welcoming you to the Data Source Configuration Wizard, Just click Next, to get to the screen (View Image)

You want to connect to a Database. So select this option, and click Next. In version 2010 of VBN NET, you'll see this screen appear (you won't see it if you have version 2008) (View Image)

Select DataSet and click Next.

In both versions 2008 and 2010, you'll then see this screen (View Image)

Click the New Connection button and another dialogue box pops up (View Image)

Click the Change button, because we want to connect to an Access database. (The default is for a SQL Server database.) When you click Change, you'll see this (View Image)

Select Microsoft Access Database File, then click OK. The previous dialogue box will then look like this (View Image)

Click the Browse button and navigate to where on your computer you downloaded our Access Database called AddressBook.mdb. Click Test Connection to see if everything is OK, and you'll hopefully see this (View Image)

Click the OK button, then click the OK button on the Add Connection dialogue box as well. You will be returned to the Data Source Configuration Wizard, which should now look like this (View Image)

Click Next to move to the next step of the Wizard. You may see a message box appear, however. Click No on the message box to stop VB copying the database each time it runs. You should then see this (View Image)

Make sure there's a tick in the box for "Save the connection", and then click Next (View Image)

Here, you can select which tables and fields you want. Tick the Tables box to include them all. You can give your DataSet a name, if you prefer. Click Finish and you're done.

When you are returned to your form, you should notice the Solution Explorer has added your new Data Source (View Image)

The Data Sources area of the Solution Explorer now displays information about your database. Click the plus symbol (an arrow in VB NET 2010) next to tblContacts (View Image)

All the Fields in the Address Book database are now showing.

To add a Field to your Form, click on one in the list. Hold down your left mouse button, and drag it over to your form (View Image)

In the image above, the FName field is being dragged on the Form. Your mouse cursor will change shape.

When your Field is over the Form, let go of your left mouse button. A textbox and a label will be added. There are two other things to notice: a navigation bar appears at the top of the form, and a lot of strange objects have appeared in the object area at the bottom (View Image)

We'll explore the Objects in a later section. But notice the Navigation bar in blue. Run your programme by hitting the F5 key on your keyboard. You should see this (View Image)

Click the Navigation arrows to scroll through the database. When you've played around with the controls, stop the form from running, and return to Design View.

Drag and Drop more Fields to your form. But don't align them yet. We'll see an easy way to do this. But once you've dragged the fields to your form, it might look like this (View Image)

I'm sure you'll agree - that's a very untidy form. But there's a very easy way to align all your controls. Try this:

Click on a Textbox and its label with your left mouse button
Hold down the Ctrl key on your keyboard, and select a second Textbox and label
With the Ctrl key still held down, click each Textbox and label in turn
When all Textbox are selected, click on the Format menu at the top
From the Format menu select Align > Lefts. The left edges of the Textboxes will align themselves
From the Format menu select Vertical Spacing > Make Equal. The space between each textbox will then be the same

With your new controls added, and nicely aligned, press F5 to run your form. For the Notes Textbox, set the MultiLine property to True. Your form might then be something like this (View Image)

Click the Navigation icons to move backwards and forwards through your database.

In the next part, you'll move away from the Wizards and learn how to add your own programming code to open up and manipulate databases.

Source: homeandlearn

Visual Basic Express and Databases - the easy way

2011-07-29T20:22:00.000-07:00

From homeandlearn

For this tutorial, we're going to create a simple Address Book project. The names and addresses will come from a Microsoft Access database.

Download the database before starting these lessons. Once you have saved the database to your own computer, you can begin.

Download the Microsoft Access Database you need for these tutorials

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, in a later section. 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 programme that reads the database and allows us to scroll through it.

The wizard will do most of the work for us, and create the controls that allow users to move through the database. The Form we create will look like this when it's finished (View Image)

By clicking the buttons at the top, you can scroll through the database in the image above. We'll make a start in the next part.

Adding a Report Designer

2011-07-29T01:28:00.000-07:00

You can add a new Report Designer to a project by selecting Add New item from the Project menu and choosing the Crystal Report icon.

In the Add New item dialog box, give the report a name (View Image).

You can either enter the .rpt extension or leave it off; the extension is added by default.

You are given a choice of the type of report to create (View Image).

You can choose Using the Report Wizard to open a wizard that steps you through the report creation process. Or you can choose As a Blank Report to create your own report from scratch.

You can also select Form an Existing Report that allows you to create a modification of a report you have already created.

Note: The report design is compiled into the project’s .exe file. If you modify the report design, you must recompile the project to see the changes.

Using Crystal Reports

2011-07-29T01:07:00.000-07:00

One of the powerful features of Visual Studio.Net is the report designer by Crystal Decisions called Crystal Reports.

The Crystal Report Gallery contains “experts” to guide you in creating standard reports, forms, and even mailing labels, or you can use an existing report or generate a new one.

You can display a report from a Windows Form or a Web Form.

It takes two steps to create and display a simple report:

1. Add a Report Designer and design the report template. The template includes the settings for connection to the database and the layout of the report.

2. Add a Crystal Report Viewer control to a form and connect it to the report template.

Once you have added the report to a project and run the project, you can view the report and send the report to the printer, if you wish.

When you create a report template, you are setting up the format of the report. The data are not included in the report layout; instead, each time you run the report, you view the current data.

Creating Variables in VB .NET

2011-07-21T22:55:00.000-07:00

Variables

Why are we discussing variables? And what is a variable?

With Visual Basic, and most programming languages, what you are doing is storing things in the computer's memory, and manipulating this store. If you want to add two numbers together, you put the numbers into storage areas and "tell" Visual Basic to add them up. But you can't do this without variables.

So a variable is a storage area of the computer's memory. Think of it like this: a variable is an empty cardboard box. Now, imagine you have a very large room, and in this room you have a whole lot of empty cardboard boxes. Each empty cardboard box is a single variable. To add two numbers together, write the first number on a piece of paper and put the piece of paper into an empty box. Write the second number on a piece of paper and put this second piece of paper in a different cardboard box.

Now, out of all your thousands of empty cardboard boxes two of them contain pieces of paper with numbers on them. To help you remember which of the thousands of boxes hold your numbers, put a sticky label on each of the two boxes. Write "number1" on the first sticky label, and "number2" on the second label.

What have we just done? Well, we've created a large memory area (the room and the cardboard boxes), and we've set up two of the boxes to hold our numbers (two variables). We've also given each of these variables a name (the sticky labels) so that we can remember where they are.

Now examine this:

Dim number1 As Integer
Dim number 2 As Integer

number1 = 3
number2 = 5

That's code from Visual Basic Net. It's VB's way of setting up (or declaring) variables.

Here's a breakdown of the variable Declaration:

Dim: Short for Dimension. It's a type of variable. You declare (or "tell" Visual Basic) that you are setting up a variable with this word. We'll meet other types of variables later, but for now just remember to start your variable declarations with Dim.
number1: This is the cardboard box and the sticky label all in one. This is a variable. In other words, our storage area. After the Dim word, Visual Basic is looking for the name of your variable. You can call your variable almost anything you like, but there are a few reserved words that VB won't allow. It's good practice to give your variables a name appropriate to what is going in the variable.
As Integer: We're telling Visual Basic that the variable is going to be a number (integer). Well meet alternatives to Integer later.
Number1 = 3: The equals sign is not actually an equals sign. The = sign means assign a value of. In other words, here is where you put something in your variable. We're telling Visual Basic to assign a value of 3 to the variable called number1. Think back to the piece of paper going into the cardboard box. Well, this is the programming equivalent of writing a value on a piece of paper

Now that you have a basic idea of what variables are, let's write a little piece of code to test them out.

First, though, let's have our first look at the coding window.

To make life easier, we're going to put a button on our form. When our button is clicked, a little message box will pop up.

Fortunately, there's no coding to write for a button, and very little at all for a message box.

Previous >> Creating a New Project

Creating a New Project

2011-07-20T19:29:00.000-07:00

Time to get our hands dirty with a bit of programming. There's no putting it off any longer, I'm afraid! We'll create a new project for the next section.

So, if you already have you VB NET software open, you can get rid of the current project by clicking File from the menu bar.

From the drop down menu, choose Close Project. You will be returned to the Start Page. Click File > New Project from the menu bars. When you get the dialogue box popping up, choose Windows Forms Application at the top. Then change the Name from WindowsApplication to Variables: (View Image)

When you click the OK button, a new form will appear.

If you look at the Solution Explorer at the top, you'll see the name of the project has changed to the Name you gave it. (View Image)

The name of the Project is now Variables - the same name as the folder that is created for you to hold all your project files.

Now that you have a new Project started, we can discuss Variables.

We'll do that in the next section.

Previous >> How to Save your VB .NET Projects

Next >>Creating Variables in VB .NET

Starting Visual Basic.Net (2008 version)

2011-07-19T02:31:00.000-07:00

Follow these easy steps:

Step 1: Open your VB.Net Software

Launch your Visual Basic .NET or Visual Studio software. When the software first loads, you'll see a screen something like this one:

This is the Start Page. (View Image)

This is where you can start a new project, or open an existing one. If you have created numerous projects before, you'll see it under the Recent Projects block located on the left side.

Below this, you will see two links : Open Project and Create Project. Open Project link is used to open an existing project while Create Project link is used to create a new project.

When you create a project, the Name you gave it will be displayed on this page, as a hyperlink just like what you see under Recent Projects block. Clicking the link will open the project.

Step 2: Create New or Open Project

To get started, click the Create Project link or Go to File > New > Project. When you do, you'll see the dialogue box appear (View Image).

By Default, the selected project type on the window is Windows Form Application. This means that you're going to be designing a Window type program to run on a computer running the Microsoft Windows operating system.

If you would like to create a web application, you can select Web > ASP.Net Web Application.

Step 3: Enter Project Name

The default name for your project is "WindowsApplication1" but you can change this to your desired project name. For example we'll going to change this to My First Project.

The default location is located in your "My Documents" folder called "Visual Studio Projects". All of your files for your first project are then saved in this folder. You can keep the Location the same as the default but you can also change this to your desired location.

A new folder will then be created for you, and its name will be the same as the one you typed in the "Name" textbox.

Step 4: Click OK button

Click the OK button, and the Visual Basic NET design time environment will open. It will look like the following :

This is the Default Form (View Image).

This is actually your program. Whatever you see on this form, its size, color and its contents, this is exactly what your program looks like.

Step 5: Run the Program

To run the form, click Debug > Start or Press F5 or , your program
will look like this (View Image).

Congratulations! You have just made your first Windows Application Program .

Next >> Designing Visual Basic.Net Form using Toolbox

How to Save your VB .NET Projects

2011-07-16T18:16:00.000-07:00

If you have a look in the top right of the Design Environment, you'll see the Solution Explorer. (If you can't see it, click View > Solution Explorer in version 2008 and View > Other Windows > Solution Explorer in version 2010.) See Image

The Solution Explorer shows you all the files you have in your project (Notice that the name of your project is at the top of the tree - "My First Project").

At first glance, it looks as though there are not many files in the project. But click the Show All Files icon (See Image).

When you click Show All Files, the Solution Explorer will look something like this (See Image).

When you save your project, you are saving all these files.

To save your work, click File > Save All and you'll see the following dialogue box (See Image).

The files are usually saved in the My Document folder in XP (Document folder in Vista and Windows 7), under Visual Studio. If you want to save your projects elsewhere, click the Browse button.

To actually save your work as you go along, just click File > Save All from the menu bar. Or press Ctrl + Shift + S on your keyboard. Or click the icon in the Toolbar (the stack of floppy disks). If you save often then you won't lose any of your work if anything goes wrong with your computer.

In the next section, we'll get down and do a bit of actual programming. It's a gentle introduction, so nothing to get too worried about!

Previous>> Adding a Splash of Colour Next >> Creating a New Project

Adding a Splash of Colour

2011-07-15T18:08:00.000-07:00

At the moment, our form looks a little bland. Time to liven it up with a splash of colour. Changing the colour of the Form means we have to change one of its properties - the BackColor property. See Image

So click anywhere on the form that is not a textbox or a label. If you do it right, you should see the sizing handles around the edges of the grey form.

The Property Box on the right will read "Form1", and that indicates that you have indeed selected the form. When the Form is selected you can change its properties.

To change the colour of the Form, click the word "BackColor" in the Property Box.

Next, click the black down-pointing arrow to the right. A drop-down box will appear.

The default colour is the one selected - Control. This is on the System Tab.

The System colours are to set whatever colour scheme the user has opted for when setting up their computers. For example, you can use the Display Properties dialogue box in Windows XP to change how things like menus and buttons look. Someone who is colour-blind might have changed his or her settings in order to see things better on the computer screen. If you stick with the System colours then a colour-blind user of your programme would not have any problems seeing your master work.

As you can see in the image above, you can choose the colour of the Active Caption. The Active Caption is the one you set earlier when you changed the text to "My First Form". The Active Caption is blue on my computer, and the Active Caption Text is white. It might be different on yours.

If you want to choose a colour that is not a System colour, click the Custom Tab. You'll then see this (View Image).

Click on any of the Colours in the colour palette and the background colour of your form will change.You can also select the Web Tab. When you do, you'll see a list of Web-Safe colours to choose from. A Web-Safe colour is one that displays correctly in a web browser, regardless of which computer being used (that's the theory, anyway). You might want to use a Web-Safe colour if you're designing a project for the internet. But you can choose one even if you're not.

To change the colour of the labels, click on a label to select it. Look in the Property box to see if it reads Label. If so, you can now go ahead and change the BackColor property of the Label in exactly the same way that we changed the BackColor property for our Form.

Change the colour of the other two labels to anything you like. To change the colour of more than one Label at a time, click on one Label to select it. Now, hold down the "Ctrl" key on your keyboard and click another Label. You'll see that two Labels now have sizing handles around them. Click the third Label with the "Ctrl" key held down, and all three Labels will be selected. You can change the BackColor property of all three at once.

If you want to change the Font size of the Labels and Textboxes, select a control. Let's start with Label1.

So click on Label 1
Scroll down the Property Box until you see Font
Click on the word "Font" to highlight it
MS Sans Serif is the default Font

Notice that the Font property has a cross next to it. This indicates that the property is expandable. Click the cross to see the following (View Image):

Notice that the Font property has a cross next to it. This indicates that the property is expandable. Click the cross to see the following (View Image).

As you can see, you can change a lot of Font properties from here: the Name of the font, its Size, whether is should be Bold or not, etc. You can also click the square box with the three dots in it. This brings up a dialogue box where you can change the font properties in the same place.

Make the following changes to the three labels:

Font: Arial
Font Style: Bold
Font Size: 10

Change the Font of the three Textboxes so that they are the same as the Labels.

When you're finished, you should have a form that looks a little more like a real programme.

Time now to save your work. Click the link below to see how to do this in VB .NET.

Previous >> The Text Property Next >> How to Save your VB .NET Projects

The Text Property

2011-07-14T18:00:00.000-07:00

Changing the values of some properties is fairly easy. We'll now change the Text properties of our labels, and the Text properties of our Textboxes.

Click on Label1 so that it has the sizing handles, and is therefore selected. Examine the Property box for the Label (See Image).

You can see that the Label control has quite a few different properties to the Form control. Think back to your television as an control. It will have different buttons and knobs to your DVD Player control. A label has different "buttons and knobs" to the Form's "buttons and knobs".

But the Label has a lot of properties that are the same. The Text property of a Label does what you'd expect it to do: adds text to your label.

We'll do that now:

With label1 selected, click inside the area next to "Text", and delete the word "Label1" by hitting the backspace key on your keyboard
Type in the words "First Name"
Click back onto the grey form, or hit the return key on your keyboard
Label1 has now changed its text caption to read "First Name"
If you've made a typing error, go back to the first step above and try again
Your form should now look like this (See Image)

Now, change the Text property of the other two labels. Change them to these values:

Label2: Last Name

Label3: Telephone Number

What you should notice is that the labels resize themselves, after you press the enter key to commit the changes. You may need to drag your labels to the left a bit. But when you're finished, your form should look like this (View Image).

The form might look a little squashed, though. Is there anything we can do to make it bigger? Well, it just so happens there is.

The Form can be resized just like the Label and the textboxes.

Click anywhere on the form that is not a textbox or a label. If you look closely around the Form's edges, you'll notice our old friends the sizing handles. To make the form bigger, just stretch them like you did the labels and the textboxes. Play around with the size of the form until you're happy with it. You can now reposition and resize the textboxes and labels so that things don't look too squashed. Your form might look like this one (View Image).

Click on Debug > Start to have a look at your programme. Or Press F5 on your keyboard. Click Debug > Stop Debugging to get back to the design environment. (Or press Shift + F5, or just click the red X at the top right of the form.)

Now, lets add a splash of colour to our form.

Previous>>An Introduction to VB .NET Properties Next>>Adding a Splash of Colour

An Introduction to VB .NET Properties

2011-07-13T00:14:00.000-07:00

You've probably noticed the area to the right of the design environment, the area with all the textboxes in a grid, the one that has those daunting names like "AccessibleDescription", "AccessibleName", "AccessibleRole". That's the Properties box (see Image).

Click anywhere on the form that is not a label or a textbox, somewhere on the form's grey areas. The form should have the little sizing handles now, indicating that the form is selected.

If your Properties box says "Textbox1 Textbox" or "Label1 Label" then you haven't yet selected the Form. Click away from the textbox or label until the Properties box reads "Form1 Form"

What you are looking at is a list of the properties that a form has: Name , BackColor, Font, Image, Text, etc.

Just to the right of these properties are the values for them. These values are the default values, and can be changed. We're going to change the value of the Text property.

First, you might want to display the list of Properties in a more accessible form. You can display the list properties alphabetically. To do that, click the Alphabetic icon at the top of the Properties box,See Image).

This will make the properties easier to find.

Before we change any in the Properties box, let's clear up what we mean by "Property".

What is a Property?

Those controls you added to the form (textboxes and labels), and the form itself, are called control objects. You can think of controls as things, something solid that you can pick up and move about. Controls (things) have properties. If your television were a control, it too would have properties: an On/Off button property, a colour property, a volume property, and a ... well, what other properties would your television have? Think about it.

The properties of your television will have values. The On/Off button would have just two values - On or Off. The volume property could have a range of values, from zero to ten, for example. If the value of the volume property was set to ten, the loudest value, then you'd probably have some very angry neighbours!

In VB.NET, you can change a property of a control from the Properties Box. (You can also change a property using code, which you'll do quite a lot.) If we go back to our Form object, and the properties and values it has, we can see how to change them using the Properties Box. We'll change only one of these values for now - the value of the Text property . So, do this:

Locate the word "Text" in the Property box, (See Image)

"Text" is a Property of Form1. Don't be confused by the word "Form1" next to the word "Text". All this means is that the current value of the Text property is set to the word "Form1". This is the default.
To change this to something of your own, do this:

Click inside the area next to "Text", and delete the word "Form1" by hitting the backspace key on your keyboard
When "Form1" has been deleted, type the words "My First Form"

Click back on the form itself (the one with the labels and textboxes), or hit the return key on your keyboard
The words "My First Form" will appear as white text on a blue background at the top of the form (See Image).

When you've correctly changed the Text property, your Form will then look like this (see Image).

As you can see, your new text has gone at the top of the form, in white on the blue background.

So the Text Property of a form is for setting the caption you want to display in the title bar at the top.

In the next part, we'll take a look at how to change the text property of labels and textboxes.

Previous>> Adding a Tool To a Form Next>>The Text Property

Designing Visual Basic.Net Form using TOOLBOX

2011-07-12T20:18:00.000-07:00

Things like buttons, textboxes, and labels are Tools that you can add to your Forms. They are keep in the Toolbox for ease of use.

The Toolbox can be found on the left side of the screen as shown (View Image).

To display all the tools, move your mouse over the toolbox icon.

You'll see several categories of tools available: All Windows Forms, Common Controls, Containers, Menus & Toolbars etc.

To display all the available tools that you can use, click on the plus symbol next to All Windows Forms and you'll see a long list of tools as shown above.

To start our design, we can use the Button, the TextBox and the Label tools.

If you want to keep the toolbox displayed, click the Pin icon next to the X button. (View Image)

To close the toolbox, simply move your mouse away.

In the next part, we'll see how to add a textbox to the form.

Previous >> Starting Visual Basic.Net (2008 version)
Next >> Adding a Tool To a Form

Adding a Tool To a Form

2011-07-11T21:10:00.000-07:00

How to Add a Control to your VB.Net Forms

Let's start with Adding a Textbox to a Form.

Step 1 : Locate the Textbox Tool (View Image)

Step 2 : Drag or Double click the icon

The textbox gets added to the top left position of your form. (View Image)

Step 3 : Drag to a New Position

To move it down, hold your mouse over the textbox and drag to a new position (View Image)

Step 4 : Resize the Textbox

Notice the small squares around the textbox. These are sizing handles. Point your mouse over one of them and the mouse pointer turns into an extended line with arrowheads.

Hold your left mouse button down and drag outwards. The textbox is resized.
Play around with the sizing handles until you're happy with the size of your textbox. (View Image)

Step 5 : Add Multiple Textboxes (Use Step 1 to Step 4) (View Image)

Adding a Label to your Form

Step 1: Locate the Textbox Tool (View Image)

Step 2 : Drag or Double click the icon (View Image)

Step 3 : Add Multiple Labels

Create two more labels, and position them to the left of the textboxes. (View Image)

Step 4 : Run the Program

Click Debug > Start from the menu bar. Or Press F5. (View Image)

Stop Debugging the Program

1. Click the Red X at the top right of your Form

2. Click Debug > Stop Debugging from the menu bar

3. Press Shift + F5 on your keyboard (View Image)

You can also click the Stop button on the VB toolbars at the top (View Image).

Previous >> Designing Visual Basic.Net Form using TOOLBOX

Next >> An Introduction to VB .NET Properties