The first statement in the Program.cs file, shown next, is a compiler directive. A compiler directive is an instruction that tells the compiler to do something; in this case, the directive tells the compiler to use the System namespace.

using System;

A namespace, covered in the next section, is a library of class descriptions. In XNA applications, namespaces provide games with access to classes belonging to the .NET Framework. The System namespace contains a collection of base classes required by Windows applications, supporting such things as the definition of commonly used values and data types, program execution, and execution handling.

When you reference a class name within a program in an XNA application, the compiler looks for it in all of the namespaces that are defined within the application until it finds it. Of course, if the class is not found, an error occurs. One advantage of namespaces is that they prevent naming conflicts by allowing similarly named resources in different namespaces to happily coexist.

XNA automatically creates a new namespace for each application you create. This namespace is defined by a code block in the next set of statements in the Program.cs file, as shown here:

namespace WindowsGame1
{

}

Note that by default, XNA assigns the same name to this namespace that you assign to your application. If, however, you do not assign a name to your application, XNA will assign a name of WindowsGameX to it (X represents a numeric value that is automatically incremented each time you create a new unnamed application). All of the classes that you define within your XNA applications will be placed within this namespace (e.g., inside the Game1.cs file).

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;

    using Microsoft.Xna.Framework.GamerServices;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Media;
    using Microsoft.Xna.Framework.Net;
    using Microsoft.Xna.Framework.Storage;

The next line in Program.cs defines a class named Program, as shown below. Note the use of the static keyword. When used, this keyword permits a single instance of the class to run. Static classes are always started first, after which the code you added to the Game1.cs program is run.

static class Program
{

}

The rest of the statements that make up the Program.cs program are all located within the Program class.

The Program class’s primary purpose is to create an instance of your XNA game and then to run it. It accomplishes this by calling upon the program’s Main method, which is accomplished through the execution of the Main() method shown here.

static void Main(string[] args)
{

}

The Main() method is of central importance to your XNA applications. Its job is to start game execution.

Within the Program class’s Main() method is an embedded code block created using the using statement. When used in this context, the using statement instructs the program to dispose of an object as soon as it finishes execution. This allows any data belonging to the object to be deleted from memory, freeing up resources for other tasks.

using (Game1 game = new Game1())
{

}

The object being referenced here is named game, which as you can see, is created using the new keyboard. This object is based on the Game1 class, which is defined within the Game1.cs file (unless, of course, you have changed its name).

The Main() method consists of a single statement to start the execution of your XNA game. This statement, shown next, executes the Game1 class’s Run() method. The Run() method, as its name implies, initiates the execution of the game loop.

game.Run();

The Run() method begins by executing the Initialize() method followed by the LoadContent() method. It then repeatedly executes the Update() and Draw() methods.

Abstraction is the process of defining a logical representation of a class within program code. This includes defining all the data members, properties, and methods required for the proper operation of the class and the objects derived from it. For example, if you were going to define a class representing a person, you might include height, weight, and age properties as well as methods like talk(), walk(), and sit().

Encapsulation is the process used to outline the base functionality of a class. It provides the ability to interact with objects created based on that class through the properties and methods defined within it. Encapsulation helps simplify things by eliminating the need to understand the inner workings of objects. Consider for example the spriteBatch class, which you have seen used to control the drawing of text to the screen. You do not know what the program code for this class looks like or how it is written and you do not need to. You can’t directly access any of the internal code outlined in the spriteBatch class. All you need to know is what properties and methods are available. How the spriteBatch class is designed is masked from view. As such, encapsulation simplifies program development.

Encapsulation also provides data protection. As such, you can add program code to your classes that processes and verifies any data passed to objects in order to ensure that the data meets certain criteria. If it does not, the data can be rejected.

Inheritance is the process in which one class is derived from another (parent) class. Inheritance allows you to create a class hierarchy. For example, inheritance allows you to define a base class. An example of this would be a class that describes a generic automobile. This would include all of the properties required to describe the characteristics (e.g., 2-door, 4-door, color, etc.) of the automobile as well as all of its basic functionality (move, break, turn, etc.). With inheritance, you could then use this base class as the foundation for creating a new child class, which would inherit all of the properties and methods of its parent class. Further, you can extend the features of the child class by adding additional properties and methods to it.

Polymorphism is a term that describes the ability to define different forms of the same thing. In C#, polymorphism is accomplished using a programming technique known as overloading. With overloading, you define the same method two or more times. Each instance of the method must be assigned a different argument list. For example, overloading allows you to create different versions of the same method, all with the same name but with different combinations of arguments. One instance of the method might be designed to process a single integer argument, whereas another instance of the method might be set up to process two arguments, one integer, and one string.

As you have already seen, anytime you create a new XNA game, a new class is created for you named Game1 and you can modify the methods and properties that make up this class. In addition, you can add a new class to an application by inserting its declaration under the existing class definition in the code editor, as shown here:

namespace WindowsGame1
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {

        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        protected override void Initialize()
        {
            base.Initialize();
        }

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
        }

        protected override void UnloadContent()
        {
        }

        protected override void Update(GameTime gameTime)
        {

            if (GamePad.GetState(PlayerIndex.One).Buttons.Back = =
              ButtonState.Pressed)
                this.Exit();

            base.Update(gameTime);
       }

       protected override void Draw(GameTime gameTime)
       {

           GraphicsDevice.Clear(Color.CornflowerBlue);
           base.Draw(gameTime);
       }
    }

    public class NameMgr
    {
    }
}

