Find Your Programming Materials

Introduction to Classes

noreply@blogger.com (Unknown) — Fri, 24 Feb 2012 07:43:00 +0000

Classes Fundamentals 99materials

Introduction:

To use a variable, we can declare it using either var keyword or a known and simple data type. For example, we can use an integer to declare a variable that represented the number of bedrooms of a house. Here is an example:

class Program
{
    static void Main()
    {
        int bedrooms = 3;
    }
}


As opposed to a simple variable, in C#, you can use one or more variables to create a more complete or complex object.

A class is a technique of using one or a group of variables to be used as a foundation for a more detailed variable. When creating a class, you start with the class keyword followed by a name and its body delimited by curly brackets.

Application: Introducing Classes  99materials



Start Microsoft Visual Studio
To create a new application, on the main menu, click File -> New Project
In the middle list, click Empty Project
Change the Name to DepartmentStore1
Click OK   

Naming a Class 99materials

Like a variable, a class must have a name. The name primarily follows the same rules as the variables. You can then add your own rules. In our lessons:

If the name of a class is in one word, the first letter will be in uppercase. Examples are Identification, Vehicle, or Student
If the name of a class is a combination of words, the first letter of each word will be in uppercase. Examples are DrivingRecord, GeometricShape, or SocialSecurityInformation.

Managing Classes 99materials

Introduction

Microsoft Visual Studio provides many tools and visual objects used to manage classes of an application. 

The studio makes it possible to conveniently rename a class (or one of its members) or to easily navigate to a 

class.

The Class View

Probably the best window to manage classes is called the Class View. To get the Class View:

If the Class View is not yet displaying, on the main menu, you can click View -> Class View
If the Class View is showing already, click its tab

The Class View is made of six sections. The title bar and the use of the Class View follow the same

description as for the Solution Explorer:

99materials classview

The second part of the title bar is its toolbar .

The Class View New Folder button allows you to create and add a new folder to the project. The Back and

the Forward buttons allow you to navigate among the classes.

Under the toolbar, there is another bar made of a combo box and a button. These allow you to search.

The body of the Class View is made of two sections. The first node of the upper section displays the

name of the project. Under the project node, the names of classes display. The bottom section of the

Class View is used to display the members of a class. To see the members of a class, you can click it

in the top window. Here is an example:

99materials-class members

Creating a Class 99materials

There are various ways you can create a class. If you are working from a text editor, start a file, type class,

followed by a name, and followed by curly brackets. Here is an example of a class named House:

class House
{
}

From your text editor, save the file with the extension .cs. The name of the file doesn't have to be the same

as the class. You should save the file in the same folder that contains the other files of the same project.

A class is created in a code file. As such, you can include it in the first file of your project. Here is an example:

class House
{
}

class Exercise
{
    static void Main()
    {
        int bedrooms = 3;
    }
}


If you are creating your project using Microsoft Visual C# 2010 Express or Microsoft Visual Studio, it can 

assist you with creating a class. In Lesson 1, we saw how to create a code file. After creating one, you 

can just type the code for the class. When you use the Add New Item option from the main menu or 

from the Solution Explorer, you can select any type of file you want to create, including a class. Otherwise,

 you can explicitly indicate that you want to create a class. This would automatically select the Class option 

in the Add New Item dialog box.

To create a new class:

On the main menu, click Project -> Add Class... (or Project -> Add New Item... In the middle list of the

           Add New Item dialog box, click Class)

In the Solution Explorer, right-click the name of the project, position the mouse on Add, and click Class
In the Class View, right-click the name of the Project, position the mouse on Add, and click Class


Any of these actions would display the Add New Item dialog box with the Class option selected. If you had 

selected the Add New Item from the main menu or the Solution Explorer, you can click Class. In the Name 

text box, accept or change the default name and click Add. A new file named after the class with the 

.cs extension would be added to your project.

You can also use skeleton code to start a class: 

In the section of the Code Editor where you want to add the class, right-click and click Insert Snippet...

           Double-click Visual C#. In the list that appears, double-click class  



 



                     99materials




If you had already written code, such as declaring some variables, and you want to include that code in



a new class, select that code. Right-click it and click Surround With...

    















99materials



 




99materials

Lesson no:5

noreply@blogger.com (Unknown) — Thu, 23 Feb 2012 09:01:00 +0000

Application: Introducing Operators and Operands

Start Microsoft Visual Studio
To create a new application, on the main menu, click File -> New Project...
In the middle list, click Empty Project
Change the Name to gdcs4 and click OK
To create a file for the code, on the main menu, click Project -> Add New Item...
In the middle list, click Code File
Change the Name to CleaningOrder
Click Add

Curly Brackets { }

Curly brackets are probably the most used and the most tolerant operators of C#. Fundamentally, curly brackets are used to create a section of code. As such they are required to delimit the bodies of namespaces, classes, structures, exceptions, etc. They are also optionally used in conditional statements. Curly brackets are also used to create variable scope.

Application: Using Curly Brackets

In the empty document, type the following:
```
class Order
{
}
```

Parentheses ( )

Parentheses are used to isolate a group of items that must be considered as belonging to one entity. For example, parentheses are used to differentiate a method such as Main from a regular variable. Here is an example:

class Exercise
{
    static void Main()
    {
    }
}

Parentheses can also be used to isolate an operation or an expression with regard to another operation or expression.

Application: Using Parentheses

To use parentheses, change the document as follows:

class Order
{
    static void Main()
    {
    }
}

Semi-Colon;

The semi-colon is used to indicate the end of an expression or a declaration. Here is an example:

int number;

As we will learn, there are other uses of the semi-colon.

Application: Introducing the Semi-Colon

In the empty document, type the following:

class Order
{
    static void Main()
    {
        double mondayDiscount;
    }
}

The Comma ,

The comma is used to separate variables used in a group. For example, a comma can be used to delimit the names of variables that are declared with the same data type. Here is an example:

class Exercise
{
    static void Main()
    {
 string firstName, lastName, fullName;
    }
}

The comma can also be used to separate the member of an enumeration or the arguments of a method. We will review all of them when the time comes.

Application: Using Commas

To use commas, change the file as follows:

class Order
{
    static void Main()
    {
        string customerName, homePhone;
        uint numberOfShirts, numberOfPants, numberOfDresses;
        decimal priceOneShirt, priceAPairOfPants, priceOneDress;
        uint orderMonth, orderDay, orderYear;
        double mondayDiscount;
    }
}

The Assignment =

When you declare a variable, a memory space is reserved for it. That memory space may be empty until you fill it with a value. To "put" a value in the memory space allocated to a variable, you can use the assignment operator represented as =. Based on this, the assignment operation gives a value to a variable. Its syntax is:

VariableName = Value

The VariableName factor must be a valid variable name. It cannot be a value such as a numeric value or a (double-quoted) string. Here is an example that assigns a numeric value to a variable:

class Exercise
{
    static void Main()
    {
 decimal salary;

 // Using the assignment operator
 salary = 12.55M;
    }
}

Once a variable has been declared and assigned a value, you can call Write() or WriteLine() to display its value. Here is an example:

class Exercise
{
    static void Main()
    {
 decimal salary;

 // Using the assignment operator
 salary = 12.55M;
 System.Console.Write("Employee's Hourly Salary: ");
 System.Console.WriteLine(salary);
    }
}

This would produce:

Employee's Hourly Salary: $12.55

The above code declares a variable before assigning it a value. You will usually perform this assignment when you want to change the value held by a variable. Providing a starting value to a variable when the variable is declared is referred to as initializing the variable. Here is an example:

class Exercise
{
    static void Main()
    {
 // Using the assignment operator
 decimal salary = 12.55M;

 System.Console.Write("Employee's Hourly Salary: ");
 System.Console.WriteLine(salary);
    }
}

We saw that you can declare various variables at once by using the same data type but separating their names with commas. When doing this, you can also initialize each variable by assigning it the desired value before the comma or the semi-colon. Here is an example:

class Exercise
{
    static void Main()
    {
 // Initializing various variables when declaring them with the same data type
 double value1 = 224.58, value2 = 1548.26;
   
 System.Console.Write("Value 1 = ");
 System.Console.WriteLine(value1);
 System.Console.Write("Value 2 = ");
 System.Console.WriteLine(value2);
 System.Console.WriteLine();
    }
}

This would produce:

Value 1 = 224.58
Value 2 = 1548.26

Application: Assigning Values to Variables

To use the assignment operator, change the file as follows:

class Order
{
    static void Main()
    {
        string  customerName, homePhone;
        uint    numberOfShirts = 5,
                numberOfPants = 2,
                numberOfDresses = 0;
        decimal priceOneShirt = 0.95M,
                priceAPairOfPants = 2.95M,
                priceOneDress = 4.55M;
        uint    orderMonth = 3, orderDay = 15, orderYear = 2002;
        double  mondayDiscount = 0.25; // 25%;
    }
}

Single-Quote '

The single quote is used to include one character to initialize, or assign a symbol to, a variable declared as char. A single-quote is usually combined with another and a character is included between them. Here is an example:

class Exercise
{
    static void Main()
    {
 char gender;
 string firstName, lastName, fullName;

 gender = 'M';
    }
}

You can include only one character between single-quotes except if the combination of symbols can be evaluated to one character. This is the case for escape sequences. Here is an example:

class Exercise
{
    static void Main()
    {
 System.Console.WriteLine('\n');
    }
}

Double-Quotes "

The double-quote " is used to delimit a string. Like the single-quote, the double-quote is usually combined with another. Between the combination of double-quotes, you can include an empty space, a character, a word, or a group of words, making it a string. Here is an example:

class Exercise
{
    static void Main()
    {
 System.Console.WriteLine("The Wonderful World of C#!!!");
    }
}

A double-quoted string can also be declared and then assigned to a variable.

Application: Using Quotes

To use single and double-quotes, change the file as follows:

class Order
{
    static void Main()
    {
        string  customerName = "James Burreck",
                homePhone = "(202) 301-7030";
        uint    numberOfShirts = 1,
                numberOfPants = 1,
                numberOfDresses = 1;
        decimal priceOneShirt = 0.95M,
                priceAPairOfPants = 2.95M,
                priceOneDress = 4.55M;
        uint    orderMonth = 3, orderDay = 15, orderYear = 2002;
        double  mondayDiscount = 0.25; // 25%;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("========================");
        System.Console.Write("Customer:   ");
        System.Console.WriteLine(customerName);
        System.Console.Write("Home Phone: ");
        System.Console.WriteLine(homePhone);
        System.Console.Write("Order Date: ");
        System.Console.Write(orderMonth);
        System.Console.Write('/');
        System.Console.Write(orderDay);
        System.Console.Write('/');
        System.Console.WriteLine(orderYear);
        System.Console.WriteLine("------------------------");
        System.Console.WriteLine("Item Type  Qty Sub-Total");
        System.Console.WriteLine("------------------------");
        System.Console.Write("Shirts      ");
        System.Console.Write(numberOfShirts);
        System.Console.Write("     ");
        System.Console.WriteLine(priceOneShirt);
        System.Console.Write("Pants       ");
        System.Console.Write(numberOfPants);
        System.Console.Write("     ");
        System.Console.WriteLine(priceAPairOfPants);
        System.Console.Write("Dresses     ");
        System.Console.Write(numberOfDresses);
        System.Console.Write("     ");
        System.Console.WriteLine(priceOneDress);
        System.Console.WriteLine("------------------------");
        System.Console.Write("Monday Discount: ");
        System.Console.Write(mondayDiscount);
        System.Console.WriteLine('%');
        System.Console.WriteLine("========================");
        
        System.Console.ReadKey();
    }
}

Execute the application to se the result. This would produce:

-/- Georgetown Cleaning Services -/-
========================
Customer:   James Burreck
Home Phone: (202) 301-7030
Order Date: 3/15/2002
------------------------
Item Type  Qty Sub-Total
------------------------
Shirts      1     0.95
Pants       1     2.95
Dresses     1     4.55
------------------------
Monday Discount: 0.25%
========================

Press Enter and return to your programming environment

Square Brackets [ ]

Square brackets are mostly used to control the dimension or index of an array. We will learn how to use them when we study arrays.

The Positive Operator +

Algebra uses a type of ruler to classify numbers. This ruler has a middle position of zero. The numbers on the left side of the 0 are referred to as negative while the numbers on the right side of the rulers are considered positive:

-∞	-6	-5	-4	-3	-2	-1	1	2	3	4	5	6	+∞
0
-∞	-6	-5	-4	-3	-2	-1	1	2	3	4	5	6	+∞

A value on the right side of 0 is considered positive. To express that a number is positive, you can write a + sign on its left. Examples are +4, +228, +90335. In this case the + symbol is called a unary operator because it acts on only one operand. The positive unary operator, when used, must be positioned on the left side of its operand, never on the right side.

As a mathematical convention, when a value is positive, you don't need to express it with the + operator. Just writing the number without any symbol signifies that the number is positive. Therefore, the numbers +4, +228, and +90335 can be, and are better, expressed as 4, 228, 90335. Because the value doesn't display a sign, it is referred as unsigned.

To express a variable as positive or unsigned, you can just type it. here is an example:

class Exercise
{
    static void Main()
    {
 // Displaying an unsigned number
 System.Console.Write("Number = ");
 System.Console.WriteLine(+802);
    }
}

This would produce:

Number = 802

The Negative Operator -

As you can see on the above ruler, in order to express any number on the left side of 0, it must be appended with a sign, namely the - symbol. Examples are -12, -448, -32706. A value accompanied by - is referred to as negative. The - sign must be typed on the left side of the number it is used to negate. Remember that if a number does not have a sign, it is considered positive. Therefore, whenever a number is negative, it MUST have a - sign. In the same way, if you want to change a value from positive to negative, you can just add a - sign to its left.

Here is an example that uses two variables. One has a positive value while the other has a negative value:

class Exercise
{
 static void Main()
 {
  // Displaying an unsigned number
  System.Console.Write("First Number  ");
  System.Console.WriteLine(+802);
  // Displaying a negative number
  System.Console.Write("Second Number ");
  System.Console.WriteLine(-802);
 }
}

This would produce:

First Number  802
Second Number -802

Unary Operators: The sizeof Operator

We have already seen that when declaring a variable, the compiler reserves a portion of space in the computer memory to hold that variable. We also illustrated how much space some data types need to store their variable. C# provides the unary sizeof operator that allows you to find out how much space a data type.

To find out how much memory space a data type uses, type it between the parentheses of the sizeof operator. Here is an example:

class Exercise
{
    static void Main()
    {
 double period = 155.50;
 int size = sizeof(double);

 System.Console.Write("The value ");
 System.Console.Write(period);
 System.Console.Write(" uses ");
 System.Console.Write(size);
 System.Console.WriteLine(" bytes\n");
    }
}

This would produce:

The value 155.5 uses 8 bytes

Here are a few more example:

class Exercise
{
    static void Main()
    {
        // The sizeof operator used to get the memory size used by 
        // a variable declared with a certain a data type
        System.Console.WriteLine("The sizeof Operator");
        System.Console.WriteLine("==========================");
        System.Console.WriteLine("Data Type     Memory Size");
        System.Console.WriteLine("--------------------------");
        System.Console.Write("char           ");
        System.Console.Write(sizeof(char));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("bool           ");
        System.Console.Write(sizeof(bool));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("int            ");
        System.Console.Write(sizeof(int));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("uint           ");
        System.Console.Write(sizeof(uint));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("short          ");
        System.Console.Write(sizeof(short));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("ushort         ");
        System.Console.Write(sizeof(ushort));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("byte           ");
        System.Console.Write(sizeof(byte));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("sbyte          ");
        System.Console.Write(sizeof(sbyte));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("float          ");
        System.Console.Write(sizeof(float));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("double         ");
        System.Console.Write(sizeof(double));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("decimal        ");
        System.Console.Write(sizeof(decimal));
        System.Console.WriteLine(" Bytes");
        System.Console.Write("long           ");
        System.Console.Write(sizeof(long));
        System.Console.WriteLine("  Bytes");
        System.Console.Write("ulong          ");
        System.Console.Write(sizeof(ulong));
        System.Console.WriteLine("  Bytes");
        System.Console.WriteLine("===========================");
        System.Console.WriteLine();
    }
}

This would produce:

The sizeof Operator
==========================
Data Type     Memory Size
--------------------------
char            2 Bytes
bool            1 Bytes
int             4 Bytes
uint            4 Bytes
short           2 Bytes
ushort          2 Bytes
byte            1 Bytes
sbyte           1 Bytes
float           4 Bytes
double          8 Bytes
decimal        16 Bytes
long            8 Bytes
ulong           8 Bytes
===========================

The Addition Operations

Introduction

The addition is an operation used to add things of the same nature one to another, as many as necessary. Sometimes, the items are added one group to another. The concept is still the same, except that this last example is faster. The addition is performed in mathematics using the + sign. The same sign is used in C#.

To get the addition of two values, you add the first one to the other. After the addition of two values has been performed, you get a new value. This means that if you add value1 to value2, you would write value1 + value2. The result is another value we could call Value3. You can also add more than two values, like a + b + c.

With numbers, the order you use to add two or more values doesn't matter. This means that value1 + value2 is the same as value2 + value1. In the same way a + b + c is the same as a + c + b the same as b + a + c and the same as c + b + a

