mcgraw-hill © 2010 the mcgraw-hill companies, inc. all rights reserved. chapter 3 variables,...

McGraw-Hill © 2010 The McGraw-Hill Companies, Inc. All rights reserved.

Chapter 3

Variables, Constants and Calculations

McGraw-Hill © 2010 The McGraw-Hill Companies, Inc. All rights reserved. 3-2

Chapter Objectives - 1

• Distinguish between variables, constants, and controls

• Differentiate among the various data types• Apply naming conventions incorporating

standards and indicating the data type• Declare variables and constants• Select the appropriate scope for a variable• Convert text input to numeric values


Chapter Objectives - 2

• Perform calculations using variables and constants

• Convert between numeric data types using implicit and explicit conversions

• Round decimal values using the decimal.Round method

• Format values for output using the ToString method

• Use try/catch blocks for error handling• Display message boxes with error messages• Accumulate sums and generate counts


Data – Variables and Constants - 1

• Variable– Memory locations that hold data that can

change during project execution• Example: Customer's name

• Constant– Memory locations that hold data that cannot

change during execution• Examples: Company name or sales tax rate



• Declare a variable or named constant– C# reserves an area of memory– Assign a name, called an identifier– Specify identifier names according to C# rules and

naming conventions• Declaration statements

– Establish project variables and constants– Give variables and constants names– Specify type of data held– Not executable



• Sample declaration statements

//Declare a string variable.string nameString;

//Declare integer variables.int counterInteger;int maxInteger = 100;

//Declare a named constant.const decimal DISCOUNT_RATE_Decimal = .15M;


Data Types - 1

bool true or false valuesbyte 0 to 255, binary datachar Single Unicode characterDateTime 1/1/0001 00:00:00 through 12/31/9999 23:59:59decimal Decimal fractions, such as dollars & cents, precision of 28 digitsfloat Single-precision floating-point numbers, six digits of accuracydouble Double-precision floating-point numbers, 14 digits of accuracyshort Small integer in the range –32,768 to +32,767int Whole numbers in the range – 2,147,483,648 to +2,147,483,647long Larger whole numbersstring Alphanumeric data: letters, digits and other charactersobject Any type of data


Data Types - 2

• Common types of variables and constants– string– int– decimal

• Guideline for use– Data used in calculations must be numeric

• decimal – any decimal fraction including dollars• int – whole number calculations• float and double – scientific applications

– Text characters and numbers not used in calculations• string – including phone or social security numbers


Naming Rules

• May contain letters, digits, and underscores

• Must begin with a letter or underscore• Cannot contain spaces or periods• Cannot be reserved words (keywords)

– Examples: print, name, value• Case sensitive

– sumInteger, SumInteger, suminteger and SUMINTEGER are different variables


Naming Conventions

• Should follow naming conventions– Identifiers must be meaningful

• Clearly indicate the purpose• Do not abbreviate• Do not use X or Y

– Include the class (data type)– Use camel casing for variables

• Begin with a lowercase letter• Capitalize each successive word

– Use uppercase for constants• Separate words with underscores


Constants: Named and Intrinsic

• Constants contain a value that does not change

• Intrinsic– Built into the environment, not defined

• Named– Defined by programmer


Named Constants - 1

• Declare using keyword const• Assign name, data type, value• A constant’s value cannot be changed

during a project’s execution• Data type declared and data type of value

must match– Example – integer constant declared, integer

value must be assigned


Named Constants - 2

• Two advantages to using– Easier to read

• MAXIMUM_PAY_Decimal more meaningful than 1000

• To change value, change constant declaration once, not every reference in code

• const Statement – Examplesconst string COMPANY_ADDRESS_String = “101 S. Main Street”;const decimal SALES_TAX_RATE_Decimal = .08m;


Assigning Values to Constants - 1

• Numeric constants– May contain only digits (0-9)– Decimal point– Sign at the left side (+ or -)– Type declaration character at the right side (optional)– Cannot contain comma, dollar sign, any other special

characters, sign (+ or -) at right side– Use type declaration character to specify the data type

