WPF

public class DialogBehavior
   {
      public static DependencyProperty DisplayModalProperty = DependencyProperty.RegisterAttached("DisplayModalProperty",
                    typeof(Boolean),
                    typeof(DialogBehavior),
                    new UIPropertyMetadata(false, AttachToDataContextChanged));

      public static void SetDisplayModal(DependencyObject target, Boolean value)
      {
         target.SetValue(DialogBehavior.DisplayModalProperty, value);
      }

      public static Boolean GetDisplayModal(DependencyObject target)
      {
         return (Boolean)target.GetValue(DisplayModalProperty);
      }

      private static void AttachToDataContextChanged(DependencyObject target, DependencyPropertyChangedEventArgs e)
      {
         FrameworkElement element = target as FrameworkElement;

            element.DataContextChanged += (a, b) =>
            {
               var dialog = new Dialog();
               dialog.DataContext = b.NewValue;
               dialog.Owner = Application.Current.MainWindow;

               if (GetDisplayModal(target))
               {
                  dialog.ShowDialog();
               }
               else
               {
                  dialog.Show();
               }
            };
         }
      }
   }

<HierarchicalDataTemplate DataType="{x:Type ViewModels:TreeNodeViewModel}" 
                             ItemsSource="{Binding Children}">
    <StackPanel>
        <FrameworkElement DataContext="{Binding Path=ModalDialogViewModel}">
            <behaviour:DialogBehavior.DisplayModal>True</behaviour:DialogBehavior.DisplayModal>
        </FrameworkElement>
        <TextBlock Text="{Binding DisplayName}" />
    </StackPanel>
</HierarchicalDataTemplate>

public static DependencyProperty DisplayModalProperty = DependencyProperty.RegisterAttached("DisplayModal",
             typeof(Boolean),
             typeof(DialogBehavior),
             new UIPropertyMetadata(false, AttachToDataContextChanged));

RichardGrimmer wrote:

My question is how / at which point should we be getting the items to fill these drop downs. As it stands, when we return the "record" to be edited (see next question also), we're also returning all of the lookup lists and binding at that point - is this the "de-rigeur" way of doing it, or should we be making multiple calls - one for the data, one for the lookups?

RichardGrimmer wrote:

Secondly, our view model currently contains an entity field, which we're using to bind to controls via a binding Path - something like {Binding Path=Customer.Name}. Now the entity class (Customer) implements INotifyPropertyChanged, and when one of (For example), my text fields change, the entity itself correctly updates and fires PropertyChanged event, but the ViewModel appears not to pick this up. The problem is that I need to intercept the change (or at least know that it's happened) at the ViewModel to requery some CanExecutes for commands. The only way around it I can see is to expose a filed per field on the form as separate properties, and then munge them together into

Abhinav S wrote:

I always feel that this depends on 1) how much data do expect to be returned on an average scenario 2) how you expect your application to be deployed - making multiple calls to different web services is not always a good idea - but if you are going to deploy your application on a intranet, I would say it would also not be a huge performance hit. After all, you will be making async calls, anyway.

Abhinav S wrote:

Are you using two-way binding?

DropDownList1.Items.FindByValue("1").Selected = true;