Here is an example that adds two numbers:

class Exercise
{
    static void Main()
    {
 System.Console.Write("244 + 835 = ");
 System.Console.WriteLine(244 + 835);
    }
}

Here is the result:

244 + 835 = 1079

You can also add some values already declared and initialized in your program. You can also get the values from the user.

In C#, you can also add string variables to add a new string. The operation is performed as if you were using numbers. For example, "Pie" + "Chart" would produce "PieChart". You can also add add as many strings as possible by including the + operator between them. Here is an example:

class Exercise
{
    static void Main()
    {
        var firstName = "Alexander";
        var lastName = "Kallack";
        var fullName = firstName + " " + lastName;

        System.Console.Write("Full Name: ");
        System.Console.WriteLine(fullName);
    }
}

This would produce:

Full Name: Alexander Kallack
Press any key to continue . . .

Application: Using the Addition Operator

To use the addition, change the file as follows:

class Order
{
    static void Main()
    {
        string customerName = "James Burreck",
                   homePhone = "(202) 301-7030";
        uint numberOfShirts = 1,
             numberOfPants = 1,
             numberOfDresses = 1;
        uint totalNumberOfItems;
        decimal priceOneShirt = 0.95M,
                priceAPairOfPants = 2.95M,
                priceOneDress = 4.55M;
        uint orderMonth = 3, orderDay = 15, orderYear = 2002;

        totalNumberOfItems = numberOfShirts + numberOfPants + numberOfDresses;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("========================");
        System.Console.Write("Customer:   ");
        System.Console.WriteLine(customerName);
        System.Console.Write("Home Phone: ");
        System.Console.WriteLine(homePhone);
        System.Console.Write("Order Date: ");
        System.Console.Write(orderMonth);
        System.Console.Write('/');
        System.Console.Write(orderDay);
        System.Console.Write('/');
        System.Console.WriteLine(orderYear);
        System.Console.WriteLine("------------------------");
        System.Console.WriteLine("Item Type  Qty Sub-Total");
        System.Console.WriteLine("------------------------");
        System.Console.Write("Shirts      ");
        System.Console.Write(numberOfShirts);
        System.Console.Write("     ");
        System.Console.WriteLine(priceOneShirt);
        System.Console.Write("Pants       ");
        System.Console.Write(numberOfPants);
        System.Console.Write("     ");
        System.Console.WriteLine(priceAPairOfPants);
        System.Console.Write("Dresses     ");
        System.Console.Write(numberOfDresses);
        System.Console.Write("     ");
        System.Console.WriteLine(priceOneDress);
        System.Console.WriteLine("------------------------");
        System.Console.Write("Number of Items: ");
        System.Console.WriteLine(totalNumberOfItems);
        System.Console.WriteLine("========================");
        
        System.Console.ReadKey();
    }
}

Execute the program. This would produce:

-/- Georgetown Cleaning Services -/-
========================
Customer:   James Burreck
Home Phone: (202) 301-7030
Order Date: 3/15/2002
------------------------
Item Type  Qty Sub-Total
------------------------
Shirts      1     0.95
Pants       1     2.95
Dresses     1     4.55
------------------------
Number of Items: 3
========================

Close the DOS window and return to your programming environment

Incrementing a Variable

We are used to counting numbers such as 1, 2, 3, 4, etc. In reality, when counting such numbers, we are simply adding 1 to a number in order to get the next number in the range. The simplest technique of incrementing a value consists of adding 1 to it. After adding 1, the value or the variable is (permanently) modified and the variable would hold the new value. This is illustrated in the following example:

// This program studies value incrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of incrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 value = value + 1;

 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This would produce:

Techniques of incrementing a value
Value = 12
Value = 13

C# provides a special operator that takes care of this operation. The operator is called the increment operator and is represented by ++. Instead of writing Value = Value + 1, you can write Value++ and you would get the same result. The above program can be re-written as follows:

// This program studies value incrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of incrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 value++;

 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

The ++ is a unary operator because it operates on only one variable. It is used to modify the value of the variable by adding 1 to it. Every time the Value++ is executed, the compiler takes the previous value of the variable, adds 1 to it, and the variable holds the incremented value:

// This program studies value incrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of incrementing a value");

 value++;
 
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 value++;
 
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
  
 Value++;

 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This would produce:

Techniques of incrementing a value
Value = 13
Value = 14
Value = 15

Pre and Post-Increment

When using the ++ operator, the position of the operator with regard to the variable it is modifying can be significant. To increment the value of the variable before re-using it, you should position the operator on the left of the variable:

// This program studies value incrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of incrementing a value");

 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 System.Console.Write("Value = ");
 System.Console.WriteLine(++value);
  
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This would produce:

Techniques of incrementing a value
Value = 12
Value = 13
Value = 13

When writing ++Value, the value of the variable is incremented before being called. On the other hand, if you want to first use a variable, then increment it, in other words, if you want to increment the variable after calling it, position the increment operator on the right side of the variable:

// This program studies value incrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of incrementing a value");

 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 System.Console.Write("Value = ");
 System.Console.WriteLine(value++);
  
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This would produce:

Techniques of incrementing a value
Value = 12
Value = 12
Value = 13

Compound Addition

It is not unusual to add a constant value to a variable. All you have to do is to declare another variable that would hold the new value. Here is an example:

// This program studies value incrementing and decrementing

public class Exercise
{
    static void Main()
    {
 double value = 12.75;
 double newValue;

 System.Console.WriteLine("Techniques of incrementing and decrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 newValue = value + 2.42;
  
 System.Console.Write("Value = ");
 System.Console.WriteLine(newValue);
    }
}

This would produce:

Techniques of incrementing and decrementing a value
Value = 12.75
Value = 15.17

The above technique requires that you use an extra variable in your application. The advantage is that each value can hold its own value although the value of the second variable depends on whatever would happen to the original or source variable. Sometimes in your program you will not need to keep the original value of the source variable. You may want to permanently modify the value that a variable is holding. In this case, you can perform the addition operation directly on the variable by adding the desired value to the variable. This operation modifies whatever value a variable is holding and does not need an additional variable.

To add a value to a variable and change the value that the variable is holding, you can combine the assignment ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã¢â‚¬Â¦ÃƒÂ¢Ã¢â€šÂ¬Ã…â€œ=ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã¢â‚¬Å¡Ãƒâ€šÃ‚Â and the addition ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã¢â‚¬Â¦ÃƒÂ¢Ã¢â€šÂ¬Ã…â€œ+ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã¢â‚¬Å¡Ãƒâ€šÃ‚Â operators to produce a new operator as +=. Here is an example:

// This program studies value incrementing and decrementing

public class Exercise
{
    static void Main()
    {
 var value = 12.75;

 System.Console.WriteLine("Techniques of incrementing and decrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 value += 2.42;
  
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This program produces the same result as the previous.

The Multiplication Operations

Introduction

The multiplication allows adding one value to itself a certain number of times, set by a second value. As an example, instead of adding a value to itself in this manner: A + A + A + A, since the variable a is repeated over and over again, you could simply find out how many times A is added to itself, then multiply a by that number which, is this case, is 4. This would mean adding a to itself 4 times, and you would get the same result.

Just like the addition, the multiplication is associative: a * b * c = c * b * a. When it comes to programming syntax, the rules we learned with the addition operation also apply to the multiplication.

Here is an example:

class Exercise
{
    static void Main()
    {
        // Initializing various variables when declaring them with the same data type
        double value1 = 224.58, value2 = 1548.26;
        var result = value1 * value2;

        System.Console.Write(value1);
        System.Console.Write(" * ");
        System.Console.Write(value2);
        System.Console.Write(" = ");
        System.Console.WriteLine(result);
        System.Console.WriteLine();
    }
}

This would produce:

224.58 * 1548.26 = 347708.2308

Press any key to continue . . .

Application: Using the Multiplication Operator

To multiply, change the file as follows:

class Order
{
    static void Main()
    {
        const decimal priceOneShirt = 0.95M;
        const decimal priceAPairOfPants = 2.95M;
        const decimal priceOneDress = 4.55M;
        string customerName = "James Burreck",
               homePhone = "(202) 301-7030";
        uint numberOfShirts = 5,
             numberOfPants = 2,
             numberOfDresses = 3;
        uint totalNumberOfItems;
        decimal subTotalShirts, subTotalPants, subTotalDresses;
        decimal totalOrder;
        uint orderMonth = 3, orderDay = 15, orderYear = 2002;

        totalNumberOfItems = numberOfShirts + numberOfPants + numberOfDresses;
        subTotalShirts = priceOneShirt * numberOfShirts;
        subTotalPants = priceAPairOfPants * numberOfPants;
        subTotalDresses = numberOfDresses * priceOneDress;
        totalOrder = subTotalShirts + subTotalPants + subTotalDresses;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("====================================");
        System.Console.Write("Customer:   ");
        System.Console.WriteLine(customerName);
        System.Console.Write("Home Phone: ");
        System.Console.WriteLine(homePhone);
        System.Console.Write("Order Date: ");
        System.Console.Write(orderMonth);
        System.Console.Write('/');
        System.Console.Write(orderDay);
        System.Console.Write('/');
        System.Console.WriteLine(orderYear);
        System.Console.WriteLine("------------------------------------");
        System.Console.WriteLine("Item Type  Qty Unit/Price Sub-Total");
        System.Console.WriteLine("------------------------------------");
        System.Console.Write("Shirts      ");
        System.Console.Write(numberOfShirts);
        System.Console.Write("     ");
        System.Console.Write(priceOneShirt);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalShirts);
        System.Console.Write("Pants       ");
        System.Console.Write(numberOfPants);
        System.Console.Write("     ");
        System.Console.Write(priceAPairOfPants);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalPants);
        System.Console.Write("Dresses     ");
        System.Console.Write(numberOfDresses);
        System.Console.Write("     ");
        System.Console.Write(priceOneDress);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalDresses);
        System.Console.WriteLine("------------------------------------");
        System.Console.Write("Number of Items: ");
        System.Console.WriteLine(totalNumberOfItems);
        System.Console.Write("Total Order:     ");
        System.Console.WriteLine(totalOrder);
        System.Console.WriteLine("====================================");
        
        System.Console.ReadKey();
    }
}

Execute the application to see the result. This would produce:

-/- Georgetown Cleaning Services -/-
====================================
Customer:   James Burreck
Home Phone: (202) 301-7030
Order Date: 3/15/2002
------------------------------------
Item Type  Qty Unit/Price Sub-Total
------------------------------------
Shirts      5     0.95     4.75
Pants       2     2.95     5.90
Dresses     3     4.55     13.65
------------------------------------
Number of Items: 10
Total Order:     24.30
====================================

Close the DOS window and return to your programming environment

Compound Multiplication

We saw that you could add or subtract a value to a variable and assign the result to the same variable. You can perform the same operation with the multiplication. Here is an example:

class Exercise
{
    static void Main()
    {
        double value = 12.75;

        System.Console.Write("Value = ");
        System.Console.WriteLine(value);

        value = Value * 2.42;

        System.Console.Write("Value = ");
        System.Console.WriteLine(value);
    }
}

This would produce:

Value = 12.75
Value = 30.855
Press any key to continue . . .

To make this operation easy, the C# language supports the compound multiplication assignment operator represented as *=. To use it, use the *= operator and assign the desired value to the variable. Here is an example:

class Exercise
{
    static void Main()
    {
        double value = 12.75;

        System.Console.Write("Value = ");
        System.Console.WriteLine(value);

        value *= 2.42;

        System.Console.Write("Value = ");
        System.Console.WriteLine(value);
    }
}

The Subtraction Operations

Introduction

The subtraction operation is used to take out or subtract a value from another value. It is essentially the opposite of the addition. The subtraction is performed with the - sign. Here is an example:

class Exercise
{
    static void Main()
    {
 // Values used in this program
 double value1 = 224.58, value2 = 1548.26;
 var result = value1 - value2;

 System.Console.Write(value1);
 System.Console.Write(" - ");
 System.Console.Write(value2);
 System.Console.Write(" = ");
 System.Console.WriteLine(result);
    }
}

This would produce:

224.58 - 1548.26 = -1323.68

Press any key to continue . . .

Unlike the addition, the subtraction is not associative. In other words, a - b - c is not the same as c - b - a. Consider the following program that illustrates this:

class Exercise
{
    static void Main()
    {
 // This tests whether the addition is associative
 System.Console.WriteLine(" =+= Addition =+=");
 System.Console.Write("128 + 42 +   5 = ");
 System.Console.WriteLine(128 + 42 + 5);
 System.Console.Write("  5 + 42 + 128 = ");
 System.Console.WriteLine(5 + 42 + 128);

 System.Console.WriteLine();

 // This tests whether the subtraction is associative
 System.Console.WriteLine(" =-= Subtraction =-=");
 System.Console.Write("128 - 42 -   5 = ");
 System.Console.WriteLine(128 - 42 - 5);
 System.Console.Write("  5 - 42 - 128 = ");
 System.Console.WriteLine(5 - 42 - 128);
   
 System.Console.WriteLine();
    }
}

This would produce:

=+= Addition =+=
128 + 42 +   5 = 175
  5 + 42 + 128 = 175

 =-= Subtraction =-=
128 - 42 -   5 = 81
  5 - 42 - 128 = -165

Notice that both operations of the addition convey the same result. In the subtraction section, the numbers follow the same order but produce different results.

Application: Using the Subtraction Operator

To subtract, change the file as follows:

class Order
{
    static void Main()
    {
        const decimal priceOneShirt = 0.95M;
        const decimal priceAPairOfPants = 2.95M;
        const decimal priceOneDress = 4.55M;
        const decimal salestaxRate = 0.0575M; // 5.75%

        string customerName = "James Burreck",
               homePhone = "(202) 301-7030";
        uint numberOfShirts = 5,
             numberOfPants = 2,
             numberOfDresses = 3;
        uint totalNumberOfItems;
        decimal subTotalShirts, subTotalPants, subTotalDresses;
        decimal taxAmount, totalOrder, netPrice;
        uint orderMonth = 3, orderDay = 15, orderYear = 2002;

        totalNumberOfItems = numberOfShirts + numberOfPants + numberOfDresses;
        subTotalShirts = priceOneShirt * numberOfShirts;
        subTotalPants = priceAPairOfPants * numberOfPants;
        subTotalDresses = numberOfDresses * priceOneDress;
        totalOrder = subTotalShirts + subTotalPants + subTotalDresses;
        taxAmount = totalOrder * salestaxRate;
        netPrice = totalOrder - taxAmount;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("====================================");
        System.Console.Write("Customer:   ");
        System.Console.WriteLine(customerName);
        System.Console.Write("Home Phone: ");
        System.Console.WriteLine(homePhone);
        System.Console.Write("Order Date: ");
        System.Console.Write(orderMonth);
        System.Console.Write('/');
        System.Console.Write(orderDay);
        System.Console.Write('/');
        System.Console.WriteLine(orderYear);
        System.Console.WriteLine("------------------------------------");
        System.Console.WriteLine("Item Type  Qty Unit/Price Sub-Total");
        System.Console.WriteLine("------------------------------------");
        System.Console.Write("Shirts      ");
        System.Console.Write(numberOfShirts);
        System.Console.Write("     ");
        System.Console.Write(priceOneShirt);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalShirts);
        System.Console.Write("Pants       ");
        System.Console.Write(numberOfPants);
        System.Console.Write("     ");
        System.Console.Write(priceAPairOfPants);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalPants);
        System.Console.Write("Dresses     ");
        System.Console.Write(numberOfDresses);
        System.Console.Write("     ");
        System.Console.Write(priceOneDress);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalDresses);
        System.Console.WriteLine("------------------------------------");
        System.Console.Write("Number of Items: ");
        System.Console.WriteLine(totalNumberOfItems);
        System.Console.Write("Total Order:     ");
        System.Console.WriteLine(totalOrder);
        System.Console.Write("Tax Rate:        ");
        System.Console.Write(salestaxRate * 100);
        System.Console.WriteLine('%');
        System.Console.Write("Tax Amount:      ");
        System.Console.WriteLine(taxAmount);
        System.Console.Write("Net Price:       ");
        System.Console.WriteLine(netPrice);
        System.Console.WriteLine("====================================");
        
        System.Console.ReadKey();
    }
}

Execute the program. This would produce:

-/- Georgetown Cleaning Services -/-
====================================
Customer:   James Burreck
Home Phone: (202) 301-7030
Order Date: 3/15/2002
------------------------------------
Item Type  Qty Unit/Price Sub-Total
------------------------------------
Shirts      5     0.95     4.75
Pants       2     2.95     5.90
Dresses     3     4.55     13.65
------------------------------------
Number of Items: 10
Total Order:     24.30
Tax Rate:        5.7500%
Tax Amount:      1.397250
Net Price:       22.902750
====================================

Close the DOS window and return to your programming environment

Decrementing a Variable

When counting numbers backward, such as 8, 7, 6, 5, etc, we are in fact subtracting 1 from a value in order to get the lesser value. This operation is referred to as decrementing a value. This operation works as if a value is decremented by 1, as in Value = Value ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â‚¬Å¡Ã‚Â¬Ãƒâ€¦Ã¢â‚¬Å“ 1:

// This program studies value decrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of decrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 value = value - 1;

 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This would produce:

Techniques of decrementing a value
Value = 12
Value = 11

As done to increment, C# provides a quicker way of subtracting 1 from a value. This is done using the decrement operator, that is --. To use the decrement operator, type ÃƒÆ’Ã†â€™Ãƒâ€šÃ‚Â¢ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â€šÂ¬Ã…Â¡Ãƒâ€šÃ‚Â¬ÃƒÆ’Ã‚Â¢ÃƒÂ¢Ã¢â‚¬Å¡Ã‚Â¬Ãƒâ€¦Ã¢â‚¬Å“- on the left or the right side of the variable when this operation is desired. Using the decrement operator, the above program could be written:

// This program studies value decrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of decrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 value--;

 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

Pre-Decrementing a Value

Once again, the position of the operator can be important. If you want to decrement the variable before calling it, position the decrement operator on the left side of the operand. This is illustrated in the following program:

// This program studies value decrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of decrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 System.Console.Write("Value = ");
 System.Console.WriteLine(--value);
  
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This would produce:

Techniques of decrementing a value
Value = 12
Value = 11
Value = 11

If you plan to decrement a variable only after it has been accessed, position the operator on the right side of the variable. Here is an example:

// This program studies value decrementing

public class Exercise
{
    static void Main()
    {
 var value = 12;

 System.Console.WriteLine("Techniques of decrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 System.Console.Write("Value = ");
 System.Console.WriteLine(Value--);
  
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This would produce:

Techniques of decrementing a value
Value = 12
Value = 12
Value = 11

Compound Subtraction

You may want to subtract a constant value from a variable. To decrement a value from a variable, use the subtraction and apply the same technique. This is done with the -= operator. Here is an example:

// This program studies value incrementing and decrementing

public class Exercise
{
    static void Main()
    {
 var value = 12.75;

 System.Console.WriteLine("Techniques of incrementing and decrementing a value");
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);

 value -= 2.42;
  
 System.Console.Write("Value = ");
 System.Console.WriteLine(value);
    }
}

This would produce:

Techniques of incrementing and decrementing a value
Value = 12.75
Value = 10.33

The Division Operation

Introduction

Dividing an item means cutting it in pieces or fractions of a set value. For example, when you cut an apple in the middle, you are dividing it in 2 pieces. If you cut each one of the resulting pieces, you will get 4 pieces or fractions. This is considered that you have divided the apple in 4 parts. Therefore, the division is used to get the fraction of one number in terms of another. The division is performed with the forward slash /. Here is an example:

class Exercise
{
    static void Main()
    {
 // Initializing various variables when declaring them with the same data type
 double value1 = 224.58, value2 = 1548.26;
 var result = value1 / value2;
   
 System.Console.Write(value1);
 System.Console.Write(" / ");
 System.Console.Write(value2);
 System.Console.Write(" = ");
 System.Console.WriteLine(result);
 System.Console.WriteLine();
    }
}

This would produce:

224.58 / 1548.26 = 0.145053156446592

Press any key to continue . . .

When performing the division, be aware of its many rules. Never divide by zero (0). Make sure that you know the relationship(s) between the numbers involved in the operation.

Application: Using the Division Operator

To use the division, change the file as follows:

class Order
{
    static void Main()
    {
        const decimal priceOneShirt = 0.95M;
        const decimal priceAPairOfPants = 2.95M;
        const decimal priceOneDress = 4.55M;
        const decimal discountRate = 0.20M; // 20%
        const decimal taxRate = 5.75M;  // 5.75%

        string customerName = "James Burreck",
               homePhone = "(202) 301-7030";
        uint numberOfShirts = 5,
             numberOfPants = 2,
             numberOfDresses = 3;
        uint totalNumberOfItems;
        decimal subTotalShirts, subTotalPants, subTotalDresses;
        decimal DiscountAmount, totalOrder, netPrice, taxAmount, salesTotal;
        decimal amountTended, difference;
        uint orderMonth = 3, orderDay = 15, orderYear = 2002;

        totalNumberOfItems = numberOfShirts + numberOfPants + numberOfDresses;
        subTotalShirts = priceOneShirt * numberOfShirts;
        subTotalPants = priceAPairOfPants * numberOfPants;
        subTotalDresses = numberOfDresses * priceOneDress;
        totalOrder = subTotalShirts + subTotalPants + subTotalDresses;
        DiscountAmount = totalOrder * discountRate;
        netPrice = totalOrder - DiscountAmount;
        taxAmount = totalOrder * taxRate / 100;
        salesTotal = netPrice + taxAmount;
        amountTended = 50M;
        Difference = amountTended - salesTotal;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("====================================");
        System.Console.Write("Customer:   ");
        System.Console.WriteLine(customerName);
        System.Console.Write("Home Phone: ");
        System.Console.WriteLine(homePhone);
        System.Console.Write("Order Date: ");
        System.Console.Write(orderMonth);
        System.Console.Write('/');
        System.Console.Write(orderDay);
        System.Console.Write('/');
        System.Console.WriteLine(orderYear);
        System.Console.WriteLine("------------------------------------");
        System.Console.WriteLine("Item Type  Qty Unit/Price Sub-Total");
        System.Console.WriteLine("------------------------------------");
        System.Console.Write("Shirts      ");
        System.Console.Write(numberOfShirts);
        System.Console.Write("     ");
        System.Console.Write(priceOneShirt);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalShirts);
        System.Console.Write("Pants       ");
        System.Console.Write(numberOfPants);
        System.Console.Write("     ");
        System.Console.Write(priceAPairOfPants);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalPants);
        System.Console.Write("Dresses     ");
        System.Console.Write(numberOfDresses);
        System.Console.Write("     ");
        System.Console.Write(priceOneDress);
        System.Console.Write("     ");
        System.Console.WriteLine(subTotalDresses);
        System.Console.WriteLine("------------------------------------");
        System.Console.Write("Number of Items: ");
        System.Console.WriteLine(totalNumberOfItems);
        System.Console.Write("Total Order:     ");
        System.Console.WriteLine(totalOrder);
        System.Console.Write("Discount Rate:   ");
        System.Console.Write(discountRate * 100);
        System.Console.WriteLine('%');
        System.Console.Write("Discount Amount: ");
        System.Console.WriteLine(DiscountAmount);
        System.Console.Write("After Discount:  ");
        System.Console.WriteLine(netPrice);
        System.Console.Write("Tax Rate:        ");
        System.Console.Write(taxRate);
        System.Console.WriteLine('%');
        System.Console.Write("Tax Amount:      ");
        System.Console.WriteLine(taxAmount);
        System.Console.Write("Net Price:       ");
        System.Console.WriteLine(salesTotal);
        System.Console.WriteLine("====================================");
        System.Console.Write("Amount Tended:   ");
        System.Console.WriteLine(amountTended);
        System.Console.Write("Difference:      ");
        System.Console.WriteLine(Difference);
        System.Console.WriteLine("====================================");

        System.Console.ReadKey();
    }
}

Execute the application to see the result. This would produce:

-/- Georgetown Cleaning Services -/-
====================================
Customer:   James Burreck
Home Phone: (202) 301-7030
Order Date: 3/15/2002
------------------------------------
Item Type  Qty Unit/Price Sub-Total
------------------------------------
Shirts      5     0.95     4.75
Pants       2     2.95     5.90
Dresses     3     4.55     13.65
------------------------------------
Number of Items: 10
Total Order:     24.30
Discount Rate:   20.00%
Discount Amount: 4.8600
After Discount:  19.4400
Tax Rate:        5.75%
Tax Amount:      1.39725
Net Price:       20.83725
====================================
Amount Tended:   50
Difference:      29.16275
====================================

Close the DOS window and return to your programming environment

Compound Division

Remember that you can add, subtract, or multiply a value to a variable and assign the result to the variable itself. You can also perform this operation using the division. Here is an example:

class Exercise
{
    static void Main()
    {
        double value = 12.75;

        System.Console.Write("Value = ");
        System.Console.WriteLine(value);

        value = value / 2.42;

        System.Console.Write("Value = ");
        System.Console.WriteLine(value);
    }
}

This would produce:

Value = 12.75
Value = 5.26859504132231
Press any key to continue . . .

To perform this operation faster, the C# language provides the /= operator. Here is an example of using it:

class Exercise
{
    static void Main()
    {
        double value = 12.75;

        System.Console.Write("Value = ");
        System.Console.WriteLine(value);

        value /= 2.42;

        System.Console.Write("Value = ");
        System.Console.WriteLine(value);
    }
}

The Remainder

Introduction

The division program gives a result of a number with decimal values if you provide an odd number (like 147), which is fine in some circumstances. Sometimes you will want to get the value remaining after a division renders a natural result. Imagine you have 26 kids at a football (soccer) stadium and they are about to start. You know that you need 11 kids for each team to start. If the game starts with the right amount of players, how many will seat and wait?

The remainder operation is performed with the percent sign (%) which is gotten from pressing Shift + 5.

Here is an example:

class Exercise
{
    static void Main()
    {
        var players = 18;
        var remainder = players % 11;

        // When the game starts, how many players will wait?.
        System.Console.Write("Out of ");
        System.Console.Write(players);
        System.Console.Write(" players, ");
        System.Console.Write(remainder);
        System.Console.WriteLine(" players will have to wait when the game starts.\n");
    }
}

This would produce:

Out of 18 players, 7 players will have to wait when the game starts.

Press any key to continue . . .

The Compound Remainder

As seen with the other arithmetic operators, you can find the remainder of a variable and assign the result to the variable itself. Here is an example:

class Exercise
{
    static void Main()
    {
        var players = 18;

        // When the game starts, how many players will wait?.
        System.Console.Write("Out of ");
        System.Console.Write(players);
        System.Console.Write(" players, ");

        players = players % 11;
            
        System.Console.Write(players);
        System.Console.WriteLine(" players will have to wait when the game starts.\n");
    }
}

To support a faster version of this operation, the C# language provides the compound remainder operator represented as %=. To use it, assign its value to the variable. Here is an example:

class Exercise
{
    static void Main()
    {
        var Players = 18;

        // When the game starts, how many players will wait?.
        System.Console.Write("Out of ");
        System.Console.Write(players);
        System.Console.Write(" players, ");

        players %= 11;
 
        System.Console.Write(players);
        System.Console.WriteLine(" players will have to wait when the game starts.\n");
    }
}

Bit Operations

Introduction

From our introduction to variables, you may remember that the computer stores its data in memory using small locations that each contains a bit of information. Because a bit can be represented only either as 1 or 0, we can say that each bit contains 1 or 0. Bit manipulation consists of changing the value (1 or 0, or 0 or 1) in a bit. As we will see in the next few operations, it is not just about changing a value. It can involve reversing a value or kind of "moving" a bit from its current position to the next position.

The operations on bits are performed on 1s and 0s only. This means that any number is decimal or hexadecimal format involved in a bit operation must be converted to binary first.

You will almost never perform some of the operations we are going to review. You will hardly perform some other operations. There is only one operation you will perform on a regular basis. The OR operation is very regular in Microsoft Windows (Win32) programming so much that we were obliged to include this whole section in the lesson, as opposed to mentioning only OR.

"Reversing" a Bit

Remember that, at any time, a box (or chunk) in memory contains either 1 or 0:

Bit reversal consists of changing the value of a bit. If the box contains 1, it would become 0. If it contains 0, it would become 1. To support this operation, the C# language provides the bitwise negation operator represented with the ~ symbol.

As an example, consider the number 286. The decimal number 286 converted to binary is 100011110. You can reverse each bit as follows:

286	1	0	0	0	1	1	1	1	0
Not 286	0	1	1	1	0	0	0	0	1

To use the bitwise negation operator, type ~ on the left side of the value. Here is an example:

class Exercise
{
    static void Main()
    {
        var number1 = 286;

        System.Console.Write("286 = ");
        System.Console.WriteLine(number1);
        System.Console.Write("Not 286 = ");
        System.Console.WriteLine(~number1);
    }
}

This would produce:

286 = 286
Not 286 = -287
Press any key to continue . . .

Bitwise Conjunction

Bitwise conjunction consists of adding the content of a bit to the content of another bit. To support the bitwise conjunction operation, the C# language provides the & operator.

To perform the bit addition on two numbers, remember that they must be converted to binary first. Then:

If a bit with value 0 is added to a bit with value 0, the result is 0

Bit0 0

Bit1 0

Bit0 And Bit1 0
If a bit with value 1 is added to a bit with value 0, the result is 0

Bit0 1

Bit1 0

Bit0 And Bit1 0
If a bit with value 0 is added to a bit with value 1, the result is 0

Bit0 0

Bit1 1

Bit0 And Bit1 0
If a bit with value 1 is added to a bit with value 1, the result is 1

Bit0 1

Bit1 1

Bit0 And Bit1 1

As an example, consider the number 286 bit-added to 475. The decimal number 286 converted to binary is 100011110. The decimal number 4075 converted to binary is 111111101011. Based on the above 4 points, we can add these two numbers as follows:

286	0	0	0	1	0	0	0	1	1	1	1	0
4075	1	1	1	1	1	1	1	0	1	0	1	1
286 & 4075	0	0	0	1	0	0	0	0	1	0	1	0

Therefore, 286 & 4075 produces 100001010 which is equivalent to:

	Bit8	Bit7	Bit6	Bit5	Bit4	Bit3	Bit2	Bit1	Bit0
	256	128	64	32	16	8	4	2	1
286 & 4075	1	0	0	0	0	1	0	1	0
	256	0	0	0	0	8	0	2	0

This means that 286 & 4075 = 256 + 16 + 2 = 266. To perform a bitwise conjunction, use the & operator. Here is an example:

class Exercise
{
    static void Main()
    {
        var number1 = 286;
        var number2 = 4075;
        var result = number1 & number2;

        System.Console.Write("286 & 4075 = ");
        System.Console.WriteLine(result);
    }
}

This would produce:

286 & 4075 = 266
Press any key to continue . . .

You can perform a bitwise conjunction on a variable and assign the result to the same variable. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 286;
        System.Console.WriteLine(number);

        number = number & 48;
        System.Console.WriteLine(number);
    }
}

This would produce:

286
16
Press any key to continue . . .

Instead of performing the operation on two steps, a shorter version of this operator consists of using the &= operator. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 286;
        System.Console.WriteLine(number);

        number &= 48;
        System.Console.WriteLine(number);
    }
}

Bitwise Disjunction

Bitwise disjunction consists of disjoining a bit from another bit. To support this operation, the C# language provides the bitwise disjunction operator represented with |.

To perform a bitwise conjunction on two numbers, remember that they must be converted to binary first. Then:

If a bit with value 0 is added to a bit with value 0, the result is 0

Bit0 0

Bit1 0

Bit0 Or Bit1 0
If a bit with value 1 is added to a bit with value 0, the result is 1

Bit0 1

Bit1 0

Bit0 Or Bit1 1
If a bit with value 0 is added to a bit with value 1, the result is 1

Bit0 0

Bit1 1

Bit0 Or Bit1 1
If a bit with value 1 is added to a bit with value 1, the result is 1

Bit0 1

Bit1 1

Bit0 Or Bit1 1

As an example, consider the number 305 bit-disjoined to 2853. The decimal number 305 converted to binary is 100110001. The decimal number 2853 converted to binary is 101100100101. Based on the above 4 points, we can disjoin these two numbers as follows:

305	0	0	1	1	1	0	1
2853	1	1	1	1	0	1	1
305 \| 2853	1	1	1	1	1	1	1

Therefore, 305 | 2853 produces 101100110101 which is equivalent to:

	Bit11	Bit10	Bit9	Bit8	Bit7	Bit6	Bit5	Bit4	Bit3	Bit2	Bit1	Bit0
	2048	1024	512	256	128	64	32	16	8	4	2	1
305 Or 2853	1	0	1	1	0	0	1	1	0	1	0	1
	2048	0	512	256	0	0	32	16	0	4	0	1

This means that 286 | 4075 = 2048 + 512 + 256 + 32 + 16 + 4 + 1 = 2869

This can also be programmatically calculated as follows:

class Exercise
{
    static void Main()
    {
        var number1 = 305;
        var number2 = 2853;
        var result = number1 | number2;

        System.Console.Write("305 Or 2853 = ");
        System.Console.WriteLine(result);
    }
}

This would produce:

305 Or 2853 = 2869
Press any key to continue . . .

You can disjoint a number of bits on a variable and assign the result to the same variable. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 305;
        System.Console.WriteLine(number);

        number = number | 22;
        System.Console.WriteLine(number);
    }
}

This would produce:

305
311
Press any key to continue . . .

A short version of this operation consists of using the |= operator. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 305;
        System.Console.WriteLine(number);

        number |= 22;
        System.Console.WriteLine(number);
    }
}

Bitwise Exclusion

Bitwise exclusion consists of adding two bits with the following rules. To support bitwise exclusion, the C# language provides the ^ operator:

If both bits have the same value, the result is 0

Bit0 0 1

Bit1 0 1

Bit0 ^ Bit1 0 0
If both bits have different values, the result is 1

Bit0 0 1

Bit1 1 0

Bit0 ^ Bit1 1 1