• Without type declaration character, whole numbers assumed to be int and fractional values assumed to be double

decimal M or mdouble D or dlong L or lshort S or sfloat F or f


Assigning Values to Constants - 2

• String constants (or literals)– Enclose in quotes– Can contain letters, digits, and special

characters– To include a quotation mark within a literal,

precede the quotation mark with a backslash (\) "He said, \“I like it.\" "

produces the string: He said, “I like it."


Intrinsic Constants

• System-defined constants• Declared in system class libraries• Specify class name or group name and

constant name– Example – Color.Red is the constant “Red” in

the class “Color”


Declaring Variables - 1

• Declare a variable– Specify data type and follow with an

identifier– Assign an initial value (optional)

string customerNameString;string customerNameString = “None”;private int totalSoldInteger;int totalSoldInteger = 0;float temperatureFloat;float temperatureFloat = 32f;decimal priceDecimal;private decimal priceDecimal = 99.95m;


Declaring Variables - 2

• Declare several variables in one statement– Data type at beginning of statement applies to

all variables in statement– Separate variable names with commas– End statement with a semicolon (;)

string nameString, addressString, phoneString;decimal priceDecimal, totalDecimal;int countInteger = 0, totalInteger = 0;


Initializing Numeric Variables

• Must assign a value before use– Variable must appear on left side of equal

sign before used on right side of equal sign• Initialize a variable when declared

int quantityInteger = 0;• Or declare variable and assign value later

int quantityInteger;quantityInteger = int.Parse(quantityTextBox.Text);


Entering Declaration Statements

• IntelliSense helps in entering declaration statements– Type correct entry– List scrolls to correct section– When correct entry is highlighted

• Press Enter, Tab, or spacebar or double-click entry with mouse


Scope and Lifetime of Variables

• Visibility of a variable is its scope– Namespace

• Also referred to as global– Class-level– Local– Block

• Scope of variable determined by where it is declared


Variable Lifetime

• Period of time a variable exists– Local or block variable

• One execution of a method• After execution variables disappear, memory

locations are released– Class-level variable

• Entire time class is loaded (usually lifetime of project)

• Variables maintain value for multiple executions of a method


Local Declarations

• Variable declared inside a method is local in scope– Known only to that method

• Must be declared prior to first use– All declarations should appear at the top of a

method (after comments)• All constants should be declared at class

level– Easy to locate to facilitate any changes


Class-Level Declarations

• Variables declared at class level can be used anywhere in that form’s class

• Place after opening brace for class, outside of any method

Class variables and constants


Calculations

• Calculations are performed with– Variables– Constants– Properties of certain objects

• i.e. Text property of text box or label• Character strings must be converted to correct

data type first


Converting Strings to a Numeric Data Type

• Parse method converts the Text property of a control to a numeric value that can be used in calculations

• int.Parse converts text to an integer• decimal.Parse converts text to a decimal• Pass the text string to convert as an argument of

the Parse method// Convert input values to numeric variables.quantityInteger = int.Parse(quantityTextBox.Text);priceDecimal = decimal.Parse(priceTextBox.Text);//Calculate the extended price.extendedPriceDecimal = quantityInteger * priceDecimal;


Using the Parse Methods

• Parse attempts to convert the string to the specified data type – Values such as blanks or nonnumeric

characters cause an error• Parse methods exist for long, float or

double conversionsquantityInteger = int.Parse(quantityTextBox.Text);priceDecimal = decimal.Parse(priceTextBox.Text);wholeNumberInteger = int.Parse(digitString);


Converting to String

• Assignment must be of like types– Assign a string value to a string variable or

property– Assign a numeric value to a numeric variable

or property• To assign the result of a calculation to the

Text property of a control, use the ToString method

resultTextBox.Text = resultDecimal.ToString();countTextBox.Text = countInteger.ToString();idString = idInteger.ToString();


Arithmetic Operations - 1

Operator Operation

+ Addition

– Subtraction

Multiplication

/ Division

% Modulus – remainder of division



• Modulus (%)– Returns the remainder of a division operation

// Assume that totalMinutesInteger = 150minutesInteger = totalMinutesInteger % 60;

