Chapter 3 - Core C# Programming Constructs Part 2

The content and code of this article is referenced from book Pro C#5.0 and the .NET 4.5 Framework by Apress. The intention of the writing is to review the konwledge and gain better understanding of the .net framework. 

 

1. Methods and parameters modifiers

Methods can be implemented within the scope of classes or structures (as well as interface type) and may decorated with various keywords (e.g static, virtual, public, new) to qualify their behavior. 

C# parameter modifiers

(None)	If a parameter is not marked with a parameter modifier, it is assumed to be passed by value, meaning the called method receives a copy of the orginal data.
out	Output parameter must be assigned by the method being called, and therefore, are passed by reference. If the called method failed to assign output parameters, you are issued a compiler error.
ref	The value is initially assigned by the caller and may be optionally reassigned by the called methods. No compiler error is generated if the called method fails to assign a ref parameter.
params	The parameter modifier allows you to send in a variable number of arguments as a single logical parameter. A method can only have a single params modifier, and it must be the final parameter of the method.

1.1 the default by value parameter-passing behavior

1.2 The out modifier

Methods that have been defined to take output parameters (via the keyword out) are under obligation to assign them to an appropriate value before exiting the method scope. 

public static void Add(int x, int y, out int answer)
{
    answer = x + y; //answer must be assigned value, as it is out parameter
}

 

The advantage of using out parameters is it allows the caller to obtain multiple ouputs from a single method invocation. 

public static void FillTheseValues(out int a, out string b, out bool c)
{
    a = 9;
    b = "test";
    c = true;
}

 

1.3 The ref modifier

Reference parameters are necessary when you wish to allow a method to operate on (and usually change the values of ) various data points declared in the caller's scope. And reference type must be initialized before they are passed to the method. 

        public static void Main (string[] args)
        {    
            string str1 = "Flip";
            string str2 = "Flop";
            SwapString (ref str1, ref str2);
            Console.WriteLine ("After :{0}, {1}", str1, str2);
        }

        public static void SwapString(ref string s1, ref string s2)
        {
            string temStr = s1;
            s1 = s2;
            s2 = temStr;
        }

 

1.4 The params modifier

The params keyword allows you to pass into a method a variable number of identically typed parameters as a single logical parameters. As well, arguments marked with the params keyword can be processed if the caller sends in a strongly typed array or a comma-delimited list of items. 

 

        public static void Main (string[] args)
        {    
            //commo delimited number
            double avg = CalculateAverage (4.0, 3.5, 2.8, 10.0);
            //pass an array of doubles
            double[] data = {4.5, 6.7, 8.9};
            avg = CalculateAverage (data);
        }

        //the method has been defined to take a parameter array of doubles
        public static double CalculateAverage(params double[] values)
        {
            double sum = 0;
            if (values.Length == 0)
                return sum;

            for (int i = 0; i < values.Length; i++) {
                sum += values [i];
            }
            return (sum / values.Length);
        }

 

The technique is nothing more than a convenience for the caller, given that the array is created by the CLR as necessary. 

 

1.5 optional parameters

C# allows you to create methods that can take optional arguments. The technique allows the caller to invoke a single method while omitting arguments deemed unnecessary, provided the caller is happy with the specified defaults. 

 

        public static void Main (string[] args)
        {    
            EnterLogData ("error occurs"); //invoke method without owner parameter
            EnterLogData ("error occurs", "manager"); //invoke method with both parameters
        }

        //parameter owner has a default value of programmer
        static void EnterLogData(string message, string owner = "programmer")
        {
            Console.WriteLine ("{0}, {1}", message, owner);
        }

 

One important thing to be aware of, is that the values assigned to an optional parameter must be known at compile time, and can not be resolved at runtime. 

        //parameter owner has a default value of programmer
        static void EnterLogData(string message, string owner = "programmer", DateTime timeStamp = DateTime.Now)  //compile error, datetime value is resolved at runtime
        {
            Console.WriteLine ("{0}, {1}", message, owner);
        }

 

1.6 Invoking methods using named parameters

Another language feature found in C# is support for named arguments. Named arguments allow you to invoke a method by specifying parameter values in any order you choose. Thus, rather than passing parameters solely by position, you can choose to specify each argument by name using a colon operator. 

        public static void Main (string[] args)
        {    
            EnterLogData (message:"error occurs", owner:"programmer"); //invoke method with name parameters

        }
            
        static void EnterLogData(string message, string owner)
        {
            Console.WriteLine ("{0}, {1}", message, owner);
        }

 

