Beispiel Erweiterbarkeit

• Introducing Microsoft LINQ
• Introducing Microsoft ASP.NET AJAX
• Introducing Microsoft Silverlight 1.0

Einleitung

Wann lohnt sich ein Template?

• Neue Klasse anlegen
• Referenz auf Logging-Framework setzen
• Logger instanzieren

Basiswissen

<programs directory>\Common7\IDE\ProjectTemplates

<programs directory>\Common7\IDE\ItemTemplates

<Eigene Dateien>\Visual Studio 2008\Templates\ProjectTemplates

<Eigene Dateien>\Visual Studio 2008\Templates\ItemTemplates

Ein konkretes Beispiel

<?xml version="1.0"?>
<AppConfiguration>
  <ReferencedConfigurations>
  </ReferencedConfigurations>
  
  <Commands>
  </Commands>
  
  <MiscSettings>
  </MiscSettings>
</AppConfiguration>

<?xml version="1.0" encoding="utf-8"?>
<VSTemplate 
  Version="3.0.0" 
  Type="Item" 
  xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
  <TemplateData>
    <Name>Custom Configuration File</Name>
    <Icon></Icon>
    <Description>
      Creates a custom configuration file
    </Description>
    <ProjectType>CSharp</ProjectType>
    <ProvideDefaultName>true</ProvideDefaultName>
    <DefaultName>ConfigurationFile.xml</DefaultName>
  </TemplateData>
  <TemplateContent>
    <ProjectItem 
      ReplaceParameters="true" 
      TargetFileName="$fileinputname$.xml">
        ConfigurationFile.xml
    </ProjectItem>
  </TemplateContent>
</VSTemplate>

Fazit

Referenzen

Living .NET

Sicherheit

LINQ

.NET Allgemein

WPF

Tools

private ColorMatrix GetSepiaMatrix()
{
    return new ColorMatrix(new float[][]
    {
        new float[] {0.393f, 0.349f, 0.272f, 0, 0},
        new float[] {0.769f, 0.686f, 0.534f, 0, 0},
        new float[] {0.189f, 0.168f, 0.131f, 0, 0},
        new float[] {     0,      0,      0, 1, 0},
        new float[] {     0,      0,      0, 0, 1}
    });
}

OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "JPEG-Files:*.jpg";
ofd.DefaultExt = ".jpg";
ofd.Title = "Open JPG File";

if (ofd.ShowDialog() == DialogResult.OK)
{
    if (OriginalPicture.Image != null)
        OriginalPicture.Image.Dispose();
    if (SepiaPicture.Image != null)
        SepiaPicture.Image.Dispose();

    Image img1 = Image.FromFile(ofd.FileName);
    Image img2 = Image.FromFile(ofd.FileName);

    OriginalPicture.Image = img1;

    ImageAttributes imageAttrs = new ImageAttributes();
    imageAttrs.SetColorMatrix(GetSepiaMatrix());
    using (Graphics g = Graphics.FromImage(img2))
    {
        g.DrawImage(
            img2, 
            new Rectangle(0, 0, img2.Width, img2.Height),
            0, 0, img2.Width, img2.Height, 
            GraphicsUnit.Pixel, imageAttrs);
    }

    SepiaPicture.Image = img2;
}

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