P. 1
Rob Miles CSharp Yellow Book 2011

Rob Miles CSharp Yellow Book 2011

|Views: 40|Likes:
Published by tejvan

More info:

Published by: tejvan on Mar 06, 2012
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

05/27/2012

pdf

text

original

Structures let us organise a set of individual values into a cohesive lump which we can
map onto one of the items in the problem that we are working on. This is important in
many applications.

4.3.1 What is a Structure?

Often when you are dealing with information you will want to hold a collection of
different things about a particular item. The Friendly Bank has commissioned an
account storage system and you can use structures to make this easier. Like any good
programmer who has been on my course you would start by doing the following:

1. Establish precisely the specification, i.e. get in written form exactly what
they expect your system to do.

2. Negotiate an extortionate fee.

3. Consider how you will go about storing the data.

A sample structure

From your specification you know that the program must hold the following:

customer name - string
customer address - string
account number - integer value
account balance - integer value
overdraft limit - integer value
The Friendly Bank have told you that they will only be putting up to 50 people into
your bank storage so, after a while you come up with the following:

const int MAX_CUST = 50;

AccountState [] states = new AccountState [MAX_CUST] ;
string [] names = new string [MAX_CUST] ;
string [] addresses = new string [MAX_CUST] ;
int [] accountNos = new int [MAX_CUST] ;
int [] balances = new int [MAX_CUST] ;
int [] overdraft = new int [MAX_CUST] ;

What we have is an array for each single piece of data we want to store about a
particular customer. If we were talking about a database (which is actually what we are
writing), the lump of data for each customer would be called a record and an individual
part of that lump, for example the overdraft value, would be called a field. In our
program we are working on the basis that balance[0] holds the balance of the first
customer in our database, overdraft [0] holds the overdraft of the first customer,
and so on. (Remember that array subscript values start at 0).

This is all very well, and you could get a database system working with this data
structure. However it would be much nicer to be able to lump your record together in a
more definite way.

4.3.2 Creating a Structure

C# lets you create data structures. A structure is a collection of C# variables which you
want to treat as a single entity. In C# a lump of data would be called a structure and
each part of it would be called a field. To help us with our bank database we could
create a structure which could hold all the information about a customer:

Creating Solutions

Structures

C# Programming © Rob Miles 2011

80

struct Account
{

public AccountState State;
public string Name ;
public string Address ;
public int AccountNumber ;
public int Balance ;
public int Overdraft ;

} ;

This defines a structure, called Account, which contains all the required customer
information. Having done this we can now define some variables:

Account RobsAccount ;
Account [] Bank = new Account [MAX_CUST];

The first declaration sets up a variable called RobsAccount, which can hold the
information for a single customer. The second declaration sets up an entire array of
customers, called Bank which can hold all the customers.

We can assign one structure variable to another, just as we would any other variable
type. When the assignment is performed all the values in the source structure are
copied into the destination:

Bank[0] = RobsAccount;

This would copy the information from the RobsAccount structure into the element at
the start of the Bank array.

We refer to individual members of a structure by putting their name after the struct
variable we are using with a . (full stop) separating them, for example:

RobsAccount.AccountNumber

- would refer to the integer field AccountNumber in the structured variable
RobsAccount. (i.e. the AccountNumber value in RobsAccount)
You can do this with elements of an array of structures too, so that:

Bank [25].Name

- would be the string containing the name of the customer in the element with subscript
25.

4.3.3 Using a Structure

A program which creates and sets up a structure looks like this:

using System;

// enum
enum AccountState
{

New,
Active,
UnderAudit,
Frozen,
Closed

} ;

Creating Solutions

Structures

C# Programming © Rob Miles 2011

81

// structure
struct Account
{

public AccountState State;
public string Name ;
public string Address ;
public int AccountNumber ;
public int Balance ;
public int Overdraft ;

} ;

// program
class BankProgram
{

public static void Main ()

{

Account RobsAccount ;
RobsAccount.State = AccountState.Active;
RobsAccount.Name = "Rob Miles";
RobsAccount.Address = "His house";
RobsAccount.AccountNumber = 1234;
RobsAccount.Balance = 0;
RobsAccount.Overdraft = -1000;
Console.WriteLine ( "Name is : " + RobsAccount.Name ) ;
Console.WriteLine ( "Balance is : " + RobsAccount.Balance ) ;

}

}

Note how the structure and enum are declared outside the BankProgram class. Once I
have created my structure I can use it in the same way that I would use something like
int or float.

This program doesn’t create an array of structures, but it does show you how to access

the various fields in a single structure variable.

Initial values in structures

When a structure is created as a local variable (i.e. in a block) the values in it are
undefined. This means that if you try to use them in your program you will get a
compilation error. This is exactly the same as if you use a variable in a program before
giving it a value. In other words:

Account RobsAccount ;
Console.WriteLine ( "Name is : " + RobsAccount.Name ) ;

- would produce a compilation error. It is your job as programmer to make sure that
you always put a value into a variable before you try to get something out of it.

Using Structure Types in Method Calls

A method can have parameters of structure type:

public void PrintAccount ( Account a )
{

Console.WriteLine ( "Name: " + a.Name );
Console.WriteLine ( "Address: " + a.Address );
Console.WriteLine ( "Balance: " + a.Balance );

}

This method provides a quick way of printing out the contents of an account variable:

PrintAccount (RobsAccount);

Creating Solutions

Objects, Structures and References

C# Programming © Rob Miles 2011

82

It is also possible to create methods that return results which are of a structure type, for
example we could create a ReadAccount method that reads an account and returns it.

Programmer’s Point: Structures are crucial

In a commercial system it is common to spend a very long time designing the structures which make up the data
storage. They are the fundamental building blocks of the program since they hold all the data upon which everything
else is built. You can regard the design of the structures and the constraints on their content as another big chunk of
metadata about a system that you create.

Designing with Types

You can see that we have added a State value to the Account structure. This makes
it easy for the program to keep track of the particular state of an account. What we have
done is created a type which can hold a number of values (our AccountState
enumerated type) and put it into another type we have designed which is to hold
information about a bank Account holder. This approach is how you attack more
complicated problems. We can get all the details of what the types should hold from
the metadata that comes from discussion with our customer.

For example, if we want to create a really impressive double glazing management
program we could come up with something like this:

enum WindowState
{

Quoted,
Ordered,
Manufactured,
Shipped,
Installed

} ;

struct Window
{

public WindowState state ;
public double Width ;
public double Height ;
public string Description ;

} ;

This would hold information about a particular window in a house, including the
dimensions of the window, the state of the window order and a string describing the
window itself. For a particular house, which contains a number of windows, we could
create an array of Window structures.

Programmer’s Point: You should give state to your objects

The Account class above is a good example of an object that will be used in different ways, depending on the state
that it is occupying. For example, it will not be possible to withdraw funds from an account which is in the Frozen
state. Just about every object in a system can be improved by the addition of state. Orders can be Empty, Pending,
Despatched and Received. Aliens can be Sleeping, Attacking or Destroyed. Whenever you invent a new object you
should immediately start to consider the states that it can occupy in your system.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->