This document discusses data representation in C# and ADO.NET. It begins by explaining that C# objects are similar to Java objects but with properties instead of getter/setter methods. It then covers how to create a class with properties in C# and use objects. The document also discusses encapsulation in ADO.NET and how it handles connecting to databases. It provides steps for connecting to a database, creating a data adapter and dataset, binding controls to display data, and adding code to populate the dataset and allow navigation between records.
2. Introduction
In the last lecture we looked at how event driven
application in .NET work.
I’ll leave it (mostly) up to you to get to grips with
C# syntax.
In this lecture we’re going to discuss the .NET data
model in relation to objects (which you know) and
ADO .NET (which you probably don’t.
ADO .NET is the database engine at the core of
.NET.
As mentioned in previous lectures, data
representation is key to eventual success with a
system.
3. C# Objects
C# objects look very much like Java objects.
Down to the syntax.
The prime differentiators are:
Declaration of a class within a namespace.
Accessors handled as properties.
Properties provide a syntactically consistent
method of handling getting and setting of
attributes.
Rather than the convention driven methods of
Java.
4. Class and Properties
using System;
namespace SimpleClassExample
{
class Person
{
private string name;
private int age;
public int Age
{
get
{
return age;
}
set
{
age = value;
}
}
}
}
5. Making Use Of Objects
using System;
namespace SimpleClassExample
{
class Program
{
static void Main(string[] args)
{
Person me = new Person();
me.Age = 80;
me.Name = "Michael";
me.adjustAge (1);
Console.WriteLine(me.Name + " is " + me.Age + " years
old");
}
}
}
6. Encapsulation
All of the hard work of connecting to a
database in C# is encapsulated in the
data objects you work with.
All you need to learn is how these objects
work, not how they interface with specific
databases.
This means that once you have written
the code to work with one database, it’s
easy to change it to work with another.
7. Bespoke Data
In the next lecture we’ll be talking about
how to hook up a program to a
database.
This is a powerful technique.
Before we get to that though, let’s talk a
little bit about why we may want to do it.
And why we might not, on occasion.
It’s the difference between using a
standard data layer (a database), and a
more bespoke data solution (hand-rolled
classes).
8. Bespoke Data Advantages
Certain contexts demand bespoke
data implementation.
Databases are optimised for certain kinds
of file IO, but are costly for other operations.
Fast paced 3D games would be a good deal
less fast-paced with a database back-end.
Very complex, tightly integrated data
manipulation is much easier to do with a
bespoke data model.
Bespoke models give you a lot of scope for
context specific optimization.
9. Database Advantages
Databases on the other hand, have
advantages of their own.
They are already optimized for what they do.
Large file IO, searching, sorting, etc
Other people are constantly working on
improving them.
A fix in the engine is a fix in your code too.
They offer a structured standard for
interrogation.
You can easily provide many different views of a
database because they all communicate with SQL.
10. Bespoke Versus Database
When would you choose one over
another?
The criteria I use is ‘how much does it matter to
me how the data is stored?
For a simple web-based ecommerce
system, a database is a clear choice with
clear benefits.
For a complex simulation, bespoke data
structures are probably better.
It is the application itself that will dictate
this to you.
11. Examples
You are a Scientist (doing science). You
want to run a variation of Conway’s
Game of Life to investigate properties of
emergent behaviour.
Bespoke or Database?
You are a businessperson (doing
business). You want to put up an online
catalogue that shows your wares and lets
people order them.
Bespoke or Database?
12. Designing A Data Layer
An ideal application allows for the data
representation to be abstracted from the
application itself.
So you can change how data is represented,
and it doesn’t matter.
This is sometimes known as an ‘3 tier’
architecture.
Bespoke data representations do not
easily allow this.
You need to write a translation layer of your
own.
ADO .NET permits the use of several
underlying databases, (mostly) seamlessly.
13. MVC
The MVC is a design pattern that
runs through the module.
Separate out the view from the controller
from the model.
Or more usually, separate out the
view/controller from the model.
Within the MVC, you can profitably look to
separate out data representation from
‘business logic’
Through the incorporation of a dedicated
data layer.
14. ADO .NET
All of this leads us to the .NET way of doing
databases.
ADO .NET
ADO .NET’s communication with
databases is based on two key elements.
The Data Provider Framework
The Data Set
The data provider framework handles the
work of connecting to an actual
database.
The Data Set handles the work of
communicating with applications.
16. ADO .NET
It is possible to interact with a database in
two ways.
Using the Data Reader, which is real-time.
Using Datasets, which are a snapshot of an
underlying data representation.
We’ll be doing the latter.
Some example code on The Interwebs may use
the former. Be mindful of this.
Data sets offer a good deal of flexibility.
They allow for database representation to be
interchangeable with XML representation.
17. Data Sets
As mentioned, data sets offer a snapshot
of the underlying data source.
This is a disconnected, memory resident
representation.
Think of it as making a copy of the data for your
own purposes.
Datasets do not permit you to play with
‘live ammunition’.
If you change things in the dataset, your
underlying database does not change until you
tell it to.
18. Data Sets
This creates some complications.
What happens if you have two data-sets
pointing to the same database, and they
have both been changed?
ADO .NET also offers the facility for
merging data-sets together to deal with
such situations.
Not something you should have to do, but
again something to be mindful of.
19. Data Sets
One of the biggest benefits of Data Sets is
that they permit the access of underlying
data in the same style as associative
arrays.
Or ‘hashmaps’, or ‘mappings’, whatever
term you may prefer.
This greatly simplifies the task of
interacting with an underlying database.
SQL, for all its power, is not an easy
language with which to Get Things Done.
20. Objects and Databases
When you make a connection to a
database in ADO .NET, it translates the
database into objects you can
manipulate.
These objects often have other objects as
part of their makeup.
Effective working within ADO .NET requires
you to be conversant with how these
work.
21. Objects and Databases
A lot of the work you do in setting up a
database is done through Visual Studio
itself.
What it’s doing though is creating and
setting objects for you.
When it comes time to do anything ‘clever’
with our databases, we’ll need to make use
of the objects.
22. Step One: Making The
Database Available
Choose ‘server explorer’
from the view menu.
Add a new data
connection.
Right click on the server
explorer and choose ‘add
connection’
It will ask you where the
database is located.
23. Step One: Making The
Database Available
If you have no u/p
information, leave
it as is.
Press ‘test
connection’ to
make sure that
the connection
works.
Then press ‘ok’.
Your database is
then available in
the server explorer
under ‘data
connections’.
24. The Server Explorer
The Server Explorer gives you an ‘in IDE’
view of the data and database.
You can modify the table, execute queries,
or enter data as needed.
Right click on the table you want to alter,
and choose ‘retrieve data’
25. Step 2: Data Adapter
Step two is to create a data adapter to
extract information from the database.
The data adapter defines the specific
information required by your application.
In cases of very large complex databases, it
is vital to simplify data access routines.
Essentially a data adapter acts as a filter
between the database and your
application.
26. Step 2: Data Adapter
In the C# .NET toolbox is a tab
that says ‘data’.
This tab contains GUI components
that represents aspects of the
ADO .NET architecture.
The OleDBDataAdapter control
lets us use the data connection
wizard to set up an adapter.
If it’s not there, it needs to be
added in manually.
27. Step 2: Data Adapter
The wizard guides you through the
process of setting up the adapter.
Step one, it asks which data connection to use.
You can choose from any nodes on the server
explorer.
Step two, it asks how to access the database.
Choose ‘use SQL statements’.
Step three, it asks what SQL statement to use.
For now, we’re simply going to use a ‘select * from
Customer’ statement.
28. Step 2: Data Adapter
Once these three steps have been taken, the data
adapter is configured.
It will create an instance of the object in the
‘invisible controls’ part of the IDE.
This control can be accessed in code the same
way as any other control.
It just doesn’t appear explicitly on the form.
Once you have this, we can move onto step 3.
29. Step 3: Dataset
The next step is to create an object that
represents the data we wish to use in our
program.
This object is called a dataset.
The dataset is a snapshot of some specific
part of the database.
It can come from tables
It can come from queries
It can come from SQL statements.
30. Step 3: Dataset
To create a dataset,
we must click on the
form to make sure it is
active.
Right click on the
form to bring up the
context sensitive
menu, and select
generate dataset.
This will bring up the
generation dialog.
31. Step 3: Dataset
We are going to create a new dataset, so
enter a identifier for the dataset in the
‘new’ box.
By convention, datasets have a ds prefix.
Ours will be called dsCustomer
The list of tables to be used for the
dataset comes from the data adapter on
your form.
Click on ‘ok’ to generate the dataset… it
will appear in the component tray along
with the data adapter.
32. Voila!
Once you have the dataset generated,
you have a framework in your application
suitable for linking up to controls.
In this lecture, we will look only at using
standard text boxes as data aware
controls.
Next week we’ll look at some more
complex examples.
33. Displaying Data
ADO .NET doesn’t simply dump an Access
table in your application.
Instead, you have to explicitly decide what
controls are to display which parts of the
database.
Most controls in C# can be bound to a
database.
One control especially suited to this is the
textbox control.
34. Displaying Data
Textboxes have many properties associated with
them.
A category of these properties are known as data
properties.
We use these to link the textbox to the dataset.
textBox1.DataBindings.Add (new Binding ("Text",
dsCustomer1, "Customer.FirstName"));
textBox2.DataBindings.Add (new Binding("Text",
dsCustomer1, "Customer.SurName"));
35. Displaying Data
Click on the text link under the data
category.
It will bring up a list of datasets
defined on the form.
They each have a little + beside them.
We can expand this tree until we
find the field we want to display in
the text box.
36. Displaying Data
We do this for each field we want to
display on the form.
As said previously, many controls can make
use of the same dataset.
If we set up all our controls in this way and
then run, nothing will appear in the next
box.
We’re not done yet.
37. One Last Step
Finally, we need to add some code to our
application to set up the dataset and link
it to the adapter.
You thought we’d done that already?
We must manually fill the dataset from the
adapter. We do that with the following
lines of code:
YourDataset.Clear()
YourDataAdapter.Fill(YourDataSet)
38. One Last Step
For example, with a dataset called
dsMyStuff and a data adapter called
OleDBDataAdapter1:
dsMyStuff.Clear()
OleDBDataAdapter1.Fill (dsMyStuff)
Where you do this depends on when you
want the dataset filled.
In the load event of a form is good if you
want it done immediately.
39. Navigation
Okay, we’ve set up the controls and
are displaying some data.
How do we navigate through it?
ADO .NET keeps track of information
about the current record and total
number of records in a dataset
through use of an object called a
CurrencyManager.
Each form in C# has a BindingContext
object that keeps track of all the
CurrencyManager objects.
40. Navigation
The specifics of this are unimportant.
All we want to know is ‘how to we
navigate through records?’.
Despite the complex structure, the code
to navigate through controls is pretty
simple.
We can access the BindingContext for a
dataset on a form using the this keyword.
41. Navigation
Consider a form with a dataset called
dsPeople and a table in that dataset
called Persons:
this.BindingContext [dsPerson1,
“Person”]
A BindingContext has some useful
properties for us to use:
Position
Count
42. Navigation
The position property determines where in
the dataset we currently are.
The count property holds how many
records are in the dataset.
We can manipulate the position property
to move forwards and backwards
through the dataset.
43. Navigation
Next:
this.BindingContext[dsCustomer1, "Customer"].Position += 1;
Previous:
this.BindingContext[dsCustomer1, "Customer"].Position -= 1;
Last:
this.BindingContext[dsCustomer1, "Customer"].Position =
this.BindingContext[dsCustomer1, "Customer"].Count - 1;
First:
this.BindingContext[dsCustomer1, "Customer"].Position = 0;
These code extracts can be bound to buttons
allowing the user to navigate through the
datasets.
44. Conclusion
Data Representation is an important
concept.
Something the more nerdy amongst us
often lose sleep over.
In any application you have a choice
between bespoke representation and a
database engine.
You should decide which of these to use on
the basis of your application.