Programming - C#

These are my notes from learning C#, collected into a single page.

Compiling from the command-line

First, make sure the path is set up correctly. In a command-prompt window, run the following:

C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\Tools\vsvars32.bat

01 - Basic command-line application

// hello.cs
// arguments: A B C D
using System;

namespace RCS
{
    public class Program
    {
        // Mandatory static Main method, the entry-point to the application
        public static int Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
            Console.WriteLine("Found {0} command line arguments:",
               args.Length );
            for (int i=0; i < args.Length; i++)
            {
                Console.WriteLine("{0}", args[i]);
            }
            return 0;
        }
    }
}

02 - Namespaces and Assembly References

Nested namespaces can be collapsed using the . syntax:

namespace Outer.Inner { }

is the same as:

namespace Outer {
    namespace Inner {

    }
}

Using

Specifies namespaces required by a unit:

using System.Console

It allows for aliases:

using Output = System.Console;
class Hello
{
    public static void Main()
    {
        Output.WriteLine("Hello");
    }
}

External Aliases

To avoid a name conflict in an external assembly, an alias can be supplied to the compiler, either via a /reference:Alias = full.assembly.name.dll on the command-line, or using the Alias property in the Visual Studio reference properties.

Assemblies

By default the C# compiler only automatically imports mscorlib.dll -- any other assemblies must be explicitly specified.

For the command-line compiler use the /r: switch:

csc ProgramUsingSystemNet /r:System.Net.dll

03 - Basic Data Types (Common Type System)

Note that string and object are reference types. All the others are value types.

Also note that strings do not act like normal reference types, because strings are immutable -- if you change a string, a completely new string is created. This means that after the following lines, s1 and s2 hold different values:

string s1 = "First string";
string s2 = s1;

s1 = "Modified string";

At this point, s2 still holds "First string".

04 - ref and out Parameters

These are akin to Delphi 'var' parameters. The main difference between them is that ref does not accept uninitialised parameters, whereas out does. There is an implied difference in the way that they are expected to be used: ref parameters are for parameters which are passed in and modified in some way, whereas out is for parameters which are simply used to return values from the method.

Note: In CLR they are identical.

Slightly bizarrely the out (or ref) keywords have to be supplied when calling the method as well as in the declaration:

int x;
int y;
Point p = new Point;
p.GetPoint(out x, out y);

Value Types and Reference Types

Value types are allocated on the stack, and assigning a value from one variable type to another creates a copy of the value.

Reference types are allocated on the heap (and must be created using 'new'), and copying from one reference variable to another creates two references to the same value.

05 - Overloading

Overloading of methods is done simply by declaring identically-named methods with differing signatures (there is no 'overload' keyword, or any other way of indicating that the methods are overloaded).

// Overloaded Add() method.
static int Add(int x, int y) { return x + y; }
static double Add(double x, double y) { return x + y; }
static long Add(long x, long y) { return x + y; }

06 - Exceptions

Easiest to demonstrate by example. Note that you can have multiple catch blocks.

using System;
class Test
{
    static int Zero = 0;
    static void AFunction()
    {
        try
        {
            int j = 22 / Zero;
        }
        catch (DivideByZeroException e)
        {
            Console.WriteLine("DivideByZero {0}", e);
        }
        catch (Exception e)
        {
            throw(new Exception("An unanticipated exception occurred in AFunction()", e));
            // You could instead do other handling here and then simply re-throw:
            //
            //     Console.WriteLine("Something bad happened!");
            //     throw;
        }
    }
    public static void Main()
    {
        try
        {
            AFunction();
        }
        catch (Exception e)
        {
            Console.WriteLine("Unexpected exception {0}", e);
        }
    }
}

.NET has a top-level handler system for exceptions, and allows application-specific handlers to be added to it:

static void Main(string[] args)
{
    AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler;
    // ... other code ...
}
static void UnhandledExceptionHandler (object sender, UnhandledExceptionEventArgs e)
{
    Exception exception = (Exception) e.ExceptionObject;
    Console.WriteLine(exception);
    System.Diagnostics.Debugger.Break();
}

When you throw a new exception from within a catch handler, this wraps the original exception in a new exception. The chain of exceptions can be accessed using the innerException property of the Exception class, which contains the Exception that was originally caught.

Generally a new Exception should be thrown if it can be used to add details about the actual exception that occurred.

When re-throwing the same Exception, use 'throw', not 'throw e', i.e. do not explicitly throw the caught Exception, as this will actually create a new Exception stack and discard the original one, losing the information.

Exception Members

• Exception.TargetSite.DeclaringType (class)
• Exception.TargetSite.MemberType
• Exception.Message
• Exception.Source (assembly)
• Exception.StackTrace
• Exception.HelpLink (blank by default)
• Exception.Data (dictionary for additional information)

Example

ex = new Exception(string.Format("Error in {0}", "