Exam 70-536 on David Cumps

Exam 70-536 - Searching, Modifying, and Encoding Text

Thu, 28 Aug 2008 00:00:00 +0200

Chapter three finished, Searching, Modifying, and Encoding Text.

Implementing globalization, drawing, and text manipulation functionality in a .NET Framework application

Exam 70-536 - Framework Fundamentals

Wed, 27 Aug 2008 00:00:00 +0200

The book I’m reading to prepare myself is Microsoft.NET Framework 2.0 Application Development Foundation

Exam 70-536 - Input/Output

Wed, 27 Aug 2008 00:00:00 +0200

Finished another chapter in my book, Input/Output, which deals with the following:

ArrayList Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Resizeable, unordered, index-based collection.
Suffers from boxing/unboxing when working with value types.
Implements IEnumerator, allowing foreach operations.
- The IEnumerator is a .NET implementation of the Iterator Pattern.

Good practice

When possible, use a generic collection instead of the object-based ArrayList.

Examples

Adding and Removing Elements

ArrayList a = new ArrayList();
a.Add(16);
a.AddRange(new object[] { "Hello", "World" });
a.Insert(0, "Start");
a.InsertRange(2, new int[] { 32, 64 });
foreach (var o in a) { Console.WriteLine(o); }
 
a.Remove("Hello");
a.RemoveAt(1);
a.RemoveRange(1, 2);
foreach (var o in a) { Console.WriteLine(o); }

Checking Existence

ArrayList a = new ArrayList();
a.AddRange(new object[] { "Hello", "World" });
Console.WriteLine(a.Contains("World") ? "World Found" : "World Missing");

BinaryReader Class and BinaryWriter Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Used to read and write binary data from streams.
Call the correct Read methods when using a BinaryReader.

Good practice

Remember to call Close, since it has a stream behind it.

Examples

Read and Write Binary

FileStream a = File.Create(@"C:\Public\BinaryTest.dat");
 
BinaryWriter b = new BinaryWriter(a);
b.Write(new byte[] { 47, 50 });
b.Write("Hello World");
b.Write(42);
b.Close();
 
a = File.OpenRead(@"C:\Public\BinaryTest.dat");
 
BinaryReader c = new BinaryReader(a);
c.ReadBytes(2);
Console.WriteLine(c.ReadString());
Console.WriteLine(c.ReadInt32());
c.Close();

BitArray Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Contains an array of true/false values.
Resizable through the Length property.
Supports bitwise operations.

Examples

Setting Values

BitArray a = new BitArray(8);
a.SetAll(false);
a[2] = true;

Xor

BitArray a = new BitArray(8);
a.SetAll(false);
a[2] = true;
 
BitArray b = new BitArray(8);
b.SetAll(false);
b[2] = false;
 
BitArray xor = a.Xor(b);
Console.WriteLine(xor[2]);

BitVector32 structure and BitVector32.Section structure

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Used to manipulate the bits of a 32 integer.
Used to pack multiple small numbers into one when storage is an issue.

Examples

Bitwise Manipulation

BitVector32 c = new BitVector32(0);
 
int firstBit = BitVector32.CreateMask();
int secondBit = BitVector32.CreateMask(firstBit);
int thirdBit = BitVector32.CreateMask(secondBit);
 
c[firstBit] = true;
c[thirdBit] = true;
 
Console.WriteLine(c.Data); // 5
Console.WriteLine(c); // BitVector32{00000000000000000000000000000101}

Bit Packing

BitVector32.Section a = BitVector32.CreateSection(10); // Max number to store is 10
BitVector32.Section b = BitVector32.CreateSection(80, a); // Max number to store is 80
BitVector32.Section c = BitVector32.CreateSection(5, b); // Max number to store is 5
 
 
BitVector32 x = new BitVector32(0);
x[a] = 5;
x[b] = 79;
x[c] = 3;
 
Console.WriteLine(x[a]); // 5
Console.WriteLine(x[b]); // 79
Console.WriteLine(x[c]); // 3
Console.WriteLine(x.Data); // 7413
Console.WriteLine(x); // BitVector32{00000000000000000001110011110101}

Boxing And Unboxing

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Boxing is an implicit conversion of a value-type to the object type.
- Boxing a value-type will copy the value on the heap, and place a pointer to the boxed value on the stack.

Good practice

Try to prevent boxing/unboxing when possible, use generics or multiple overloads instead.
- Read Boxing/Unboxing In .NET for performance tests.

Examples

Boxing Operation

int i = 123;
object o = (object)i;

Unboxing Operation

object o = 123;
int i = (int)o;

BufferedStream Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Provides an buffer for another Stream.
Used when the underlying stream is not very efficient in handling constant calls.

Good practice

Remember to call Close on a stream.

Examples

Write to File

FileStream a = File.Create(@"C:\Public\TestBuff.txt");
BufferedStream b = new BufferedStream(a);
StreamWriter c = new StreamWriter(b);
 
c.WriteLine("Hello World");
c.WriteLine("Bye Bye!");
c.Close();

CollectionsUtil

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Helper method to create a case-insensitive Hashtable or SortedList

Examples

CollectionsUtil.CreateCaseInsensitiveHashtable();
CollectionsUtil.CreateCaseInsensitiveSortedList();

Comparer Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Used as the default comparer when sorting with ArrayList for example.
Implements the IComparer interface.

Good practice

When possible, use the generic version of IComparer<T> and Comparer<T>.

Examples

Compare Strings

// Returns 0 when equal, -1 when a < b and 1 when a > b
Console.WriteLine("Is a equal to b? {0}", Comparer.DefaultInvariant.Compare("a", "b"));

Reverse Sort

public class Program
{
 static void Main(string[] args)
 {
 ArrayList a = new ArrayList();
 a.AddRange(new string[] { "Hello", "World", "Aloha" });
 a.Sort();
 foreach (var s in a) { Console.WriteLine(s); }
 a.Sort(new ReverseSort());
 foreach (var s in a) { Console.WriteLine(s); }
 }
}
 
public class ReverseSort : IComparer
{
 public int Compare(object x, object y)
 {
 return y.ToString().CompareTo(x.ToString());
 }
}

DeflateStream Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Used to compress and decompress data.
Slightly smaller result than GZipStream because of lack of header information.
Use for internal use in your own application.
Works like a BufferedStream as it sits on top of another stream.
Limited to files up to 4GB (uncompressed).

Good practice

Remember to call Close on a stream.

Compress File

FileStream fileIn = File.OpenRead(@"C:\Public\Test.txt");
FileStream fileOut = File.OpenWrite(@"C:\Public\TestComp.txt");
 