// Result is 30.// (150 divided by 60 is 2 with a remainder of 30.)



• Division (/)– Divide fractional values or integers– If at least one value is fractional, the result is

fractional– If both values are integer, the result is integer

(any remainder is dropped)// Assume that minutesInteger = 150// Integer division.hoursInteger = minutesInteger / 60; // Result is 2.// Fractional division.hoursFloat = minutesInteger / 60.0f; // Result is 2.5.



• Exponentiation– C# does not have an operator for

exponentiation– Use Math.Pow

• See Appendix B for Math methods• See Chapter 5 for an example

– “Writing a Method with Multiple Arguments”


Order of Operations - 1

• Hierarchy of operations or order of precedence in arithmetic expressions1. Any operation inside parentheses2. Multiplication and division3. Modulus4. Addition and subtraction



• Using parentheses controls the order of evaluation

3 + 4 2 = 11 Multiply then add

(3 + 4) 2 = 14 Add then multiply

8 / 4 2 = 4 Divide then multiply

8 / (4 2) = 1 Multiply then divide



• Evaluation of an expression occurs in this order

1. All operations within parenthesesMultiple operations within the parentheses are performed according to the rules of precedence

2. All multiplication and divisionMultiple operations are performed from left to right

3. Modulus operationsMultiple operations are performed from left to right

4. All addition and subtraction are performed from left to right


Using Calculations in Code

• Perform calculations in assignment statements– Calculation appears on the right side of the equal sign– Result is assigned to a variable or property on the left

side of the equal sign (never a constant)

averageDecimal = sumDecimal / countInteger;amountDueLabel.Text = (priceDecimal – (priceDecimal * discountRateDecimal)).ToString();commissionTextBox.Text = (salesTotalDecimal * commissionRateDecimal).ToString();


Assignment Operators

• Combined assignment operators– Perform both a calculation and an assignment

• += Add to the operator on the lefttotalSalesDecimal += saleDecimal;

• –= Subtract from the operator on the leftcountDownInteger –= 1;

= Multiply by operator on left and assign result to the operatorresultInteger = 2;

• /= Divide into operator on left and assign result to the operatorsumDecimal /= countInteger;

• += (Strings) concatenate to the operator on the leftbigString += smallString;


Increment and Decrement Operators

• Increment (++) — Adds 1 to a variablecountInteger++;

• Decrement (– –) — Subtracts 1 from the variable countDownInteger– –;

• Prefix notation– Prefix to perform the increment before the arithmetic operation

Add 1 to countInteger before subtracting from 100 resultInteger = 100 – ++countInteger;

• Postfix notation– Postfix to perform the increment after the arithmetic operation

Subtract countInteger from 100 before incrementing countInteger

resultInteger = 100 – countInteger++;


Converting between Numeric Data Types - 1

• Implicit conversions– Converts value from narrower data type to a wider

type when there is no danger of losing precision• Note: C# has no implicit conversions to convert from decimal

From To byte short, int, long, float, double, decimal short int, long, float, double, decimal int long, float, double, decimal long float, double, decimal float double



• Explicit conversions– Also called casting– Convert between data types without implicit

conversions– Specify the destination data type in

parentheses before the data value to convert– Generates an exception if significant digits will

be lost numberDecimal = (decimal) numberFloat; valueInt = (int) valueDouble;



• Convert class methods– C# methods available

• ToDecimal, ToSingle, ToDouble– Integer data types use .NET class names

• short – ToInt16• int – ToInt32• long – ToInt64

– ExamplesnumberDecimal =

Convert.ToDecimal(numberSingle);valueInteger = Convert.ToInt32(valueDouble);


Performing Calculations withUnlike Data Types

• C# performs the calculations using the wider data type

• Perform a cast if you want to convert the result to a different data type

(int) countInteger / numberDecimal(float) countInteger / numberDecimal

• C# does not convert to a different data type until necessary

countInteger / 2 amountDecimal – Division produces an integer intermediate result; then

multiplication produces a decimal result


Rounding Numbers

• Round decimal fractions using decimal.Round– Returns a decimal result rounded to the specified number of

