I think we can understand this better with an example. See this class:

    public class Employee
    {
       public int Id { get; set; }
       public string Name { get; set; }
    }

and the following xaml:

    &lt;ComboBox ItemsSource=&quot;{Binding Source={StaticResource Employees}}&quot;
              DisplayMemberPath=&quot;Name&quot;
              SelectedValuePath=&quot;Id&quot;/&gt;

`DisplayMemberPath` points to the `Name` property, so the value displayed in the `ComboBox` and the `Employee` entries contained in the drop down list, will be the `Name` property of the `Employee` object.

To understand the other two, you should first understand `SelectedItem`. `SelectedItem` will return the currently selected `Employee` object from the `ComboBox`. You can also assign `SelectedItem` with an `Employee` object to set the current selection in the `ComboBox`.

`SelectedValuePath` points to `Id`, which means you can get the `Id` of currently selected `Employee` by using `SelectedValue`. You can also set the currently selected `Employee` in the `ComboBox` by setting the `SelectedValue` to an `Id` (which we assume will be present in the `Employees` list).




I&#39;ve implemented `onSharedPreferenceChanged` in my main activity. 

If I change the preferences in the main activity, my event fires. 

If I change the preferences through my preferences screen (`PreferenceActivity`) my event does NOT fire when preferences are changed (because it&#39;s a separate activity and separate reference to sharedPreferences?)

Does anybody have a recommendation of how I should go about overcoming this situation? 

Thanks!

EDIT1: I tried adding the event handler right in my preference activity but it never fires. The following method gets called during onCreate of my preference activity. When I change values, it never prints the message (`msg()` is a wrapper for `Log.d`). 

	private void registerChangeListener () {
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);

		sp.registerOnSharedPreferenceChangeListener(new OnSharedPreferenceChangeListener () {
			public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
				msg (&quot; ***** Shared Preference Update ***** &quot;);
				Intent i = new Intent();
				i.putExtra(&quot;KEY&quot;, key);
				i.setAction(&quot;com.gtosoft.dash.settingschanged&quot;);
				
				sendBroadcast(i);
				
				// TODO: fire off the event
			}
		});
	}



onSharedPreferenceChanged not fired if change occurs in separate activity?

I have a few files open in vim, in multiple windows. Is there a command like :e that will reload the buffers for all the files I have open? I need this because I sometime alter some of the files with another editor while they are also open in vim.

How do you reload all vim windows at once?

I have always struggled with those comboBox properties

 

 1. DisplayMemberPath 
 2. SelectedValue 
 3.  SelectedValuePath

I am building a master detail form . 

   1. ComboBox filled with Customers
   2. User Selects a Customer in Combo
   3. All the textBoxes  EG Fills correctly

The problem I am having I have made it work but I don&#39;t understand those properties and the differences.
Is there a noddy example explaining what they do? 

Confused with wpf ComboBox DisplayMemberPath,SelectedValue and SelectedValuePath

I have always struggled with those comboBox properties
<ol>
<li>DisplayMemberPath</li>
<li>SelectedValue</li>
<li>SelectedValuePath</li>
</ol>
I am building a master detail form .
<ol>
<li>ComboBox filled with Customers</li>
<li>User Selects a Customer in Combo</li>
<li>All the textBoxes EG Fills correctly</li>
</ol>
The problem I am having I have made it work but I don't understand those properties and the differences.
Is there a noddy example explaining what they do?

Can anybody suggest how I can convert an image to a byte array and vice versa? 

I&#39;m developing a WPF application and using a stream reader.


How to convert image to byte array

I lately had the problem of creating add and edit dialogs for my wpf app.

All I want to do in my code was something like this. (I mostly use viewmodel first approach with mvvm)

ViewModel which calls a dialog window:

    var result = this.uiDialogService.ShowDialog(&quot;Dialogwindow Title&quot;, dialogwindowVM);
    // Do anything with the dialog result

How does it work?

First, I created a dialog service:

    public interface IUIWindowDialogService
    {
        bool? ShowDialog(string title, object datacontext);
    }

    public class WpfUIWindowDialogService : IUIWindowDialogService
    {
        public bool? ShowDialog(string title, object datacontext)
        {
            var win = new WindowDialog();
            win.Title = title;
            win.DataContext = datacontext;

            return win.ShowDialog();
        }
    }

`WindowDialog` is a special but simple window.  I need it to hold my content:

    &lt;Window x:Class=&quot;WindowDialog&quot;
        xmlns=&quot;http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot; 
        Title=&quot;WindowDialog&quot; 
        WindowStyle=&quot;SingleBorderWindow&quot; 
        WindowStartupLocation=&quot;CenterOwner&quot; SizeToContent=&quot;WidthAndHeight&quot;&gt;
        &lt;ContentPresenter x:Name=&quot;DialogPresenter&quot; Content=&quot;{Binding .}&quot;&gt;
        
        &lt;/ContentPresenter&gt;
    &lt;/Window&gt;