As an example, consider the number 618 bit-excluded from 2548. The decimal number 618 converted to binary is 1001101010. The decimal number 2548 converted to binary is 100111110100. Based on the above 2 points, we can bit-exclude these two numbers as follows:

618	0	1	0	0	1	1	0	1	0	1
2548	1	0	1	1	1	1	1	0	1	0
618 ^ 2548	1	1	1	1	0	0	1	1	1	1

Therefore, 305 ^ 2853 produces 101110011110 which is equivalent to:

	Bit11	Bit10	Bit9	Bit8	Bit7	Bit6	Bit5	Bit4	Bit3	Bit2	Bit1	Bit0
	2048	1024	512	256	128	64	32	16	8	4	2	1
618 ^ 2548	1	0	1	1	1	0	0	1	1	1	1	0
	2048	0	512	256	128	0	0	16	8	4	2	0

This means that 286 ^ 4075 = 2048 + 512 + 256 + 128 + 16 + 8 + 4 + 2 = 2974

This can also be programmatically calculated as follows:

class Exercise
{
    static void Main()
    {
        var number1 = 618;
        var number2 = 2548;
        var result = number1 ^ number2;

        System.Console.WriteLine(result);
    }
}

This would produce:

2974
Press any key to continue . . .

You can bitwise exclude a number of bits from a variable and assign the result to the variable itself. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 618;
        System.Console.WriteLine(number);

        number = number ^ 38;
        System.Console.WriteLine(number);
    }
}

This would produce:

618
588
Press any key to continue . . .

As an alternative, you can use the ^= operator to get the same result. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 618;
        System.Console.WriteLine(number);

        number ^= 38;
        System.Console.WriteLine(number);
    }
}

Left-Shifting the Bits

Left shifting the bits consists of pushing each bit from right to left. You can do this by one ore more bits. Once again, to perform this operation, the number has to be converted to its binary equivalent. To support this operation, the C# language provides an operator represented as <<.

Imagine you have a number as 741. Its binary equivalent is 1011100101 and can be represented as:

To perform a left shift operation on these bits, you push each from its position to the left, depending on the number of pushes you want. For example, to left-shift by 1 bit, you push each bit to the left by one position. Actually, you consider the bit at position x and the bit to its left at position y. You replace the value of Bit y by the value of Bit x. If Bit x is the most right bit, it receives a value of 0. This can be illustrated as follows:

Original		1	0	1	1	1	0	0	1	0	1
<< by 1	1	0	1	1	1	0	0	1	0	1	0

As a result, we get 10111001010. The decimal result can be calculated as follows:

	Bit10	Bit9	Bit8	Bit7	Bit6	Bit5	Bit4	Bit3	Bit2	Bit1	Bit0
	1024	512	256	128	64	32	16	8	4	2	1
741 << 1	1	0	1	1	1	0	0	1	0	1	0
	1024	0	256	128	64	0	0	8	0	2	0

Consequently, 741 << 1 = 1024 + 256 + 128 + 64 + 8 + 2 = 1482. To programmatically perform this operation, use the << operator. Here is an example:

class Exercise
{
    static void Main()
    {
        System.Console.WriteLine(741 << 1);
    }
}

This would produce:

1482
Press any key to continue . . .

In the same way, you can push the bits to the left by more than one unit. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 248 << 5;

        System.Console.WriteLine(number);
    }
}

This would produce:

7936
Press any key to continue . . .

You can push a few bits to the left of a variable and assign the result to the variable itself. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 248;
        System.Console.WriteLine(number);

        number = number << 5;
        System.Console.WriteLine(number);
    }
}

This would produce:

248
7936
Press any key to continue . . .

To provide another version of this operation, the C# language is equipped with the <<= operator. Here is an example of using it:

class Exercise
{
    static void Main()
    {
        var number = 248;
        System.Console.WriteLine(number);

        number <<= 5;
        System.Console.WriteLine(number);
    }
}

Right-Shifting the Bits

You can shift the bits to the right. Everything is done as reviewed for the left shift but in reverse order. To support this operation, the C# language provides the >> operator.

Application: Ending the Lesson

Close your programming environment
When asked whether you want to save, click No

Lesson no:4

noreply@blogger.com (Unknown) — Mon, 13 Feb 2012 05:37:00 +0000

Application: Using Unsigned Integers

Start Microsoft Visual Studio
To create a new application, on the main menu, click File -> New Project...
In the middle list, click Empty Project
Change the Name to gdcs3 and click OK
To create a file for the code, on the main menu, click Project -> Add New Item...
In the middle list, click Code File
Change the Name to CleaningOrder
Click Add

In the empty document, type the following:

class Order
{
    static void Main()
    {
     byte?   shirts     = null;
        byte?   pants      = null;
        ushort? otherItems = null;

        shirts     = 4;
        pants      = 0;
        otherItems = 3;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("========================");
        System.Console.WriteLine("------------------------");
        System.Console.WriteLine("Item Type  Qty");
        System.Console.WriteLine("------------------------");
        System.Console.Write("Shirts      ");
        System.Console.WriteLine(shirts);
        System.Console.Write("Pants       ");
        System.Console.WriteLine(pants);
        System.Console.Write("Other Items ");
        System.Console.WriteLine(otherItems);
        System.Console.WriteLine("========================");
        
        System.Console.ReadKey();
    }
}

Execute the program to see the result
Close the DOS window

Signed Integers

A double-word is large enough to contain double the amount of data that can be stored in a word. This is equivalent to 32 bits or 4 bytes or 4,294,967,295. Therefore, a double-word is used for large numbers that would not fit in a word.

To use a variable that would hold quite large numbers, besides the var keyword, you can declare it using the intkeyword. A variable declared as int can store values between 2,147,483,648 and 2,147,484,647 negative or positive, that can fit in 32 bits.

Here are examples:

class Exercise
{
    static void Main()
    {
 int coordX;
 int coordY;
 
 coordX = 12;
 coordY = -8;

 System.Console.Write("Cartesian Coordinate System: ");
 System.Console.Write("P(");
 System.Console.Write(coordX);
 System.Console.Write(", ");
 System.Console.Write(coordY);
 System.Console.WriteLine(")\n");
    }
}

When executed, the program would produce:

Cartesian Coordinate System: P(12, -8)

If you declare an integer variable using the var keyword and initialize it with a value lower than 2,147,484,647, the compiler concludes that the memory needed to store that variable is 32 bits:

When initializing an integral variable, instead of a decimal number, you can also initialize it with a hexadecimal value whose decimal equivalent is less than 2,147,484,647. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 0xF0488EA;

        System.Console.Write("Number: ");
        System.Console.WriteLine(number);
    }
}

This would produce:

Number: 251955434
Press any key to continue . . .

Unsigned Integers

If the variable must hold only positive natural numbers, you can declared it using the uint keyword, which represents an unsigned integer. The uint keyword is used to identify a 32-bit positive integer whose value would range from 0 to 4,294,967,295. Here are examples:

class Exercise
{
    static void Main()
    {
 uint dayOfBirth;
 uint monthOfBirth;
 uint yearOfBirth;
 
 dayOfBirth   = 8;
 monthOfBirth = 11;
 yearOfBirth  = 1996;

 System.Console.WriteLine("Red Oak High School");
 System.Console.Write("Student Date of Birth: ");
 System.Console.Write(monthOfBirth);
 System.Console.Write("/");
 System.Console.Write(dayOfBirth);
 System.Console.Write("/");
 System.Console.Write(yearOfBirth);
    }
}

This would produce:

Red Oak High School
Student Date of Birth: 11/8/1996

Application: Using Unsigned Integers

To use unsigned variables, change the file as follows:

class Order
{
    static void Main()
    {
        byte?   shirts     = null;
        byte?   pants      = null;
        ushort? otherItems = null;

        uint? orderDay   = null;
        uint? orderMonth = null;
        uint? orderYear  = null;

        shirts     = 4;
        pants      = 0;
        otherItems = 3;
        orderDay   = 15;
        orderMonth = 7;
        orderYear  = 2002;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("========================");
        System.Console.Write("Order Date: ");
        System.Console.Write(orderMonth);
        System.Console.Write('/');
        System.Console.Write(orderDay);
        System.Console.Write('/');
        System.Console.WriteLine(orderYear);
        System.Console.WriteLine("------------------------");
        System.Console.WriteLine("Item Type  Qty");
        System.Console.WriteLine("------------------------");
        System.Console.Write("Shirts      ");
        System.Console.WriteLine(shirts);
        System.Console.Write("Pants       ");
        System.Console.WriteLine(pants);
        System.Console.Write("Other Items ");
        System.Console.WriteLine(otherItems);
        System.Console.WriteLine("========================");
        
        System.Console.ReadKey();
    }
}

Execute the program. This would produce:

-/- Georgetown Cleaning Services -/-
========================
Order Date: 7/15/2002
------------------------
Item Type  Qty
------------------------
Shirts      4
Pants       0
Other Items 3
========================

Close the DOS window

A Quad-Word

Introduction

Sometimes you may want to store values that a double-word cannot handle. To store a very large number in a variable, you can consider a combination of 64 bits. The group can also be referred to as a quad-word. A quad-word is so large it can store numbers in the range of -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807.

If you declare an integer variable using the var keyword and initialize it with a value between 2,147,484,647 and 9,223,372,036,854,775,807, the compiler concludes that the memory needed to store that variable is 64 bits:

Long Integers

If you want to use a variable that can hold very large numbers that would require up to 64 bits, you can declare it using either the var or the long keyword.

As stated previously, if you initialize the variable with a value lower than 2,147,484,647, the compiler would allocate 32 bits of memory for it. If you initialize the variable with a value between 2,147,484,647 and 9,223,372,036,854,775,807, the compiler would allocate 64 bits of memory for it. If the value is higher than 9,223,372,036,854,775,807, which is too large, the compiler would present an error:

This means that you should limit the values assigned to integral variables to 64 bits, which is very significant.

Here is an example:

class Exercise
{
    static void Main()
    {
        var countryArea = 5638648;

        System.Console.Write("Country Area: ");
        System.Console.Write(countryArea);
        System.Console.Write("km2\n");
    }
}

This would produce:

Country Area: 5638648km2
Press any key to continue . . .

As mentioned for other integral types, you can initialize a long variable with a hexadecimal value.

Although the long data type is used for large numbers, it mainly indicates the amount of space available but you don't have to use the whole space. For example, you can use the long keyword to declare a variable that would hold the same range of numbers as the short, the int, or the uint data types. If you declare a variable as long but use it for small numbers that don't require 64 bits, the compiler would allocate the appropriate amount of space to accommodate the values of the variable. Consequently, the amount of space made available may not be as large as 64 bits. If you insist and want the compiler to reserve 64 bits, when assigning a value to the variable, add an L suffix to it. Here is an example that uses a long variable to store a number that would fit in 32 bits:

class Exercise
{
    static void Main()
    {
 long countryArea;
  
 countryArea = 5638648L;

 System.Console.Write("Country Area: ");
 System.Console.Write(countryArea);
 System.Console.Write("km2\n");
    }
}

Therefore, keep in mind that an int, a uint, a short, or a ushort can fit in a long variable.

Unsigned Long Integers

You can use a combination of 64 bits to store positive or negative integers. In some cases, you will need a variable to hold only positive, though large, numbers. To declare such a variable, you can use the ulong data type. A variable declared as ulong can handle extremely positive numbers that range from 0 to 18,446,744,073,709,551,615 to fit in 64 bits.

Real Numbers

Introduction

A real number is a number that displays a decimal part. This means that the number can be made of two sections separated by a symbol that is referred to as the Decimal Separator or Decimal Symbol. This symbol is different by language, country, group of languages, or group of countries. In US English, this symbol is the period as can be verified from the Regional (and Language) Settings of the Control Panel:

On both sides of the decimal symbol, digits are used to specify the value of the number. The number of digits on the right side of the symbol determines how much precision the number offers.

Floating-Point Numbers

The integers we have used so far have the main limitation of not allowing decimal values. C# provides floating values that would solve this problem. The most fundamental floating variable is declared with the float keyword. A variable declared as float can store real numbers that range from Ã‚Â±1.5 xÃ‚Â 10âˆ’⁴⁵ to Ã‚Â±3.4 xÃ‚Â 10³⁸ with a precision of 7 digits in 32 bits. Here is an example:

class Exercise
{
    static void Main()
    {
 float distance;
    }
}

Double-Precision Numbers

When a variable is larger than the float can handle and requires more precision, you should declare it using either the var or the the double keyword. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 62834.9023;

        System.Console.Write("Number: ");
        System.Console.WriteLine(number);
    }
}

This would produce:

Number: 62834.9023
Press any key to continue . . .

A variable declared as double uses 64 bits to store very large numbers ranging from Ã‚Â±5.0 x 10âˆ’³²⁴ to Ã‚Â±1.7 x Ã‚Â10³⁰⁸ with a precision of 15 or 16 digits. Because the double data type provides a better result with better precision than the float, whenever you declare a variable using either the var or the float keyword and assign it a value, the compiler allocates 64 bits to store the values of the variable. If you insist on the variable being treated as float, when assigning it a value, add an f or an F suffix to the value. Here is an example:

class Exercise
{
    static void Main()
    {
 float distance;
  
 distance = 248.38F;

 System.Console.Write("Distance = ");
 System.Console.Write(distance);
 System.Console.WriteLine("km\n");
    }
}

This would produce:

Distance = 248.38km

Remember that if you declare the variable as var and want to treat it as a value with single precision, add an f or anF suffix to the value assigned to it. Here is an example:

class Exercise
{
    static void Main()
    {
        var  number = 62834.9023F;

        System.Console.Write("Number: ");
        System.Console.WriteLine(number);
    }
}

On the other hand, if you want a value to be treated with double-precision, add a d or a D suffix to it. Here is an example:

class Exercise
{
    static void Main()
    {
        var  number = 62834.9023D;

        System.Console.Write("Number: ");
        System.Console.WriteLine(number);
    }
}

Application: Using a Double-Precision Variable

To use a double-precision value, change the file as follows:

class Order
{
    static void Main()
    {
        byte?   shirts     = null;
        byte?   pants      = null;
        ushort? otherItems = null;

        uint? orderDay   = null;
        uint? orderMonth = null;
        uint? orderYear  = null;

        double? mondayDiscount = null;

        shirts         = 4;
        pants          = 0;
        otherItems     = 3;
        orderDay       = 15;
        orderMonth     = 7;
        orderYear      = 2002;
        mondayDiscount = 0.25D; // 25%

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("========================");
        System.Console.Write("Order Date: ");
        System.Console.Write(orderMonth);
        System.Console.Write('/');
        System.Console.Write(orderDay);
        System.Console.Write('/');
        System.Console.WriteLine(orderYear);
        System.Console.WriteLine("------------------------");
        System.Console.WriteLine("Item Type  Qty");
        System.Console.WriteLine("------------------------");
        System.Console.Write("Shirts      ");
        System.Console.WriteLine(shirts);
        System.Console.Write("Pants       ");
        System.Console.WriteLine(pants);
        System.Console.Write("Other Items ");
        System.Console.WriteLine(otherItems);
        System.Console.WriteLine("------------------------");
        System.Console.Write("Monday Discount: ");
        System.Console.Write(mondayDiscount);
        System.Console.WriteLine('%');
        System.Console.WriteLine("========================");

        System.Console.ReadKey();
    }
}

Execute the application to see the result:

-/- Georgetown Cleaning Services -/-
========================
Order Date: 7/15/2002
------------------------
Item Type  Qty
------------------------
Shirts      4
Pants       0
Other Items 3
------------------------
Monday Discount: 0.25%
========================

Close the DOS window

Decimal

The decimal data type can be used to declare a variable that would hold significantly large values that can be stored in a combination of 128 bits. You declare such a variable using the decimal keyword. The values stored in a decimal variable can range from Â±1.0 xÂ 10âˆ’²⁸ to Â±7.9 xÂ 10²⁸ with a precision of 28 to 29 digits. Because of this high level of precision, the decimal data type is suitable for currency values.

After declaring a decimal variable, you can initialize it with a natural number. To indicate that the variable holds a decimal value, when initializing it, add an m or an M suffix to its value. Here is an example:

class Exercise
{
    static void Main()
    {
 decimal hourlySalary;
  
 hourlySalary = 24.25M;

 System.Console.Write("Hourly Salary = ");
 System.Console.WriteLine(hourlySalary);
 System.Console.WriteLine();
    }
}

This would produce:

Hourly Salary = 24

As seen in previous sections and this one, when declaring and initializing a real variable, the suffix you give to its assigned value indicates to the compiler the actual type of value and the type of memory that would be allocated for the variable:

If the value receives an f or an F suffix, it is considered a floating point number with single precision
If the value receives a d or a D suffix, it is considered a floating point number with double precision
If the value receives an m or an M suffix, it is considered a large decimal number

Consider the following program:

class Program
{
    static void Main()
    {
        System.Console.Write("560 / 672 = ");
        System.Console.WriteLine(560 / 672);
    }
}

The purpose of this program is to get the division of 560 by 672. This would produce:

560 / 672 = 0
Press any key to continue . . .

Notice that, when such numbers are submitted to the program, the compiler decides that these are integers and the result produces 0. If you write such an equation and want the result to appear as a real number, you must explicitly indicate it to the compiler. One way you can do this consists of adding decimal places to at least one of the numbers. Here is an example:

