3: C# Language Fundamentals in C#

Maker Code 128 Code Set A in C# 3: C# Language Fundamentals

The entries in the enumeration are separated by commas. Many programmers like to leave a comma after the last entry in an enumeration as a convenience for adding more values later. Other programmers find this, at best, sloppy. The code will compile either way.

The syntax for specifying an enumeration uses the enum keyword, as follows:

enum identifier [:base-type] {enumerator-list};

In a specification statement such as the preceding example, the square brackets indicate an optional element. Thus, you can declare an enum with no base type, simply by leaving it out (leave out the square brackets as well).

There are also optional attributes and modifiers you can use, but you don t need them right now. An enumeration begins with the keyword enum, which is generally followed by an identifier; in this case, Temperatures:

The base type is the underlying type for the enumeration. You might specify that you are declaring constant ints, constant longs, or something else. If you leave out this optional value (and often you will), it defaults to int, but you are free to use any of the integral types (ushort, long) except for char. For example, the following fragment declares an enumeration with unsigned integers (uint) as the base type:

enum ServingSizes : uint { Small = 1, Regular = 2, Large = 3 }

Notice that an enum declaration ends with the enumerator list, which contains the constant assignments for the enumeration, each separated by a comma. Example 3-5 rewrites Example 3-4 to use an enumeration.

using using using using System; System.Collections.Generic; System.Linq; System.Text;

|

enum Temperatures { WickedCold = 0, FreezingPoint = 32, LightJacketWeather = 60, SwimmingWeather = 72, BoilingPoint = 212, } static void Main( ) { System.Console.WriteLine("Freezing point of water: {0}", (int)Temperatures.FreezingPoint); System.Console.WriteLine("Boiling point of water: {0}", (int)Temperatures.BoilingPoint); } } }

In Example 3-5, you declare an enumerated constant called Temperatures. When you want to use any of the values in an enumeration in a program, the values of the enumeration must be qualified by the enumeration name. That is, you can t just refer to FreezingPoint; instead, you use the enumeration identifier (Temperature) followed by the dot operator and then the enumerated constant (FreezingPoint). This is called qualifying the identifier FreezingPoint. Thus, to refer to the FreezingPoint, you use the full identifier Temperature.FreezingPoint. You might want to display the value of an enumerated constant to the console, as in the following:

Console.WriteLine("The freezing point of water is {0}", (int) Temperature.FreezingPoint);

To make this work properly, you must cast the constant to its underlying type (int). In this case, you are saying, Treat this enumerated constant as an int. Because you know the underlying type is int, this is safe to do. (See Casting earlier in this chapter.) In Example 3-5, the values in the two enumerated constants FreezingPoint and BoilingPoint are both cast to type int; then that integer value is passed to WriteLine( ) and displayed. Each constant in an enumeration corresponds to a numerical value. In Example 3-5, each enumerated value is an integer. If you don t specifically set it otherwise, the enumeration begins at 0 and each subsequent value counts up from the previous. Thus, if you create the following enumeration:

enum SomeValues {

First, Second, Third = 20, Fourth }

It is nearly impossible to write a C# program without creating strings, and we wouldn t want to deprive you of them here. Strings are actually complex classes that we ll cover much more thoroughly in 15. For now, though, all you need to know is that a string object holds a series of characters. You declare a string variable using the string keyword much as you would create an instance of any type:

string myString;

You specify a string literal by enclosing it in double quotes:

"Hello World"

You already used a string literal back in 1, in the Hello World example. You ll frequently initialize a string variable by assigning it a string literal:

string myString = "Hello World";