Dictionary<int, string> dict = new Dictionary<int, string>();

Type dictType = dict.GetType();

Console.WriteLine("IsGenericType: " + dictType.IsGenericType);

foreach (Type t in dictType.GetGenericArguments())
    Console.WriteLine("Argument-Typ: " + t.FullName);

if (dictType.IsGenericParameter)
    foreach (Type t in dictType.GetGenericParameterConstraints())
        Console.WriteLine("Contraint: " + t.FullName);

Type typeDef = dictType.GetGenericTypeDefinition();
Console.WriteLine("TypeDefinition: " + typeDef.FullName);

IsGenericType: True
Argument-Typ: System.Int32
Argument-Typ: System.String
TypeDefinition: System.Collections.Generic.Dictionary`2

Einführung

Beispiel aus dem .NET Framework

SqlConnectionStringBuilder connStringBuilder = 
  new SqlConnectionStringBuilder();
connStringBuilder.DataSource = "(local)";
connStringBuilder.InitialCatalog = "MyDatabase";
connStringBuilder.UserID = "username";
connStringBuilder.Password = "$password%";

SqlConnection sqlConn = 
  new SqlConnection(connStringBuilder.ToString());

Ein eigenes Beispiel

public class AddressParser : AParser
{
    AddressBuilder _builder = null;

    public AddressParser(IBuilder builder)
    {
        _builder = (AddressBuilder)builder;
    }

    public override void Parse(XmlNode data)
    {
        if (data != null && _builder != null)
        {
            _builder.ResetData();

            XmlNode xnStreet = data.SelectSingleNode("street");
            XmlNode xnStreetNumber = 
                data.SelectSingleNode("streetnumber");
            XmlNode xnZip = data.SelectSingleNode("zip");
            XmlNode xnCity = data.SelectSingleNode("city");
            XmlNode xnCountry = data.SelectSingleNode("country");

            if (xnStreet != null) 
                _builder.Street = xnStreet.InnerText;
            if (xnStreetNumber != null) 
                _builder.StreetNumber = xnStreetNumber.InnerText;
            int zip = 0;
            if (xnZip != null) 
                Int32.TryParse(xnZip.InnerText, out zip);
            _builder.Zip = zip;
            if (xnCity != null) 
                _builder.City = xnCity.InnerText;
            if (xnCountry != null) 
                _builder.Country = xnCountry.InnerText;                
        }
    }
}

public class AddressBuilder : ABuilder
{
    private string _street = null;
    private string _streetnumber = null;
    private int _zip = 0;
    private string _city = null;
    private string _country = null;

    public string Street
    {
        get { return this._street; }
        set { this._street = value; }
    }

    public string StreetNumber
    {
        get { return this._streetnumber; }
        set { this._streetnumber = value; }
    }

    public int Zip
    {
        get { return this._zip; }
        set { this._zip = value; }
    }

    public string City
    {
        get { return this._city; }
        set { this._city = value; }
    }

    public string Country
    {
        get { return this._country; }
        set { this._country = value; }
    }

    public void ResetData()
    {
        this._city = null;
        this._country = null;
        this._street = null;
        this._streetnumber = null;
        this._zip = 0;
    }

    public override BaseObject Build()
    {
        Address address = new Address();

        address.City = this._city;
        address.Country = this._country;
        address.Street = this._street;
        address.StreetNumber = this._streetnumber;
        address.Zip = this._zip;

        return address;
    }
}

List<Address> addresses = new List<Address>();

XmlDocument doc = new XmlDocument();
doc.Load("addresslist.xml");

XmlNodeList xnlAddresses = doc.SelectNodes("/addresses/address");

if (xnlAddresses != null && xnlAddresses.Count > 0) 
{
    AddressBuilder builder = new AddressBuilder();
    AddressParser parser = new AddressParser(builder);

    foreach (XmlNode xnAddress in xnlAddresses) 
    {
        parser.Parse(xnAddress);
        Address address = (Address)builder.Build();
        addresses.Add(address);
    }
}

foreach (Address a in addresses)
{
    Console.WriteLine(a.ToString());
    Console.WriteLine("---------------------");
}

Console.Read();

Fazit