class Program
{
    static void Main()
    {
        System.Console.Write("560 / 672 = ");
        System.Console.WriteLine(560.00 / 672.00);
    }
}

This time, the compiler will conclude that the value is a floating-point number; but which one? By default, the compiler would apply the double data type. This version of the program would produce:

560 / 672 = 0.833333333333333
Press any key to continue . . .

If you want to indicate that the value is a float, a double, or a decimal, add the appropriate prefix to it: f, F, d, D,m, or M. Here are examples:

class Program
{
    static void Main()
    {
        System.Console.Write("560 / 672 = ");
        System.Console.WriteLine(560F / 672f);
    }
}

This version of the program would produce:

560 / 672 = 0.8333333
Press any key to continue . . .

Application: Using Decimal Values

To use decimal variables, change the file as follows:

class Order
{
    static void Main()
    {
            byte?    shirts            = null;
            decimal? priceOneShirt     = null;
            byte?    pants             = null;
            decimal? priceAPairOfPants = null;
            ushort?  otherItems        = null;
            decimal? priceOtherItems   = null;

            uint? orderDay   = null;
            uint? orderMonth = null;
            uint? orderYear  = null;

            double? mondayDiscount = null;

            shirts = 5;
            priceOneShirt = 0.95M;
            pants = 2;
            priceAPairOfPants = 1.95M;
            otherItems = 3;
            priceOtherItems = 4.55M;
            orderDay = 15;
            orderMonth = 7;
            orderYear = 2002;
            mondayDiscount = 0.25D; // 25%

            System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
            System.Console.WriteLine("========================");
            System.Console.Write("Order Date: ");
            System.Console.Write(orderMonth);
            System.Console.Write('/');
            System.Console.Write(orderDay);
            System.Console.Write('/');
            System.Console.WriteLine(orderYear);
            System.Console.WriteLine("------------------------");
            System.Console.WriteLine("Item Type  Qty Unit Price");
            System.Console.WriteLine("------------------------");
            System.Console.Write("Shirts      ");
            System.Console.Write(shirts);
            System.Console.Write("     ");
            System.Console.WriteLine(priceOneShirt);
            System.Console.Write("Pants       ");
            System.Console.Write(pants);
            System.Console.Write("     ");
            System.Console.WriteLine(priceAPairOfPants);
            System.Console.Write("Other Items ");
            System.Console.Write(otherItems);
            System.Console.Write("     ");
            System.Console.WriteLine(priceOtherItems);
            System.Console.WriteLine("------------------------");
            System.Console.Write("Monday Discount: ");
            System.Console.Write(mondayDiscount);
            System.Console.WriteLine('%');
            System.Console.WriteLine("========================");
            
            System.Console.ReadKey();
    }
}

Execute the program. This would produce:

-/- Georgetown Cleaning Services -/-
========================
Order Date: 7/15/2002
------------------------
Item Type  Qty Unit Price
------------------------
Shirts      5     0.95
Pants       2     1.95
Other Items 3     4.55
------------------------
Monday Discount: 0.25%
========================

Close the DOS window

Accessory Data Types

Strings

A string is an empty space, a character, a word, or a group of words that you want the compiler to consider "as is", that is, not to pay too much attention to what the string is made of, unless you explicitly ask it to. This means that, in the strict sense, you can put in a string anything you want.

Primarily, the value of a string starts with a double quote and ends with a double-quote. An example of a string is "Welcome to the World of C# Programming!". You can include such a string in System.Console.Write() to display it on the console. Here is an example:

class Exercise
{
    static void Main()
    {
 System.Console.WriteLine("Welcome to the World of C# Programming!");
    }
}

This would produce:

Welcome to the World of C# Programming!
Press any key to continue . . .

Sometimes, you will need to use a string whose value is not known in advance. Therefore, you can first declare a string variable. To do this, use either the var or the string keyword followed by a name for the variable. When declaring a string variable, you can initialize it with an empty space, a character, a symbol, a word, a group of words, or null (but you must not use string?). If not using null, the value given to a string must be included in double-quotes. Here are two examples:

class Exercise
{
    static void Main()
    {
        var team = "Real Madrid";
        string country = "GuinÃ©e Equatoriale";

        System.Console.WriteLine("Welcome to the World of C# Programming!");
        System.Console.Write("Team:    ");
        System.Console.WriteLine(team);
        System.Console.Write("Country: ");
        System.Console.WriteLine(country);
        System.Console.WriteLine();
    }
}

This would produce:

Welcome to the World of C# Programming!
Team:    Real Madrid
Country: GuinÃ©e Equatoriale

Press any key to continue . . .

Application: Using Strings

To use strings, change the file as follows:

class Order
{
    static void Main()
    {
            string customerName;
            string customerHomePhone;

            byte? shirts = null;
            decimal? priceOneShirt = null;
            byte? pants = null;
            decimal? priceAPairOfPants = null;
            ushort? otherItems = null;
            decimal? priceOtherItems = null;

            uint? orderDay = null;
            uint? orderMonth = null;
            uint? orderYear = null;

            double? mondayDiscount = null;

            customerName = "Gregory Almas";
            customerHomePhone = "(301) 723-4425";
            shirts = 5;
            priceOneShirt = 0.95M;
            pants = 2;
            priceAPairOfPants = 1.95M;
            otherItems = 3;
            priceOtherItems = 4.55M;
            orderDay = 15;
            orderMonth = 7;
            orderYear = 2002;
            mondayDiscount = 0.25D; // 25%

            System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
            System.Console.WriteLine("========================");
            System.Console.Write("Customer:   ");
            System.Console.WriteLine(customerName);
            System.Console.Write("Home Phone: ");
            System.Console.WriteLine(customerHomePhone);
            System.Console.Write("Order Date: ");
            System.Console.Write(orderMonth);
            System.Console.Write('/');
            System.Console.Write(orderDay);
            System.Console.Write('/');
            System.Console.WriteLine(orderYear);
            System.Console.WriteLine("------------------------");
            System.Console.WriteLine("Item Type  Qty Unit Price");
            System.Console.WriteLine("------------------------");
            System.Console.Write("Shirts      ");
            System.Console.Write(shirts);
            System.Console.Write("     ");
            System.Console.WriteLine(priceOneShirt);
            System.Console.Write("Pants       ");
            System.Console.Write(pants);
            System.Console.Write("     ");
            System.Console.WriteLine(priceAPairOfPants);
            System.Console.Write("Other Items ");
            System.Console.Write(otherItems);
            System.Console.Write("     ");
            System.Console.WriteLine(priceOtherItems);
            System.Console.WriteLine("------------------------");
            System.Console.Write("Monday Discount: ");
            System.Console.Write(mondayDiscount);
            System.Console.WriteLine('%');
            System.Console.WriteLine("========================");
            
            System.Console.ReadKey();
    }
}

Execute the program. This would produce:

-/- Georgetown Cleaning Services -/-
========================
Customer:   Gregory Almas
Home Phone: (301) 723-4425
Order Date: 7/15/2002
------------------------
Item Type  Qty Unit Price
------------------------
Shirts      5     0.95
Pants       2     1.95
Other Items 3     4.55
------------------------
Monday Discount: 0.25%
========================

Close the DOS window

Dates and Times

A date is a unit that measures the number of years, months, or days elapsed in a specific period. A time is a unit that counts the number of seconds that have elapsed since midnight of the day considered. Although dates and times are large subjects that would require a detailed study, at this time, we will consider them in simple terms.

To declare a variable that would hold date or time values, use the DateTime data type.

class Exercise
{
    static void Main()
    {
 DateTime DateHired;
    }
}

The .NET Framework sets its starting periodic date to January 1, 0001 at midnight (12:00:00 or 0:00 AM). If not assigned a specific value (in future lessons, we will learn that this is equivalent to declaring a variable using the default constructor), the variable is initialized to 1/1/0001 at midnight.

Objects

The object data type is used to declare a variable whose type is not primarily defined and can be any of the other data types we have introduced. After creating an object variable, you can use its value as you see fit. For example, you can enter the variable in the parentheses of System.Console.Write() or System.Console.WriteLine() to display it in the console window. Here is an example:

class Exercise
{
    static void Main()
    {
        var EmployeeName = "Ernestine Lamb";
        object Address = "10244 Lockwood Drive";

        System.Console.Write("Employee Name: ");
        System.Console.WriteLine(EmployeeName);
        System.Console.Write("Home Address:  ");
        System.Console.WriteLine(Address);
        System.Console.WriteLine();
    }
}

This would produce:

Employee Name: Ernestine Lamb
Home Address:  10244 Lockwood Drive

Press any key to continue . . .

A variable declared with object can embrace almost any value. This means that, when initializing the variable, you can use any of the types of values we have seen so far. Here are examples:

class Program
{
    static void Main()
    {
        object propertyNumber = "293749";
        object propertyType = 'S';
        object stories = 3;
        object bedrooms = 4;
        object value = 425880;

        System.Console.WriteLine("=//= Altair Realtors =//=");
        System.Console.WriteLine("Properties Inventory");
        System.Console.Write("Property #:    ");
        System.Console.WriteLine(propertyNumber);
        System.Console.Write("Property Type:  ");
        System.Console.WriteLine(propertyType);
        System.Console.Write("Stories:        ");
        System.Console.WriteLine(stories);
        System.Console.Write("Bedrooms:       ");
        System.Console.WriteLine(bedrooms);
        System.Console.Write("Market Value:   ");
        System.Console.WriteLine(value);
    }
}

This would produce:

=//= Altair Realtors =//=
Properties Inventory
Property #:    293749
Property Type:  S
Stories:        3
Bedrooms:       4
Market Value:   425880
Press any key to continue . . .

Constants

Custom Constants

Suppose you intend to use a number such as 39.37 over and over again. Here is an example:

class Exercise
{
    static void Main()
    {
 double meter, inch;
  
 meter = 12.52D;
 inch = Meter * 39.37D;

        System.Console.Write(meter);
        System.Console.Write("m = ");
        System.Console.Write(inch);
        System.Console.WriteLine("in\n");
    }
}

Here is an example of running the program:

12.52m = 492.9124in

If you use this 39.37 many times in your program, at one time, you may make a mistake and type it as 3937 or 3.937 or else. Consider the following program:

class Exercise
{
    static void Main()
    {
        double meter, inch;

        meter = 12.52D;
        inch = Meter * 39.37;

        System.Console.Write(meter);
        System.Console.Write("m = ");
        System.Console.Write(inch);
        System.Console.WriteLine("in\n");

        meter = 12.52D;
        Inch = Meter * 3.937;
        System.Console.Write(meter);
        System.Console.Write("m = ");
        System.Console.Write(inch);
        System.Console.WriteLine("in\n");

        meter = 12.52D;
        Inch = Meter * 393.7;
        System.Console.Write(meter);
        System.Console.Write("m = ");
        System.Console.Write(inch);
        System.Console.WriteLine("in\n");
    }
}

This would produce:

12.52m = 492.9124in

12.52m = 49.29124in

12.52m = 4929.124in

Because of mistakes in the way to represent the number, the same calculation produces different results. To make sure that this is unlikely, you can instead use a variable that holds the value. Then, when you need that value, you can access the variable instead of the value itself. A number such as 39.37 is called a constant.

A constant is a value that never changes such as 244, "ASEC Mimosa", 39.37, or True. These are constant values you can use in your program any time. You can also declare a variable and make it a constant; that is, use it so that its value is always the same.

To create a constant, type the const keyword to its left. When declaring a constant, you must initialize it with an appropriate value. Here is an example:

const double ConversionFactor = 39.37D;

Once a constant has been created and it has been appropriately initialized, you can use its name where the desired constant would be used. Here is an example of a constant variable used various times:

class Exercise
{
    static void Main()
    {
        const double conversionFactor = 39.37D;
        double meter, inch;

        meter = 12.52D;
        inch = Meter * ConversionFactor;

        System.Console.Write(meter);
        System.Console.Write("m = ");
        System.Console.Write(inch);
        System.Console.WriteLine("in\n");

        meter = 12.52D;
        inch = Meter * ConversionFactor;

        System.Console.Write(meter);
        System.Console.Write("m = ");
        System.Console.Write(inch);
        System.Console.WriteLine("in\n");

        meter = 12.52D;
        inch = Meter * ConversionFactor;

        System.Console.Write(meter);
        System.Console.Write("m = ");
        System.Console.Write(inch);
        System.Console.WriteLine("in\n");
    }
}

This would produce:

12.52m = 492.9124in

12.52m = 492.9124in

12.52m = 492.9124in

Notice that, this time, the calculation is more accurate. Also, this time, if you mistype the name of the variable in an operation, you would receive an error, giving you the time to fix it.

To initialize a constant variable, the value on the right side of the assignment operator "=" must be a constant or a value that the compiler can determine as constant. Instead of using a known constant, you can also assign it another variable that has already been declared as constant.

Built-in Constants

There are two main categories of constants you will use in your programs. You can create your own constant as we saw above. The C# language also provides various constants. Some constants are part of the C# language. Some other constants are part of the .NET Framework. Before using a constant, of course, you must first know that it exists. Second, you must know how to access it. A constant that is part of the C# language can be accessed anywhere in your code (normally, those constant are defined in the System namespace; other constant are defined in various appropriate namespaces).

null: The null keyword is a constant used to indicate that a variable doesn't hold a known value

PI: PI is a constant used as the ratio of the circumference of a circle to its diameter. PI is defined in Math. To use it, you would type Math.PI.

Managing Code

Introduction

The primary means of creating a program consists of adding code to a document. This is done by typing code using the keyboard. Once the code exists, you can do various things on it. In most cases, you must first select the text. Normally, from your experience of using computers, you should already know how to select text, using the mouse, or a combination of the mouse and keyboard.

Accessing a Variable

As mentioned already, you will write your code in normal text editors, whether using Notepad, the Code Editor of Microsoft Visual Studio, or else. Also, you may be familiar already with how to look for a character, a symbol, a word, or a group of words in a document. Just as reminder, on the main menu of the application, you can click Edit -> Find...

This would display a dialog box where you can type the item and click Find. If you are using Microsoft Visual Studio and if you want to find different occurrences of a known character, symbol, word, or group of words, first select that item. Then:

On the main menu, click Edit -> Quick Find
Press Ctrl + F

In the same way, if you have a variable that is used more than once in your code and you want to see all places where that variable is used, simply click the name (and wait two seconds) and all of its occurrences would be highlighted:

To get a list of all sections where the variable is used, if you are using Microsoft Visual Studio:

In the Code Editor, right-click the name of the variable and click Find All References

Press Ctrl + F12

This would produce a list of all sections where the variable is used and would display the list in the Find Symbol Results window:

To access a particular section where the variable is used, double-click its entry in the list.

Cutting, Copying, and Pasting Code

Normally, from your knowledge of using computers, you probably already know how to select, cut, and copy text. These two operations can be valuable to save code in Microsoft Visual Studio. This means that, if you have code you want to use in different sections, you can preserve it somewhere to access it whenever necessary.

To save code to use over and over again, first type the code in any text editor, whether in Notepad, Microsoft Word, or the Code Editor of Microsoft Visual Studio. You can use code from any document where text can be copied, including a web page. Select that code and copy it to the clipboard. To preserve it, in Microsoft Visual Studio, display the Toolbox (on the main menu, you can click View -> Toolbox). Right-click an empty area on the Toolbox and click Paste:

An alternative is to select the code, whether in the Code Editor or in a text editor. Then drag it and drop it on the Toolbox. In the same way, you can add different code items to the Toolbox. After pasting or adding the code to the Toolbox, it becomes available. To use that code, drag it from the Toolbox and drop it in the section of the Code Editor where you want to use it.

Renaming a Variable

As we will see throughout our lessons, there are many names you will use in your programs. After creating a name, in some cases you will have to change it. You can find where the name is and edit it. If the name is used in many places, you can continue looking for it and modify it. There is a chance you will make a mistake. If you are writing your code using a text editor, you can use the Edit -> Replace option of the main menu to find and replace every instance of that name. You can use the same approach in the Code Editor. Unfortunately, this technique works for only one file. If your project has many files and the name is used in those files, it would be cumbersome to remember to change the name in all of them.

Microsoft Visual Studio makes it easy to find and change a name wherever it is used. Consider the following code:

class Order
{
    static void Main()
    {
        int nbr = 148;

        System.Console.WriteLine(nbr);
    }
}

To change the name of a variable, in the Code Editor:

Double-click the name of the variable and edit (change) it. The name will then have a small underline:

If you position your mouse on it, a tag would appear and you can click the arrow to reveal a short menu:

If you click the first option, all instances of the variable would be changed. If you want to display a preview window (next), click the second option
Right-click it, position the mouse on Refactor, and click Rename...

This would display the Rename dialog box with the primary name. If you want to change it, type the new name:

If you want the studio to find and change the name inside the comments, click the Search in Comments check box. If the name is used in strings and you want to replace it, click the Search in Strings check box. When you click OK, the Preview Changes - Rename dialog box would come up. It shows the various parts where the name is used and will be replaced:

If you still want to replace, click Apply.

Accessing a Variable's Declaration

