WPF

<Window x:Class="TestWPFApplication.MainWindow"
        xmlns:testns="clr-namespace:TestWPFApplication"
        ...

<Window x:Class="TestWPFApplication.MainWindow"<br />
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:testns="clr-namespace:TestWPFApplication"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525"
        >
        <Window.Resources><br />
        <testns:TestViewModel x:Key="_testViewModel" Name="Abdul">
        </testns:TestViewModel>
    </Window.Resources>
    <Grid>
        <Label Content="Enter Name" HorizontalAlignment="Left" Margin="58,62,0,0" VerticalAlignment="Top" Name="lblName"/>
        <TextBox Text="{Binding Name, Mode=OneWay}"  HorizontalAlignment="Left" Height="22" Margin="160,64,0,0" TextWrapping="Wrap" 
                 Name="txtName" VerticalAlignment="Top" Width="120"/>

<pre>
    <Button Content="Save" HorizontalAlignment="Left" Margin="277,142,0,0" VerticalAlignment="Top" Width="74" Name="btnSaveSpecific"
            Command="{Binding Path=TestSpecificCommand}"
            CommandParameter="{Binding ElementName=txtName, Path=Text}" />
    <Label Content="Enter Id" HorizontalAlignment="Left" Margin="58,17,0,0" VerticalAlignment="Top" Name="lblId"/>
    <TextBox Text="{Binding Name, Mode=OneWay}"  HorizontalAlignment="Left" Height="22" Margin="160,18,0,0" TextWrapping="Wrap" 
             Name="txtId" VerticalAlignment="Top" Width="120"/>
    <Button Content="Save 2" HorizontalAlignment="Left" Margin="412,142,0,0" VerticalAlignment="Top" Width="74" Name="btnSaveSpecific2"
            Command="{Binding Path=ClickCommand}"
            />
    <DataGrid HorizontalAlignment="Left" Margin="103,188,0,0" VerticalAlignment="Top" Height="98" Width="313" 
        IsSynchronizedWithCurrentItem="True" ItemsSource="{Binding Path=PersonNames, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" 
              AutoGenerateColumns="False"  >
        <DataGrid.Columns>
            <DataGridTextColumn Header="Name of Employee" Binding="{Binding Path=Name}" />
        </DataGrid.Columns> 
    </DataGrid>
</Grid>

indian143 wrote:

Hi Pete,

indian143 wrote:

Invalid Markup on the UI screen

xmlns:testns="clr-namespace:TestWPFApplication.ViewModel"

xmlns:testns="clr-namespace:TestWPFApplication"

xmlns:vm="clr-namespace:MyApplication.ViewModelNamespace"

<Window.DataContext><vm:NameOfViewModel></Window.Resources>

<Window x:Class="TestWPFApplication.MainWindow"<br />
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:testns="clr-namespace:TestWPFApplication"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525"
        >
        <Window.Resources><br />
        <testns:TestViewModel x:Key="_testViewModel" Name="Abdul">
        </testns:TestViewModel>
    </Window.Resources>
    <Grid>
        <Label Content="Enter Name" HorizontalAlignment="Left" Margin="58,62,0,0" VerticalAlignment="Top" Name="lblName"/>
        <TextBox Text="{Binding Name, Mode=OneWay}"  HorizontalAlignment="Left" Height="22" Margin="160,64,0,0" TextWrapping="Wrap" 
                 Name="txtName" VerticalAlignment="Top" Width="120"/>

<pre>
    <Button Content="Save" HorizontalAlignment="Left" Margin="277,142,0,0" VerticalAlignment="Top" Width="74" Name="btnSaveSpecific"
            Command="{Binding Path=TestSpecificCommand}"
            CommandParameter="{Binding ElementName=txtName, Path=Text}" />
    <Label Content="Enter Id" HorizontalAlignment="Left" Margin="58,17,0,0" VerticalAlignment="Top" Name="lblId"/>
    <TextBox Text="{Binding Name, Mode=OneWay}"  HorizontalAlignment="Left" Height="22" Margin="160,18,0,0" TextWrapping="Wrap" 
             Name="txtId" VerticalAlignment="Top" Width="120"/>
    <Button Content="Save 2" HorizontalAlignment="Left" Margin="412,142,0,0" VerticalAlignment="Top" Width="74" Name="btnSaveSpecific2"
            Command="{Binding Path=ClickCommand}"
            />
    <DataGrid HorizontalAlignment="Left" Margin="103,188,0,0" VerticalAlignment="Top" Height="98" Width="313" 
        IsSynchronizedWithCurrentItem="True" ItemsSource="{Binding Path=PersonNames, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" 
              AutoGenerateColumns="False"  >
        <DataGrid.Columns>
            <DataGridTextColumn Header="Name of Employee" Binding="{Binding Path=Name}" />
        </DataGrid.Columns> 
    </DataGrid>
</Grid>

using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;

namespace TestWPFApplication
{
    public class TestViewModel : INotifyPropertyChanged
    {
        TestData _testData;