digits // Round to two decimal positions.resultDecimal = decimal.Round(amountDecimal, 2);

• decimal.Round and Convert methods use "rounding toward even" if the digit to the right of the final digit is exactly 5.

Decimal value to round Number of decimal positions Result

1.455 2 1.461.445 2 1.441.5 0 22.5 0 2


Formatting Data for Display

• Display numeric data in a label or text box by converting the value to a string– Use ToString method

displayTextBox.Text = numberInteger.ToString();

• Format the data using formatting codes as an argument of the ToString method– Specifies dollar sign, percent sign, and

commas– Specifies the number of digits to the right of

the decimal point


Using Format Specifier Codes - 1

• "C" or "c" – Currency– String formatted with a dollar sign, commas separating each

group of three digits, and two digits to the right of the decimal point

extendedpriceTextBox.Text = (quantityInteger * priceDecimal).ToString("C");

• "N" or "n" – Number– String formatted with commas separating each group of three

digits, two digits to right of the decimal point discountTextBox.Text = discountDecimal.ToString("N");

• Specify number of decimal positions by placing a numeric digit following the specifier code

discountTextBox.Text = discountDecimal.ToString("N3");


Using Format Specifier Codes - 2

• Additional Format Specifier Codes– "F" or "f" – Fixed point

• String of numeric digits, no commas, two decimal places, minus sign at left for negative values

– "D" or "d" – Digits• Force a specified number of digits to display• For integer data types only, minus sign at left

– "P" or "p" – Percent• Multiplies the value by 100, adds a space and a percent sign,

rounds to two decimal places– Additional codes for dates and times

• d, D, t, T, f, F, g, G, m, M, r, R• Date and time codes are case sensitive


Choosing the Controlsfor Program Output

• Output can display in labels or text boxes– Labels – Cannot be changed by the user

• Used traditionally for program output– Text boxes – Can be changed by the user

• To use for output– Set ReadOnly property to true (BackColor property changes to

Control)– Set TabStop property to false– Set BorderStyle property to Fixed3D or FixedSingle

• Advantages over using labels for output– Text boxes do not disappear when cleared– Form layout looks more uniform– The clipboard Copy command is available to the user


Format Specifier Code Examples

Variable Value Format Specifier Code Output

totalDecimal 1125.6744 "C" $1,125.67totalDecimal 1125.6744 "N" 1,125.67totalDecimal 1125.6744 "N0" 1,126balanceDecimal 1125.6744 "N3" 1,125.674balanceDecimal 1125.6744 "F0" 1126pinInteger 123 "D6" 000123rateDecimal 0.075 "P" 7.50 %rateDecimal 0.075 "P3" 7.500 %rateDecimal 0.075 "P0" 8 %valueInteger –10 "C" ($10.00)valueInteger –10 "N" – 10.00valueInteger –10 "D3" – 010


Handling Exceptions

• Exceptions cause run-time errors– Blank or non-numeric data cause Parse methods to

fail– Entering a number that results in an attempt to divide

by zero• Exception Handling catches bad data before a

run-time error occurs– Writing code to catch exceptions is called exception

handling– Exception handling in Visual Studio.NET is

standardized for all languages that use the CLR


try/catch Blocks

• Enclose any statement(s) that might cause an error in a try/catch block– If an exception occurs while the statements in

the try block are executing, program control transfers to the catch block

– The code in a finally block (if included) executes last, whether or not an exception occurred


The try Block – General Form

• try• {• // Statements that may cause error.• }• catch [(ExceptionType [VariableName])]• {• // Statements for action when exception occurs.• }• [finally• {• // Statements that always execute before exit of try

block.• }]


The try Block - Example

• Write different catch statements to specify the type of exception to catch

• This catch will catch any exceptiontry{ quantityInteger = int.Parse(quantityTextBox.Text); quantityTextBox.Text = quantityInteger.ToString();}catch{ messageLabel.Text = "Error in input data.";}


The Exception Class - 1

• Each exception is an instance of the Exception class– The properties of this class allow the