DeflateStream compress = new DeflateStream(fileOut, CompressionMode.Compress);
 
byte[] buffer = new byte[fileIn.Length];
fileIn.Read(buffer, 0, buffer.Length);
compress.Write(buffer, 0, buffer.Length);
compress.Close();
 
fileIn.Close();
fileOut.Close();

Decompress File

FileStream compressedFile = File.OpenRead(@"C:\Public\TestComp.txt");
DeflateStream decompress = new DeflateStream(compressedFile, CompressionMode.Decompress);
StreamReader read = new StreamReader(decompress);
 
Console.WriteLine(read.ReadToEnd());
read.Close();
decompress.Close();
compressedFile.Close();

Delegate Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Holds a reference to a method.
Declared as a single line, the framework provides the underlying implementation.

Good practice

A delegate should contain 2 parameters, an object sender and event arguments.
You should derive from EventArgs to supply custom event data.

Examples

Simple Delegate

public delegate void MyEventHandler(object sender, EventArgs e);

Directory Class and DirectoryInfo Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

DirectoryInfo
- Extends FileSystemInfo with directory specific operations.
- It is possible to create a DirectoryInfo object for a non-existent directory.
- GetDirectories and GetFiles allow the use of wildcards.

Examples

Create SubDir

DirectoryInfo a = new DirectoryInfo(@"C:\Public\Test");
 
a.Create();
a.CreateSubdirectory("Subtest");
 
foreach (var dir in a.Parent.GetDirectories())
{
 Console.WriteLine(dir.FullName);
}

Set Current Directory

Console.WriteLine(Directory.GetCurrentDirectory()); // Returns a 'bin' Debug/Release directory
Directory.SetCurrentDirectory(@"C:\Public\Test");
Console.WriteLine(Directory.GetCurrentDirectory());

DriveInfo Class and DriveType Enumeration

Tue, 26 Aug 2008 00:00:00 +0200

Overview

DriveInfo
- Will not work on non-existent drives.
- AvailableFreeSpace returns the freeBytesForUser.
- TotalFreeSpace returns the freeBytes.

Examples

Get Drive Information

class Program
{
 static void Main(string[] args)
 {
 DriveInfo a = new DriveInfo("a");
 DriveInfo c = new DriveInfo("c");
 
 WriteDriveInfo(a);
 WriteDriveInfo(c);
 }
 
 private static void WriteDriveInfo(DriveInfo drive)
 {
 try
 {
 Console.WriteLine(string.Format("{0} ({1}): {2}", drive.DriveType, drive.DriveFormat, drive.VolumeLabel));
 Console.WriteLine(string.Format("{0} / {1}", drive.TotalFreeSpace.Humanize(), drive.TotalSize.Humanize()));
 }
 catch (DriveNotFoundException dex)
 {
 Console.WriteLine(dex.Message);
 }
 }
}
 
public static class SizeExtensions
{
 // Credits to http://blogs.interakting.co.uk/brad/archive/2008/01/24/C-Getting-a-user-friendly-file-size-as-a-string.aspx
 public static string Humanize(this long bytes)
 {
 double s = bytes;
 string[] format = new string[] { "{0} bytes", "{0} KB", "{0} MB", "{0} GB", "{0} TB", "{0} PB", "{0} EB", "{0} ZB", "{0} YB" };
 int i = 0;
 while (i < format.Length - 1 && s >= 1024)
 {
 s = (100 * s / 1024) / 100.0;
 i++;
 
 }
 return string.Format(format[i], s.ToString("###,###,##0.##")); 
 }
}

Get All Drives

foreach (var drive in DriveInfo.GetDrives())
{
 WriteDriveInfo(drive);
}

Encode text by using Encoding classes

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Provides information about Encodings.
Default .NET Encoding is UTF-16.
Notepad has trouble displaying UTF-7 and UTF-32 encoded files, even though the file has been properly encoded.
Remember to specify the Encoding when reading a file!

Good practice

When in doubt, accept the default UTF-16 encoding.

Examples

Get Available Encodings

EncodingInfo[] e = Encoding.GetEncodings();
 
foreach (var enc in e)
{
 Console.WriteLine("{0}: {1}, {2}", enc.CodePage, enc.Name, enc.DisplayName);
}

Check Different Encodings

StreamWriter u7 = new StreamWriter(@"C:\Public\u7.txt", false, Encoding.UTF7);
StreamWriter u8 = new StreamWriter(@"C:\Public\u8.txt", false, Encoding.UTF8);
StreamWriter u16 = new StreamWriter(@"C:\Public\u16.txt", false, Encoding.Unicode);
StreamWriter u32 = new StreamWriter(@"C:\Public\u32.txt", false, Encoding.UTF32);
 
string hello = "Hello, World!";
u7.Write(hello);
u8.Write(hello);
u16.Write(hello);
u32.Write(hello);
 
u7.Close();
u8.Close();
u16.Close();
u32.Close();
 
// Now view each file in Notepad, and it's properties for the size

EventArgs Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Defines the arguments to pass in an event.
The EventArgs class is used to raise an event without any data.
- Derive from EventArgs when you need to pass custom data, demonstrated below.

Good practice

Always use a class to pass event data via a delegate instead of defining separate parameters for each piece of event data.

Examples

Custom Event Arguments

public class MyEventArgs : EventArgs
{
 private string _someData;
 
 public MyEventArgs(string someEventData)
 {
 this._someData = someEventData;
 }
}

EventHandler Delegates

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Provides an easier way to define events, without having to declare a delegate.
The EventHandler delegate is used for events without data, while the EventHandler<T> delegate is used with your own EventArgs class.

Good practice

Implement the IDisposable interface when working with events to prevent memory leaks.
- Read .Net EventHandlers - Best Practices for more information.
- See the example below on how to implement.
In C# 3.0 it is possible to omit the null check of an event by using the Null Pattern in the constructor to make sure there is always a listener.

Examples

Event With Custom EventArgs

public class MyEventArgs : EventArgs
{
 private string _someData;
 
 public MyEventArgs(string someEventData)
 {
 this._someData = someEventData;
 }
}
 
public class Program
{
 public event EventHandler<MyEventArgs> MyOtherEvent;
}
 
public void Test()
{
 Program p = new Program();
 //p.MyEvent += new Program.MyEventHandler(p_MyEvent);
 p.MyOtherEvent += new EventHandler<MyEventArgs>(p_MyOtherEvent);
}
 
void p_MyOtherEvent(object sender, MyEventArgs e)
{
 throw new NotImplementedException();
}

Disposing Event Listeners

