• Deklaration der einzelnen Elemente, damit via Sourcecode darauf zugegriffen werden kann.
• Methode InitializComponent
• Methode Connect

• Gewohnheit: Windows Forms kennt man und weiß sie auch einzusetzen. Probleme sind genauso bekannt wie die möglichen Umsetzungsvarianten. Der Umstieg zu einer deklarativen Form (obwohl das ja auch nur ein Teil der WPF ist) ist somit nicht einfach zu bewerkstelligen, zumal bei kleinen Anwendungen, Tools, Hilfen die Vorteile bei weitem nicht so klar auf der Hand liegen.
• Es ist neu. Neues verursacht immer wieder Angst. Man weiß nicht, womit genau man’s zu tun hat, wie es reagiert, was man damit alles machen kann. Im ersten Schritt werden daher grundlegende Informationen besorgt, welche dann natürlich aber auch sehr schnell zeigen können, dass etwas eventuell aufwändiger ist, als man es bisher gewohnt war. In einigen Fällen (und hier zähle ich die WPF dazu) wirkt dies jedoch nur auf den ersten Blick so. Allerdings muss hier auch die Größe der Anwendung berücksichtigt werden.
• Es ist anders. Ganz klar, es ist natürlich anders, weil es neu ist. Bei neuen Techniken werden oft neue (oder aufgewärmte) Wege gegangen. Im Falle der WPF handelt es sich dabei um den Einsatz einer deklarativen Programmierung, soweit es zumindest XAML betrifft. Dies mag auf den ersten Blick etwas aufwändig erscheinen, dennoch ermöglicht gerade dies ungeahnte Möglichkeiten in der Trennung zwischen Design und Logik.

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