Implementierung

<Application x:Class="WpfExceptionDemo.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    StartupUri="Window1.xaml" 
    DispatcherUnhandledException="App_DispatcherUnhandledException">
    <Application.Resources>
         
    </Application.Resources>
</Application>

public partial class App : Application
{
    public App()
    {
        this.DispatcherUnhandledException += 
            new DispatcherUnhandledExceptionEventHandler(
                App_DispatcherUnhandledException);
    }
}

void App_DispatcherUnhandledException(
    object sender, 
    DispatcherUnhandledExceptionEventArgs e)
{
    MessageBox.Show(
        String.Format("An error occured: {0}", e.Exception.Message), 
            "Error");
    e.Handled = true;
}

Wichtige Hinweise

Fazit

<Window x:Class="WpfXCodeDemo.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="63" Width="300">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="25"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Button x:Name="btnClickMe" 
                Content="Click Me" 
                Click="btnClickMeClick"/>
        <x:Code>
            void btnClickMeClick(object sender, 
                RoutedEventArgs e)
            {
                MessageBox.Show("Clicked");
            }
        </x:Code>
    </Grid>
</Window>

Hinweise zum x:Code Element

Resultierende Probleme

Fazit

Einleitung

Erste Schritte

<UserControl x:Class="WpfAnimationDemo.PictureControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Height="300" Width="300">
    <DockPanel>
        <DockPanel Background="Black">
            <Image x:Name="ImageControl" Margin="5"/>
        </DockPanel>
    </DockPanel>
</UserControl>

public partial class PictureControl : UserControl
{
    private Size _originSize;
    private Point _originLocation;

    public static DependencyProperty OriginSizeProperty = 
        DependencyProperty.Register(
            "OriginSize", 
            typeof(Size), typeof(Size));
    public static DependencyProperty OriginLocationProperty = 
        DependencyProperty.Register(
        "OriginLocation", 
        typeof(Point), typeof(Point));

    public PictureControl()
    {
        InitializeComponent();
    }

    public void SetImage(string path)
    {
        ImageControl.Source = BitmapFrame.Create(new Uri(path));
    }

    public Size OriginSize
    {
        get { return _originSize; }
        set { this._originSize = value; }
    }

    public Point OriginLocation
    {
        get { return _originLocation; }
        set { _originLocation = value; }
    }
}

<Window x:Class="WpfAnimationDemo.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:WpfAnimationDemo"
    Title="Picture Animation Demo" Height="570" Width="800">
    <Canvas>
        <local:PictureControl 
            x:Name="PicControl1" 
            HorizontalAlignment="Left" 
            Width="160" 
            Height="120" 
            Canvas.Left="10" 
            Canvas.Top="10" />
        <local:PictureControl 
            x:Name="PicControl2" 
            HorizontalAlignment="Left" 
            Width="160" 
            Height="120" 
            Canvas.Left="10" 
            Canvas.Top="140"/>
        <local:PictureControl 
            x:Name="PicControl3" 
            HorizontalAlignment="Left" 
            Width="160" 
            Height="120" 
            Canvas.Left="10" 
            Canvas.Top="270" />
        <local:PictureControl 
            x:Name="PicControl4" 
            HorizontalAlignment="Left" 
            Width="160" 
            Height="120" 
            Canvas.Left="10" 
            Canvas.Top="400" />
    </Canvas>
</Window>

Animation erstellen

• DoubleAnimationBase
• BooleanAnimationBase
• ByteAnimationBase
• CharAnimationBase
• ColorAnimationBase
• DecimalAnimationBase
• Int16AnimationBase
• Int32AnimationBase
• Int64AnimationBase
• MatrixAnimationBase
• ObjectAnimationBase
• Point3DAnimationBase
• PointAnimationBase
• QuaternionAnimationBase
• RectAnimationBase
• Rotation3DAnimationBase
• SingleAnimationBase
• SizeAnimationBase
• StringAnimationBase
• Vector3DAnimationBase
• VectorAnimationBase