public class Program
{
 static void Main(string[] args)
 {
 DisposableClass a = new DisposableClass();
 // Uncommenting the next line will not cause the program to crash,
 // because there is always a handler present for SomeEvent. (see constructor)
 a.SomeEvent += new EventHandler<MyEventArgs>(a_SomeEvent);
 a.SomeMethod();
 a.Dispose();
 }
 
 static void a_SomeEvent(object sender, MyEventArgs e)
 {
 Console.WriteLine(e.SomeData);
 }
}
 
public class MyEventArgs : EventArgs
{
 private string _someData;
 
 public string SomeData
 {
 get { return _someData; }
 }
 
 public MyEventArgs(string someEventData)
 {
 this._someData = someEventData;
 }
}
 
public class DisposableClass : IDisposable
{
 private bool _disposed = false;
 
 private event EventHandler<MyEventArgs> _someEvent;
 
 public event EventHandler<MyEventArgs> SomeEvent
 {
 add { _someEvent += value; }
 remove { _someEvent -= value; }
 }
 
 public DisposableClass()
 {
 SomeEvent += (s, e) => { };
 }
 
 public void SomeMethod()
 {
 _someEvent(this, new MyEventArgs("Hello"));
 }
 
 public void Dispose()
 {
 Dispose(true);
 GC.SuppressFinalize(this);
 }
 
 protected virtual void Dispose(bool disposing)
 {
 if (!_disposed)
 {
 if (disposing)
 {
 // Dispose managed resources.
 _someEvent = null;
 }
 
 // Release unmanaged resources.
 }
 
 _disposed = true;
 }
 
 ~DisposableClass()
 {
 Dispose(false);
 }
}

Exception classes

Tue, 26 Aug 2008 00:00:00 +0200

Overview

All .NET exceptions derive from the System.SystemException class.
All custom exceptions derive from the System.Exception class.
- For most applications, derive custom exceptions from the Exception class. It was originally thought that custom exceptions should derive from the ApplicationException class; however in practice this has not been found to add significant value. (From MSDN)
The try/catch structure will use the first catch which applies. Order catches from most specific to most general in the code.
Finally will always be executed, whether an exception got thrown or not.
A try/catch/finally construct has multiple separated scopes, demonstrated below.

Good practice

End custom exception classes with ‘Exception’.
Implement the three recommended common constructors, as shown in the example.

Examples

Scopes

int a;
try
{
 int b;
 // a and b are accessible.
}
catch (Exception e)
{
 int c;
 // a and c are accessible.
}
finally
{
 int d;
 // a and d are accessible.
}

Constructors

using System;
public class EmployeeListNotFoundException : Exception
{
 public EmployeeListNotFoundException()
 {
 }
 
 public EmployeeListNotFoundException(string message)
 : base(message)
 {
 }
 
 public EmployeeListNotFoundException(string message, Exception inner)
 : base(message, inner)
 {
 }
}

File Class and FileInfo Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

FileInfo
- Extends FileSystemInfo with file specific operations.
- It is possible to create a FileInfo object for a non-existent file.
File
- Contains static methods allowing you to perform operations without a FileInfo instance.
- Most methods perform atomic operations when writing and reading files.

Examples

Encrypt File

FileInfo a = new FileInfo(@"\\davidcxp\Public\Hello.txt");
 
a.Encrypt();
// At this point, the file will be encrypted at NTFS level
// When you have colors enabled in Explorer, it'll be green.
 
a.Decrypt();

Replace & Backup File

FileInfo a = new FileInfo(@"C:\Public\Hello.txt");
 
// Moves Hello.txt to OtherHello.txt and backs up OtherHello.txt to BackupHello.txt
// Hello.txt and OtherHello.txt has to exist.
// Replace performs a call to ReplaceFile in kernel32.dll in the background
a.Replace(@"C:\Public\OtherHello.txt", @"C:\Public\BackupHello.txt");

Non-Existent File

FileInfo a = new FileInfo(@"C:\Public\bla.txt");
Console.WriteLine(a.Exists);

Writing Files

File.WriteAllText(@"C:\Public\Test.txt", "Hello"); // Overwrites Test.txt if it exists
File.AppendAllText(@"C:\Public\Test.txt", " There!"); // Appends or creates Text.txt

FileStream Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Provides a file specific implementation of a Stream.

Good practice

Remember to call Close on a stream.

Examples

Read a File

// FileStream is simply a stream around a file, overriding Stream methods
FileStream a = new FileStream(@"C:\Public\Test.txt", FileMode.Open);
 
while (a.Position != a.Length)
{
 Console.Write((char)a.ReadByte());
}

FileSystemInfo Class and FileSystemWatcher Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

FileSystemInfo
- FileSystemInfo forms the base for FileInfo and DirectoryInfo, but not DriveInfo.
- Information contained by FileSystemInfo is cached on first call, use Refresh() to update it.
- Absolute, Relative and UNC paths are allowed as format.
- Get information from Attributes using bitwise operators.
FileSystemWatcher

Generic Dictionary class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Generic version of the Hashtable class.
Retains the order in which items were added.
Contains KeyValuePair<K, T> internally.

Generic KeyValuePair structure

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Internal representation of the generic Dictionary.

Generic List class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Generic version of the ArrayList class.
Supports delegates for sorting, see below.

Examples

Sorting

static void Main(string[] args)
{
 List<int> list = new List<int>();
 
 list.Add(5);
 list.Add(10);
 list.Add(2);
 
 list.Sort(IntComparison);
 
 foreach (int i in list)
 {
 Console.WriteLine(i);
 }
}
 
public static int IntComparison(int x, int y)
{
 return x.CompareTo(y);
}

Generic List.Enumerator structure, and Generic SortedList class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Generic version of the Arraylist class.
Sorted version of the generic List class.
Automatically sorts items based on the key.

Generic Queue class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Generic version of the Queue class.

Generic SortedDictionary class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Generic version of the Hashtable class.
Sorted version of the generic Dictionary class.
Contains KeyValuePair<K, T> internally.
Automatically sorts items based on the key.

Generic Types

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Allows you to use placeholders for parameters, which get defined later by the caller.
Allows for strongly typed collections, which enable compile-time checking of types.
Requires the developer to write generic code, which is valid for all types of T.
- Can be avoided by using constraints on allowed types for T, demonstrated below.
- You can only use 1 class as a constraint, but multiple interfaces.

Good practice

Generics FAQ: Best Practices - MSDN document describing possible problems/solutions with generics.

Examples

Generic Placeholder

class MyHolder<T> 
 //where T: struct
 //where T: MyNumber
 //where T: class
 //where T: class, IComparable
 //where T: new()
{
 private T _thing;
 
 public T Thing
 {
 get { return this._thing; }
 }
 
 public MyHolder(T thing)
 {
 this._thing = thing;
 }
}

