a ^= b;
b ^= a;
a ^= b;

a^=b^=a^=b;

EDIT: In class Book Fields durch Properties ersetzt

   public class Book
    {
        private int pages = -1;

        public Book(int pages)
        {
            this.pages = pages;
        }

        public string Title { get; set; }
        public int ReleaseYear { get; set; }
        public Author Author { get; set; }
        
        public int GetPages()
        {
            return pages;
        }
    }
	
	public class Author
       {
           public string FirstName { get; set; }
           public string LastName { get; set; }
           public string FancyName { get; set; }
           public string Name { get { return FirstName +" "+ LastName;} }
           public Biography Bio { get; set; }
       }
	
	public class Biography
        {
            public string Name { get; set; }
         }
	

static string GetMembers(Type type)
{
	string sMemberInfos = string.Empty;
	foreach (string sMember in GetMembers(type, string.Empty))
		sMemberInfos += String.Concat(sMember, Environment.NewLine);
}

static List<string> GetMembers(Type type, string sMemberCallPath)
{
	// list to temporary hold the callpaths
	List<string> callPaths = new List<string>();

	if (sMemberCallPath != string.Empty)
		sMemberCallPath += ".";

	// filter all types of namespace System
	if (type.FullName.StartsWith("System"))
		return new List<string>();
			
	MemberInfo[] members = type.GetMembers();

	foreach (MemberInfo member in members)
	{
		switch (member.MemberType)
		{
			case MemberTypes.Field:
				FieldInfo finfo = member as FieldInfo;
				if(!callPaths.Contains(String.Concat(sMemberCallPath,finfo.Name)))
					callPaths.Add(String.Concat(sMemberCallPath,finfo.Name));
				if (finfo.IsPublic)
					callPaths.AddRange(GetMembers(finfo.FieldType, String.Concat(sMemberCallPath, member.Name)));
				break;
			case MemberTypes.Property:
				PropertyInfo pinfo = member as PropertyInfo;
				if (!callPaths.Contains(String.Concat(sMemberCallPath, pinfo.Name)))
					callPaths.Add(String.Concat(sMemberCallPath, pinfo.Name));
					callPaths.AddRange(GetMembers(pinfo.PropertyType, String.Concat(sMemberCallPath, member.Name)));
				break;
			case MemberTypes.Method:
				string sMemberName = member.Name;
				if (member.Name.StartsWith("Get") || member.Name.StartsWith("Set"))
					sMemberName = member.Name.Remove(0, 3);
				else if (member.Name.StartsWith("get_") || member.Name.StartsWith("set_"))
					sMemberName = member.Name.Remove(0, 4);
				if(!callPaths.Contains(String.Concat(sMemberCallPath, sMemberName)))
					callPaths.Add(String.Concat(sMemberCallPath, sMemberName));
				break;
		}
	}

	callPaths.Sort();

	return callPaths; ;
}

  string sMemberInfos = string.Empty;
    foreach (string sMember in sMemberInfos )
        sMemberInfos += String.Concat(sMember, Environment.NewLine);

  string sMemberInfos = string.Empty;
    foreach (string sMember in sMemberInfos )

static string GetMembers(Type type)
{
    string sMemberInfos = string.Empty;
    foreach (string sMember in GetMembers(type, string.Empty))
        sMemberInfos += String.Concat(sMember, Environment.NewLine);

   return sMemberInfos;
}