DoubleAnimation doubleAnimHeight = new DoubleAnimation();
doubleAnimHeight.From = 10;
doubleAnimHeight.To = 100;
doubleAnimHeight.Duration = new Duration(
    TimeSpan.FromSeconds(0.5));

DoubleAnimation doubleAnimWidth = new DoubleAnimation();
doubleAnimWidth.From = picControl.Width;
doubleAnimWidth.To = size.Width;
doubleAnimWidth.Duration = new Duration(
    TimeSpan.FromSeconds(0.5));

DoubleAnimation doubleAnimHeight = new DoubleAnimation();
doubleAnimHeight.From = picControl.Height;
doubleAnimHeight.To = size.Height;
doubleAnimHeight.Duration = new Duration(
    TimeSpan.FromSeconds(0.5));

DoubleAnimation doubleAnimTop = new DoubleAnimation();
doubleAnimTop.From = Canvas.GetTop(picControl);
doubleAnimTop.To = location.Y;
doubleAnimTop.Duration = new Duration(
    TimeSpan.FromSeconds(0.5));

DoubleAnimation doubleAnimLeft = new DoubleAnimation();
doubleAnimLeft.From = Canvas.GetLeft(picControl);
doubleAnimLeft.To = location.X;
doubleAnimLeft.Duration = new Duration(
    TimeSpan.FromSeconds(0.5));

PictureControl picControl = (PictureControl)sender;

Point location = new Point(
    Canvas.GetLeft(picControl), 
    Canvas.GetTop(picControl));
Size size = new Size(
    picControl.ActualWidth, 
    picControl.ActualHeight);

if (location != _targetLocation)
{
    location = _targetLocation;
    size = _targetSize;
}
else
{
    location = picControl.OriginLocation;
    size = picControl.OriginSize;
}

board.Children.Clear();
board.Children.Add(doubleAnimWidth);
board.Children.Add(doubleAnimHeight);
board.Children.Add(doubleAnimTop);
board.Children.Add(doubleAnimLeft);

Storyboard.SetTargetName(
    doubleAnimWidth, 
    picControl.Name);
Storyboard.SetTargetName(
    doubleAnimHeight, 
    picControl.Name);
Storyboard.SetTargetName(
    doubleAnimLeft, 
    picControl.Name);
Storyboard.SetTargetName(
    doubleAnimTop, 
    picControl.Name);

Storyboard.SetTargetProperty(
    doubleAnimWidth, 
    new PropertyPath(PictureControl.WidthProperty));
Storyboard.SetTargetProperty(
    doubleAnimHeight, 
    new PropertyPath(PictureControl.HeightProperty));
Storyboard.SetTargetProperty(
    doubleAnimLeft, 
    new PropertyPath(Canvas.LeftProperty));
Storyboard.SetTargetProperty(
    doubleAnimTop, 
    new PropertyPath(Canvas.TopProperty));

board.Begin(this);

Fazit

Einführung

Erstellung einer ValidationRule

public class DateTimeValidationRule : ValidationRule
{
    public override ValidationResult Validate(
        object value, 
        System.Globalization.CultureInfo cultureInfo)
    {
        string val = value as string;
        DateTime dtResult;
        bool bRet = DateTime.TryParse(val, out dtResult);
        ValidationResult vr = new ValidationResult(bRet, "No valid date");
        return vr;
    }
}

Binding erstellen

public class MyData
{
    private string _date;

    public string Date
    {
        get { return _date; }
        set { _date = value; }
    }

    public MyData()
    {
        _date = DateTime.Now.ToShortDateString();
    }
}

WPF Window und Bindings erstellen