1.7 Method overloading

Method overloading, when you define a set of identically named methods that differ by the number (or type) or parameters, the method in question is said to be overloaded. 

        public static void Main (string[] args)
        {    
            int answer = Add (4, 5);
            double answerD = Add (4.0, 5.5);
        }
            
        static int Add(int x, int y)
        {
            return x + y;
        }

        static double Add(double x, double y)
        {
            return x + y;
        }

 

2. Arrays 

An Array is a set of data items, accessed using a numerical index. 

 

static void SimpleArray()
{
    int[] myInts = new int[3]; //index starts from 0
    myInts [0] = 100;
    myInts [1] = 200;
    myInts [2] = 300;

    foreach (int i in myInts) {
        Console.WriteLine (i);
    }
}

2.1 Array initialization syntax

You are able to fill the items of an array using C# array initialization syntax. 

 

static void SimpleArray()
{
    int[] myInts = { 10, 20, 30 }; //array initialization with curly brackets

    foreach (int i in myInts) {
    Console.WriteLine (i);
}

 

Notice that when you make use of this syntax, you do not need to specify the size of the array, given that this will be inferred by the number of items within the scope of the curly brackets. Also the use of new keyword is optional. 

 

2.2 Implicitly typed local arrays

The var keyword can be used to define implicity typed local arrays. 

 

        static void SimpleArray()
        {
            var a = new int[] {10, 20, 30}; // int array
                    
            foreach (var i in a) {
                Console.WriteLine (i);
            }

        }

 

2.3 Defining an array of objects

In most cases, when you define an array, you do so by specifying the explicit type of item that can be within the array variable. As the System.Object is the ultimate base class to each and every type in the .net system, if you define the array of objects, the subitems could be anything at all. 

 

        static void ArrayOfObjects()
        {
            object[] myObjects = new object[4];

            myObjects [0] = 10;
            myObjects [1] = true;
            myObjects [2] = "test";
            myObjects [3] = 23.3;

            foreach (object obj in myObjects) {
                Console.WriteLine ("Type : {0}, Value : {1}", obj.GetType (), obj);
            }
        }

 

2.4 Multidimensional arrays

In addition to the single-dimension array you have seen so far, C# also supports two varieties of multidimensional arrays. The first one is termed a rectangular array, which is simple an array of multiple dimensions, where each row is of the same length. 

 

        static void RectMultidimensionalArray()
        {
            int[,] myMatrix = new int[6, 6];

            for (int i = 0; i < 6; i++) {
                for (int j = 0; j < 6; j++) {
                    myMatrix [i, j] = i * j;
                }
            }

            //print value 
            for (int i = 0; i < 6; i++) {
                for (int j = 0; j < 6; j++) {
                    Console.Write (myMatrix [i, j] + "\t");
                }
                Console.WriteLine ();
            }

        }

 

The second type of multidimensional array is termed a jagged array, which contains some number of inner arrays, each of which may have a different upper limit. 

        static void JaggedMultidimensionalArray()
        {
            int[][] myJagArray = new int[5][];

            for (int i = 0; i < myJagArray.Length; i++) {
                myJagArray [i] = new int[i + 7];
            }

            for (int i = 0; i < 5; i++) {
                for (int j = 0; j < myJagArray [i].Length; j++) {
                    Console.Write (myJagArray [i] [j] + " ");
                }
                Console.WriteLine ();
            }
        }

 

2.5 Arrays as arguments or return values

You are free to pass array as an argument or receive it as a member return value. 

 

        static void PrintArray(int[] myInts)
        {
            foreach (int i in myInts) {
                Console.WriteLine (i);
            }
        }        

 

2.6 System.Array base class

Each array you create gathers much of its functionality from the System.Array class. 

Clear()	This static method sets a range of elements in the array to empty values
CopyTo()	This method is used to copy elements from the source array into the destination array
Length	This property returns the number of items within the array
Rank
Reverse()	This static method reverse the content of a one-dimensional array
Sort()	This static method sorts a one-dimensional array of intrinsic type.

 

 

        static void SystemArrayFunctionality()
        {
            string[] myString = { "text 1", "text 2", "text 3" };
            //reverse the string
            Array.Reverse (myString);
            foreach (string s in myString) {
                Console.WriteLine (s);
            }

            //clear the array
            Array.Clear(myString, 0, 2);
            foreach (string s in myString) {
                Console.WriteLine (s);
            }
        }    

 

3. Enum type

When building a system, it is often convenient to create a set of symbolic names that map to known numerical values. C# supports the notion of custom enumerations for this very reason.

 

        enum EmpType
        {
            Manager, //0
            Grunt, //1
            Contractor, //2
            VicePresiden //3
        }

 

The EmpType enumeration defines four named constants, corresponding to discrete numerical values. By default, the first element is set to value zero, followed by an n + 1 progression. You are also free to change the initial value. 

        enum EmpType
        {
            Manager = 102, //102
            Grunt, //103
            Contractor, //104
            VicePresiden //105
        }

Enumerations do not necessarily need to follow a sequential ordering. 

        enum EmpType
        {
            Manager = 102, 
            Grunt = 10, 
            Contractor = 8, 
            VicePresiden = 1 
        }

 

 

3.1 underlying storage for an enum

By default, the storage type used to hod the values of an enumeration is System.Int32; however, you are free to change this you liking. 

        enum EmpType : byte
        {
            Manager = 102, 
            Grunt = 10, 
            Contractor = 8, 
            VicePresiden = 1 
        }

 

3.2 declare enum

Enumerations are nothing more than a user-defined data type, you are able to use them as function return values, method parameters, local variables, and so forth. 

 

        public static void Main (string[] args)
        {    
            EmpType emp = EmpType.Contractor;
            AskForBonus (emp);
        }
            
        static void AskForBonus(EmpType e)
        {
            switch (e) 
            {
            case EmpType.Manager:
                Console.WriteLine ("manager bouns");
                break;
            case EmpType.Grunt:
                Console.WriteLine ("grunt bouns");
                break;
            case EmpType.Contractor:
                Console.WriteLine ("contractor bouns");
                break;
            case EmpType.VicePresiden:
                Console.WriteLine ("vp bouns");
                break;
            default:
                Console.WriteLine ("default bouns");
                break;
            }
        }

 

 

 

3.3 System.Enum type

The interesting thing about .net enumerations is that they gain functionality from the System.Enum class type. This class defines a number of methods that allow you to interrogate and transform a given enumeration. One helpful method is the static Enum.GetUnderlyingType()

 

        public static void Main (string[] args)
        {    
            EmpType emp = EmpType.Contractor;
            AskForBonus (emp);

            Console.WriteLine ("EmpType uses a {0} for storage", Enum.GetUnderlyingType (emp.GetType()));
            //or
            Console.WriteLine ("EmpType uses a {0} for storage", Enum.GetUnderlyingType(typeof(EmpType)));
        }

 

 

3.4 Dynamically discovering an enum's name/value pairs

Beyond the Enum.GetUnderlyingType() method all c# enumerations support a method named toString(), which returns the string name of the current enumeration's value. 

        public static void Main (string[] args)
        {    
            EmpType emp = EmpType.Contractor;
            AskForBonus (emp);

            Console.WriteLine ("emp is {0}", emp.ToString());
        }

If you are interested in discovering the value of a given enumeration variable, rather than its name, you can simply cast the enum variable against the underlying storeage type. 

        public static void Main (string[] args)
        {    
            EmpType emp = EmpType.Contractor;
            AskForBonus (emp);

            Console.WriteLine ("emp is {0}, value is {1}", emp.ToString(), (byte)emp);
        }

System.Enum also defines another static method named GetValues(). This method returns an instance of System.Array. Each item in the array corresponds to a member of the specified enumeration. 

        public static void Main (string[] args)
        {    
            Array enumData = Enum.GetValues (typeof(EmpType));
            for (int i = 0; i < enumData.Length; i++) {
                Console.WriteLine ("Name : {0}, Value: {0:D}", enumData.GetValue (i));
            }
        }

 

4. Struct type

 Struct is a user-defined type, however structures are not simply a collection of name/value paris. Rather, structures are types that can contain any number of data fields and members that operate on these fields. 

You can think of a structure as a "lightweight class type", given that structures provide a way to define a type that supports encapsulation, but cannot be build a family of related types. 

        struct Point
        {
            //fields of the structure
            public int x;
            public int y;

            public Point(int xPos, int yPos)
            {
                x = xPos;
                y = yPos;
            }

            //add 1 to the (x, y) position
            public void Increment()
            {
                x++;
                y++;
            }

            //subtract 1 from the (x, y) position
            public void Decrement()
            {
                x--;
                y--;
            }

            public void Display()
            {
                Console.WriteLine ("x = {0}, y = {1}", x, y);
            }
        }
            

        public static void Main (string[] args)
        {    
            Point p1 = new Point (10, 10);
            p1.Display ();
        }

 

5. Value type vs Reference type

Unlike array, string, or enumerations, c# structure does not have an identically named representation in the .net library, but are implicitly derived from System.ValueType. The role of System.ValueType is to ensure that the derived type is allocated on the stack, rather than the garbage-collected heap. The data in the stack can be created and desctoryed very quickly, as it lifetime is determined by the defining scope. Heap allocated data, on the other hand, is monitored by .net garbage collector. 

 

        public abstract class ValueType : Object
        {
            public virtual bool Equals(object obj);
            public virtual int GetHashCode();
            public Type GetType();
            public virtual string ToString();
        }        

 

Functionally, the only purpose of System.ValueType is to override the virtual method defined by System.Object to use value-based, versus reference-based. 

When a value type variable falls out of the defining scope, it is removed from memory immediately.

        static void LocalValueTypes()
        {
            int i = 0;
            float f = 0.0f;
        } // i and f are removed from stack here

 

5. 1 value type, reference type and assignment operator

When you assign one value type to another, a member-by-member copy of the field is achieved. In constract to value types, when you apply the assignment operator to reference types, you are redirecting what the reference variable points to in memory. 

 

5.2 passing reference by value

    public class Person
    {
        public string personName;
        public int personAge;

        public Person (string name, int age)
        {
            personName = name;
            personAge = age;
        }

        public void Display()
        {
            Console.WriteLine ("Name: {0}, Age: {1}", personName, personAge);
        }
    }

        public static void Main (string[] args)
        {    
            Person fred = new Person ("Fred", 12);
            fred.Display ();

            //call method 
            SendAPersonByValue(fred);
            fred.Display ();
        }

        static void SendAPersonByValue(Person p)
        {
            p.personAge = 99; //working

            p = new Person("test", 100); //not working
        }  

The value of personAge has been changed to 99, which the name is still Fred. Therefore, while we pass the reference type by value, .net only copy the reference to the caller's object. As a result, we are able to change the state of the object, but we can't reassign what the reference is pointing to . 

5.3 Passing reference types by reference

 

        static void SendAPersonByReference(ref Person p)
        {
            p.personAge = 99;

            p = new Person("test", 100);
        }  

As you might expect, this allows complete flexibility of how the callee is able to manipulate the incoming parameter. Not only the callee change the state of the object, but if it so chooses, it may also reassign the reference to a new person object. 

5.4 Vaue type vs Reference type

Where are objects allocated?	stack	heap
How is a variable represented?	value type are local copies	reference type are pointing to the memory
What is the base type?	System.ValueType	any other type (except System.ValueType)
Can this type function as a base to other types?	No, ValueTypes are always sealed and can not be inherited from	yes, as long as it is not sealed class
What is the default parameter passing behavior	passed by value	For value type, the object is copied-by_value. For reference type, the reference is copied by value
Can this type override system.Object.Finalize()?	no	yes
Can I define constructors for this type?	yes	yes
When do variables of this type die?	fall out of the defining scope	when the object is garbage collected

 

 

6. Nullable type

Value type can never be assigned the value of null, as that is used to establish an empty object reference. However, C# supports the concept of nullable data types. The nullable type can represent all the values of its underlying type, plus the value null. This is extremely helpful when working with relational database, given that it is quite common to encounter undefined columns in database tables. 

To define a nullable variable type, the question mark symbol is suffixed to the underlying data type. 

 

        static void LocalNullableValues()
        {
            int? nullableInt = 10;
            double? nullableDouble = null;
        }  

 

In C#, the ? suffix notation is shorthand for creating an instance of the generic System.Nullable<T> strcuture type. 

 

 

        static void LocalNullableValues()
        {
            Nullable<int> nullableInt = 10;
            Nullable<double> nullableDouble = null;
        }  

 

static void LocalNullableValues()
        {
            Nullable<int> nullableInt = 10;
            Nullable<double> nullableDouble = null;

            if (nullableInt.HasValue) {
                Console.WriteLine ("it is not null");
            }
        }  

6.1 ?? operator

This operator allows you to assign a value to a nullable type if the retrieved value is in fact null. 

int value = nullableInt ?? 11; //if it is null, assign 11 to value