static List<string> GetMembers(Type type, string sMemberCallPath)
{
    // list to temporary hold the callpaths
    List<string> callPaths = new List<string>();

    if (sMemberCallPath != string.Empty)
        sMemberCallPath += ".";

    // filter all types of namespace System
    if (type.FullName.StartsWith("System"))
        return new List<string>();

    MemberInfo[] members = type.GetMembers();

    foreach (MemberInfo member in members)
    {
        switch (member.MemberType)
        {
            case MemberTypes.Field:
                FieldInfo finfo = member as FieldInfo;
                if(!callPaths.Contains(String.Concat(sMemberCallPath,finfo.Name)))
                    callPaths.Add(String.Concat(sMemberCallPath,finfo.Name));
                if (finfo.IsPublic)
                    callPaths.AddRange(GetMembers(finfo.FieldType, String.Concat(sMemberCallPath, member.Name)));
                break;
            case MemberTypes.Property:
                PropertyInfo pinfo = member as PropertyInfo;
                if (!callPaths.Contains(String.Concat(sMemberCallPath, pinfo.Name)))
                    callPaths.Add(String.Concat(sMemberCallPath, pinfo.Name));
                    callPaths.AddRange(GetMembers(pinfo.PropertyType, String.Concat(sMemberCallPath, member.Name)));
                break;
            case MemberTypes.Method:
                string sMemberName = member.Name;
                if (member.Name.StartsWith("Get") || member.Name.StartsWith("Set"))
                    sMemberName = member.Name.Remove(0, 3);
                else if (member.Name.StartsWith("get_") || member.Name.StartsWith("set_"))
                    sMemberName = member.Name.Remove(0, 4);
                if(!callPaths.Contains(String.Concat(sMemberCallPath, sMemberName)))
                    callPaths.Add(String.Concat(sMemberCallPath, sMemberName));
                break;
        }
    }

    callPaths.Sort();

    return callPaths; ;
}

	public class Program
	{
		private const string Path = @"C:\Temp\SecretMessage.jpg";

		static void Main( string[] args )
		{
			CreateBitmap(Path, 32, new char[] { 'H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D' });

			Console.WriteLine(ReadBitmap(Path, 32));

			Console.ReadKey();
		}


		private static void CreateBitmap( string path, int pixelHeightAndWidth, char[] message )
		{
			var tmpBitmapWidth = message.Length * pixelHeightAndWidth;
			var tmpBitmapHeight = pixelHeightAndWidth;

			using ( var bmp = new Bitmap( tmpBitmapWidth, tmpBitmapHeight ) )
			{
				var tmpOffsetWidth = 0;
				foreach ( var t in message )
				{
					for ( var x = tmpOffsetWidth; x < ( tmpOffsetWidth + pixelHeightAndWidth ); x++ )
					{
						for ( var y = 0; y < tmpBitmapHeight; y++ )
						{
							var tmpColor = Color.FromArgb( 255, t, t, t );
							bmp.SetPixel( x, y, tmpColor );
						}

					}
					tmpOffsetWidth += pixelHeightAndWidth;
				}
				bmp.Save( path );
			}
		}

		private static string ReadBitmap( string path, int pixelHeightAndWidth )
		{
			var tmpRes = new StringBuilder();

			using (var FS = new FileStream(path, FileMode.Open,FileAccess.Read,FileShare.Read))
			{
				using ( var bmp = new Bitmap( FS ) )
				{
					for ( int x = 0; x < bmp.Width; x += pixelHeightAndWidth )
					{
						tmpRes.Append((char)bmp.GetPixel(x, 1).R);
					}
				}
			}

			return tmpRes.ToString();
		}
	}

static Bitmap Encode(int height, string message)
{
    int width = message.Length * height;
    Bitmap bitmap = new Bitmap(width, height);
    using (Graphics g = Graphics.FromImage(bitmap))
    {
        for (int i = 0, j = 0; i < width; i += height, j++)
            g.FillRectangle(new SolidBrush(Color.FromArgb(255, message[j], message[j], message[j])), new Rectangle(i, 0, height, height));
    }
    return bitmap;
}

var limit = 10;
limit = "five";

limit = "five";

using System;

static class Program
{
    static void Main()
    {
        var limit = 10;
        limit = "five";
        for (var x=0;x<limit;x++)
        {
            Console.WriteLine(x);
            Console.WriteLine("The current value of x is {0}",x);
        }
    }
}

// new code here

class var
{
    static string[] words = { "zero", "one", "two", "three", "four", "five"};
    int val {get; set;}
    public static implicit operator var(int n){ return new var(){val=n}; }
    public static implicit operator var(string s) { return Array.IndexOf(words, s); }
    public static implicit operator int(var v) { return v.val; }
    public static bool operator <(var a, var b) { return a.val < b.val; }
    public static bool operator >(var a, var b){ return b < a; }
    public static var operator ++(var v) { v.val++; return v; }
    override public string ToString() { return words[val]; }
}