MyHolder<int> nr = new MyHolder<int>(5);
MyHolder<string> name = new MyHolder<string>("CumpsD");
 
Console.WriteLine(nr.Thing);
Console.WriteLine(name.Thing);

Group Class and GroupCollection Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Contains the named and unnamed results of matches in a regex.
- Unnamed results are numbered starting from 1.

Examples

Scanning Text

string input = "The dog ate a bone.";
string regex = @"^The (?<animal>\w+)\b ate (?<food>.+)\.$";
 
Match m = Regex.Match(input, regex);
Console.WriteLine(string.Format("Animal: {0}, Food: {1}!", m.Groups["animal"], m.Groups[2]));

GZipStream Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Used to compress and decompress data.
Slightly larger result than DeflateStream because of extra header information.
Use for files that need to be able to be opened with gzip.
Works like a BufferedStream as it sits on top of another stream.
Limited to files up to 4GB (uncompressed).

Good practice

Remember to call Close on a stream.

Examples

Compress File

FileStream fileIn = File.OpenRead(@"C:\Public\Test.txt");
FileStream fileOut = File.OpenWrite(@"C:\Public\TestComp.txt");
 
GZipStream compress = new GZipStream(fileOut, CompressionMode.Compress);
 
byte[] buffer = new byte[fileIn.Length];
fileIn.Read(buffer, 0, buffer.Length);
compress.Write(buffer, 0, buffer.Length);
compress.Close();
 
fileIn.Close();
fileOut.Close();

Decompress File

FileStream compressedFile = File.OpenRead(@"C:\Public\TestComp.txt");
GZipStream decompress = new GZipStream(compressedFile, CompressionMode.Decompress);
StreamReader read = new StreamReader(decompress);
 
Console.WriteLine(read.ReadToEnd());
read.Close();
decompress.Close();
compressedFile.Close();

HashTable Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Key-value pair based collection.
Contains DictionaryEntry objects.
Not accessible by index, only by key.
Values are returned based on the hash value when doing a foreach.
Internally uses hashes to store objects, derived from the GetHashCode method on each object.
- Hashes are used for equality of objects.
- No duplicate hashes can occur.

Good practice

When possible, use a generic collection instead of the object-based HashTable.
Implement GetHashCode and Equals in custom objects when you need HashTable to treat objects as the same.
Use a ListDictionary or HybridDictionary when working with smaller collections than 10 or unknown size collections.

Examples

Adding and Removing Elements

Hashtable a = new Hashtable();
a.Add("Key1", "Hello");
a.Add("Key2", "World");
a.Add("Key0", "Start");
Console.WriteLine(a["Key1"] + " " + a["Key2"]);
foreach (DictionaryEntry d in a) { Console.WriteLine(d.Value); }
foreach (var v in a.Values) { Console.WriteLine(v); }
 
a.Remove("Key1");
foreach (var k in a.Keys) { Console.WriteLine(a[k]); }

ICloneable Interface

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Enable objects to be cloned.
Does not specify if you need to implement deep-copy or shallow-copy. (Problematic in public APIs)

Good practice

Avoid using ICloneable ;)
- Read Should we Obsolete ICloneable, founding member of the CLR stating in 2004 to avoid it.

Examples

Object Cloning

class MyNumber: ICloneable
{
 private int _x;
 
 public int X
 {
 get { return this._x; }
 set { this._x = value; }
 }
 
 public MyNumber(int x)
 {
 this._x = x;
 }
 
 #region ICloneable Members
 public object Clone()
 {
 return new MyNumber(this.X);
 }
 #endregion
}

MyNumber a = new MyNumber(10);
MyNumber b = (MyNumber)a.Clone();
MyNumber c = a;
a.X += 100; // Incremented to display b.X does not get incremented, while c.X does.
Console.WriteLine(a.X); // Prints 110
Console.WriteLine(b.X); // Prints 10
Console.WriteLine(c.X); // Prints 110

IComparable Interface

Tue, 26 Aug 2008 00:00:00 +0200

Overview

IComparable is required for sorting.
CompareTo is used for sorting, Equals is used to compare equality. (IEquatable interface)
- Returns less than 0, 0 or greater than 0 to indicate how another object relates to the current one.

Good practice

For objects A, B and C, the following must be true:
A.CompareTo(A) is required to return zero.
If A.CompareTo(B) returns zero, then B.CompareTo(A) is required to return zero.
If A.CompareTo(B) returns zero and B.CompareTo(C) returns zero, then A.CompareTo(C) is required to return zero.
If A.CompareTo(B) returns a value other than zero, then B.CompareTo(A) is required to return a value of the opposite sign.
If A.CompareTo(B) returns a value x not equal to zero, and B.CompareTo(C) returns a value y of the same sign as x, then A.CompareTo(C) is required to return a value of the same sign as x and y.

Examples

Custom Sorting

struct MyPoint: IComparable
{
 private int _x;
 private int _y;
 
 public int X
 {
 get { return this._x; }
 }
 
 public int Y
 {
 get { return this._y; }
 }
 
 public MyPoint(int x, int y)
 {
 this._x = x;
 this._y = y;
 }
 
 #region IComparable Members
 public int CompareTo(object obj)
 {
 if (obj is MyPoint)
 {
 MyPoint other = (MyPoint)obj;
 
 if (this._x.CompareTo(other.X) == 0)
 {
 return this._y.CompareTo(other.Y);
 }
 else
 {
 return this._x.CompareTo(other.X);
 }
 }
 else
 {
 throw new NotSupportedException("obj is not a MyPoint");
 }
 }
 #endregion
}

List<MyPoint> list = new List<MyPoint>();
list.Add(new MyPoint(10, 5));
list.Add(new MyPoint(10, 2));
list.Add(new MyPoint(10, 3));
list.Add(new MyPoint(4, 1));
list.Add(new MyPoint(15, 1));
 
list.Sort();
 
foreach (MyPoint p in list)
{
 Console.WriteLine(p);
}
 
/*
Will Print:
(4, 1)
(10, 2)
(10, 3)
(10, 5)
(15, 1)
*/

IConvertible Interface

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Enables a class to be converted to a base type such as Boolean, Byte, Double, or String.
C# allows widening conversion without any casting, e.g.: going from int to double, see below.
Narrowing conversion requires explicit conversion.
Overloading operators allows for implicit and explicit conversion of custom types, as demonstrated below.
Implementing IConvertible allows the use of Convert with your custom type.

Examples

Widening conversion

int i = 1;
double d = 1.0001;
d = i; // Compiles without casting.