        //public TestCommand TestCommand { get; set; }
        public TestSpecificCommand TestSpecificCommand { get; set; }

        public TestViewModel()
        {
            _testData = new TestData();
            _personNames = new ObservableCollection<TestData>();
            //_dictionaryNames = new ObservableCollection<Tuple<int, TestData>>();

            //this.TestCommand = new TestCommand(this);
            this.TestSpecificCommand = new TestSpecificCommand(this);
        }

        private string _name;
        public string Name
        {
            get { return _name; }
            set
            {
                _name = value; NotifyPropertyChanged("Name");
            }
        }

        ObservableCollection<TestData> _personNames;
        public ObservableCollection<TestData> PersonNames
        {
            get { return _personNames; }
            set
            {
                _personNames = value; NotifyPropertyChanged("PersonNames"); 
            }
        }

        ObservableCollection<Tuple<int, TestData>> _dictionaryNames;
        ObservableCollection<Tuple<int, TestData>> DictionaryNames
        {
            get { return _dictionaryNames; }
            set
            {
                _dictionaryNames = value; NotifyPropertyChanged("DictionaryNames");
            }
        }     

        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(string propertyName)
        {<br />
            PropertyChangedEventHandler handler = PropertyChanged;
            if (null != handler)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
        }
        }

        private ICommand _clickCommand;
        public ICommand ClickCommand
        {
            get
            {
                return _clickCommand ?? (_clickCommand = new TestSpecificCommand(() => AddAnItem(), _canExecute));

            }

        }

        public bool _canExecute { get; set; }
        private int _id;
        public int Id
        {
            get { return _id; }
            set
            {
                _id = value; NotifyPropertyChanged("Id");
            }
        }
        public void AddAnItem()
        {<br />
            _personNames.Add(new TestData(Id, _name));
        }  

        public void AddAnItem(string _name)
        {
            int t;

            if ((_personNames == null) || (_personNames.Count() <= 0))
                t = 1;
            else
                t = (_personNames.Count <= 0) ? 1 : _personNames.Max(x => x.Id) + 1;
            _personNames.Add(new TestData(t, _name));
        }        
    }
}

<Window.DataContext>
  <testns:TestViewModel />
</Window.DataContext>

Error   1   The name "TestViewModel" does not exist in the namespace "clr-namespace:TestWPFApplication.ViewModel".  \\VBOXSVR\VMShared\Test Projects\TestWPFApplication\TestWPFApplication\View\MainWindow.xaml 9   9   TestWPFApplication

<Window x:Class="TestWPFApplication.MainWindow"<br />
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:testns="clr-namespace:TestWPFApplication.ViewModel"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525" >
       <Window.DataContext>
        <testns:TestViewModel Name="Abdul">
        </testns:TestViewModel>
    </Window.DataContext>
    <Grid>
        <Label Content="Enter Name" HorizontalAlignment="Left" Margin="58,62,0,0" VerticalAlignment="Top" Name="lblName"/>
        <TextBox Text="{Binding Name, Mode=OneWay}"  HorizontalAlignment="Left" Height="22" Margin="160,64,0,0" TextWrapping="Wrap" 
                 Name="txtName" VerticalAlignment="Top" Width="120"/>

<pre>
    <Button Content="Save" HorizontalAlignment="Left" Margin="277,142,0,0" VerticalAlignment="Top" Width="74" Name="btnSaveSpecific"
            Command="{Binding Path=TestSpecificCommand}"
            CommandParameter="{Binding ElementName=txtName, Path=Text}" />
            <DataGrid HorizontalAlignment="Left" Margin="103,188,0,0" VerticalAlignment="Top" Height="98" Width="313" 
        IsSynchronizedWithCurrentItem="True" ItemsSource="{Binding Path=PersonNames, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" 
              AutoGenerateColumns="False"  >
        <DataGrid.Columns>
            <DataGridTextColumn Header="Name of Employee" Binding="{Binding Path=Name}" />
        </DataGrid.Columns> 
    </DataGrid>
</Grid>

<TextBox Text="{Binding Name, Mode=OneWayToSource}" HorizontalAlignment="Left" Height="22" Margin="160,64,0,0" TextWrapping="Wrap" VerticalAlignment="Top" Width="120"/>

//--------------------------------------------------------------------------
// 
//  Copyright (c) Microsoft Corporation.  All rights reserved. 
// 
//  File: ObservableConcurrentDictionary.cs
//
//--------------------------------------------------------------------------

using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Threading;
using System.Diagnostics;

