Objectives

In this session, you will learn to:

Describe memory allocation
Use structure
Use enumerations
Implement arrays
Describing Memory Allocation

The memory allocated to variables is referred to in the

following ways:
Value types: Contains data. Built-in data types, such as int, char,
and float are value types.
Reference types: Contains address referring to a block of
memory. Data types, such as string and class are reference
types.

Let us understand the concept of memory allocation in detail.

Describing Memory Allocation (Contd.)

Value Type:

int Num1; Variable Declaration

Num1=50; Num1
Initialization
50

Both Num1 and Num2 Contain 50

Num2

50
int Num2; Variable Declaration
Num2=Num1; Initializing Num2 with Num1
Describing Memory Allocation (Contd.)

Value Type (Contd.):

Num1
New Value Assigned to Num1 Num1=60;
60

The Value of Num2 Remains Unaffected Num2

50
Describing Memory Allocation (Contd.)

Reference Type:

Car Suzuki= new Car(); Object of Class Car()

Suzuki.Model=10; Initialization
Member Variable of Class Car()

Car Mercedes; Object of Class Car()

Mercedes=Suzuki; Initializing Mercedes with Suzuki
Describing Memory Allocation (Contd.)

Reference Type (Contd.):

Suzuki
Referring to Memory
***
Location Where the Data
is Stored

10

Mercedes
Referring to Memory
***
Location Where the Data
is Stored
Using Structure

A structure is a value type data type.

When you want a single variable to hold related data of
various data types, you can create a structure.
To create a structure you use the struct keyword.
The following code shows the example of a declaring a
structure names Bill_Details:
struct Bill_Details
{ public string inv_No; // Invoice Number
string ord_Dt; // Order Date
string custName; // Customer name
Using Structure (Contd.)

public string product; // Product Name

public double cost; // Cost of the product
public double due_Amt; // Total amount due
}
Using Enumeration

Enumeration is a value type data type.

Enumeration contains its own values and cannot inherit or
pass inheritance.
Enumerators allows you to assign symbolic names to
integral constants.
To enumerate, you can use the enum keyword.
Declaring an Enumeration

The following code is an example of declaring an

enumeration named Days:
enum Days { Sat, Sun, Mon, Tue, Wed, Thu, Fri };
Implementing Enumerations

After declaring the enumeration type, you can use the

enumeration type in the same manner as any other data
type:
int First_Day = (int)Days.Sat;
int Last_Day = (int)Days.Fri;
Implementing Arrays

An array is a collection of values of the same data type.

The following figure shows the array structure in the
system’s memory.

Index Index

Value 0 Value 6
Declaring an Array

An array needs to be declared before it can be used in a

program.
You can declare an array by using the following statement:
datatype[] Arrayname;

Let us understand the explanation of the various elements of

the array declaration through an example.
Declaring an Array (Contd.)

int[ ] Score; Datatype

Is used to specify the
data type for the
elements
Declaring an Array (Contd.)

int[ ] Score; []
Is used to specify the
rank of the array
Declaring an Array (Contd.)

int[ ] Score; Arrayname

Is used to specify the
name of the array using
which the elements of the
array will be initialized and
manipulated
Initializing and Assigning Values to Array

In C#, you can initialize the array variable and can assign
values to the array elements. In addition, you can copy the
array variable to another variable.
During initialization, you need to use the new keyword to
create an instance of the array. In addition, the size of the
array is also specified while it is initialized.
The following is an example of array initialization:
int[] Score; // Array declaration
Score = new int[10]; //Array Instance
Initializing and Assigning Values to Array (Contd.)

You can assign values to each element of the array by using

the index number, which is called the array subscript of the
element.
The following is an example of assigning values to the array:
int[] Score = new int[3];
Score[0]=10;
Or
int[] Score={5,10,15};
When you copy the array variable, both the source and
target variable refer to the same array instance in the
memory.
The following is an example of copying the array variables:
int[] Source = new int[10] {0, 1, 2, 3, 4};
int[] Target= Source;
Manipulating Array Elements

When an array is initialized, you can access the element

values and manipulate them.
The foreach loop is specially used for manipulating arrays.
The following is the syntax of the foreach loop:
foreach (type identifier in expression)
{
//statements
}
Manipulating Array Elements (Contd.)

The following is the example of foreach loop:

int[] Numbers = { 4, 3, 2, 1, 0, -1, -2, 9, 5 };
Console.WriteLine("The Contents of an Array
is:");
foreach (int K in Numbers)
{
Console.WriteLine("{0} \t",K);
}
Manipulating Array Elements (Contd.)

While declaring a method if you are not sure about the

number of arguments passed as a parameter, you can use
the param array.
The following is the example of param array:
public int Adding_ArrayElement(params int[]
List)
{
int Total = 0;
foreach ( int I in List )
{
Total += I;
}
return Total;
}
Demo: Matrix Subtraction Using Arrays

Problem Statement:
David, a student of California University, is currently pursuing
mathematics. He is working on a project named Matrix
Subtraction. He needs to perform the following tasks for his
project:
Accept data in two Arrays.
Perform the subtraction operation.
Verify the value of subtraction.
Help David to create the C# program using Visual Studio IDE.
Demo: Matrix Subtraction Using Arrays (Contd.)

Solution:
To solve the preceding problem, David needs to perform the
following tasks:
1. Create a console-based application for Matrix Subtraction.
2. Build and execute an application.
Multidimensional Arrays

The rank value of the array is also known as the dimension

of the array.
The array can be single dimensional or multidimensional.
Single dimensional array stores data in a row.
Multidimensional array stores data using different
dimensions.
The following figure is a graphical representation of values
stored in a single dimensional array and a multidimensional
array.
int [] Num; int[,] Num;

0 1 2 3 4 1

0 1 2 3 4
Multidimensional Arrays (Contd.)

The Array class is the base class for all the arrays in C#.
The Array class provides properties and methods to work
with arrays.
Properties: The following table explains some of the most
commonly used properties of the Array class.

Properties Explanation

Length Returns the total number of items in all the dimensions of an

array
Rank Returns the total number of items in all the dimensions of an
array
IsFixedSize Return a value indicating if an array has a fixed size or not

IsReadOnly Returns a value indicating if an array is read-only or not

Multidimensional Arrays (Contd.)

Methods: The following table explains some of the most

commonly used methods of the Array class.

Properties Explanation
Sort Performs sort operation on an array passed to it as a parameter
Clear Removes all items of an array and sets a range of items in the
array to 0
GetLength Returns the number of items in an Array
GetValue Returns the value of the specified item in an Array
IndexOf Returns the index of the first occurrence of a value in a
one-dimensional Array or in a portion of the Array
Summary

In this session, you learned that:

Memory allocated to variables are of two types, value type and
reference type.
Value-types are the simplest types in C#. Variables of value
types directly contain their data in the variable.
Reference-types variables contain only a reference to data. The
data is stored in a separate memory area.
A value type variable holds its value in the stack.
A reference type variable holds a reference to an object in the
heap.
To hold related data of various data type in single variable,
structures are used.
C# provides the features of enum to create user defined data
types with numbers as an index value to access them.
An array is a collection of values of the same data type.
Summary (Contd.)

The foreach statement interprets the common loop process

and removes the need for you to check the array size.
Param arrays are used in the methods with parameter list when
the total number of parameters is not known.