A problem with dialogs in wpf is the `dialogresult = true` can only be achieved in code.  That&#39;s why I created an interface for my `dialogviewmodel` to implement it. 

    public class RequestCloseDialogEventArgs : EventArgs
    {
        public bool DialogResult { get; set; }
        public RequestCloseDialogEventArgs(bool dialogresult)
        {
            this.DialogResult = dialogresult;
        }
    }

    public interface IDialogResultVMHelper
    {
        event EventHandler&lt;RequestCloseDialogEventArgs&gt; RequestCloseDialog;
    }

Whenever my ViewModel thinks it&#39;s time for `dialogresult = true`, then raise this event.

    public partial class DialogWindow : Window
    {
        // Note: If the window is closed, it has no DialogResult
        private bool _isClosed = false;

        public DialogWindow()
        {
            InitializeComponent();
            this.DialogPresenter.DataContextChanged += DialogPresenterDataContextChanged;
            this.Closed += DialogWindowClosed;
        }

        void DialogWindowClosed(object sender, EventArgs e)
        {
            this._isClosed = true;
        }

        private void DialogPresenterDataContextChanged(object sender,
                                  DependencyPropertyChangedEventArgs e)
        {
            var d = e.NewValue as IDialogResultVMHelper;

            if (d == null)
                return;

            d.RequestCloseDialog += new EventHandler&lt;RequestCloseDialogEventArgs&gt;
                                        (DialogResultTrueEvent).MakeWeak(
                                            eh =&gt; d.RequestCloseDialog -= eh;);
        }

        private void DialogResultTrueEvent(object sender, 
                                  RequestCloseDialogEventArgs eventargs)
        {
            // Important: Do not set DialogResult for a closed window
            // GC clears windows anyways and with MakeWeak it
            // closes out with IDialogResultVMHelper
            if(_isClosed) return;

            this.DialogResult = eventargs.DialogResult;
        }
     }

Now at least I have to create a `DataTemplate` in my resource file(`app.xaml` or something):

    &lt;DataTemplate DataType=&quot;{x:Type DialogViewModel:EditOrNewAuswahlItemVM}&quot; &gt;
            &lt;DialogView:EditOrNewAuswahlItem/&gt;
    &lt;/DataTemplate&gt;

Well thats all, I can now call dialogs from my viewmodels:

     var result = this.uiDialogService.ShowDialog(&quot;Dialogwindow Title&quot;, dialogwindowVM);

Now my question, do you see any problems with this solution?


Edit: for completeness. The ViewModel should implement `IDialogResultVMHelper` and then it can raise it within a `OkCommand` or something like this:

    public class MyViewmodel : IDialogResultVMHelper
    {
        private readonly Lazy&lt;DelegateCommand&gt; _okCommand;

        public MyViewmodel()
        {
             this._okCommand = new Lazy&lt;DelegateCommand&gt;(() =&gt; 
                 new DelegateCommand(() =&gt; 
                     InvokeRequestCloseDialog(
                         new RequestCloseDialogEventArgs(true)), () =&gt; 
                             YourConditionsGoesHere = true));
        }

        public ICommand OkCommand
        { 
            get { return this._okCommand.Value; } 
        }

        public event EventHandler&lt;RequestCloseDialogEventArgs&gt; RequestCloseDialog;
        private void InvokeRequestCloseDialog(RequestCloseDialogEventArgs e)
        {
            var handler = RequestCloseDialog;
            if (handler != null) 
                handler(this, e);
        }
     }


