Design

Implementierung

public abstract class Command
{
    public abstract void Execute();

    public abstract void Undo();

    public abstract void Redo();
}

public class CommandManager
{
    #region Static Attributes

    private static object _lockObject = new object();
    private static CommandManager _instance = null;

    #endregion Static Attributes

    #region Attributes

    private Stack<Command> _commandStack = new Stack<Command>();
    private Stack<Command> _undoneStack = new Stack<Command>();

    #endregion Attributes

    #region ctor

    private CommandManager() { }

    #endregion ctor

    #region Static Methods

    public static CommandManager GetInstance
    {
        get
        {
            if (_instance == null)
            {
                lock (_lockObject)
                {
                    _instance = new CommandManager();
                }
            }
            return _instance;
        }
    }

    #endregion Static Methods

    #region Public Methods

    public void Execute(Command command)
    {
        command.Execute();
        _commandStack.Push(command);
    }

    public void Redo()
    {
        Command redoCommand = _undoneStack.Pop();
        redoCommand.Redo();
        _commandStack.Push(redoCommand);
    }

    public void Undo()
    {
        Command undoCommand = _commandStack.Pop();
        undoCommand.Undo();
        _undoneStack.Push(undoCommand);
    }

    #endregion Public Methods
}

public class Person : ICloneable
{
    #region Properties

    public String Firstname { get; set; }
    public String Lastname { get; set; }

    #endregion Properties

    #region ICloneable Members

    public object Clone()
    {
        Person p = new Person();
        p.Firstname = this.Firstname;
        p.Lastname = this.Lastname;
        return p;
    }

    #endregion ICloneable Members

    #region Overrides

    public override string ToString()
    {
        return String.Format("{0}, {1}", Lastname, Firstname);
    }

    #endregion Overrides
}

public class PersonCommand : Command
{
    private Person _person;
    private Person _personStateBefore;

    public PersonCommand(Person person)
    {
        _person = person;
    }

    public override void Execute()
    {
        _personStateBefore = _person.Clone() as Person;

        _person.Firstname = "Norbert";
        _person.Lastname = "Eder";
    }

    public override void Undo()
    {
        _person.Firstname = _personStateBefore.Firstname;
        _person.Lastname = _personStateBefore.Lastname;
    }

    public override void Redo()
    {
        Execute();
    }
}

CommandManager manager = CommandManager.GetInstance;

Person p = new Person();
p.Firstname = "<not set>";
p.Lastname = "<not set>";
Console.WriteLine(
    String.Format("Before first execution: " + p.ToString()));

manager.Execute(new PersonCommand(p));
Console.WriteLine(
    String.Format("After first execution : " + p.ToString()));

manager.Undo();
Console.WriteLine(
    String.Format("After undo            : " + p.ToString()));

manager.Redo();
Console.WriteLine(
    String.Format("After redo            : " + p.ToString()));

Console.Read();

Fazit

Abgrenzung

• Austauschen von Verhaltensweisen via Konfiguration als auch zur Laufzeit
• Austauschen von einzelnen Methoden via Konfiguration als auch zur Laufzeit

Einführung

Strategy Pattern hilft bei Verhaltensänderungen

public interface IStrategy
{
    void DoWork();
}

public class ConcreteStrategy1 : IStrategy
{
    #region IStrategy Members

    public void DoWork()
    {
        Console.WriteLine("ConcreteStrategy1");
    }

    #endregion
}

public class ConcreteStrategy2 : IStrategy
{
    #region IStrategy Members

    public void DoWork()
    {
        Console.WriteLine("ConcreteStrategy2");
    }

    #endregion
}

public class StrategyContext
{
    private IStrategy _strategy;

    public StrategyContext(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public void DoWork()
    {
        _strategy.DoWork();
    }
}

class Program
{
    static void Main(string[] args)
    {
        StrategyContext context = new StrategyContext(new ConcreteStrategy1());
        context.DoWork();
    }
}

Austausch von einzelnen Methoden

public interface ICommand
{
    void Execute();
}

public class CustomWorker1 : ICommand
{
    #region ICommand Members

    public void Execute()
    {
        Console.WriteLine("CustomWorker1");
    }

    #endregion
}

public class CustomWorker2 : ICommand
{
    #region ICommand Members

    public void Execute()
    {
        Console.WriteLine("CustomWorker2");
    }

    #endregion
}

public class StrategyProxy
{
    private IStrategy _usedStrategy;

    public StrategyProxy(IStrategy usedStrategy)
    {
        _usedStrategy = usedStrategy;
    }

    public void DoWork()
    {
        _usedStrategy.DoWork();
    }

    public void DoWork(ICommand customWorker)
    {
        customWorker.Execute();
    }
}

Fazit

• 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