<Window.Resources>
    <my:MyData x:Key="md"/>
    
    <ControlTemplate x:Key="validationTemplate">
        <DockPanel>
            <TextBlock Foreground="Red" 
                       FontSize="14">!</TextBlock>
            <AdornedElementPlaceholder/>
        </DockPanel>
    </ControlTemplate>

    <Style x:Key="ErrorTextBoxStyle" 
           TargetType="{x:Type TextBox}">
        <Style.Triggers>
            <Trigger Property="Validation.HasError" 
                     Value="true">
                <Setter 
                    Property="ToolTip" 
                    Value="{Binding RelativeSource={x:Static RelativeSource.Self}, 
                    Path=(Validation.Errors)[0].ErrorContent}"/>
                <Setter 
                    Property="Foreground" 
                    Value="Red"/>
            </Trigger>
        </Style.Triggers>
    </Style>
</Window.Resources>

<TextBox Grid.Row="1" Name="textBox1" Width="75"
    HorizontalAlignment="Left"
    Validation.ErrorTemplate="{StaticResource validationTemplate}"
    Style="{StaticResource ErrorTextBoxStyle}"
    Margin="2">
        <TextBox.Text>
            <Binding Path="Date" Source="{StaticResource md}"
                UpdateSourceTrigger="PropertyChanged" >
                <Binding.ValidationRules>
                    <my:DateTimeValidationRule/>
                </Binding.ValidationRules>
            </Binding>
        </TextBox.Text>
</TextBox>

Fazit

Bietet die WPF bereits ein entsprechendes Konzept?

Das Model-View ViewModel Pattern

Weitere Patterns

Fazit

Warum UI von Aufgaben trennen

Wie kann die WPF hier helfen?

• Commands müssen das UI aktualisieren
• Commands können komplett frei von allen UI-Einflüssen ausgeführt werden

• ApplicationCommands
• ComponentCommands
• NavigationCommands
• MediaCommands
• EditingCommands

<UserControl.CommandBindings>
    <CommandBinding 
      Command="MediaCommands.Play" 
      CanExecute="OnQueryExecute" 
      Executed="Execute"/>
</UserControl.CommandBindings>

<StackPanel Grid.Row="2" Orientation="Horizontal">
    <Button 
      Command="MediaCommands.Play" 
      Content="{Binding RelativeSource={RelativeSource Self}, 
        Path=Command.Text}" />
</StackPanel>

Eigene Commands via ICommand implementieren

• CanExecute
• Execute
• CanExecuteChanged

public class MySaveCommand : ICommand
{
    #region ICommand Members

    public bool CanExecute(object parameter)
    {
        return true;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        if (parameter is EasySum)
        {
            EasySum es = (EasySum)parameter;
            es.Result = es.Summand1 + es.Summand2;
        }
    }

    #endregion
}

RoutedCommand erstellen

public static RoutedCommand ChangeBackgroundCommand = new RoutedCommand();

private void ChangeBackgroundCommandCanExecute(
    object sender, CanExecuteRoutedEventArgs e)
{
    if (sender is Panel)
        e.CanExecute = true;
    else
        e.CanExecute = false;

}

private void ChangeBackgroundCommandExecuted(
    object sender, ExecutedRoutedEventArgs e)
{
    Panel target = e.Source as Panel;
    if (target != null)
    {
        if (target.Background == Brushes.AliceBlue)
        {
            target.Background = Brushes.LemonChiffon;
        }
        else
        {
            target.Background = Brushes.AliceBlue;
        }

    }
}

<StackPanel Name="MyStackPanel"
    Background="AliceBlue"
    Focusable="True">
    <StackPanel.CommandBindings>
        <CommandBinding 
            Command="{x:Static custom:Window1.ChangeBackgroundCommand}"
            Executed="ChangeBackgroundCommandExecuted"
            CanExecute="ChangeBackgroundCommandCanExecute"/>
    </StackPanel.CommandBindings>
    <Label>A StackPanel</Label>
    <Button Command="{x:Static custom:Window1.ChangeBackgroundCommand}"
      CommandParameter="ButtonOne"
      CommandTarget="{Binding ElementName=MyStackPanel}" 
      Content="Change Background" />
</StackPanel>

Fazit