In this example, a new class named NameMgr has been defined. At the moment, the class does not have any data members, properties, or methods defined to it. A data member is a variable that is defined within a class. Each object that you instantiate based on the class inherits the class’s variable definitions and can store its own data in its data members. This data is separate and distinct from the data that may be stored in other objects created from that same class.

Ordinarily, data members are hidden from the outside world and used only within the class. However, data members can be made directly accessible from outside the class by preceding their declaration with the Public keyword.

In the previous example, a new class named NameMgr was defined. However, the class is empty in that it does not specify anything yet. Let’s change this by modifying the class as shown here.

public class NameMgr
{
     private string UserName;
}

Here, a data member has been defined within the class. Class data members are private. By default, a private data member is accessible only to methods within the class where it is defined. Since class members are private by default, you can eliminate the private keyword as shown here, but the result is still the same.

string UserName;

A private data member cannot be accessed from outside the class. If you want, you can make data members publicly available by preceding them with the public keyword, as shown here.

public string Name;

You can also make a data member protected using the protected keyword, as shown here.

protected string Name;

A protected data member is accessible to methods within a class and to methods in child classes but not to objects based on other classes.

Data members can be accessed from outside the class in which they are defined. A data member is not, however, a property of a class. Publicly accessible data members mean that you lose the ability to control access to the data stored in them. Instead of creating public data members, it is better to make them private. You can then control access to the data stored within a class’s data members through properties.

Rather than allow unrestricted access to public data members, you can use properties to control access to data stored within data members. To set up a property in a class, you must declare a data member private and then define a public property that can be used to control access to the value stored in the data member. C# supports the following types of property procedures.

The following example demonstrates how to add a property to a class.

public class NameMgr
{
    private string UserName;

    public string Name
    {
        get
        {
             return UserName;
        }
        set
        {

             UserName = value;
         }
    }
}

As you can see, access to the value stored in the UserName data member is made private. As a result, only methods defined within its class can access it. Two procedures are then set up to control access to the value stored in the data member. The first procedure allows the retrieval of the value stored in the data member and the second procedure allows that value to be modified.

In order to use the NameMgr class, you must instantiate an object based on it. This is done using the new keyword, as demonstrated here:

NameMgr x = new NameMgr();

Once instantiated, you can store and retrieve a value using the UserName data member through the class’s Name property. For example, the following statement demonstrates how to store a string value via the Name property.

x.Name = "Bob";

As you can see, the reference to the Name property is made by specifying the name of the object, followed by a period and the property name. When you assign a value to the Name property, the set property procedure executes. The set property procedure is passed an argument made up of the data that was assigned to the Name property. Within the set property procedure, the value of the argument is assigned to the data member (e.g., UserName). Similarly, if you later retrieve the Name property, the value of the data stored in the UserName data member is returned.

A primary advantage of using properties as means of indirectly accessing data members is that you can include programming logic that performs data validation before allowing a data member’s value to be modified.

public class NameMgr
{
    private string UserName;

    public string Name
    {
        get
        {
            return UserName;
        }
        set
        {
           if (value.Length > 0)
           {
                 UserName = value;
           }
        }
    }
}

This new example prevents an empty string from being assigned as the data member’s value.

In addition to data members and properties, you can also add methods to your custom classes. To add a method, all you have to do is add a method definition, as demonstrated here:

public class NameMgr
{
    private string UserName;

    public string Name
    {
        get

        {
           return UserName;
        }
        set
        {
           if (value.Length > 0)
           {
               UserName = value;
           }
        }
    }
    public string GenerateAddress()
    {
       return (UserName + "@yahoo.com");
    }
}

In this example, a method named GenerateAddress() has been modified. This method appends the string “@yahoo.com” to the value stored in the UserName data member and returns it when called. Within your program code, you execute this method just as you do with any other method by specifying the name of its object followed by a period and the method’s name.

As already discussed, Visual C# supports polymorphism through a process referred to as overloading, whereby a method is defined two or more times with different sets of arguments. When you overload a method, as demonstrated below, Visual C# makes sure that the correct method is executed based on the argument list that is specified.

public class NameMgr
{
    private string UserName;

    public string Name
    {
        get
        {
            return UserName;
        }
        set

        {
            if (value.Length > 0)
            {
                UserName = value;
            }
        }
    }
    public string GenerateAddress()
    {
        return (UserName + "@yahoo.com");
    }
    public string GenerateAddress(string input)
    {
        return (input + "@yahoo.com");
    }
}

Here two different versions of the GenerateAddress() method have been defined. The first instance appends the string “@yahoo.com” to the value stored in the UserName data member and returns the result. This version of the Generate-Address() method is executed whenever the GenerateAddress() method is called without any arguments. The second version of the GenerateAddress() method is executed when the method is passed a single string argument. When executed it appends the string “@yahoo.com” to the argument string and returns the result.

The derived class inherits its features from the base class. In addition to inheriting from classes provided to you by Visual C# and the .NET Framework, you can derive new classes from classes that you create. The following example demonstrates how to create a new class named NameMgrTwo using the NameMgr class as the base class.

public class NameMgr
{
    private string UserName;
    public string Name

    {

        get
        {
            return UserName;
        }
        set
        {
            if (value.Length > 0)
            {
                UserName = value;
            }
        }
    }
    public string GenerateAddress()
    {
        return (UserName + "@yahoo.com");
    }
}
public class NameMgrTwo : NameMgr
{
    public string GenerateAddress(string input)
    {
        return (input + "@yahoo.com");
    }
}

The NameMgrTwo class inherits all of the data member’s properties and methods belonging to the NameMgr class and then extends its functionality by adding an additional method (overloading the GenerateAddress() method).