Santiago Blanco on .Net

WPF – Bind ContextMenu Command from DataGrid Header.

Santiago Blanco — Wed, 21 Dec 2011 13:56:29 +0000

The DataGridColumnHeaders on the WPF DataGrid are not part of the VissualTree so we cannot use bindings to bind the content to the ViewModel, or in my case the commands on the header context menu.

To make the bindings work, we are going to need the CommandReference class that was part of the MVVM Toolkit:

  /// 
/// This class facilitates associating a key binding in XAML markup to  a command     
/// defined in a View Model by exposing a Command dependency property.      
/// The class derives from Freezable to work around a limitation in WPF when data-binding from XAML.      
///       
public class CommandReference : Freezable, ICommand
{
    public static readonly DependencyProperty CommandProperty = DependencyProperty.Register( "Command", typeof( ICommand ), typeof( CommandReference ),
        new PropertyMetadata( new PropertyChangedCallback( OnCommandChanged ) ) );
 
    public CommandReference()
    { }
 
 
    public ICommand Command
    {
        get { return (ICommand)GetValue( CommandProperty ); }
        set { SetValue( CommandProperty, value ); }
    }
 
 
    #region ICommand Members
 
 
    public bool CanExecute( object parameter )
    {
        if( Command != null )
            return Command.CanExecute( parameter );
 
        return false;
    }
 
    public void Execute( object parameter )
    {
        Command.Execute( parameter );
    }
 
 
    public event EventHandler CanExecuteChanged;
 
    private static void OnCommandChanged( DependencyObject d, DependencyPropertyChangedEventArgs e )
    {
        CommandReference commandReference = d as CommandReference;
        ICommand oldCommand = e.OldValue as ICommand;
        ICommand newCommand = e.NewValue as ICommand;
 
        if( oldCommand != null )
        {
            oldCommand.CanExecuteChanged -= commandReference.CanExecuteChanged;
        }
 
        if( newCommand != null )
        {
            newCommand.CanExecuteChanged += commandReference.CanExecuteChanged;
        }
    }
 
    #endregion
 
 
    #region Freezable
 
    protected override Freezable CreateInstanceCore()
    {
        throw new NotImplementedException();
    }
 
    #endregion
 
}

Using this class we create a command reference on the view resources for each command that we want to bind to the ViewModel:

<UserControl.Resources>
  <pr:CommandReference x:Key="FirstCommandReference" Command="{Binding FirstCommand}" />
  <pr:CommandReference x:Key="SecondCommandReference" Command="{Binding SecondCommand}" />

Then we create a context menu also as a Style resource for the column header:

<Style x:Key="dataGridColumnHeaderStyle" TargetType="{x:Type DataGridColumnHeader}">
  <Setter Property="ContextMenu" >
    <Setter.Value>
      <ContextMenu>
        <MenuItem Header="First Command" Command="{StaticResource FirstCommandReference}" />
        <MenuItem Header="Second Command" Command="{StaticResource SecondCommandReference}" />
      ContextMenu>
    Setter.Value>
  Setter>
Style>

And as a final step, we apply that style to the column header on the DataGrid:

<DataGrid ItemsSource="{Binding MyDataSourceOnTheViewModel}" CanUserReorderColumns="False"
          ColumnHeaderStyle="{StaticResource dataGridColumnHeaderStyle }" 
          CurrentColumn="{Binding CurrentColumn, Mode=OneWayToSource}" AutoGenerateColumns="True">

Configuration – Multi-Level Configuration Sections using System.Configuration

Santiago Blanco — Fri, 04 Feb 2011 01:22:40 +0000

I’ve been trying to find examples or documentation on how to do this but practically all the examples I found where based on one or two level hierarchies, or on custom solutions to overcome the falsely perceived limitation. It turns out that the solution is simple but the lack of examples or documentation makes it not straightforward, so I’m posting the solution here.

This is a simplified version of the configuration hierarchy I needed for my configuration file:

<ConfigurationSectionName>
  <SubSection1>
    <ItemsGroup label=“Group1a“>
      <Item title=“Title1“ command=“commandName1“/>
      <Item title=“Title2“ command=“commandName2“/>
    ItemsGroup>
    <ItemsGroup label=“Group1b“>
      <Item title=“Title1“ command=“commandName1“/>
      <Item title=“Title2“ command=“commandName2“/>
    ItemsGroup>
  SubSection1>
  <SubSection2>
    <ItemsGroup label=“Group2a“>
      <Item title=“Title1“ command=“commandName1“/>
      <Item title=“Title2“ command=“commandName2“/>
    ItemsGroup>
    <ItemsGroup label=“Group2b“>
      <Item title=“Title1“ command=“commandName1“/>
      <Item title=“Title2“ command=“commandName2“/>
    ItemsGroup>
  SubSection2>