EDIT 2: I used the code from here to make my EventHandler register weak:  
http://diditwith.net/2007/03/23/SolvingTheProblemWithEventsWeakEventHandlers.aspx  
(Website no longer exists, [WebArchive Mirror][1])


    public delegate void UnregisterCallback&lt;TE&gt;(EventHandler&lt;TE&gt; eventHandler) 
        where TE : EventArgs;

    public interface IWeakEventHandler&lt;TE&gt; 
        where TE : EventArgs
    {
        EventHandler&lt;TE&gt; Handler { get; }
    }

    public class WeakEventHandler&lt;T, TE&gt; : IWeakEventHandler&lt;TE&gt; 
        where T : class 
        where TE : EventArgs
    {
        private delegate void OpenEventHandler(T @this, object sender, TE e);

        private readonly WeakReference mTargetRef;
        private readonly OpenEventHandler mOpenHandler;
        private readonly EventHandler&lt;TE&gt; mHandler;
        private UnregisterCallback&lt;TE&gt; mUnregister;

        public WeakEventHandler(EventHandler&lt;TE&gt; eventHandler,
                                    UnregisterCallback&lt;TE&gt; unregister)
        {
            mTargetRef = new WeakReference(eventHandler.Target);

            mOpenHandler = (OpenEventHandler)Delegate.CreateDelegate(
                               typeof(OpenEventHandler),null, eventHandler.Method);

            mHandler = Invoke;
            mUnregister = unregister;
        }

        public void Invoke(object sender, TE e)
        {
            T target = (T)mTargetRef.Target;

            if (target != null)
                mOpenHandler.Invoke(target, sender, e);
            else if (mUnregister != null)
            {
                mUnregister(mHandler);
                mUnregister = null;
            }
        }

        public EventHandler&lt;TE&gt; Handler
        {
            get { return mHandler; }
        }

        public static implicit operator EventHandler&lt;TE&gt;(WeakEventHandler&lt;T, TE&gt; weh)
        {
            return weh.mHandler;
        }
    }

    public static class EventHandlerUtils
    {
        public static EventHandler&lt;TE&gt; MakeWeak&lt;TE&gt;(this EventHandler&lt;TE&gt; eventHandler, 
                                                        UnregisterCallback&lt;TE&gt; unregister)
            where TE : EventArgs
        {
            if (eventHandler == null)
                throw new ArgumentNullException(&quot;eventHandler&quot;);

            if (eventHandler.Method.IsStatic || eventHandler.Target == null)
                throw new ArgumentException(&quot;Only instance methods are supported.&quot;,
                                                &quot;eventHandler&quot;);

            var wehType = typeof(WeakEventHandler&lt;,&gt;).MakeGenericType(
                              eventHandler.Method.DeclaringType, typeof(TE));

            var wehConstructor = wehType.GetConstructor(new Type[] 
                                 { 
                                     typeof(EventHandler&lt;TE&gt;), typeof(UnregisterCallback&lt;TE&gt;) 
                                 });

            IWeakEventHandler&lt;TE&gt; weh = (IWeakEventHandler&lt;TE&gt;)wehConstructor.Invoke(
                                            new object[] { eventHandler, unregister });

            return weh.Handler;
        }
    }


  [1]: http://web.archive.org/web/20140319163345/http://diditwith.net/2007/03/23/SolvingTheProblemWithEventsWeakEventHandlers.aspx

Good or bad practice for Dialogs in wpf with MVVM?

Is there a standard message box in WPF, like WinForms&#39; [`System.Windows.Forms.MessageBox.Show()`](https://msdn.microsoft.com/en-us/library/system.windows.forms.messagebox.aspx), or should I use the WinForms message box?

Is there a MessageBox equivalent in WPF?

I have a DataGrid with first column as text column and second column as CheckBox column. What I want is, if I click the check box. It should get checked.&lt;br/&gt;&lt;br/&gt;
But, it takes two click to get selected, for first click the cell is getting selected, for the second clicks the check box is getting checked. How to make the check box to get checked/unchecked with a single click.

I&#39;m using WPF 4.0. Columns in the DataGrid are AutoGenerated.

How to perform Single click checkbox selection in WPF DataGrid?

Simple WPF/XAML question. In XAML, how do I reference the Self/this object in a given context? In a very basic app with a main window, one control, and a coded C# property of the window, I want to bind a property of the control to the hand coded property of the window. 

In code, this is very easy - in the Window&#39;s constructor, I added this:

    Binding bind = new Binding();
    bind.Source = this;
    bind.Path = new PropertyPath(&quot;ButtonWidth&quot;);
    button1.SetBinding(WidthProperty, bind);

Obviously, I have a property called ButtonWidth, and a control called button1. I can&#39;t figure out how to do this in XAML. Various attempts like the following example have not worked:

    &lt;Button x:Name=&quot;button1&quot; Width=&quot;{Binding Source=Self Path=ButtonWidth}&quot;/&gt;

    &lt;Button x:Name=&quot;button1&quot; Width=&quot;{Binding RelativeSource={RelativeSource Self} Path=ButtonWidth}&quot;/&gt; 

etc

Thanks




Content Type	Original Author	Original Content on Stackoverflow
Question	user451259	View Question on Stackoverflow
Solution 1 - Wpf	Yogesh	View Answer on Stackoverflow

Confused with wpf ComboBox DisplayMemberPath,SelectedValue and SelectedValuePath

Wpf Problem Overview

Wpf Solutions

Solution 1 - Wpf

How do you reload all vim windows at once?

onSharedPreferenceChanged not fired if change occurs in separate activity?

Attributions