• Case Diagrams
• Component Diagrams
• State Charts
• Class Diagrams
• Activity Diagrams
• Persistent Object Models

• Erweiterungen Data Access Application Block: Provider für MySql, SqLite und SqlEx
• Erweiterungen Exception Handling Application Block: SqlException Wrap Handler
• Erweiterungen Logging Application Block: LogParser
• Erweiterungen Policy Injection Application Block: PostSharp4EntLib, neue Matching-Regeln und neue Call-Handler
• Erweiterungen Validation Application Block: CollectionCountValidator, TypeValidator, ObjectValidator usw.

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Practices.EnterpriseLibrary.ExceptionHandling;

namespace ExceptionLoggingDemo
{
    public class DoSomethingClass
    {
        public void ThrowAnException()
        {
            try
            {
                int i = 0;
                i = 1 / i;
            }
            catch (Exception ex)
            {
                ExceptionPolicy.HandleException(ex, "DemoException");
                throw ex;
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace ExceptionLoggingDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            new DoSomethingClass().ThrowAnException();
            Console.WriteLine("Exception thrown");
            Console.ReadKey();
        }
    }
}

[ConfigurationElementType(typeof(CustomTraceListenerData))]
public class NLogTraceListener : CustomTraceListener
{
    private LogLevel _logLevel = LogLevel.Info;

    public override void TraceData(
        TraceEventCache eventCache, 
        string source, 
        TraceEventType eventType, 
        int id, 
        object data)
    {
        if (data is LogEntry && this.Formatter != null)
        {
            switch (eventType)
            {
                case TraceEventType.Critical:
                    _logLevel = LogLevel.Fatal;
                    break;
                case TraceEventType.Error:
                    _logLevel = LogLevel.Error;
                    break;
                case TraceEventType.Information:
                    _logLevel = LogLevel.Info;
                    break;
                case TraceEventType.Warning:
                    _logLevel = LogLevel.Warn;
                    break;
                case TraceEventType.Verbose:
                    _logLevel = LogLevel.Debug;
                    break;
                default:
                    _logLevel = LogLevel.Info;
                    break;
            }

            this.WriteLine(this.Formatter.Format(data as LogEntry));
        }
        else
        {
            this.WriteLine(data.ToString());
        }
    }

    public override void Write(string message)
    {
        LogManager.GetCurrentClassLogger().Log(_logLevel, message);
    }

    public override void WriteLine(string message)
    {
        LogManager.GetCurrentClassLogger().Log(_logLevel, message);
    }
}

[ConfigurationElementType(typeof(CustomTraceListenerData))]

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

using System;
using System.Collections.Generic;
using System.Text;

namespace ProxyPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            CalculatorProxy proxy = new CalculatorProxy();
            Console.WriteLine(
                String.Format("12 + 17 = {0}", proxy.Add(12, 17))
                );
            Console.WriteLine(
                String.Format("12 - 17 = {0}", proxy.Sub(12, 17))
                );

            Console.Read();
        }
    }

    public interface ICalculator
    {
        decimal Add(decimal x, decimal y);
        decimal Sub(decimal x, decimal y);
    }

    public class Calculator : ICalculator
    {
        public decimal Add(decimal x, decimal y)
        {
            return x + y;
        }

        public decimal Sub(decimal x, decimal y)
        {
            return x - y;
        }
    }

    public class CalculatorProxy : ICalculator
    {
        private Calculator _calculator = new Calculator();

        public decimal Add(decimal x, decimal y)
        {
            return _calculator.Add(x, y);
        }

        public decimal Sub(decimal x, decimal y)
        {
            return _calculator.Sub(x, y);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Security;

namespace ProxyPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                CalculatorProxy proxy = new CalculatorProxy("test2");
                Console.WriteLine(
                    String.Format("12 + 17 = {0}", proxy.Add(12, 17))
                    );
                Console.WriteLine(
                    String.Format("12 - 17 = {0}", proxy.Sub(12, 17))
                    );

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }
    }

    public interface ICalculator
    {
        decimal Add(decimal x, decimal y);
        decimal Sub(decimal x, decimal y);
    }

    public class Calculator : ICalculator
    {
        public decimal Add(decimal x, decimal y)
        {
            return x + y;
        }

        public decimal Sub(decimal x, decimal y)
        {
            return x - y;
        }
    }

    public class CalculatorProxy : ICalculator
    {
        private Calculator _calculator = new Calculator();
        private string _password = "test";
        private string _givenPassword = null;

        public CalculatorProxy(string password)
        {
            this._givenPassword = password;
        }

        public decimal Add(decimal x, decimal y)
        {
            if (this._givenPassword == this._password)
                return _calculator.Add(x, y);
            else
                throw new SecurityException("Not allowed: Add");
        }

        public decimal Sub(decimal x, decimal y)
        {
            if (this._givenPassword == this._password)
                return _calculator.Sub(x, y);
            else
                throw new SecurityException("Not allowed: Sub");
        }
    }
}

Microsoft.Practices.EnterpriseLibrary.Logging

Logger.Write("test");