If you create a long document that has many lines of code, in a certain section you may encounter a variable but you want to find out where it was declared. If you are using Microsoft Visual Studio, to access the place where a variable was declared:

Right-click the variable and click Go To Definition...

Click the name of the variable and press Shift + F2

In both cases, the caret would jump to where the variable was declared.

Accessing a Line of Code by its Index

If you are using the Code Editor of Microsoft Visual Studio, if you create a long document that has many lines of code, if you want to jump to a certain line of code:

On the main menu, click Edit -> Go To...
Press Ctrl + G

This would display a dialog box. Enter the line number and click OK or press Enter.

Application: Ending the Lesson

Close your programming environment
When asked whether you want to save, click No

Introduction to Values of a Program

noreply@blogger.com (Unknown) — Sat, 11 Feb 2012 13:00:00 +0000

Lesson no.3

Application: Introducing Variables

Start Microsoft Visual C# 2010 Express or Microsoft Visual Studio 2010

From now on, we will only refer to Microsoft Visual C#
To create a new application, on the Start Page, click New Project...
In the middle list, click Empty Project
Change the Name to gdcs2 (which stands for Georgetown Dry Cleaning Services 2)
Click OK
To create a file for the code, on the main menu, click Project -> Add New Item...
In the middle list, click Code File
Change the Name to CleaningOrder
Click Add

In the empty document, type the following:

class Order
{
    static void Main()
    {
     System.Console.WriteLine("Georgetown Dry Cleaning Services");
        System.Console.ReadKey();
    }
}

Names

A variable must have a name and there are stricts rules you must follow to create a name. To start, there are words, called keywords, that you must not use because the language itself uses them. These keywords are:

abstract	continue	finally	interface	out (generic)	short	typeof
as	decimal	fixed	internal	out (methods)	sizeof	uint
base	default	float	is	override	stackalloc	ulong
bool	delegate	for	lock	params	static	unchecked
break	do	foreach	long	private	string	unsafe
byte	double	goto	namespace	protected	struct	ushort
case	else	if	new (generic)	public	switch	using
catch	enum	implicit	new (LINQ)	readonly	this	virtual
char	event	in (foreach)	new (variable)	ref	throw	void
checked	explicit	in (generic)	null	return	true	volatile
class	extern	int	object	sbyte	try	while
const	false		operator	sealed

There are other names that are not considered C#Keywords but should be avoided because they may cause a conflict in your code. They are referred to as contextual keywords and they are:

add	global	let	partial (type)	set	where (generic)
dynamic	group	orderby	remove	value	where (query)
from	into	partial (method)	select	var	yield
get	join

As mentioned already, there are rules you must observe to name anything in your program. There are rules specified by the C# language standard but there are also rules you can add for your own taste. In our lessons, here are the rules we will follow to name things:

A name can consist of one letter (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, or z). Although these are letters of the US English alphabet, the C# language accepts international (non-US English) letters (that follow the Unicode standard)
The C# language allows that a name be made of an underscore only _. Although this is allowed, you should refrain from using the underscore as the only character of a name. It makes the code difficult to read
Except for the underscore, special symbols are not used anywhere in a name. Therefore, don't use |, !, ", /, $, %, ?, &, *, (, ), +, #, \, @, <, >, [, ], ;, {, }, or the comma inside any name
If the name is made of more than one character, it must start with either a letter or an underscore
After the first letter or underscore, the name can have a combination of letters, digits (0, 1, 2, 3, 4, 5, 6, 7, 8, or 9), and/or underscores
The name cannot have a space

Besides these rules, you can also create your own rules but that follow the above restrictions. For example:

It the name of a variable is in one word, many people use lowercase letters
If the name is a combination of words, many people use the camel notation in which the first word is in lowercase and the first letter of each subsequent word is in uppercase

C# is case-sensitive. This means that the names Case, case, and CASE are completely different. For example, main is always written Main.

Values and Variables on the Console

The applications of a C# language display their results in a dark object called the DOS window. Here is an example:

To display a value in this window, you can enter it in the parentheses of System.Console.Write() orSystem.Console.WriteLine(). Here are two examples:

class Exercise
{
    static void Main()
    {
        System.Console.WriteLine(248);
        System.Console.Write(1);
    }
}

If you write System.Console.WriteLine() with empty parentheses, an empty line would be displayed.

Numeric Representations

Introduction

A computer program is a series of instructions that tell the computer what to do, when to do something, and how to do it. You, as the programmer, create these instructions. As mentioned in the previous lessons, you write the instructions in a text editor based on rules of the C# language but using a familiar language, which is English. An example of an instruction would ask the program to store a number in the computer memory. Another instruction could ask the computer to add a number to the previously stored number. Another instructor could ask the computer to move something from one part to another. The instructions you write must be transmitted to the computer.

As you can imagine, different people write various and all types of instructions. In fact, since C# is not the only computer language in the world, people use different means of giving instructions to the machine. To understand all of them and in fact to bring all these disparate instructions to one common language, the computer uses its own that all languages should understand and must follow. And actually, they don't. Instead, a computer language such as C#, that uses English, submits its instructions to an intermediary program named an assembler. The assembler transforms the previous instructions into a shorter version that uses new words but that are still in English. Using this new version, the assembler transforms the instructions in an even more simplified version (in reality, there is nothing simple with this process) that the computer can understand.

The simplified language the computer understands uses a combination of 1s and 0s. This means that the assembler must bring your C# instructions to 1s and 0s. The combinations or sequences of 1s and 0s indicate what needs to be done.

Numeric Systems

We are familiar with the system that uses 10 digits as 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. A combination of these 10 digits can produce any number we want. Because this system uses 10 digits. It is named the decimal system.

As mentioned already, the language of the computer is made of combinations of two values: 1 and 0. This is called the binary system (because it is based on two values only). Examples of numbers in the binary system, or binary numbers, are 1, 10, 1001, or 1010110111. When you submit a value to a computer, the value must be changed into a compbination of 1s and 0s.

You can imagine how hard it would be to represent a large number. One alternative uses the 10 digits of the decimal system and uses the first 6 letters of the English alphabets: A, B, C, E, D, and F or a, b, c, d, e, and f. This means that this system uses a combination of 16 characters to create any number. For this reason, it is called the hexadecimal system. To differenciate a hexadecimal number from a word, the number must start with 0x. Examples are 0x2, or 0xED8, or 0x962AAED3.

Signed and Unsigned

One of the characteristics of a number is to indicate whether it is lower than 0, equal to 0, or higher than 0. A number that is lower than 0 is said to be negative. Such a number must be preceded by -. If a number is higher than 0, it is said to be positive. Such a number can be preceded by + or no sign. The ability for a number to hold a sign makes it possible to say that such a number is signed. It is important to know that, when a number is said to besigned, that number can be negative or positive.

Any number that uses neither - or + is said to be positive and, because it doesn't use a sign, it is said to beunsigned. Normally, the 0 number doesn't use a sign.

Variable Declaration

Representing Memory Bits

We mentioned that, to store a value in the computer memory, you must indicate how much memory you will need and you must give it a name. The amount of memory you need is referred to as a data type. As you can imagine, different values require different amount of memory. We also mentioned that the computer considers a value as a combination of 1s and 0s. The area of memory that holds a single piece of 1 or 0 is called a bit.

Consider a bit like a small object (like a cup of a cup cake) that can be full or can be empty:

When it is empty, a bit holds a value or 0. When it is full, it holds a value of 1:

Different combinations of empty (0) and full (1) objects produce the necessary values.

Declaring a Variable

To use a combination of bits, you let the compiler know that you want a variable. This is referred to as declaring a variable. As mentioned already, the amount of memory you need is called a data type. Therefore, when declaring a variable, you must specify the desired data type. In C# (and many other languages, but not all languages), a data type is represented by a keyword (in some languages such as C and C++, a data type can be specified using a combination of keywords).

To actually declare a variable, you have two options.

If you know the type of value you want to store in memory, use the following formula:
```
DataType VariableName;
```
In later sections, we will seen what data types are available
If you don't want to specify the type of value, you have other options
- You can use the var keyword
- You can use the object keyword
- You can use the dynamic keyword

Initializing a Variable

The Nullity of a Variable

