Question

in general TextBox control TextChanged event is working but in ItemsControl, the TextBox TextChanged Event is not fired how can i do this. I trying to do by using following code which I have implemented but not getting result which I want.

So, what am I doing wrong?

View

<Window x:Class="SoniSoft.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:ff="clr-namespace:SoniSoft"
        Title="Window1" Height="300" Width="300">

    <Window.DataContext>
                <ff:ViewModels/>
            </Window.DataContext>
    <Grid>
            <Grid.RowDefinitions>
                <RowDefinition Height="38"/>
                <RowDefinition Height="*"/>
            </Grid.RowDefinitions>
    <TextBox Grid.Row="0" ff:TextBoxBehaviour.TextChangedCommand="{Binding TextChanged}"  />

    <ItemsControl Margin="7,0,0,0" Grid.Row="3" ItemsSource="{Binding Path=ViewModelSearchResults}" x:Name="list">
                <ItemsControl.ItemTemplate>
                    <DataTemplate >
                        <Grid>
                            <TextBox  ff:TextBoxBehaviour.TextChangedCommand="{Binding TextChanged}" Text="{Binding Path=CategoryName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" FontSize="14" FontWeight="Normal" x:Name=" TextBoxCategoryName" />
                        </Grid>
                    </DataTemplate>
                </ItemsControl.ItemTemplate>
            </ItemsControl>
        </Grid>
    </Window>

View Models

class ViewModels :ViewModelBase
            {
                public ObservableCollection<Category> AllCategorys = new ObservableCollection<Category>();
                DatabaseDataContext db = new DatabaseDataContext();
                private ListCollectionView _objViewModelSearchResults;
                public ListCollectionView ViewModelSearchResults
                {
                    get { return _objViewModelSearchResults; }
                    set
                    {
                        _objViewModelSearchResults = value;
                        OnPropertyChanged("ViewModelSearchResults");
                    }
                }
                public ViewModels()
                {
                    AllCategorys.Clear();
                    foreach (var item in db.Categories.OrderBy(c => c.CategoryName))
                    {
                        AllCategorys.Add(item);
                    }
                    ViewModelSearchResults = new ListCollectionView(AllCategorys);
                }
                public ICommand TextChanged
                {
                    get
                    {
                        //  this is very lazy: I should cache the command!
                        return new TextChangedCommand();
                    }
                }
        private class TextChangedCommand : ICommand
                {
                    public event EventHandler CanExecuteChanged;
                    public void Execute(object parameter)
                    {
                        MessageBox.Show("Text Changed");
                    }

                    public bool CanExecute(object parameter)
                    {
                        return true;
                    }
                }
            }

DependencyProperty

class EventBehaviourFactory
                {
                    public static DependencyProperty CreateCommandExecutionEventBehaviour(RoutedEvent routedEvent, string propertyName, Type ownerType)
                    {
                        DependencyProperty property = DependencyProperty.RegisterAttached(propertyName, typeof(ICommand), ownerType,
                                                                           new PropertyMetadata(null,
                                                                               new ExecuteCommandOnRoutedEventBehaviour(routedEvent).PropertyChangedHandler));

                        return property;
                    }
    private class ExecuteCommandOnRoutedEventBehaviour : ExecuteCommandBehaviour
                    {
                        private readonly RoutedEvent _routedEvent;

                        public ExecuteCommandOnRoutedEventBehaviour(RoutedEvent routedEvent)
                        {
                            _routedEvent = routedEvent;
                        }

                        /// <summary>
                        /// Handles attaching or Detaching Event handlers when a Command is assigned or unassigned
                        /// </summary>
                        /// <param name="sender"></param>
                        /// <param name="oldValue"></param>
                        /// <param name="newValue"></param>
                        protected override void AdjustEventHandlers(DependencyObject sender, object oldValue, object newValue)
                        {
                            UIElement element = sender as UIElement;
                            if (element == null) { return; }

                            if (oldValue != null)
                            {
                                element.RemoveHandler(_routedEvent, new RoutedEventHandler(EventHandler));
                            }

                            if (newValue != null)
                            {
                                element.AddHandler(_routedEvent, new RoutedEventHandler(EventHandler));
                            }
                        }

                        protected void EventHandler(object sender, RoutedEventArgs e)
                        {
                            HandleEvent(sender, e);
                        }
                    }

                    internal abstract class ExecuteCommandBehaviour
                    {
                        protected DependencyProperty _property;
                        protected abstract void AdjustEventHandlers(DependencyObject sender, object oldValue, object newValue);

                        protected void HandleEvent(object sender, EventArgs e)
                        {
                            DependencyObject dp = sender as DependencyObject;
                            if (dp == null)
                            {
                                return;
                            }

                            ICommand command = dp.GetValue(_property) as ICommand;

                            if (command == null)
                            {
                                return;
                            }

                            if (command.CanExecute(e))
                            {
                                command.Execute(e);
                            }
                        }

                        /// <summary>
                        /// Listens for a change in the DependencyProperty that we are assigned to, and
                        /// adjusts the EventHandlers accordingly
                        /// </summary>
                        /// <param name="sender"></param>
                        /// <param name="e"></param>
                        public void PropertyChangedHandler(DependencyObject sender, DependencyPropertyChangedEventArgs e)
                        {
                            // the first time the property changes,
                            // make a note of which property we are supposed
                            // to be watching
                            if (_property == null)
                            {
                                _property = e.Property;
                            }

                            object oldValue = e.OldValue;
                            object newValue = e.NewValue;

                            AdjustEventHandlers(sender, oldValue, newValue);
                        }
                    }

                }

             class TextBoxBehaviour
                {
                    public static readonly DependencyProperty TextChangedCommand = EventBehaviourFactory.CreateCommandExecutionEventBehaviour(TextBox.TextChangedEvent, "TextChangedCommand", typeof(TextBoxBehaviour));

                    public static void SetTextChangedCommand(DependencyObject o, ICommand value)
                    {
                        o.SetValue(TextChangedCommand, value);
                    }

                    public static ICommand GetTextChangedCommand(DependencyObject o)
                    {
                        return o.GetValue(TextChangedCommand) as ICommand;
                    }
                 }

Answer 1

Here is the problem. You are setting the command in an ItemTemplate. Thus it is binding to the Category object you have in the ListCollectionView. Now this is the object that doesnt contain any command for your text changed. What does contain the command for your TextChanged is the DataContext of the UserControl and you need to bind it to that.

Now there are is a way to work around and its called Ancestor RelativeSource. As I work with silverlight it might work different but this line of code should do.

Edit:

The actual line should be. this because it is ofcourse a window and you need to have the DataContext (the viewmodel) and then the property TextChanged:

<TextBox ff:TextBoxBehaviour.TextChangedCommand="{Binding RelativeSource={RelativeSource AncestorType={x:Type Window}, Path=DataContext.TextChanged}" />