Sams Teach Yourself C# in 24 Hours

By James Foxall and Wendy Haro-Chun

• Table of Contents
  • Copyright
  • About the Authors
  • Acknowledgments
  • Tell Us What You Think!
  • Introduction
  • Audience and Organization
  • Conventions Used in This Book
  • Onward and Upward!
  • Part I. The Visual Studio Environment
  • Hour 1. A C# Programming Tour
  • Hour 2. Navigating C#
  • Hour 3. Understanding Objects and Collections
  • Hour 4. Understanding Events
  • Part II. Building a User Interface
  • Hour 5. Building FormsPart I
  • Hour 6. Building FormsPart II
  • Hour 7. Working with the Traditional Controls
  • Hour 8. Advanced Controls
  • Hour 9. Adding Menus and Toolbars to Forms
  • Hour 10. Drawing and Printing
  • Part III. Making Things HappenProgramming!
  • Hour 11. Creating and Calling Methods
  • Hour 12. Using Constants, Data Types, Variables, and Arrays
    • Understanding Data Types
    • Defining and Using Constants
    • Declaring and Referencing Variables
    • Determining Scope
    • Naming Conventions
    • Summary
    • Q&A
    • Workshop
  • Hour 13. Performing Arithmetic, String Manipulation, and Date/Time Adjustments
  • Hour 14. Making Decisions in C# Code
  • Hour 15. Looping for Efficiency
  • Hour 16. Debugging Your Code
  • Hour 17. Designing Objects Using Classes
  • Hour 18. Interacting with Users
  • Part IV. Working with Data
  • Hour 19. Performing File Operations
  • Hour 20. Controlling Other Applications Using Automation
  • Hour 21. Working with a Database
  • Part V. Deploying Solutions and Beyond
  • Hour 22. Deploying a Solution
  • Hour 23. Introduction to Web Development
  • Hour 24. The 10,000-Foot View
  • Appendix A. Answers to Quizzes/Exercises

Defining and Using Constants

When you hard-code numbers in your code (such as in intVotingAge = 19;), a myriad of things can go wrong. Hard-coded numbers are generally referred to as "magic numbers" because they're often shrouded in mystery; the meaning of such a number is obscure because the digits themselves give no indication as to what the number represents. Constants are used to eliminate the problems of magic numbers.

You define a constant as having a specific value at design time, and that value never changes throughout the life of your program. Constants offer the following benefits:

• Elimination or reduction of data entry problems It is much easier, for example, to remember to use a constant named c_pi than it is to enter 3.14159265358979 everywhere that pi is needed. The compiler will catch misspelled or undeclared constants, but it doesn't care one bit what you enter as a literal value. (Incidentally, you can retrieve the value of pi using System.Math.PI, so you don't have to worry about creating your own constant!)
• Code is easier to update If you hard-coded a mortgage interest rate at 6.785, and rates were changed to 7.00, you would have to change every occurrence of 6.785 in code. In addition to the possibility of data entry problems, you'd run the risk of changing a value of 6.785 that had nothing to do with the interest rate—perhaps a value that represented a savings bond yield. With a constant, you change the value once, and all code uses the new value.
• Code is easier to read Magic numbers are often anything but intuitive. Well-named constants, on the other hand, add clarity to code. For example, which of the following statements makes the most sense?

  decInterestAmount = ((decLoanAmount * 0.075) * 12);
  

• or

  decInterestAmount = ((decLoanAmount * c_fltInterestRate) * _
                      c_intMonthsInTerm);
  

Constant definitions have the following syntax:

const datatype name = value;

For example, to define a constant to hold the value of pi, you could use a statement such as this:

const float c_pi = 3.14159265358979;

Note how I prefix the constant name with c_. I do this so that it's easier to determine what's a variable and what's a constant when reading code. See the section on naming conventions later in this hour for more information.

After a constant is defined, you can use the constant's name anywhere in code in place of the constant's value. For example, to output the result of two times the value of pi, you could use a statement like this (the * character is used for multiplication and is covered in the next hour):

Debug.WriteLine(c_pi * 2);

Using the constant is much easier and less error prone than typing this:

Debug.WriteLine(3.14159265358979 * 2);

Constants can be referenced only in the scope in which they are defined. I discuss scope in the section "Determining Scope."

Share This