Narrowing Conversion

Int16 a = 1;
Int32 b = 1;
double c = 1;
 
a = (Int16)b; // a = b will not be allowed, narrowing!
a = (Int16)c; // a = c will not be allowed, narrowing!
 
b = a; // Allowed, widening
b = (Int32)c; // b = c will not be allowed, narrowing!
 
c = a; // Allowed, widening
c = b; // Allowed, widening

Overloading Operators

class Program
{
 static void Main(string[] args)
 {
 MyPlaceholder a ;
 int b;
 
 // Allowed because of the 'implicit' operator
 a = 5;
 Console.WriteLine(a.Value);
 
 // Allowed because of the string implicit operator,
 // don't do this however!! Way to error-prone!
 a = "7";
 Console.WriteLine(a.Value);
 
 // Allowed because of the 'explicit' operator
 b = (int)a;
 Console.WriteLine(b);
 }
}
 
public class MyPlaceholder
{
 public int Value { get; private set; }
 
 public MyPlaceholder(int value)
 {
 Value = value;
 }
 
 public static implicit operator MyPlaceholder(int arg)
 {
 MyPlaceholder obj = new MyPlaceholder(arg);
 return obj;
 }
 
 public static implicit operator MyPlaceholder(string arg)
 {
 MyPlaceholder obj = new MyPlaceholder(Convert.ToInt32(arg));
 return obj;
 }
 
 public static explicit operator int(MyPlaceholder arg)
 {
 return arg.Value;
 }
}

Implementing IConvertible

class Program
{
 static void Main(string[] args)
 {
 MyPlaceholder a = new MyPlaceholder(5);
 int b;
 
 // Allowed because of the IConvertible interface
 b = Convert.ToInt32(a);
 Console.WriteLine(b);
 
 // Allowed because of the IConvertible interface
 Console.WriteLine(Convert.ToDouble(a));
 
 // Not Allowed because of the InvalidCastException
 Console.WriteLine(Convert.ToDateTime(a));
 }
}
 
public class MyPlaceholder: IConvertible
{
 public int Value { get; private set; }
 
 public MyPlaceholder(int value)
 {
 Value = value;
 }
 
 #region IConvertible Members
 public double ToDouble(IFormatProvider provider) { return Value; }
 public float ToSingle(IFormatProvider provider) { return Value; }
 public int ToInt32(IFormatProvider provider) { return Value; }
 public long ToInt64(IFormatProvider provider) { return Value; }
 public string ToString(IFormatProvider provider) { return Value.ToString(); }
 
 public TypeCode GetTypeCode()
 {
 return TypeCode.Object;
 }
 
