Home > Articles

Introducing C#

  • Print
  • + Share This
This chapter is from the book

This chapter is from the book

Data Types

An important part in the life of a C# programmer is the management of data types. Just as in C and C++, every variable has a fixed data type. Every data type provides a rich set of operators that can be used to perform a very special operation. Objects can be seen as data types as well, but we'll take a closer look at that later in this book.

Predefined Data Types

C# supports a list of predefined data types. In this section, we examine the most important types. Table 3.1 contains an overview.

Table 3.1 Predefined Data Types

C#

Mono

Signed

Memory

Range

sbyte

System.Sbyte

Yes

1 byte

–128 to 127

short

System.Int16

Yes

2 bytes

–32768 to 32767

int

System.Int32

Yes

4 bytes

–2147483648 to 2147483647

long

System.Int64

Yes

8 bytes

–9223372036854775808 to 9223372036854775807

byte

System.Byte

No

1 byte

0 to 255

ushort

System.Uint16

No

2 bytes

0 to 65535

uint

System.Uint32

No

4 bytes

0 to 4294967295

ulong

System.Uint64

No

8 bytes

0 to 18446744073709551615

float

System.Single

Yes

4 bytes

–1.5x10-45 to 3.4 x x1038

double

System.Double

Yes

8 bytes

–5.0x10-324 to 1.7x10308

decimal

System.Decimal

Yes

12 bytes

1.0x10-28 to 7.9x1028

char

System.Char

 

2 bytes

Unicode characters

boolean

System.Boolean

 

1 byte

True or false


After this brief overview, we'll show you how variables and data types can be used efficiently. The following example shows how a variable can be declared and displayed on screen:

using System;

class  Hello
{
    public static void Main()
    {
        int x = 3;
        Console.WriteLine("The value is " + x );
    }
}

Declaring a variable works just like in C and C++. The way data is displayed is reminiscent of Java. We use the plus operator to connect two strings with each other. The output is not surprising:

[hs@localhost csharp]$ mono hello4.exe
The value is 3

Using the plus operator is truly easy, but it could also be a danger. In most cases, the plus operator is used as a mathematical operator. If it's used differently, the result might be a bit unexpected:

using System;

class  Hello
{
    public static void Main()
    {
        uint x = 3;
        Console.WriteLine("The value is " + x + 1 );
        Console.WriteLine("The value is " + (x + 1) );
    }
}

We perform two operations that look pretty similar. However, the results differ significantly:

[hs@localhost csharp]$ mono hello5.exe
The value is 31
The value is 4

The first operation connects two strings. The second example performs an addition. As you can see, the plus operator has more than just one meaning.

One-Dimensional Arrays

It's frequently necessary to store more than just one value in a variable. Fields can be used for this purpose. Arrays are needed to store a set of information. The following example explains how things work:

using System;

class  Hello
{
    public static int Main()
    {
        String[] son = { "Hans", "Peter", "Olaf" };
        Console.WriteLine("Son: " + son[0] );

        String[] daughter = new string[3] {
            "Paula", "Petra", "Clara" };
        Console.WriteLine("Daughter: " + daughter[2] );

        return 1;
    }
}

Two arrays are created. Names of men are stored in the first array. To tell Mono that the array called son contains more than just one value, we have to use brackets. To read data in an array, indexes are required. Just as in most other programming languages, the index of an array does not start with 1 but with 0. In the first part of our example, we try to access the array.

The second part of the example shows a slightly different way to create an array. In this case, the size of the array is defined explicitly. Again the elements in the array are accessed using an index. Let's see what comes out when the program is executed:

[hs@duron csharp]$ mono array.exe
Son: Hans
Daughter: Clara

The values in an array usually aren't static. To modify a value inside an array, the = operator can be called. The next example documents how a value inside an array can be overwritten and how to modify an array:

using System;

class  Hello
{
    public static int Main()
    {
        String[] daughter = new string[3] {
            "Paula", "Petra", "Clara" };
        tochter[2] = "Eva-Maria";
        Console.WriteLine("daughter: " + tochter[2] );

        return 1;
    }
}

In this scenario, the third element is replaced with a string that's longer than the original value. The main idea of this example is that you need not worry about memory management anymore because this task is done by Mono. C programmers will know that the operation we've performed is not that simple when using C or C++.

The result is displayed as expected:

[hs@duron csharp]$ mono array.exe
daughter: Eva-Maria

Multidimensional Arrays

Multidimensional arrays enable the user to implement complex and efficient data structures. Whenever it's necessary to store combinations of different elements, multidimensional arrays are definitely a good idea. C# provides a rich set of sophisticated methods for managing data structures. The following example shows how names can be stored:

using System;

class  Hello
{
    public static int Main()
    {
        string[ , ] data = new string[2, 2];

        data[0, 0] = "Paul"; data[1, 0] = "Rudi";
        data[0, 1] = "Ruth"; data[1, 1] = "Evi";

        Console.WriteLine("Value: " + data[1, 1] );

        return 1;
    }
}

As you can see in the example, many names are stored in a two-dimensional array. Women can be found in the second axis. The first axis enables us to access the names. The next listing shows what the results look like:

[hs@duron csharp]$ mono marray.exe
Value: Evi

When working with arrays, it can be interesting to find out how many axes an array contains. In most programming languages, multidimensional data structures are truly painful. However, in C#, those problems have nearly been solved for you because the programming language itself does most of the work. Let's have a look at an additional example:

using System;

class  Hello
{
    public static int Main()
    {
        string[ , ] a = new string[2, 2];
        string[ ,,, ] b = new string[2, 2, 2, 2];

        Console.WriteLine("a: " + a.Rank );
        Console.WriteLine("b: " + b.Rank );

        return 1;
    }
}

At the beginning of the program, two arrays are created. The number of axes can be found in a variable called Rank.

Let's see which result we get:

[hs@duron csharp]$ mono main.exe
a: 2
b: 4
  • + Share This
  • 🔖 Save To Your Account