ConfigurationSectionName>

First, we need to create a ConfigurationSection derived class to act as the root of the configuration hierarchy and as the config handler on the application config file.

public class MyConfigurationSection : ConfigurationSection
{
 
    // Declare a collection element represented in the configuration file by the sub-section
    //    
    // Note: the “IsDefaultCollection = false” instructs the .NET Framework to build a nested section like  ….
    [ConfigurationProperty( "SubSection1", IsDefaultCollection = false )]
    public SubSectionConfigElement SubSection1ItemGroups
    {
        get
        {
            SubSectionConfigElement subSection1ConfigElement = (SubSectionConfigElement)base[ "SubSection1" ];
            return subSection1ConfigElement;
        }
    }
 
 
    [ConfigurationProperty( "SubSection2", IsDefaultCollection = false )]
    public SubSectionConfigElement SubSection2ItemGroups
    {
        get
        {
            SubSectionConfigElement subSection2ConfigElement = (SubSectionConfigElement)base[ "SubSection2" ];
            return subSection2ConfigElement;
        }
    }
 
}

Each property on the ConfigurationSection class corresponds to one of the subsections on the main configuration section.

The trick to allow more sublevels here, is to derive the SubSectionConfigElement class from ConfigurationElementCollection instead of ConfigurationElement and to populate the AddElementName property with the name of the XML element on our config file, in this case ItemsGroup.

public class SubSectionConfigElement : ConfigurationElementCollection
{
 
    public SubSectionConfigElement()
    {
        AddElementName = “ItemsGroup”;
    }
 
    protected override ConfigurationElement CreateNewElement()
    {
        return new ItemsGroupConfigElement();
    }
 
 
    protected override Object GetElementKey( ConfigurationElement element )
    {
        return ((ItemsGroupConfigElement)element).Label;
    }
 
}

To support another level on the hierarchy, we derive the class returned by the CreateNewElement() method (ItemsGroupConfigElement) from the ConfigurationElementCollection. This doesn’t prevent us from also adding properties to the class that are going to be represented as attributes in the XML file.

public class ItemsGroupConfigElement : ConfigurationElementCollection
{
 
    public ItemsGroupConfigElement()
    {
        AddElementName = “Item”;
    }
 
    [ConfigurationProperty( "label", IsRequired = true, IsKey = true )]
    public string Label
    {
        get
        {
            return (string)this[ "label" ];
        }
        set
        {
            this[ "label" ] = value;
        }
    }
 
    protected override ConfigurationElement CreateNewElement()
    {
        return new ItemConfigElement();
    }
 
    protected override Object GetElementKey( ConfigurationElement element )
    {
        return ((ItemConfigElement)element).Title;
    }
}

We again populate the AddElementName with the name of the child elements on the XML file and return last element of the hierarchy (ItemConfigElement), which derives directly from ConfigurationElement.

public class ItemConfigElement : ConfigurationElement
{
 
    [ConfigurationProperty( "title", IsRequired = true, IsKey = true )]
    public string Title
    {
        get
        {
            return (string)this[ "title" ];
        }
        set
        {
            this[ "title" ] = value;
        }
    }
 
    [ConfigurationProperty( "command" )]
    public string Command
    {
        get
        {
            return (string)this[ "command" ];
        }
        set
        {
            this[ "command" ] = value;
        }
    }
}

WPF – Bind TreeView SelectedItem to a property on the ViewModel

Santiago Blanco — Wed, 15 Dec 2010 21:59:44 +0000

The TreeView control doesn’t have a bindable SelectedItem property (it is ReadOnly) that allows binding the selected tree item to a property on the ViewModel or Presenter.

One solution for one-way notification is to add an event-handler to the SelectedItemChanged event on the code-behind file:

private void TreeView_SelectedItemChanged( object sender, RoutedPropertyChangedEventArgs<object> e )
{
    SomeDialogPresenter presenter = this.DataContext as SomeDialogPresenter;
    presenter.SelectedTreeItem = e.NewValue;
}

but this doesn’t allow to change the selected item programmatically.

Other solution is to implement an “IsSelected” property on the Adapter/ViewModel that gets bound to each TreeNode and bind that property to the “IsSelected” property on the TreeViewItem using a Style:

<TreeView ItemsSource="{Binding ItemsSourceOnThePresenter}" SelectedItemChanged="TreeView_SelectedItemChanged" Margin="5,10">
  <TreeView.ItemContainerStyle>
    <Style>
      <Setter Property="TreeViewItem.IsSelected" Value="{Binding IsSelected, Mode=TwoWay}" />
      <Setter Property="TreeViewItem.IsExpanded" Value="True"/>
    Style>
  TreeView.ItemContainerStyle>
TreeView>

On the Adapter/ViewModel (that implements INotifyPropertyChanged):

public bool IsSelected
{
    get { return m_isSelected; }
    set
    {
        m_isSelected = value;
        OnPropertyChanged( "IsSelected" );
    }
}

Then on the view presenter you can set the property on the node ViewModel and the node gets selected on the tree control.

PRISM 4

Santiago Blanco — Tue, 16 Nov 2010 16:13:39 +0000

Prism 4 was released on November 12th. Here are the links to the official sites:

http://compositewpf.codeplex.com/

Prism 4.0 – November 2010

Upgrading existing VS2008 WSSF solutions to VS2010

Santiago Blanco — Thu, 08 Jul 2010 18:46:15 +0000

I’ve found the solution here (thanks to AndyFurnival) and it worked fine for me after I checked out the .ssfproject project from source control before I opened the solution from VS2010.

These are the steps from the link above with a couple of additions:

Backup your project files.
Open the solution on VS2008 and check out all the files. Close VS008.
Open the solution on VS2010 and follow the solution upgrade wizard.
Remove the *.ssfproject from your solution.
Rename the ssfproject file extension to a csproj extension (assuming you are using C#)
Add the project back into your solution.
Click Tools -> Guidance Package Manager in VS 2010 IDE, and Click Enable Packages, and then Check Web Service Software Factory 2010 beta. Press OK (unless it is already enabled)

BizTalk 2009 – Cannot create new BizTalk projects in Visual Studio 2008

Santiago Blanco — Thu, 06 May 2010 19:32:43 +0000

Today I was trying to create a new BizTalk solution on VS2008 using the BizTalk Software Factory and I kept getting an exception. Then I realized that I wasn’t able to create new BizTalk projects either and I found this solution online:

Known Issues When Developing BizTalk Server Applications

After making the registry change everything went back to normal.

BizTalk 2009 – Toolkits and Frameworks

Santiago Blanco — Fri, 30 Apr 2010 14:31:16 +0000

These are a few links to useful resources for building BizTalk applications:

LINQ – How to find the object with the largest value on one of its properties

Santiago Blanco — Thu, 11 Mar 2010 02:42:31 +0000

The first thing to remember when using LINQ to Objects methods is to add the namespace System.Linq to the list of using statements in our class. This allows us to use the extension methods for IEnumerable defined on that namespace.

Most of the examples I found related to this were using arrays of ints and the Max() method but that gives you the largest value found, not the object that contains that value.

Let’s assume we have a list of CampaignInfoData objects that have one property named NumberOfBatches of type int.

private List<CampaignInfoData> m_campaignInfosList = new List<CampaignInfoData>();

Using the Max method, we can get the largest number of batches in one campaign:

int largestNumberOfBatches = m_campaignInfosList.Max( f => f.NumberOfBatches );

but what I wanted was to get the campaign object with the largest number of batches. To get that, we can use the Aggregate method:

CampaignInfoData largestCampaign = m_campaignInfosList.Aggregate( ( seed, f ) => f.NumberOfBatches > seed.NumberOfBatches ? f : seed );

The Aggregate method accepts a lambda expression with two parameters. The first parameter holds the result of the previous lambda function execution, and the second is the current item on the list at a specific point in time.

The method traverses the list from beginning to end, and for each element, executes the code to the right of the => symbol on the lambda expression. After that, it puts the result value on the first parameter (seed) and moves to the next element on the list.

When it reaches the last element, the Aggregate method returns the result of the last lambda function execution.

This gives us the campaign object we were looking for without affecting the order of the elements on the list.

WPF custom ListBox with scrollbar on the background.

Santiago Blanco — Tue, 09 Mar 2010 04:42:27 +0000

I just posted an article on CodeProject explaining how to create a custom ListBox using Styles:

http://www.codeproject.com/KB/WPF/AutoScrollListBox.aspx

You can download the sample code from there.

Enterprise Library 5.0 Beta1 and Unity 2.0 Beta1 are released

Santiago Blanco — Tue, 16 Feb 2010 21:53:18 +0000

The Patterns & Practices team has released beta versions of both libraries:

http://entlib.codeplex.com/wikipage?title=EntLib5%20Beta1