 public bool ToBoolean(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public byte ToByte(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public char ToChar(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public DateTime ToDateTime(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public decimal ToDecimal(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public short ToInt16(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public sbyte ToSByte(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public object ToType(Type conversionType, IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public ushort ToUInt16(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public uint ToUInt32(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 
 public ulong ToUInt64(IFormatProvider provider)
 {
 throw new InvalidCastException();
 }
 #endregion
}

IDisposable Interface

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Enable assemblies that create an instance of your class to free up any resources the instance has consumed.
Only implement IDisposable when one of your members implements it, or when you use native resources.

Good practice

Implement a virtual Dispose(bool) in your base class which combines disposing native and managed resources.
- Dispose() will call Dispose(true), while the finalizer will call Dispose(false).
A Dispose method should call the GC.SuppressFinalize method for the object it is disposing.

Examples

Basic IDisposable Implementation

public class DisposableClass : IDisposable
{
 private bool _disposed = false;
 
 public void Dispose()
 {
 Dispose(true);
 GC.SuppressFinalize(this);
 }
 
 protected virtual void Dispose(bool disposing)
 {
 // Note that Dispose() is not thread-safe in this form!
 // If thread-safety is required, you need to implement this.
 if (!_disposed)
 {
 if (disposing)
 {
 // Dispose managed resources.
 }
 
 // Release unmanaged resources.
 }
 
 _disposed = true;
 }
 
 ~DisposableClass()
 {
 Dispose(false);
 }
 
 public void SomeMethod()
 {
 if (this._disposed) { throw new ObjectDisposedException(this.GetType().Name); }
 }
}
 
public class DisposableSubClass : DisposableClass
{
 private bool _disposed = false;
 
 protected override void Dispose(bool disposing)
 {
 if (!_disposed)
 {
 try
 {
 if (disposing)
 {
 // Release the managed resources you added in
 // this derived class here.
 }
 // Release the native unmanaged resources you added
 // in this derived class here.
 
 _disposed = true;
 }
 finally
 {
 // Call Dispose on your base class.
 base.Dispose(disposing);
 }
 }
 }
}

using (DisposableClass c = new DisposableClass())
{
 c.SomeMethod();
}

IEquatable Interface

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Enables instances of a class to be compared for equality.
- e.g.: if (a = = b)

Good practice

Whenever implementing IEquatable, also override Object.Equals and if needed the == and != operator.
- See Implementing IEquatable Properly for more details.

Examples

Comparing Custom Class

class MyNumber : IEquatable<MyNumber>
{
 private int _x;
 
 public int X
 {
 get { return this._x; }
 set { this._x = value; }
 }
 
 public MyNumber(int x)
 {
 this._x = x;
 }
 
 public override int GetHashCode()
 {
 return this._x.GetHashCode();
 }
 
 public override bool Equals(object obj)
 {
 if (obj == null) return base.Equals(obj);
 
 if (!(obj is MyNumber))
 {
 throw new InvalidCastException("The 'obj' argument is not a MyNumber object.");
 }
 else
 {
 return Equals(obj as MyNumber);
 }
 }
 
 #region IEquatable<MyNumber> Members
 public bool Equals(MyNumber other)
 {
 if (other == null)
 {
 return false;
 }
 else
 {
 return (other.X == this.X);
 }
 }
 #endregion
 
 public static bool operator ==(MyNumber a, MyNumber b)
 {
 if (object.ReferenceEquals(a, b)) return true;
 if (object.ReferenceEquals(a, null)) return false;
 if (object.ReferenceEquals(b, null)) return false;
 
 return a.Equals(b);
 }
 
 public static bool operator !=(MyNumber a, MyNumber b)
 {
 return !(a == b);
 }
}

MyNumber a = new MyNumber(10);
MyNumber b = new MyNumber(10);
 
Console.WriteLine(a.Equals(b)); // True
Console.WriteLine(a == b); // True

IFormattable Interface

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Enable classes to display themselves with greater control than ToString.

Examples

Custom Formats

struct MyPoint: IFormattable
{
 private int _x;
 private int _y;
 
 public int X
 {
 get { return this._x; }
 }
 
 public int Y
 {
 get { return this._y; }
 }
 
 public MyPoint(int x, int y)
 {
 this._x = x;
 this._y = y;
 }
 
 #region IFormattable Members
 public string ToString(string format, IFormatProvider formatProvider)
 {
 string formattedString;
 if (format != null) { format = format.ToLower(); }
 
 switch (format)
 {
 case null: 
 formattedString = String.Format("({0}, {1})", this.X, this.Y);
 break;
 case "x":
 formattedString = this.X.ToString();
 break;
 case "y":
 formattedString = this.Y.ToString();
 break;
 default: 
 throw new FormatException(String.Format("Invalid format string: '{0}'.", format));
 }
 
 return formattedString;
 }
 #endregion
}

MyPoint a = new MyPoint(5, 15);
Console.WriteLine("The point's value is {0}", a);
Console.WriteLine("The point's x value is {0:x}", a);
Console.WriteLine("The point's y value is {0:y}", a);
 
// Prints:
// The point's value is (5, 15)
// The point's x value is 5
// The point's y value is 15

IsolatedStorageFile Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Represents a sandbox location to store application specific data in.
Assembly/Machine store for application-level data.
Assembly/User store for user-level data.
Use IsolatedStorageFileStream to work with files in a store.

Good practice

Don’t write your state to local .xml files everywhere on the system, but store them in an IsolatedStorage.

Examples

Initialize Store

IsolatedStorageFile a = IsolatedStorageFile.GetMachineStoreForAssembly();
 
foreach (var f in a.GetFileNames("*"))
{
 Console.WriteLine(f);
}

IsolatedStorageFileStream Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Represents a sandbox location to store application specific data in.
Assembly/Machine store for application-level data.
Assembly/User store for user-level data.
File paths are relative inside a store.

Good practice

Don’t write your state to local .xml files everywhere on the system, but store them in an IsolatedStorage.

Examples

Using a Store

IsolatedStorageFile a = IsolatedStorageFile.GetMachineStoreForAssembly();
IsolatedStorageFileStream b = new IsolatedStorageFileStream("MyState.config", FileMode.OpenOrCreate, a);
 
StreamWriter c = new StreamWriter(b);
c.WriteLine("Hello World!");
c.Close();
 
foreach (var storeFile in a.GetFileNames("*"))
{
 Console.WriteLine(storeFile);
}
 
IsolatedStorageFileStream d = new IsolatedStorageFileStream("MyState.config", FileMode.Open, a);
 
StreamReader e = new StreamReader(d);
Console.WriteLine(e.ReadToEnd());
e.Close();

Match Class and MatchCollection Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Contains the result of matches in a regex.

Examples

Scanning Text

string input = "Hello world! Hello!";
string regex = "(?<1>ll)";
 
for (Match m = Regex.Match(input, regex); m.Success; m = m.NextMatch())
{
 Console.WriteLine(m.Groups[1].Index + ": " + m.Groups[1]);
}

Formatting Text

string input = "[link=\"http://blog.cumps.be/starting-exam-70-536-study/\"]Starting Exam 70-536 Study[/link]";
string regex = @"\[link=""(?<link>((.|\n)*?))""\](?<text>((.|\n)*?))\[\/link\]";
 
Console.WriteLine(Regex.Match(input, regex).Result("${text}: ${link}"));

MemoryStream Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Provides an in-memory implementation of a Stream.
Is meant for temporary streams.
- Possibly to minimize the time you need to hold another stream open, e.g.: locking a file with FileStream.

Good practice

Remember to call Close on a stream.
- Make sure to call them in the right order, and not too early. See the example below, where closing ‘b’ to early would close ‘a’ as well.

Examples

Write to File

// MemoryStreams are usually temporary streams
// intended to be written to another stream later
MemoryStream a = new MemoryStream();
StreamWriter b = new StreamWriter(a);
 
b.WriteLine("Hello World");
b.WriteLine("Bye Bye!");
b.Flush();
 
FileStream c = File.Create(@"C:\Public\TestMem.txt");
a.WriteTo(c);
 
c.Close();
b.Close();
a.Close();

NameValueCollection Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Acts like a StringDictionary which can contain duplicate keys.
Values can be retrieved by key and index.

Good practice

When possible, use a generic collection instead.

Examples

Simple Usage

NameValueCollection valueCollection = new NameValueCollection();
 
valueCollection.Add("Key1", "Value1");
valueCollection.Add("Key1", "Value2");
valueCollection.Add("Key2", "Value3");
 
foreach (string s in valueCollection.Keys)
{
 Console.WriteLine(valueCollection[s]);
}

Path Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Provides helper methods for working with file system paths as strings.

Examples

Change Extensions

// This does NOT rename the file! It is only a string operation.
Console.WriteLine(Path.ChangeExtension(@"C:\Public\Test.txt", ".doc"));

Combine Paths

string root = @"C:\Public\Test";
string subdir = @"Subtest\";
string combined = Path.Combine(root, subdir);
Console.WriteLine(combined);
 
// If there is no trailing slash at Subtest\ this would give
// C:\Public\Test instead of C:\Public\Test\Subtest
Console.WriteLine(Path.GetDirectoryName(combined));

Create Random Files

Console.WriteLine(Path.ChangeExtension(Path.GetRandomFileName(), ".txt"));

Queue Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

First-in, First-out logic.
Acts as a queue of customers in a bank.

Good practice

When possible, use the generic version of Queue<T>.

Examples

Queueing and Dequeuing

Queue q = new Queue();
q.Enqueue("Hello");
q.Enqueue("World");
Console.WriteLine(q.Dequeue() + " " + q.Dequeue());
 
Queue<string> qg = new Queue<string>();
qg.Enqueue("Hello");
qg.Enqueue("World");
Console.WriteLine(qg.Dequeue() + " " + qg.Dequeue());

Reference Types

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Data stored on the heap, a pointer to that data is stored on the stack.
The heap gets cleaned by the garbage collector, removing items which don’t have a reference to it anymore.
Copying reference types will only copy the pointer, not duplicate the data.
- This means altering a reference type through one variable will also be reflected when accessing it through another variable, pointing at the same heap location.
Reference types can be immutable, System.String being the most known one.

Good practice

Use String.Concat, String.Join, String.Format or a StringBuilder when excessively working with strings.
- See String Concatenation vs Memory Allocation for detailed analysis of string operations.

Examples

Value types vs Reference types

// ---------------------------------------------------------------------------------------------
// Example of reference types.
// ---------------------------------------------------------------------------------------------
 
MyNumber a, b;
a = new MyNumber(5); // Store 5 in a
b = a; // Copy the reference to 'MyNumber' a into b
a.X = 10; // Modify a, but since b is pointing to the same object, b will change too
 
Console.WriteLine(a.X); // Will print 10
Console.WriteLine(b.X); // Will print 10

class MyNumber
{
 private int _x;
 
 public int X
 {
 get { return this._x; }
 set { this._x = value; }
 }
 
 public MyNumber(int x)
 {
 this._x = x;
 }
}

Strings

string[] words = new string[] { "Word1", "Word2", "Word3" };
Console.WriteLine(String.Join(" | ", words)); // Word1 | Word2 | Word3
Console.WriteLine(String.Concat(words)); // Word1Word2Word3
 
StringBuilder longString = new StringBuilder();
longString.Append("Hello World");
Console.WriteLine(longString.ToString());

Regex Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Used to work with regular expressions.
A good free tool to read and create regexs is Expresso.
There are many good tutorials around.

Good practice

Always include the ^ and $ when matching expressions.
- Without these you will simply check if a string contains the regex, which can expose a security vulnerability.
- See the example below for an example on what can happen when forgetting the leading ^.
Start your regex with the @ sign for readability, instead of having to escape backslashes.

Examples

Checking Input

string regex = @"^\d{5}$";
 
Console.WriteLine(Regex.IsMatch("12345", regex) ? "Matches!" : "No match");
Console.WriteLine(Regex.IsMatch("1234", regex) ? "Matches!" : "No match");
Console.WriteLine(Regex.IsMatch("DROP DATABASE YourApp; -- 12345", @"\d{5}$") ? "Matches!" : "No match");

Replacing Input

string input = "The dog ate a bone.";
string regex = @"^The (?<animal>\w+)\b ate (?<food>.+)\.$";
 
Console.WriteLine(Regex.Replace(input, regex, "Animal: ${animal}, Food: ${food}"));

Using Groups

Match x = Regex.Match("Wim", "(?<FirstLetter>.).*");
Console.WriteLine(x.Groups["FirstLetter"]);

Snippets

Tue, 26 Aug 2008 00:00:00 +0200

Operator Overloading

struct MyPoint
{
 private int _x;
 private int _y;
 
 public int X
 {
 get { return this._x; }
 }
 
 public int Y
 {
 get { return this._y; }
 }
 
 public MyPoint(int x, int y)
 {
 this._x = x;
 this._y = y;
 }
 
 public static MyPoint operator +(MyPoint a, int b)
 {
 // Returns a new object, conform to the immutability.
 return new MyPoint(a.X + b, a.Y + b);
 }
}

Predicates

static void Main(string[] args)
{
 int[] ar = { 3, 1, 2 };
 Console.WriteLine(Array.TrueForAll<int>(ar, new Predicate<int>(Check))); // Returns False
}
 
static bool Check(int target)
{
 return (target == 3);
}

SortedList Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Key-value pair based collection.
Contains DictionaryEntry objects.
Accessible by index and key.
Sorts items when they are added.

Good practice

When possible, use a generic collection instead of the object-based SortedList.

Examples

Adding and Removing Elements

SortedList a = new SortedList();
a.Add("Key2", "Hello");
a.Add("Key1", "World");
a.Add("Key0", "Start");
 
Console.WriteLine(a["Key1"] + " " + a["Key2"]);
Console.WriteLine();
foreach (DictionaryEntry d in a) { Console.WriteLine(d.Value); }
Console.WriteLine();
foreach (var v in a.Values) { Console.WriteLine(v); }
Console.WriteLine();
a.Remove("Key1");
foreach (var k in a.Keys) { Console.WriteLine(a[k]); }

Specialized Dictionary

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Special case dictionaries
ListDictionary
- Used as a HashTable for fewer than 10 items.
- Implemented as a simple linked list behind the scenes.
- Same interface as HashTable, easy to replace.
HybridDictionary
- Used as a HashTable for unknown sizes of items.
- Implemented as a combination between HashTable and ListDictionary.
- Switches over to a HashTable when the collection becomes too big.
- Same interface as HashTable, easy to replace.
OrderedDictionary
- Used as a HashTable when you need access to the index.
- A plain dictionary mapping, like a cross between HashTable and ArrayList.

Good practice

When possible, use a generic collection instead.

Examples

ListDictionary: Adding and Removing Elements

ListDictionary a = new ListDictionary();
a.Add("Key2", "Hello");
a.Add("Key1", "World");
a.Add("Key0", "Start");
 
Console.WriteLine(a["Key1"] + " " + a["Key2"]);
Console.WriteLine();
foreach (DictionaryEntry d in a) { Console.WriteLine(d.Value); }
Console.WriteLine();
foreach (var v in a.Values) { Console.WriteLine(v); }
Console.WriteLine();
a.Remove("Key1");
foreach (var k in a.Keys) { Console.WriteLine(a[k]); }

HybridDictionary: Adding and Removing Elements

HybridDictionary a = new HybridDictionary();
a.Add("Key2", "Hello");
a.Add("Key1", "World");
a.Add("Key0", "Start");
 
Console.WriteLine(a["Key1"] + " " + a["Key2"]);
Console.WriteLine();
foreach (DictionaryEntry d in a) { Console.WriteLine(d.Value); }
Console.WriteLine();
foreach (var v in a.Values) { Console.WriteLine(v); }
Console.WriteLine();
a.Remove("Key1");
foreach (var k in a.Keys) { Console.WriteLine(a[k]); }

OrderedDictionary: Adding and Removing Elements

OrderedDictionary a = new OrderedDictionary();
a.Add("Key1", "Hello");
a.Add("Key2", "World");
a.Add("Key0", "Start");
a.Insert(1, "Key10", "Inserted");
 
Console.WriteLine(a["Key1"] + " " + a["Key2"]);
Console.WriteLine();
foreach (DictionaryEntry d in a) { Console.WriteLine(d.Value); }
Console.WriteLine();
foreach (var v in a.Values) { Console.WriteLine(v); }
Console.WriteLine();
a.Remove("Key1");
a.RemoveAt(0);
foreach (var k in a.Keys) { Console.WriteLine(a[k]); }

Specialized String classes

Tue, 26 Aug 2008 00:00:00 +0200

Overview

StringCollection
- Acts as a strongly typed ArrayList of strings. Equivalent to List<string> with generics.
StringDictionary
- Acts as a strongly typed Hashtable of strings. Equivalent to Dictionary<string> with generics.

Good practice

When possible, use a List<string> or Dictionary<string, string> instead.

Stack Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Last-in, First-out logic.
Acts as a stack of papers on a desk.

Good practice

When possible, use the generic version of Stack<T>

Examples

Push and Pop

Stack s = new Stack();
s.Push("Hello");
s.Push("World");
Console.WriteLine(s.Pop() + " " + s.Pop());
 
Stack<string> sg = new Stack<string>();
sg.Push("Hello");
sg.Push("World");
Console.WriteLine(sg.Pop() + " " + sg.Pop());

Starting Exam 70-536 Study

Tue, 26 Aug 2008 00:00:00 +0200

Taking a little break right now, got a bit of a burn out, lack of sleep might have something to do with it :)

Stream Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

A stream is an abstraction of a sequence of bytes, which helps isolating the programmer from the underlying implementation.

Good practice

Remember to call Close on a stream.
- Calling Close on a Stream flushes any buffered data, essentially calling Flush for you.
- Close releases operating system resources such as file handles, network connections, or memory used for any internal buffering.
- Make use of the finally block in a try/catch/finally when working with a stream, demonstrated below.

Examples

Finally Block

StreamReader sr = new StreamReader("text.txt");
try
{
 Console.WriteLine(sr.ReadToEnd());
}
catch (Exception ex)
{
 // If there are any problems reading the file, display an error message
 Console.WriteLine("Error reading file: " + ex.Message);
}
finally
{
 // Close the StreamReader, whether or not an exception occurred
 sr.Close();
}

StreamReader Class and StreamWriter Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Provides extra helper methods intended to read a stream as a string.
Calling Close() on a StreamReader will close the underlying Stream as well.

Good practice

Remember to call Close on a stream.
Use ‘using’ statements when you want the stream to be automatically closed at the end.

Examples

Read a File

// FileStream is simply a stream around a file, overriding Stream methods
FileStream a = new FileStream(@"C:\Public\Test.txt", FileMode.Open);
 
while (a.Position != a.Length)
{
 Console.Write((char)a.ReadByte());
}
 
a.Seek(0, SeekOrigin.Begin);
 
StreamReader b = new StreamReader(a);
Console.WriteLine(b.ReadToEnd());
b.Close();

Writing a File

// FileStream is simply a stream around a file, overriding Stream methods
FileStream a = new FileStream(@"C:\Public\Test.txt", FileMode.Create);
 
using (var writer = new StreamWriter(a))
{
 writer.AutoFlush = true;
 writer.WriteLine("Hello World");
}
 
// The FileStream has been closed because of the using statement
a = new FileStream(@"C:\Public\Test.txt", FileMode.Open);
StreamReader b = new StreamReader(a);
Console.WriteLine(b.ReadToEnd());
b.Close();
 
// Simple version if you only need to read the entire file
Console.WriteLine(File.ReadAllText(@"C:\Public\Test.txt"));

StringBuilder Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

A StringBuilder maintains an internal buffer instead of allocating a new string every time.
Initial buffer size is 16 bytes, but can be passed via the constructor.
Use a StringBuilder when appending lots of strings.

Good practice

Use StringBuilder when excessively working with strings.
- See String Concatenation vs Memory Allocation for detailed analysis of string operations.
Try to estimate the initial size for a StringBuilder whenever possible, this will avoid unneeded buffer growths.

Examples

Concatenating

public string GetBuildString()
{
	StringBuilder builder = new StringBuilder();
	builder.Append("SELECT column1,");
	builder.Append("	 column2,");
	builder.Append("	 column3,");
	builder.Append("	 column4,");
	builder.Append("	 column5,");
	builder.Append("	 column6,");
	builder.Append(" FROM table1 t1");
	builder.Append(" JOIN table2 t2");
	builder.Append("	ON t1.column1 = t2.column1");
	return builder.ToString();
}

StringReader Class and StringWriter Class

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Used to read and write in-memory strings.
StringWriter uses a StringBuilder behind the scenes.

Examples

Read and Write Strings

StringWriter a = new StringWriter();
a.Write("Hello World!");
a.Write(a.NewLine);
a.Write("I span two lines!");
 
StringReader r = new StringReader(a.ToString());
 
while (r.Peek() != -1)
{
 Console.WriteLine(r.ReadLine());
}

TypeForwardTo Attribute

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Attribute to indicate a type has moved from one assembly to another.
Enables you to update your assemblies without recompiling the clients using them.
Great example can be found at What is TypeForwardedToAttribute?

Value Types

Tue, 26 Aug 2008 00:00:00 +0200

Overview

Stored on the stack.
Contain a value, not a reference.
Inherit from System.Value
Exists of built-in types, user-defined types and enumerations.
Prefer to use Int32 (int) and Double (double) for counters/floating numbers. These are optimized by the framework/hardware.
Nullable types have .HasValue and .Value properties to determine if they have been set.
- Console.WriteLine( (myBool.HasValue) ? myBool.Value.ToString() : “not set” );
Structures are value types as well, user-defined value types.
Enums are stored as value types, and primarily used for code readability.
object.GetType().IsValueType returns true for value types.

Good practice

Always define the value of a value type upon declaration.
- Initialize it to null if needed.
- The use of nullable types can help to enable bool variables to store null.
  - Nullable<bool> myBool = null;
  - bool? myBool = null;
  - Read Nullable<T> Usage Guidelines however, to avoid using a bool as a tri-state switch.
Use structures for objects which represent a single combined value, which is smaller then 16 bytes.
Structures should be immutable.
Don’t define a default constructor on a structure.

Examples

Value types vs Reference types

// ---------------------------------------------------------------------------------------------
// Example of value types holding a value instead of a reference.
// ---------------------------------------------------------------------------------------------
 
int a, b;
a = 5; // Store 5 in a
b = a; // Copy the value of a into b, instead of holding a reference
a = 10; // Store 10 in a, will not affect the value of b, since it's been copied.
Console.WriteLine(a); // Will print 10
Console.WriteLine(b); // Will print 5

Nullable Types

Nullable<bool> myBool = null; 
Console.WriteLine((myBool.HasValue) ? myBool.Value.ToString() : "not set");
myBool = true;
Console.WriteLine((myBool.HasValue) ? myBool.Value.ToString() : "not set");

Structures

struct MyPoint
{
 private int _x;
 private int _y;
 
 public int X
 {
 get { return this._x; }
 }
 
 public int Y
 {
 get { return this._y; }
 }
 
 public MyPoint(int x, int y)
 {
 this._x = x;
 this._y = y;
 }
}

Enums

enum TestEnum : int
{
 Value1,
 Value2
}
 
static void Main(string[] args)
{
 TestEnum en = TestEnum.Value1;
 Console.WriteLine((int)en + " : " + en);
}