namespace System.Collections.Concurrent
{
    /// <summary>
    /// Provides a thread-safe dictionary for use with data binding.
    /// </summary>
    /// <typeparam name="TKey">Specifies the type of the keys in this collection.</typeparam>
    /// <typeparam name="TValue">Specifies the type of the values in this collection.</typeparam>
    [DebuggerDisplay("Count={Count}")]
    public class ObservableConcurrentDictionary<TKey, TValue> :
        ICollection<KeyValuePair<TKey, TValue>>, IDictionary<TKey, TValue>,
        INotifyCollectionChanged, INotifyPropertyChanged
    {
        private readonly SynchronizationContext _context;
        private readonly ConcurrentDictionary<TKey, TValue> _dictionary;

        /// <summary>
        /// Initializes an instance of the ObservableConcurrentDictionary class.
        /// </summary>
        public ObservableConcurrentDictionary()
        {
            _context = AsyncOperationManager.SynchronizationContext;
            _dictionary = new ConcurrentDictionary<TKey, TValue>();
        }

        /// <summary>Event raised when the collection changes.</summary>
        public event NotifyCollectionChangedEventHandler CollectionChanged;
        /// <summary>Event raised when a property on the collection changes.</summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Notifies observers of CollectionChanged or PropertyChanged of an update to the dictionary.
        /// </summary>
        private void NotifyObserversOfChange()
        {
            var collectionHandler = CollectionChanged;
            var propertyHandler = PropertyChanged;
            if (collectionHandler != null || propertyHandler != null)
            {
                _context.Post(s =>
                {
                    if (collectionHandler != null)
                    {
                        collectionHandler(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
                    }
                    if (propertyHandler != null)
                    {
                        propertyHandler(this, new PropertyChangedEventArgs("Count"));
                        propertyHandler(this, new PropertyChangedEventArgs("Keys"));
                        propertyHandler(this, new PropertyChangedEventArgs("Values"));
                    }
                }, null);
            }
        }

        /// <summary>Attempts to add an item to the dictionary, notifying observers of any changes.</summary>
        /// <param name="item">The item to be added.</param>
        /// <returns>Whether the add was successful.</returns>
        private bool TryAddWithNotification(KeyValuePair<TKey, TValue> item)
        {
            return TryAddWithNotification(item.Key, item.Value);
        }

        /// <summary>Attempts to add an item to the dictionary, notifying observers of any changes.</summary>
        /// <param name="key">The key of the item to be added.</param>
        /// <param name="value">The value of the item to be added.</param>
        /// <returns>Whether the add was successful.</returns>
        private bool TryAddWithNotification(TKey key, TValue value)
        {
            bool result = _dictionary.TryAdd(key, value);
            if (result) NotifyObserversOfChange();
            return result;
        }

        /// <summary>Attempts to remove an item from the dictionary, notifying observers of any changes.</summary>
        /// <param name="key">The key of the item to be removed.</param>
        /// <param name="value">The value of the item removed.</param>
        /// <returns>Whether the removal was successful.</returns>
        private bool TryRemoveWithNotification(TKey key, out TValue value)
        {
            bool result = _dictionary.TryRemove(key, out value);
            if (result) NotifyObserversOfChange();
            return result;
        }

        /// <summary>Attempts to add or update an item in the dictionary, notifying observers of any changes.</summary>
        /// <param name="key">The key of the item to be updated.</param>
        /// <param name="value">The new value to set for the item.</param>
        /// <returns>Whether the update was successful.</returns>
        private void UpdateWithNotification(TKey key, TValue value)
        {
            _dictionary[key] = value;
            NotifyObserversOfChange();
        }

        #region ICollection<KeyValuePair<TKey,TValue>> Members
        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
        {
            TryAddWithNotification(item);
        }

        void ICollection<KeyValuePair<TKey, TValue>>.Clear()
        {
            ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).Clear();
            NotifyObserversOfChange();
        }

        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
        {
            return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).Contains(item);
        }

        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).CopyTo(array, arrayIndex);
        }

        int ICollection<KeyValuePair<TKey, TValue>>.Count
        {
            get { return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).Count; }
        }

        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
        {
            get { return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).IsReadOnly; }
        }

        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
        {
            TValue temp;
            return TryRemoveWithNotification(item.Key, out temp);
        }
        #endregion

        #region IEnumerable<KeyValuePair<TKey,TValue>> Members
        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
        {
            return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((ICollection<KeyValuePair<TKey, TValue>>)_dictionary).GetEnumerator();
        }
        #endregion

        #region IDictionary<TKey,TValue> Members
        public void Add(TKey key, TValue value)
        {
            TryAddWithNotification(key, value);
        }

        public bool ContainsKey(TKey key)
        {
            return _dictionary.ContainsKey(key);
        }

        public ICollection<TKey> Keys
        {
            get { return _dictionary.Keys; }
        }

        public bool Remove(TKey key)
        {
            TValue temp;
            return TryRemoveWithNotification(key, out temp);
        }

        public bool TryGetValue(TKey key, out TValue value)
        {
            return _dictionary.TryGetValue(key, out value);
        }

        public ICollection<TValue> Values
        {
            get { return _dictionary.Values; }
        }

        public TValue this[TKey key]
        {
            get { return _dictionary[key]; }
            set { UpdateWithNotification(key, value); }
        }
        #endregion
    }
}