programmer to:• Determine the code location of the error• Determine the type and cause of the error• The Message property contains a text message

about the error• The Source property contains the name of the

object causing the error


The Exception Class - 2

• Include the text message associated with the exception

• Declare a variable name in the catch statement for the exceptioncatch (FormatException theException){ messageLabel.Text = "Error in input data: " theException.Message;}


Handling Multiple Exceptions - 1

• Include multiple catch blocks (handlers)• Catch statements are checked in sequence• First one with a matching exception is used• Same variable name can be used for multiple

catch statements– Variable’s scope is only that block– Omit variable name for exception if no need to refer to

properties of the exception object in the catch block


Handling Multiple Exceptions - 2

catch (FormatException theException){ // Statements for nonnumeric data.}catch (ArithmeticException theException){ // Statements to handle calculation problem.}catch (Exception theException){ // Statements for any other exception.}


Displaying Messages in Message Boxes

• Display a message in a message box– User has entered invalid data– User neglects to enter required data

• Specify message, optional icon, title bar text and buttons

• Use Show method of the MessageBox object to display a message box


The MessageBox Object –General Form

• Arguments must match one of the formats• Do not reverse, transpose or leave out any

argument

MessageBox.Show(TextMessage);MessageBox.Show(TextMessage, TitlebarText);MessageBox.Show(TextMessage, TitlebarText, MessageBoxButtons);MessageBox.Show(TextMessage, TitlebarText, MessageBoxButtons, MessageBoxIcon);


The TextMessage String

• TextMessage String– String literal enclosed in quotes– String variable– May concatenate several items

• i.e. Combine a literal with a variable value– If message is too long, will wrap to next line


The Titlebar Text

• TitlebarText– Appears in the title bar of message box– If no TitlebarText argument, title bar will

appear empty


MessageBox Buttons

• Specify button(s) to display– Use the MessageBoxButtons constants of

MessageBox class• OK (default)• OKCancel• RetryCancel• YesNo• YesNoCancel• AbortRetryIgnore


MessageBoxIcon

• IntelliSense pops up with complete list• Constants for MessageBoxIcon

– Asterisk– Error– Exclamation– Hand– Information– None– Question– Stop– Warning


Using Overloaded Methods

• Overloading allows the Show method to act differently for different arguments

• Each argument list is called a signature– The Show method has several signatures

• Supplied arguments must exactly match one of the signatures

• IntelliSense helps in entering the arguments (no need to look up or memorize the signatures)


Testing Multiple Fields

• Each input field presents an opportunity for an exception

• To indicate the field that caused the error, nest one try/catch block inside another one


Nested try/catch Blocks - 1

• One try/catch block completely contained inside another one is a nested try/catch block– Nest as deeply as needed– Place calculations within the most deeply nested try

• Do not perform calculations unless all input values are converted without an exception

– Test each Parse method• Specify which field caused error and set focus back to field in

error• Use SelectAll method of text box

– Makes text appear selected to aid user


Nested try/catch Blocks - 2try // Outer try block for the first field.{ // Convert first field to numeric. try // Inner try block for the second field. { // Convert second field to numeric. // Perform the calculations for the fields that passed conversion. } catch (FormatException secondException) { // Handle any exceptions for the second field. // Display a message and reset the focus for the second field. } // End of inner try block for the second field.}catch (FormatException firstException){ // Handle exceptions for the first field. // Display a message and reset the focus for the first field.}


Counting & Accumulating Sums

• Declare a class level variable– Retains its value for multiple calls

• Allows accumulation of totals

• Static variables– Discussed in Chapter 12


Summing Numbers

• Declare a class-level variable• Inside the calculate event handler

– Add the current amount to the total

totalAmountDecimal += amountDecimal;


Counting

• Declare a counter variable as integer at the class-level

int saleCountInteger;

• Add 1 to the counter variable in the calculate event method

saleCountInteger ++;


Calculating an Average

• Divide sum of items by count of items

averageSaleDecimal = totalAmountDecimal / saleCountInteger;

mcgraw-hill © 2010 the mcgraw-hill companies, inc. all rights reserved. chapter 3 variables,...

Documents