When you declare a variable, you ask the compiler to reserve a certain area and amount of memory to eventually hold a value for that variable. At that time, no clear value is stored in that reserved area of memory (some languages, such as Visual Basic, put an initial value in that area, depending on the type of value you specified). Instead, the area gets filled with garbage (with some languages, such as C/C++, you can find out what that garbage is; some other languages, such as C#, don't allow you to access that garbage; after all, it is garbage and it is useless). A value is referred to as null when it cannot be clearly determined. A null value is not 0 because 0 is a an actual value.

In C#, normally, not all variables can hold null values. When declaring a variable, to indicate that it can hold either an actual value or it can be null, after its data type, add the question mark. This can be done as follows:

DataType? VariableName;

Assigning a Value to a Variable

Initializing a variable consists of storing an initial value in that reserved area. The technique you use is the same for all types but the type of value you want to store depends: you should not and must not try to store just any type of value.

To assign a value to a variable:

Type its data type, followed by a name for the variable, followed by =, followed by the desired but appropriate value. This can be done as follows:
```
class Exercise
{
    static void Main()
    {
 DataType VariableName = DesiredValue;
    }
}
```
If you use this approach, you can first declare the variable by specifing its name and its data type ended by a semicolon. Then, on another line, type the name of the variable, followed by =, and the value. This can be done as follows:
```
class Exercise
{
    static void Main()
    {
 DataType VariableName;

 VariableName = DesiredValue;
    }
}
```
Type the keyword var followed by the variable's name, followed by =, and followed by the value. This can be done as follows:
```
class Exercise
{
    static void Main()
    {
 var VariableName = DesiredValue;
    }
}
```
This time, you must do this at once: you cannot first declare the variable on one line using the var keyword and ending with a semicolon, then initialize the variable on another line. You would receive an error. The following formula will not work:
```
class Exercise
{
    static void Main()
    {
 var VariableName;
 
 VariableName = DesiredValue; // Error
    }
}
```
Two other options consist of using the object or the dynamic keywords

When you declare a variable and initialize it, the compiler stores its value in the memory that was reserved for it. You can then access that value when you want. And of course, you can change it if necessary.

The null Value

As mentioned already, when declaring a variable, you can indicate that it can hold a null value by adding a question mark to its data type. To let you initialize the variable, the C# language provides the null keyword. To initialize a variable with it, simply assign null to it:

You can assign null when declaring the variable:

class Exercise
{
    static void Main()
    {
 DataType? VariableName = null;
 
 // You can use the variable
    }
}

You can assign null after the variable has been declared:

class Exercise
{
    static void Main()
    {
 DataType? VariableName;
 
 VariableName = null;
 
 // You can use the variable
    }
}

The rule is that you must assign the value before the variable can be used.

A Byte

A Combination of Four Bits

Although there are cases where you can use or access a bit, you cannot actually store a value in it. That is, you cannot ask the compiler to store the value 1 is a certain bit. This is because even the simplest value in C# needs more than one bit to store itself. Still, the minimum combination of bits you can be concerned with is four (in some languages, or in some implementations of the Assembly language, a combination of four bits is called a nibble).

By creating different combinations of empty (0) and full (1) objects grouped in four, you can get 16 combinations:

In a combination of four bits, the bits are counted as 0, 1, 2, and 3. The bit on the most right side is Bit 0 and it is called the low order bit (or LOBIT):

The last bit, the bit on the most left side, is Bit 3 and it is called the high order bit (or HIBIT).

If you represent the four-combination bits in binary formats, you get 0000, 0001, 0010, 0011, 0100, 0101, 0110, 0111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, which produces 16 combinations. In decimal format, these combinations produce 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, and 15. In hexadecimal format, these combinations produce 0x0 (0x0000), 0x1 (or 0x0001), 0x2 (or 0x0002), 0x3 (or 0x0003), 0x4 (or 0x0004), 0x5 (0x0005), 0x6 (0x0006), 0x7 (or 0x0007), 0x8 (or 0x0008), 0x9 (or 0x0009), 0xA (or 0xa), 0xB (or 0xb), 0xC (or 0xc), 0xD (or 0xd), 0xE (or 0xe), and 0xF (or 0xF).

As a result, we get a table as follows:

Decimal	Binary	Hexadecimal
0	0000	0x0
1	0001	0x1
2	0010	0x2
3	0011	0x3
4	0100	0x4
5	0101	0x5
6	0110	0x6
7	0111	0x7
8	1000	0x8
9	1001	0x9
10	1010	0xA
11	1011	0xB
12	1100	0xC
13	1101	0xD
14	1110	0xE
15	1111	0xF

Table of Numeric Conversions

The minimum and maximum values in a combination of four bits are:

	Decimal	Hexadecimal	Binary
Minimum	0	0x0	0000
Maximum	15	0xf	1111

You will never be concerned with combinations of four bits because you cannot store anything in it (these combinations are too small). We presented them here for two reasons. First, you should be aware of such a thing as a combination of four bits so you will know where the number 16 comes from when you see it mentioned in different places. Second, it allowed us the introduce the byte.

A Combination of 8 Bits

A byte is a combination of eight adjacent bits. The first bit, located on the most right side, is Bit 0. The last bit, on the most left side, is Bit 7:

Bit 0 is called the least significant bit. It is also valled the low order bit or LOBIT. Bit 7 is called the most significant bit. It is also called the high order bit or HIBIT.

If you create different combinations of empty (0) and full (1) objects grouped in eight, in binary formats, you get 00000000, 00000001, 00000010, 00000011, 00000100, 00000101, 00000110, 00000111, 00001000, 00001001, 00001010, 00001011, 00001100, 00001101, 00001110, 00001111, etc, up to 11111111. When a large number is represented in binary format, it can be difficult to read. An alternative is to create groups of four bits so that instead of writing 01001011, you would write 0100 1011.

To evaluate the number of combinations in decimal format, you use the number 2 that represents decimal, you elevate it to the power of the position of the bit (0, 1, 2, 3, 4, 5, 6, or 7), and you add the number. This can be done as follows:

2⁷ + 2⁶ + 2⁵ + 2⁴ + 2³ + 2² + 2¹ + 2⁰
= 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1
= 255

Therefore, we 255 possible combinations of eight bits. The combinations can also be represented in hexadecimal format as 0x1, 0x2, ..., 0xA, 0xA1, ..., 0xC8, ..., up to 0xFFFF

In the three numeric systems, we get:

	Decimal	Hexadecimal	Binary
Minimum	0	0x0	0000
Maximum	255	0xff	1111 1111

The minimum storage area offered by the (Intel) computer is the byte. As you know already, a byte is a group of 8 consecutive bits. The amount of memory space offered by a byte can be used to store just a single symbol, such as those you see on your keyboard. These symbols, also called characters, have been organized by the American Standard Code for Information Exchange (ASCII) in a set list. But, ASCII uses only 128 decimal numbers (based on a 7-bit format) to represent symbols counted from 0 to 127. To compensate for the remaining 1 bit, IBM used it to organize special characters, foreign language characters, mathematical symbols, small graphics, etc. Each one of these characters has a decimal, a hexadecimal, and a binary equivalents.

Each one of the characters you see on your keyboard is represented as a numeric value, but whether it appears as a number, a letter, or a symbol, each one of these is considered a character. To display any character on your screen, you can pass it to Write() or WriteLine() and include the character between single-quotes, as follows:

class Exercise
{
    static void Main()
    {
 System.Console.WriteLine('n');
    }
}

The file was saved as Exercise.cs in a folder named Variables on the C:\ drive. When compiled and executed, it displayed the letter n

Characters

In the English alphabet, a letter is one of the following symbols: a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, and Z. Besides these readable characters, the following symbols are called digits and they are used to represent numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. In addition, some symbols on the (US QWERTY) keyboard are also called characters or symbols. They are ` ~ ! @ # $ % ^ & * ( ) - _ = + [ { ] } \ | ; : ' < ? . / , > ". Besides the English language, other languages use other or additional characters that represent verbal or written expressions.

C# recognizes that everything that can be displayed as a symbol is called a character. To declare a variable whose value would be a character, you can use the var keyword and initialize the variable with a character in single-quotes. Here is an example:

class Exercise
{
    static void Main()
    {
        var gender = 'F';

        System.Console.Write("Student Gender: ");
        System.Console.WriteLine(gender);
    }
}

This would produce:

Alternatively, you can use the char keyword. Here is an example:

class Exercise
{
    static void Main()
    {
 char gender = 'M';

 System.Console.Write("Student Gender: ");
 System.Console.WriteLine(gender);
 System.Console.ReadKey();
    }
}

This would produce:

Student Gender: M

Note
All C-based languages support the char data type

Escape Sequences

An escape sequence is a special character that displays non-visibly. For example, you can use this type of character to indicate the end of line, that is, to ask the program to continue on the next line. An escape sequence is represented by a backslash character, \, followed by another character or symbol. For example, the escape sequence that moves to the next line is \n.

An escape can be included in single-quotes as in '\n'. It can also be provided in double-quotes as "\n".

Note:
All C-based languages support these escape sequencces

The C# language recognizes other escape sequences:

Escape Sequence	Name	Description
\a	Bell (alert)	Makes a sound from the computer
\b	Backspace	Takes the cursor back
\t	Horizontal Tab	Takes the cursor to the next tab stop
\n	New line	Takes the cursor to the beginning of the next line
\v	Vertical Tab	Performs a vertical tab
\f	Form feed
\r	Carriage return	Causes a carriage return
\"	Double Quote	Displays a quotation mark (")
\'	Apostrophe	Displays an apostrophe (')
\?	Question mark	Displays a question mark
\\	Backslash	Displays a backslash (\)
\0	Null	Displays a null character

To use an escape sequence, you can also first declare a char variable and initialize it with the desired escape sequence in single-quotes.

The Byte Data Type

A byte is an unsigned number whose value can range from 0 to 255 and therefore can be stored in one byte. You can use it when you know a variable would hold a relatively small value such as people's age, the number of children of one mother, etc. To declare a variable that would hold a small natural number, use the byte keyword. Here is an example:

Note:
C and C++ don't have a byte data type

byte Age;

You can initialize a byte variable when declaring it or afterwards. Here is an example that uses the byte data type:

class Exercise
{
    static void Main()
    {
 byte age = 14;
 System.Console.Write("Student Age: ");
 System.Console.WriteLine(age);

 age = 12;
 System.Console.Write("Student Age: ");
 System.Console.WriteLine(age);
    }
}

This would produce:

Make sure you don't use a value that is higher than 255 for a byte variable, you would receive an error. When in doubt, or when you think that there is a possibility a variable would hold a bigger value, don't use the byte data type as it doesn't like exceeding the 255 value limit.

Alternatively, you can also use the var keyword to declare the variable and initialize it with a small number. Here is an example:

class Exercise
{
    static void Main()
    {
        var age = 14;
        System.Console.Write("Student Age: ");
        System.Console.WriteLine(age);

        age = 12;
        System.Console.Write("Student Age: ");
        System.Console.WriteLine(age);
 System.Console.ReadKey();
    }
}

Instead of a decimal number, you can also initialize an integral variable with a hexadecimal value. When doing this, make sure the decimal equivalent is less than 255. Here is an example:

class Exercise
{
    static void Main()
    {
        var number = 0xFE;

        System.Console.Write("Number: ");
        System.Console.WriteLine(number);
 System.Console.ReadKey();
    }
}

This would produce:

Number: 254
Press any key to continue . . .

Application: Using Bytes

Change the Program.cs file as follows:

class Order
{
    static void Main()
    {
        byte? shirts = null;
        byte? pants  = null;

        shirts = 4;
        pants  = 1;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("========================");
        System.Console.WriteLine("Item Type  Qty");
        System.Console.WriteLine("------------------------");
        System.Console.Write("Shirts      ");
        System.Console.WriteLine(shirts);
        System.Console.Write("Pants       ");
        System.Console.WriteLine(pants);
        System.Console.WriteLine("========================");
        
        System.Console.ReadKey();
    }
}

To execute the application, on the main menu, click Debug -> Start Debugging. This would produce:

-/- Georgetown Cleaning Services -/-
========================
Item Type  Qty
------------------------
Shirts      4
Pants       1
========================

To close the DOS window, press Enter

Signed Byte

A byte number is referred to as signed if it can hold a negative or a positive value that ranges from -128 to 127, which can therefore fit in a byte. To declare a variable for that kind of value, use the sbyte keyword. Here is an example:

class Exercise
{
    static void Main()
    {
 sbyte roomTemperature = -88;

 System.Console.Write("When we entered, the room temperature was ");
 System.Console.WriteLine(roomTemperature);
    }
}

This would produce:

When we entered, the room temperature was -88

A Word

Introduction

A word is a group of 16 consecutive bits. The bits are counted from right to left starting at 0:

Considered as a group of 16 bits, the most right bit of a word, bit 0, is called the least significant bit or low order bit or LO bit or LOBIT. The most left bit, bit 15, is called the most significant bit or high order bit or HI bit or HIBIT. The other bits are referred to using their positions: bit 1, bit 2, bit 3, etc.

Considering that a word is made of two bytes, the group of the right 8 bits is called the least significant byte or low order byte or LO byte or LOBYTE. The other group is called the most significant byte or high order byte or HI byte or HIBYTE.

The representation of a word in binary format is 0000000000000000. To make it easier to read, you can group bits by 4, like this: 0000 0000 0000 0000. Therefore, the minimum binary value represented by a word is 0000 0000 0000 0000. The minimum decimal value of a word is 0. The minimum hexadecimal value you can store in a word is 0x0000000000000000. This is also represented as 0x00000000, or 0x0000, or 0x0. All these numbers produce the same value, which is 0x0.

The maximum binary value represented by a word is 1111 1111 1111 1111. To find out the maximum decimal value of a word, you can use the base 2 formula, filling out each bit with 1:

1*2¹⁵+1*2¹⁴+1*2¹³ + 1*2¹² + 1*2¹¹ + 1*2¹⁰ + 1*2⁹ + 1*2⁸ + 1*2⁷ + 1*2⁶ + 1*2⁵ + 1*2⁴ + 1*2³ + 1*2² + 1*2¹ + 1*2⁰

= 32768 + 16384 + 8192 + 4096 + 2048 + 1024 + 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1

= 65535

To find out the maximum hexadecimal number you can store in a word, replace every group of 4 bits with an f or F:

1111

= 0xffff

= 0xFFFF

= 0Xffff

= 0XFFFF

Short Integers

A word, which is a group of 16 contiguous bits or 2 bytes, can be used to hold a natural number. As we have studied, the maximum numeric value that can fit in a word is 65535. To declare a variable for such a value, you can use the var keyword and initialize the variable with a value between -32768 et 32767. Here is an example:

class Exercise
{
    static void Main()
    {
        var schoolEffective = 1400; // Number of Students

        System.Console.Write("School Effective: ");
        System.Console.WriteLine(schoolEffective);
    }
}

This would produce:

School Effective: 1400
Press any key to continue . . .

Since the byte is used for characters and very small numbers, whenever you plan to use a number in your program, the minimum representation you should use is a word.

A natural number is also called an integer. If you want to declare the variable using a data type, the smallest integer you can store in a word is declared with the short keyword. Because ashort integer is signed by default, it can store a value that ranges from -32768 to 32767. Here is an example program that uses two short integers:

Note:
C++ supports the signed and the signed shortdata types.

class Exercise
{
    static void Main()
    {
 short numberOfPages;
 short temperature;

 numberOfPages = 842;
 temperature   = -1544;

 System.Console.Write("Number of Pages of the book: ");
 System.Console.WriteLine(numberOfPages);
 System.Console.Write("Temperature to reach during the experiment: ");
 System.Console.Write(temperature);
 System.Console.WriteLine(" degrees\n");
    }
}

This would produce:

Number of Pages of the book: 842
Temperature to reach during the experiment: -1544 degrees

Because a short integer handles numbers that are larger than the signed byte, any variable you can declare for a signed byte can also be declared for a short variable.

Unsigned Short Integers

If a variable must hold positive and relatively small numbers, it is referred as an unsigned short integer. Such a variable can be declared using either the var or the ushort keyword. An unsigned short integer can hold numbers that range from 0 to 65535 and therefore can fit in 16 bits. Here are examples:

Note:
the C++ equivalent isunsigned short.

class Exercise
{
    static void Main()
    {
 // These variables must hold only positive integers
 ushort numberOfTracks;
 ushort musicCategory;

 numberOfTracks = 16;
 musicCategory  = 2;

 System.Console.Write("This music album contains ");
 System.Console.Write(numberOfTracks);
 System.Console.WriteLine(" tracks");
 System.Console.Write("Music Category: ");
 System.Console.Write(musicCategory);
 System.Console.WriteLine();
    }
}

This would produce:

This music album contains 16 tracks
Music Category: 2

Application: Using Unsigned Short Integers

To use unsigned short integers, change the file as follows:

class Order
{
    static void Main()
    {
        byte? shirts = null;
        byte? pants  = null;
        ushort? otherItems = null;

        shirts     = 4;
        pants      = 1;
        otherItems = 3;

        System.Console.WriteLine("-/- Georgetown Cleaning Services -/-");
        System.Console.WriteLine("========================");
        System.Console.WriteLine("Item Type  Qty");
        System.Console.WriteLine("------------------------");
        System.Console.Write("Shirts      ");
        System.Console.WriteLine(shirts);
        System.Console.Write("Pants       ");
        System.Console.WriteLine(pants);
        System.Console.Write("Other Items ");
        System.Console.WriteLine(otherItems);
        System.Console.WriteLine("========================");
        
        System.Console.ReadKey();
    }  
}

To execute the program, on the main menu, click Debug -> Start Debugging. This would produce:

-/- Georgetown Cleaning Services -/-
========================
Order Date: 7/15/2002
------------------------
Item Type  Qty
------------------------
Shirts      4
Pants       1
Other Items 3
========================

To close the DOS window, press Enter
Close your programming environment
When asked whether you want to save, click No

Continuation

noreply@blogger.com (Unknown) — Thu, 09 Feb 2012 04:25:00 +0000

Lesson2:

Introduction to C# Projects

Introduction to C# as a Computer Language

A computer programming language, also called a computer language, or a programming language, is used to give instructions to a computer to perform a specific assignment. Like a spoken language, a computer language has meaning words, syntaxes, grammar, formulas, and rules that must be followed to construct meaningful sentences.Just like there are many languages, there are also various types of computer languages. A significant characteristic of computer languages, as opposed to human languages, is that they are categorized by roles or purposes.Hardware is a series of objects that can receive instructions from a computer language. The hardware can consist of all the parts used on a cell phone, a microwave oven, a car, the roller coaster of an amusement park, a health care machine, or a personal computer. Some languages deal with specific hardware or some instructions can target a specific environment, such as a cell phone or a roller coaster. Such an environment uses a specific operating system that cannot be carried from one machine to another. Some other languages do not specify the hardware they are meant to serve.

Some languages are used to solve a specific type of problem and they cannot perform general assignments. For example, some languages used on the Internet are meant to display things on a browser. Such languages cannot perform arithmetic or geometric calculations. Some other languages are used to operate on specific values, such as true or false values. Some other languages are used to solve all, or almost all, types of problems. Languages in this latter category are probably the most regularly used. These are referred to as general purpose languages.C#, pronounced c sharp, is a general purpose programming language used to create instructions for the computer to solve a problem or to assist a user with performing an assignment. C# is a universal language that is used on many operating systems, including Microsoft Windows. C# is one of the languages used in the Microsoft .NET Framework. The Microsoft .NET Framework is a library of objects that create or draw things on the computer.

Introduction to C# Projects

A computer project is a group of files and objects that contain the necessary instructions for the intended application to produced the desired results. A C# project is made of one or more files that contain the instructions of the project. A simple C# project can contain one file that holds all the necessairy instructions. An advanced project would contain more than that. To narrow our goal, our lessons will focus only on the C# language. The language is very huge so much that we may need more than fourty lessons just to cover the essentials. But don't be discouraged. This language is fun and helps you understand many things about computer programming. Also, we assume you don't know any language. So we will learn scratch.

Introduction

Console Applications

The C# language is used to create applications that display on a black window referred to as the DOS prompt or DOS window. Those are the types of applications we will create in our lessons. To start such an application, you can write the instructions in a normal text editor such as Notepad or you can use a programming environment such as Microsoft Visual Studio or Microsoft Visual C# 2010 Express. Our lessons assume that you have access to one of those. We also assume that you have installed the programming environment you will use to follow the lessons, unless you decide to use Notepad, which is part of Microsoft Windows.

To launch Microsoft Visual C# 2010 Express, you can click Start -> (All) Programs -> Microsoft Visual Studio 2010 Express -> Microsoft Visual C# 2010 Express:

To launch Microsoft Visual Studio 2010, you can click Start -> (All) Programs -> Microsoft Visual Studio 2010.

Application: Starting a Project

Start Microsoft Visual C# 2010 Express or Microsoft Visual Studio 2010
To create a new application, on the main menu, click File -> New Project...
In the middle list, click Console Application
Change the Name to gdcs1 (which stands for Georgetown Dry Cleaning Services 1)
Click OK

Creating a File for Code

The programs we will write are meant to give instructions to the computer. You write these instructions in easy to understand English words. We will find out what those words are. This means that a regular instruction uses normal text with alphabetic characters, numbers, and non-readable symbols.

You can write your instructions using any text editor such as Notepad, WordPad, WordPerfect, or Microsoft Word, etc. When writing your instructions, there are rules your must follow and suggestions you should observe. The group of instructions used by your program is also referred to as code.

To assist you with writing code, if you use Microsoft Visual C# Express or Microsoft Visual Studio Professional, it includes a text editor referred to as the Code Editor. If you create your project as a Console Application, a default file would be created and you can customize it. If you start your program as an empty project, you must explicitly add a file to it. To do that:

On the main menu, click Project -> Add New Item...
In the Solution Explorer, right-click the name of the project, position the mouse on Add, and click New Item...

Any of these actions would display the Add New Item dialog box. From there, in the middle list, click Code File. Accept the name or change it. When you click OK, a blank document would display. In the same way, you can add as many files as you need for your project.

Application: Creating a File

To add a file for the code, on the main menu, click Project -> Add New Item...

If you are using Microsoft Visual Studio, in the left list, expand Visual C# Items and click Code.

In the middle list, click Code File
Change the name to CleaningOrder
Click Add

The Primary C# Code

To create the most basic application in C#, there is a very basic code you must write. This code looks as follows:


class Exercise
{

static void Main()
 
{

System.Console.WriteLine("Hello world");
    }


}

This code contains many things, in fact all of its things, we cannot explain at this time. We rather wait for appropriate sections in later lessons. Unfortunately, each one of the items in this code is required:

The class keyword will be introduced in Next Tutorials
The word Exercise is just a name. We will review the rules of names in the next lesson
The curly brackets, { and }, and the parentheses, ( and ), will be introduced in Lesson 4 but various ways of using them will be explained in many other lessons
The use of the static keyword will be explained in Next Tutorials
The meaning of the void keyword will be reviewed in Next Tutorials
Main will be introduced in Next Tutorials and expanded in Next Tutorials
The role of the word System is explained in Next Tutorials
The role of the period "." will be introduced in Next Tutorials
Console and WriteLine will be introduced in Next Tutorials and expanded in other lessons
The double-quotes " will be formally introduced in Next Tutorials

We kept this code to a minimum. Every word and every operator in this code is required but there are various ways that each of these words and operators can be used. For now, please use this code "as is". We can safely promise that by the end of these lessons, you will know everything about those words.

Application: Writing Primary Code

In the empty document, write the following code


class Order
{

  static void Main()
 
{

System.Console.WriteLine("Georgetown Dry Cleaning Services");
     
System.Console.ReadKey();
    }


}

Comments

A comment is a line or paragraph of text that will not be considered as part of your code. There are two types of comments recognized by C#.

To display a comment on a line of text, start the line with two forward slashes //. Anything on the right side of // would be ignored. Here is an example:

// This line will be ignored. I can write in it anything I want

The above type of comment is used on only one line. You can also start a comment with /*. This type of comment ends with */. Anything between this combination of /* and */ would not be read. Therefore, you can use this technique to span a comment on more than one line.

Application: Creating Comments

To create comments, change the file as follows:


//  Application Name: Georgetown Dry Cleaning Services

class Order

{

    //  This application is used to perform processing orders for this business

    static void Main()
{

  /* Always greet the customers before processing an order.


          Check the types of clothes a customer has brought.


            Find out the type of cleaning (starch, etc) the customer wants.

           If there are special needs the customer has, make a note. */


    System.Console.WriteLine("Georgetown Dry Cleaning Services");

System.Console.ReadKey();
    }


}

Managing Files

Introduction

In Microsoft Visual C# 2010 Express and in Microsoft Visual Studio, when a project is made of various files, each file is represented by a label in the top section of the Code Editor.Each file is also represented in the main menu under Windows.

The Solution Explorer

The Solution Explorer is a window that displays a list of the files that make up a project. To access the Solution Explorer:

If the Solution Explorer is not yet showing on the screen:
- On the main menu, click View -> Solution Explorer
- On the Standard toolbar, click the Solution Explorer button
If the Solution Explorer is already showing, click its tab

The Solution Explorer is made of four sections. Like every regular window, the Solution Explorer is equipped with a title bar that displays its name on the left side and three buttons on the right side:

The Window Position button displays a menu when you click it:

The Float option is enabled if the window is docked to a side of the screen. The Float option is disabled if the window is already floating. If the window is docked and you click Float, it would be moved from its docked position and would float. As an alternative to float a docked window, drag its title bar away from its docked position:

To dock a floating window, drag its title bar

Under its title bar, the second section of the Solution Explorer is a toolbar::

The Properties button allows you to display the Properties window
The Show All Files button is used to show the hidden files of the project
As its name indicates, the Refresh button is used to refresh the list of files and resources of the project
The View Code button is used to show the code of a class

The third part of the Solution Explorer is its body. It shows the folders, files, and resources that are part of the current project. To expand a node, you can either click its button or double-click its name. To collapse a node, either click its button or double-click it.

The root of the list is the name of the solution. Under the root is the name of the current project. If the solution contains more than one project, the name of each project is represented under the solution. Inside of the project are its folders, files, and resources. The first item under a project name is References. After the References node, there are the names of the classes that are part of the project.

The fourth part of the Solution Explorer is its tab.

The Properties Window

The Properties window shows the Windows operating system's details of the files or resources used in a project. To display it:

If the Properties window is not yet displaying
- On the main menu, click View -> Properties window
- On the Standard toolbar, click the Properties button
If the Properties window is displaying already, click its tab

The display and rectangular behavior of the Properties window follows the description we had for the Solution Explorer.

To show the operating system's characteristics of a project or a file, in the Solution Explorer, click the object:

If you click a solution, the Properties window would show its name and its location
If you click a project, the Properties window would show its project file
If you click a file, the Properties window would show its name (in the File Name field) and its location (in the Full Path) field

The Properties window displays different fields depending on the item selected in the Solution Explorer. You can change some things in the Properties window. When a field is disabled, it means you cannot modify it.

Accessing or Opening a File

If you are using a text editor to write your code, you can use that editor to open a file. For example, in Notepad, you can click File -> Open... If you are trying to open a C# file, first change the file type combo box to All Files (*). Then locate the file from its folder and click Open.

If a file is a member of the current project, to open it:

On the main menu, click Window and click the name of the file
In the top section of the Code Editor, click the label that holds the name of the file
In the Solution Explorer, double-click the name of the file

If you are using Microsoft Visual C# 2010 Express or Microsoft Visual Studio, to open a file:

On the main menu, click File -> Open File...
On the Standard toolbar, click the Open File button

Any of these actions would display the Open File dialog box. From there, locate the file from its folder and click it. When you click Open, Microsoft Visual Studio will try to open the file. If it can, it would display it inside its interface. If it cannot, it would start looking for a program in the computer that can open the file and hand the job to it. That application would then decide whether it can open the file or not. For example, if you try opening a video (a file with AVI, MOD or another video extension), Microsoft Visual Studio would launch the Windows Media Player that would then try to play the video.

Besides the Code Editor, the integrated development interface (IDE) of the Microsoft Visual C# 2010 is made of various parts, which we will review when necessary.

Solution and Project Management

Introduction

We have seen how to create a console application. Microsoft Visual Studio allows you to create various other types of applications. This is why you should first display the New Project dialog box to select your option. Besides console applications, in future lessons, we will also learn how to create a library using the Class Library option.

Code Snippets

Microsoft Visual C# ships with many skeleton codes you can use and customize. It writes the primary code for you and add all the necessary default behaviors. Once it has done this, you can change or remove any section. To access these code skeletons, in the section of the file where you want to add it, right-click and click Insert Snippet...:

In the menu that comes up, double-click Visual C#:

This would display a list of codes:

If you see the type of code you want to use, double-click it.

In some cases, if you have already written some code, you may want to change it or rather add some code to it. The Code Editor provides some skeleton codes you can use. To use this approach, right-click the code you want to modify and click Surround With... In the list that appears, double-click the desired option.

Code Colors

Code is written in a wide area with a white background. This is the area you use the keyboard to insert code with common readable characters. The Code Editor uses some colors to differentiate categories of words or lines of text.

The colors used are highly customizable. To change the colors, on the main menu, you can click Tools -> Options... In the Options dialog box, in the Environment section, click Fonts and Colors. To set the color of a category, in the Display Items section, click the category. In the Item Foreground combo box, select the desired color. If you want the words of the category to have a colored background, click the arrow of the Item Background combo box and select one:

In both cases, the combo boxes display a fixed list of colors. If you want more colors, you can click a Custom button to display the Color dialog box that allows you to "create" a color.

Indentation 

Indentation is another feature that makes your program easy to read. Indentation is a technique of grouping lines of code by category. To delimit the items of your code, you should indent them by two empty spaces or one tab. Indentation should be incremental. That is, when a line of code appears to be a child of the previous line, the new line should be indented.

To control the indentation of your code, on the main menu, click Tools -> Options... In the left list, expand C#, followed by Formatting and click Indentation. Then change the options on the right side:

After making the changes, click OK to validate or Cancel to ignore.

Saving a Project 

If you are creating your application using a text editor, you must save your file(s) in a folder you will create.

In previous versions of Microsoft Visual C# (namely 2002 and 2003), you always had to formally create a project in order to use one and you always had to save it. After realizing that many of the projects that developers or students create are for experimental purposes, Microsoft provided the ability to only temporarily create a project, then to save it or not. Saving a project allows you to keep it on a medium so you can refer to it later.

When Microsoft Visual Studio 2010 (any edition) is installed, it creates a folder named Visual Studio 2010 in your Documents folder. The Documents folder is called your personal drive or your personal directory. Inside of the Visual Studio 2010 folder, it creates a sub-folder named Projects. By default, this is where it would save your projects, each with its own folder.

To save a project, on the Standard toolbar, you can click the Save All button . Alternatively, on the main menu, you can click File -> Save All. If the project had already been saved but you want to save it under a different name, on the main menu, you can click File -> Save project name As...

Opening a Project 

There are a various ways you can open an existing project:

On the main menu, click File -> Open Project...
On the Start Page, click Open Project...
Press Ctrl + Shift + O

A Solution

A solution is used to coordinate the different aspects of an application that is being created. When you create a project, it represents one detail of the application you have in mind. Besides the code you are writing, you may want to add other items. Instead of one project, in the next sections, we will see that a solution can contain more than one project.

When creating a project, the solution holds the same name as the project. You can see their names in the Solution Explorer:

The solution and a project can have different names. While working on a project, to rename the solution, in the Solution Explorer, you can click the first node, which is the name of the solution starting with Solution. Then, in the Properties window, click (Name) and type the name of your choice:

This name is temporary, especially if you have not yet saved the project. If you want to permanently save a solution for later use, there are two techniques you can use.

If you start saving a project for the first time, it would bring the Save Project dialog box. By default, Microsoft Visual Studio selects your personal directory as the path to the solution. This is called the location. In the location, Microsoft Visual Studio creates a folder as the solution of the project. The solution must have, or must be stored, in its own folder. As mentioned earlier, Microsoft Visual Studio uses the name of the project as the name of the solution. To rename the solution, you can change the string in the Solution Name text box. Remember that you can enter the name of the project in the Name text box. Here is an example:

When you save a project (for the first time), by default, Microsoft Visual C# creates a new folder for it in the My Documents\Visual Studio 2008\Projects folder. It uses the name of the solution to name the folder. It creates some files and stores them in that new folder. Then, it creates a sub-folder, using the name of the project, inside of the folder of the solution. Besides the sub-folder with the name as the project, it creates another folder named debug. It also creates another folder named Debug in the sub-folder of the name of the project. In each folder and some other folders, it creates some files that we will not pay attention to for now.

If the project had already been saved but you want to change the name of the solution, on the main menu, you can click File -> Save solution-name.sln As... This would bring the Save File As dialog box where you can specify the name of the solution and click Save.

Building a Project

After creating a project and writing code, you may want to see the result. To do this, you must first build the application. This would create an executable.

To allow you to create programs, a computer language such as C# is equipped with an application named a compiler. A compiler is a computer program made of internal other sub-programs. One of the sub-programs, in fact probably the first, of a compiler is called a parser. A parser "scans" a file that contains (part of) the program. It checks the syntax, keywords, unknown words, and some other routines. If the parser finds a problem, which could be anything, either it stops or it continues making a list of the mistakes it found. Then it displays this list to you to fix. Sometimes it would point to the exact line where the/a problem was found. Sometimes it would point to the line where the problem showed its impact although the problem may be found somewhere else. With experience, you will know how to fix the programs or troubleshoot the problems.

If the parser doesn't find any problem, or after you have fixed the problems, it (the parser) passes its result(s) to the compiler. The compiler calls another program called a linker. If the program contains just one file, the linker considers it. If the program contains more than one file, the linker considers them. The linker gathers some of the files that the C# compiler shipped with (those files that your program needs in order to work, since your program doesn't need all possible files that the .NET Framework provides), puts them together ("links" them) with your file(s) to get your instructions in a manner that can produce a suitable result. If there is no significant problem, the compiler creates the program. This doesn't mean that everything is alright, it only means that the compiler thinks that everything is alright: it is still possible that the result may not be what you would expect. We will come back to these issues when studying debugging.

To make your life easier, all of the sub-programs (parser, linker, debugger, etc) that ship with C# are grouped in one large program: the compiler. Therefore, from now on, we will use the word "compiler" to refer to the program you use to "translate" your English instructions into a computer-based language.

The compiler that Microsoft created, and that we will use, that is, the compiler of the Microsoft .NET Framework is called csc. Like most other programs, it has the extension .exe. This csc name is not standard. This means that another C# compiler may have another name; csc.exe is just the name of the compiler we will use.

The csc compiler is freely available if you download the .NET Framework from the Microsoft web site.

To build an application at the Command Prompt, you use the csc.exe compiler. After download the .NET Framework, you must install it. What interests us is the csc.exe application. By default, it is installed inC:\Windows\Microsoft.NET\Framework\v4.0.21006.

You should add the path of the csc.exe to the Path of the Environment Variables. To start, use a file utility such as Windows Explorer and display the folder where csc is installed.

Select the path in the top combo box and copy it to the clipboard. Start the Control Panel. Click System and Security:

In the System and Security section, click System:

In the System window, click Change Settings. In the System Properties dialog box, click the Advanced tab. Click the Environment Variables button:

In the System Variables section, double-click Path or click it and click Edit:

Press the End key, type a semi-colon ";". Paste the value you had copied from the clipboard:

Click OK three times.

Open the Command Prompt. Type CD\ and press Enter to move to the root drive. Type CD and a space, followed by the folder (and sub-folder(s)) where the file is located, and press Enter. To compile, type csc followed by the name of the file and its extension:

The file produced from this operation has the extension .exe. By default, it holds same name as the file you had used. If you want to get an executable using a name of your choice, after csc, type /out: followed by the name you want, followed by a .exe extension, followed by a space, and followed by the name of the file you had created, with its extension. The formula to follow would be:

csc /out:NameOfExecutate.exe Filename.cs

The NameOfExecutate represents the name you want the executable to have. If the name you want is in one word, you can just type it. If you want a name made of various words, you can include those words in double-quotes.

If you are creating your application using a text editor and if you create many files, when compiling the project, you must remember to reference each file. To do that, in the last section, add the name of each file with its extension:

csc FileName1.cs FileName2.cs FileName_n.cs

The executable you get is the one you can use on other computers and that you can distribute to other people.

Executing a Project

After building a project, you and your users can execute it. If you are working from the Command Prompt, to execute the project, type the name of the file that has the .exe extension and press Enter:

If you are working from Microsoft Visual C# 2010 Express or from Microsoft Visual Studio, to execute an application, on the main menu, you can click Debug -> Start Debugging.

Application: Executing an Application

To execute the application, on the main menu, click Debug -> Start Debugging
After viewing the result in a DOS window, press Enter to close it
Close Microsoft Visual C# 2010 Express or Microsoft Visual Studio
When asked whether you want to save, click No

C# Tutorial Basics to Advance

noreply@blogger.com (Unknown) — Wed, 08 Feb 2012 14:09:00 +0000

Lesson1:
Introduction to Microsoft Visual Studio

C#, pronounced c sharp, is a programming language that can be used to give instructions to a computer. The instructions can be written from a text editor such as Notepad. Another way is to use a programming environment that is equipped with many tools that make it easy to work on projects, to create the necessary files, and to distribute a completed application.Many programming environments are available. Probably the most popular programming environment you can use to write C# instructions is Microsoft Visual Studio. This is commercial application available for purchase from Microsoft. If your primary goal is to learn the C# language, Microsoft provides a free programming studio you can use: Microsoft Visual C# 2010 Express.

Starting Microsoft Visual C# Express

To launch Microsoft Visual C# 2010 Express, you can click Start -> (All) Programs -> Microsoft Visual Studio 2010 Express -> Microsoft Visual C# 2010 Express:

The Microsoft Visual Studio Interface

The Main Menu

The top section of Microsoft Visual Studio displays the main menu divided in categories such as File or Edit. The main menu is used like the menu of a normal application.

The Toolbars

Under the main menu, there is a toolbar. Normally, when the studio is launched, it displays the Standard toolbar as its default. Some additional toolbars will display in response to an action from you. Still, you can display other toolbars if you want. To do this:

On the main menu, click View -> Toolbars and click the toolbar of your choice
Right-click the main menu or any toolbar. In the that appears, click the desired toolbar

Toolbars are used the same way they are in other applications.

Microsoft Visual Studio's menus and toolbars can be customized. You can customize a menu category on the main menu by adding a menu item to it. You can customize a toolbar by adding a button to it. To start, right-click anything on the main menu or on any toolbar and click Customize... For example, imagine you want to add an item named Start Without Debugging to the left side of the Start button:

To do this:
1. Right-click the main menu or a toolbar and click Customize
2. On the Customize dialog box, click the Commands tab
3. Click the Toolbars radio button
4. In the Toolbars combo box, select the toolbar that will host the button. For our example, that would be Standard
5. In the Controls list, click the button that will come after the new button. For our example, that would be Start / Continue:
6. Click Add Command...
7. In the Categories list of the Add Command dialog box, select the category that has the button you want. For our example, that would be Debug
8. In the Commands list, click the desired button or menu item. For our example, that would be Start Without Debugging
9. After making the selection, click OK
10. On the Customize dialog box, click Close:
In the same way, you can customize any toolbar and any menu category.

The Start Page

The Start Page is the main body of Microsoft Visual Studio or Microsoft Visual C# Express when it has been launched. It starts on top with a tab labeled Start Page. The main body of Microsoft Visual C# Express displays Microsoft Visual C# 2010 Express. The left section shows two labels: New Project... and Open Project... When some projects have been previously created or used, their names appear under Open Project... When you work on a project, the Start Page is usually in the background but it is represented by a tab. At any time, to display the Start Page:
- You can click the Start Page label in the top section of the Code Editor
- On the main menu, you can click View -> Start Page
Showing and Closing a Window

When you start or open a project, the studio makes some windows available. These are the most regularly used windows. If you think that one of them is not regularly used in your types of assignments, you can remove it from the screen. To hide a window, you can click its Close button .

All of the windows you can use are listed in the View menu. Therefore, if a window is not displaying, you can click View on the main menu and click a window of your choice.

Auto Hiding a Window

When working on a project, you will use a set of windows that each accomplishes a specific purpose. Some windows are represented by an icon but hide the rest of the body. To display such a window, you can position the mouse on it. This would expand the window:

If you expand a window, it would display a title bar with three buttons. One of the button is called Auto Hide:

If you expand a window but find out you don't need it any more, you can just move the mouse away. The window would return to its previous state. Based on this functionality, if you are working with a window and move the mouse away, it would retract. If you need it again, you would have to reopen it using the same technique. If you are going to work with a certain window for a while, you can keep it open even if you move the mouse away. To do this, you can click the Auto Hide button. If clicked, the Auto Hide button changes from pointing left to pointing down:

By default, the studio installs some windows to the left and some others to the right of the screen. You can change this arrangement if you want. To do this, expand a window, then click its title bar and start dragging. While you are dragging, to assist you with a new position, the studio displays five boxes:

Docking a Window to a Side of the Studio

To position a window on one side of the studio, drag its title bar to the box that represents that side. When you get to a side, a transparent blue rectangle would be drawn to indicate the possible position. Drop the window to either the most left guiding box to position it to the left of the screen, or to the most right guiding box to position it to the right of the screen. Here is an example:

or

To position a window to the top or the bottom side of the studio, drag its title bar to either the most top guiding box to position it to the top of the studio or to the most bottom guiding box to position it to the bottom of the studio. Here is an example:

Docking a Window Above or Below Another

To make two windows share an area, you can position one above or below an existing window. Of course, you must first have a window as reference. Then, drag the second window to the existing window. Drop it in the top or the bottom guiding box of the middle big box.

This

Becomes

Floating Windows

Most of the windows you will use are positioned on one side of the screen. If you want, you can have a window that stays on top of other windows but is not "glued" to one side. Such a window is said to float. To float a window, drag its title bar and release it somewhere in the middle of the screen but not on a guiding box.

When a window is floating, it displays a Maximize button on the title bar. If you click this button, the window occupies the whole interface of Microsoft Visual Studio. In the same way, if you double-click the title bar, the window gets maximized.

If a window is currently floating and you want to dock it, right-click its title bar and click Dock:

If a window is currently docked and you want to float it, right-click its title bar and click Float.

Coupling Windows

You can make two or more windows share one side of the screen or to share an area. To do this, first expand and dock the window that you will use as the base (or reference). Then, drag the title bar of the window that will share the area to its target until the bottom part of the base window shows a highlighted and a non highlighted area:

Then release the mouse:

To remove a window that shares an area, drag its tab away:

To position a window to the left or the right of an existing window, first drag the second window to where the existing window is. Then click the left (or the right, depending on the side you want) guiding box of the multiple-box.

This

becomes this

In the same way, you can make two or more windows share the same area.

Tabbed Windows

You can make a window display its tab in the top section of the Code Editor and share the area with it. There are two ways yon do it:
- You can drag a window and drop it on the tab of the Start Page.
This

becomes this

If a window is already represented with a tab on top of the Code Editor, you can drag the second window and drop it to the left or of the right tab of the existing window.
- You can right-click Dock as Tabbed Document