diff --git a/src/Avalonia.DataGrid/DataGrid.cs b/src/Avalonia.DataGrid/DataGrid.cs
index bb799f1214..6f07bd4417 100644
--- a/src/Avalonia.DataGrid/DataGrid.cs
+++ b/src/Avalonia.DataGrid/DataGrid.cs
@@ -20,7 +20,9 @@ using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Text;
+using System.Linq;
 using Avalonia.Input.Platform;
+using System.ComponentModel.DataAnnotations;
 
 namespace Avalonia.Controls
 {
@@ -73,7 +75,6 @@ namespace Avalonia.Controls
         // DataGrid Template Parts
         private ValidationSummary _validationSummary;
         
-        private List<ValidationResult> _bindingValidationResults;
         private List<ValidationResult> _indeiValidationResults;
         private DataGridCellCoordinates _previousAutomationFocusCoordinates;
         private List<ValidationResult> _propertyValidationResults;
@@ -83,11 +84,14 @@ namespace Avalonia.Controls
         private List<Style> _rowGroupHeaderStylesOld;
         private ValidationSummaryItem _selectedValidationSummaryItem;
         private string _updateSourcePath;
-        private Dictionary<INotifyDataErrorInfo, string> _validationItems;
-        private List<ValidationResult> _validationResults;
 
         */
 
+        //private Dictionary<INotifyDataErrorInfo, string> _validationItems;
+        private List<Exception> _validationErrors;
+        private List<Exception> _bindingValidationErrors;
+        private IDisposable _validationSubscription;
+
         private INotifyCollectionChanged _topLevelGroup;
         private ContentControl _clipboardContentControl;
 
@@ -144,6 +148,7 @@ namespace Avalonia.Controls
         private DataGridSelectedItemsCollection _selectedItems;
         private bool _temporarilyResetCurrentCell;
         private object _uneditedValue; // Represents the original current cell value at the time it enters editing mode.
+        private ICellEditBinding _currentCellEditBinding;
 
         // An approximation of the sum of the heights in pixels of the scrolling rows preceding 
         // the first displayed scrolling row.  Since the scrolled off rows are discarded, the grid
@@ -780,7 +785,7 @@ namespace Avalonia.Controls
             RowGroupHeadersTable = new IndexToValueTable<DataGridRowGroupInfo>();
             //_validationItems = new Dictionary<INotifyDataErrorInfo, string>();
             //_validationResults = new List<ValidationResult>();
-            //_bindingValidationResults = new List<ValidationResult>();
+            _bindingValidationErrors = new List<Exception>();
             //_propertyValidationResults = new List<ValidationResult>();
             //_indeiValidationResults = new List<ValidationResult>();
 
@@ -1978,7 +1983,6 @@ namespace Avalonia.Controls
         /// <returns>True if operation was successful. False otherwise.</returns>
         public bool CommitEdit(DataGridEditingUnit editingUnit, bool exitEditingMode)
         {
-            Debug.WriteLine("DataGrid : CommitEdit");
             if (!EndCellEdit(
                     editAction: DataGridEditAction.Commit, 
                     exitEditingMode: editingUnit == DataGridEditingUnit.Cell ? exitEditingMode : true, 
@@ -2351,7 +2355,7 @@ namespace Avalonia.Controls
         /// <summary>
         /// Builds the visual tree for the column header when a new template is applied.
         /// </summary>
-        //TODO Validation
+        //TODO Validation UI
         protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
         {
             // The template has changed, so we need to refresh the visuals
@@ -3365,7 +3369,6 @@ namespace Avalonia.Controls
 
         private bool CommitEditForOperation(int columnIndex, int slot, bool forCurrentCellChange)
         {
-            Debug.WriteLine("DataGrid : CommitEditForOperation");
             if (forCurrentCellChange)
             {
                 if (!EndCellEdit(DataGridEditAction.Commit, exitEditingMode: true, keepFocus: true, raiseEvents: true))
@@ -3413,9 +3416,10 @@ namespace Avalonia.Controls
             Debug.Assert(EditingRow.Slot < SlotCount);
             
             //if (!ValidateEditingRow(scrollIntoView: true, wireEvents: false))
-            //{
-            //    return false;
-            //}
+            if(!EditingRow.IsValid)
+            {
+                return false;
+            }
 
             DataConnection.EndEdit(EditingRow.DataContext);
 
@@ -3955,7 +3959,6 @@ namespace Avalonia.Controls
             {
                 return true;
             }
-            Debug.WriteLine("DataGrid : EndCellEdit");
 
             Debug.Assert(EditingRow != null);
             Debug.Assert(_editingColumnIndex >= 0);
@@ -3997,7 +4000,7 @@ namespace Avalonia.Controls
                 Debug.Assert(_editingColumnIndex == CurrentColumnIndex);
             }
 
-            //_bindingValidationResults.Clear();
+            //_bindingValidationErrors.Clear();
 
             // If we're canceling, let the editing column repopulate its old value if it wants
             if (editAction == DataGridEditAction.Cancel)
@@ -4032,16 +4035,69 @@ namespace Avalonia.Controls
                 //    bindingData.Element.BindingValidationError -= new EventHandler<ValidationErrorEventArgs>(EditingElement_BindingValidationError);
                 //}
 
-                // Re-validate
-                //ValidateEditingRow(scrollIntoView: true, wireEvents: false);
+                void SetValidationStatus(ICellEditBinding binding)
+                {
+                    if (binding.IsValid)
+                    {
+                        ResetValidationStatus();
+                        if (editingElement != null)
+                        {
+                            DataValidationErrors.ClearErrors(editingElement);
+                        }
+                    }
+                    else
+                    {
+                        if (EditingRow != null)
+                        {
+                            if (editingCell.IsValid)
+                            {
+                                editingCell.IsValid = false;
+                                editingCell.UpdatePseudoClasses();
+                            }
 
-                //if (_bindingValidationResults.Count > 0)
-                //{
-                //    ScrollSlotIntoView(CurrentColumnIndex, CurrentSlot, forCurrentCellChange: false, forceHorizontalScroll: true);
-                //    return false;
-                //}
+                            if (EditingRow.IsValid)
+                            {
+                                EditingRow.IsValid = false;
+                                EditingRow.UpdatePseudoClasses();
+                            }
+                        }
+
+                        if(editingElement != null)
+                        {
+                            var errorList = 
+                                binding.ValidationErrors
+                                       .SelectMany(ex => ValidationUtil.UnpackException(ex))
+                                       .ToList();
+
+                            DataValidationErrors.SetErrors(editingElement, errorList);
+                        }
+                    }
+                }
+
+                var editBinding = CurrentColumn?.CellEditBinding;
+                if(editBinding != null && !editBinding.CommitEdit())
+                {
+                    SetValidationStatus(editBinding);
+                    _validationSubscription?.Dispose();
+                    _validationSubscription = editBinding.ValidationChanged.Subscribe(v => SetValidationStatus(editBinding));
+
+                    ScrollSlotIntoView(CurrentColumnIndex, CurrentSlot, forCurrentCellChange: false, forceHorizontalScroll: true);
+                    return false;
+                }
+                else
+                {
+                    // Re-validate
+                    //ValidateEditingRow(scrollIntoView: true, wireEvents: false);
+
+                    //if (_bindingValidationResults.Count > 0)
+                    //{
+                    //    return false;
+                    //}
+                }
             }
 
+            ResetValidationStatus();
+
             if (exitEditingMode)
             {
                 _editingColumnIndex = -1;
@@ -4127,7 +4183,7 @@ namespace Avalonia.Controls
                     return false;
                 }
             }
-            //ResetValidationStatus();
+            ResetValidationStatus();
 
             // Update the previously edited row's state
             if (exitEditingMode && editingRow == EditingRow)
@@ -5911,7 +5967,6 @@ namespace Avalonia.Controls
         /// Occurs when the DataGridRowGroupHeader is available for reuse.
         /// </summary>
         public event EventHandler<DataGridRowGroupHeaderEventArgs> UnloadingRowGroup;
-        
 
         // Recursively expands parent RowGroupHeaders from the top down
         private void ExpandRowGroupParentChain(int level, int slot)
@@ -6066,613 +6121,620 @@ namespace Avalonia.Controls
 
         #endregion
 
+        #region Validation
         
         /// <summary>
-        /// Raises the AutoGeneratingColumn event.
+        /// Validates the current editing row and updates the visual states.
         /// </summary>
-        protected virtual void OnAutoGeneratingColumn(DataGridAutoGeneratingColumnEventArgs e)
+        /// <param name="scrollIntoView">If true, will scroll the editing row into view when a new error is introduced.</param>
+        /// <param name="wireEvents">If true, subscribes to the asynchronous INDEI ErrorsChanged events.</param>
+        /// <returns>True if the editing row is valid, false otherwise.</returns>
+        //TODO Validation
+        /*private bool ValidateEditingRow(bool scrollIntoView, bool wireEvents)
         {
-            AutoGeneratingColumn?.Invoke(this, e);
-        }
+            //_propertyValidationResults.Clear();
+            //_indeiValidationResults.Clear();
 
-    }
+            if (EditingRow != null)
+            {
+                object dataItem = EditingRow.DataContext;
+                Debug.Assert(dataItem != null);
 
-    /*
-     
-    [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling")]
-    [TemplatePart(Name = DataGrid.DATAGRID_elementRowsPresenterName, Type = typeof(DataGridRowsPresenter))]
-    [TemplatePart(Name = DataGrid.DATAGRID_elementColumnHeadersPresenterName, Type = typeof(DataGridColumnHeadersPresenter))]
-    [TemplatePart(Name = DataGrid.DATAGRID_elementFrozenColumnScrollBarSpacerName, Type = typeof(FrameworkElement))]
-    [TemplatePart(Name = DataGrid.DATAGRID_elementHorizontalScrollbarName, Type = typeof(ScrollBar))]
-    [TemplatePart(Name = DataGrid.DATAGRID_elementValidationSummary, Type = typeof(ValidationSummary))]
-    [TemplatePart(Name = DataGrid.DATAGRID_elementVerticalScrollbarName, Type = typeof(ScrollBar))]
-    [TemplateVisualState(Name = VisualStates.StateDisabled, GroupName = VisualStates.GroupCommon)]
-    [TemplateVisualState(Name = VisualStates.StateNormal, GroupName = VisualStates.GroupCommon)]
-    [TemplateVisualState(Name = VisualStates.StateInvalid, GroupName = VisualStates.GroupValidation)]
-    [TemplateVisualState(Name = VisualStates.StateValid, GroupName = VisualStates.GroupValidation)]
-    [StyleTypedProperty(Property = "CellStyle", StyleTargetType = typeof(DataGridCell))]
-    [StyleTypedProperty(Property = "ColumnHeaderStyle", StyleTargetType = typeof(DataGridColumnHeader))]
-    [StyleTypedProperty(Property = "DragIndicatorStyle", StyleTargetType = typeof(ContentControl))]
-    [StyleTypedProperty(Property = "DropLocationIndicatorStyle", StyleTargetType = typeof(ContentControl))]
-    [StyleTypedProperty(Property = "RowHeaderStyle", StyleTargetType = typeof(DataGridRowHeader))]
-    [StyleTypedProperty(Property = "RowStyle", StyleTargetType = typeof(DataGridRow))]
-    public partial class DataGrid : Control 
-    
-     */
+                // Validate using the Validator.
+                var validationResults = new List<ValidationResult>();
+                var context = new ValidationContext(dataItem);
+                Validator.TryValidateObject(dataItem, context, validationResults, true);
 
-    #region Automation
+                var validationErrors =
+                    validationResults.Where(r => !r.IsValid())
+                                     .Select(r => (Exception)new ValidationException(r.ErrorMessage))
+                                     .ToList();
+
+                // Add any existing exception errors (in case we're editing a cell).
+                // Note: these errors will only be displayed in the ValidationSummary if the
+                // editing data item implements IDEI or INDEI.
+                foreach (var error in _bindingValidationErrors)
+                {
+                    validationErrors.AddExceptionIfNew(error);
+                    //_propertyValidationResults.Add(validationResult);
+                }
 
+                // IDEI entity validation.
+                //ValidateIdei(dataItem as IDataErrorInfo, null, null, validationResults);
 
-    /// <summary>
-    /// Creates AutomationPeer (<see cref="UIElement.OnCreateAutomationPeer"/>)
-    /// </summary>
-    /*protected override AutomationPeer OnCreateAutomationPeer()
-    {
-        return new DataGridAutomationPeer(this);
-    } */
+                ValidateIndeiObject(dataItem as INotifyDataErrorInfo, validationErrors);
 
+                // INDEI entity validation.
+                //ValidateIndei(dataItem as INotifyDataErrorInfo, null, null, null, validationResults, wireEvents);
 
-    #endregion
+                // IDEI and INDEI property validation.
+                //foreach (DataGridColumn column in ColumnsInternal.GetDisplayedColumns(c => c.IsVisible && !c.IsReadOnly))
+                //{
+                //    foreach (string bindingPath in column.BindingPaths)
+                //    {
+                //        string declaringPath = null;
+                //        object declaringItem = dataItem;
+                //        string bindingProperty = bindingPath;
+
+                //        // Check for nested paths.
+                //        int lastIndexOfSeparator = bindingPath.LastIndexOfAny(new char[] { TypeHelper.PropertyNameSeparator, TypeHelper.LeftIndexerToken });
+                //        if (lastIndexOfSeparator >= 0)
+                //        {
+                //            declaringPath = bindingPath.Substring(0, lastIndexOfSeparator);
+                //            declaringItem = TypeHelper.GetNestedPropertyValue(dataItem, declaringPath);
+                //            if (bindingProperty[lastIndexOfSeparator] == TypeHelper.LeftIndexerToken)
+                //            {
+                //                bindingProperty = TypeHelper.PrependDefaultMemberName(declaringItem, bindingPath.Substring(lastIndexOfSeparator));
+                //            }
+                //            else
+                //            {
+                //                bindingProperty = bindingPath.Substring(lastIndexOfSeparator + 1);
+                //            }
+                //        }
+
+                //        // IDEI property validation.
+                //        ValidateIdei(declaringItem as IDataErrorInfo, bindingProperty, bindingPath, validationResults);
+
+                //        // INDEI property validation.
+                //        ValidateIndei(declaringItem as INotifyDataErrorInfo, bindingProperty, bindingPath, declaringPath, validationResults, wireEvents);
+                //    }
+                //}
 
-    #region Validation
+                // Merge the new validation results with the existing ones.
+                UpdateValidationResults(validationErrors, scrollIntoView);
 
-    //TODO Validation
-    /// <summary>
-    /// Create an ValidationSummaryItem for a given ValidationResult, by finding all cells related to the
-    /// validation error and adding them as separate ValidationSummaryItemSources.
-    /// </summary>
-    /// <param name="validationResult">ValidationResult</param>
-    /// <returns>ValidationSummaryItem</returns>
-    /*private ValidationSummaryItem CreateValidationSummaryItem(ValidationResult validationResult)
-    {
-        Debug.Assert(validationResult != null);
-        Debug.Assert(_validationSummary != null);
-        Debug.Assert(EditingRow != null);
+                // Return false if there are validation errors.
+                if (!IsValid)
+                {
+                    return false;
+                }
+            }
 
-        ValidationSummaryItem validationSummaryItem = new ValidationSummaryItem(validationResult.ErrorMessage);
-        validationSummaryItem.Context = validationResult;
+            // Return true if there are no errors or there is no editing row.
+            ResetValidationStatus();
+            return true;
+        }*/
 
-        string messageHeader = null;
-        foreach (DataGridColumn column in ColumnsInternal.GetDisplayedColumns(c => c.IsVisible && !c.IsReadOnly))
+        /// <summary>
+        /// Updates the DataGrid's validation results, modifies the ValidationSummary's items,
+        /// and sets the IsValid states of the UIElements.
+        /// </summary>
+        /// <param name="newValidationResults">New validation results.</param>
+        /// <param name="scrollIntoView">If the validation results have changed, scrolls the editing row into view.</param>
+        //TODO Validation
+        /*private void UpdateValidationResults(List<Exception> newValidationErrors, bool scrollIntoView)
         {
-            foreach (string property in validationResult.MemberNames)
+            bool validationResultsChanged = false;
+            Debug.Assert(EditingRow != null);
+
+            // Remove the validation results that have been fixed
+            List<ValidationResult> removedValidationResults = new List<ValidationResult>();
+            foreach (ValidationResult oldValidationResult in _validationResults)
             {
-                if (!string.IsNullOrEmpty(property) && column.BindingPaths.Contains(property))
+                if (oldValidationResult != null && !newValidationResults.ContainsEqualValidationResult(oldValidationResult))
                 {
-                    validationSummaryItem.Sources.Add(new ValidationSummaryItemSource(property, EditingRow.Cells[column.Index]));
-                    if (string.IsNullOrEmpty(messageHeader) && column.Header != null)
+                    removedValidationResults.Add(oldValidationResult);
+                    validationResultsChanged = true;
+                }
+            }
+            foreach (ValidationResult removedValidationResult in removedValidationResults)
+            {
+                _validationResults.Remove(removedValidationResult);
+                if (_validationSummary != null)
+                {
+                    ValidationSummaryItem removedValidationSummaryItem = FindValidationSummaryItem(removedValidationResult);
+                    if (removedValidationSummaryItem != null)
                     {
-                        messageHeader = column.Header.ToString();
+                        _validationSummary.Errors.Remove(removedValidationSummaryItem);
                     }
                 }
             }
-        }
 
-        Debug.Assert(validationSummaryItem.ItemType == ValidationSummaryItemType.ObjectError);
-        if (_propertyValidationResults.ContainsEqualValidationResult(validationResult))
-        {
-            validationSummaryItem.MessageHeader = messageHeader;
-            validationSummaryItem.ItemType = ValidationSummaryItemType.PropertyError;
-        }
-
-        return validationSummaryItem;
-    } */
-
-    /// <summary>
-    /// Handles the ValidationSummary's FocusingInvalidControl event and begins edit on the cells
-    /// that are associated with the selected error.
-    /// </summary>
-    /// <param name="sender">ValidationSummary</param>
-    /// <param name="e">FocusingInvalidControlEventArgs</param>
-    /*private void ValidationSummary_FocusingInvalidControl(object sender, FocusingInvalidControlEventArgs e)
-    {
-        Debug.Assert(_validationSummary != null);
-        if (EditingRow == null || !ScrollSlotIntoView(EditingRow.Slot, scrolledHorizontally: false))
-        {
-            return;
-        }
-
-        // We need to focus the DataGrid in case the focused element gets removed when we end edit.
-        if ((_editingColumnIndex == -1 || (Focus() && EndCellEdit(DataGridEditAction.Commit, true, true, true)))
-            && e.Item != null && e.Target != null && _validationSummary.Errors.Contains(e.Item))
-        {
-            DataGridCell cell = e.Target.Control as DataGridCell;
-            if (cell != null && cell.OwningGrid == this && cell.OwningColumn != null && cell.OwningColumn.IsVisible)
+            // Add any validation results that were just introduced
+            foreach (ValidationResult newValidationResult in newValidationResults)
             {
-                Debug.Assert(cell.ColumnIndex >= 0 && cell.ColumnIndex < ColumnsInternal.Count);
-
-                // Begin editing the next relevant cell
-                UpdateSelectionAndCurrency(cell.ColumnIndex, EditingRow.Slot, DataGridSelectionAction.None, scrollIntoView: true);
-                if (_successfullyUpdatedSelection)
+                if (newValidationResult != null && !_validationResults.ContainsEqualValidationResult(newValidationResult))
                 {
-                    BeginCellEdit(new RoutedEventArgs());
-                    if (!IsColumnDisplayed(CurrentColumnIndex))
+                    _validationResults.Add(newValidationResult);
+                    if (_validationSummary != null && ShouldDisplayValidationResult(newValidationResult))
                     {
-                        ScrollColumnIntoView(CurrentColumnIndex);
+                        ValidationSummaryItem newValidationSummaryItem = CreateValidationSummaryItem(newValidationResult);
+                        if (newValidationSummaryItem != null)
+                        {
+                            _validationSummary.Errors.Add(newValidationSummaryItem);
+                        }
                     }
+                    validationResultsChanged = true;
                 }
             }
-            e.Handled = true;
-        }
-    } */
-
-    /// <summary>
-    /// Handles the ValidationSummary's SelectionChanged event and changes which cells are displayed as invalid.
-    /// </summary>
-    /// <param name="sender">ValidationSummary</param>
-    /// <param name="e">SelectionChangedEventArgs</param>
-    /*private void ValidationSummary_SelectionChanged(object sender, SelectionChangedEventArgs e)
-    {
-        // ValidationSummary only supports single-selection mode.
-        if (e.AddedItems.Count == 1)
-        {
-            _selectedValidationSummaryItem = e.AddedItems[0] as ValidationSummaryItem;
-        }
 
-        UpdateValidationStatus();
-    } */
-
-    /// <summary>
-    /// Searches through the DataGrid's ValidationSummary for any errors that use the given
-    /// ValidationResult as the ValidationSummaryItem's Context value.
-    /// </summary>
-    /// <param name="context">ValidationResult</param>
-    /// <returns>ValidationSummaryItem or null if not found</returns>
-    /*private ValidationSummaryItem FindValidationSummaryItem(ValidationResult context)
-    {
-        Debug.Assert(context != null);
-        Debug.Assert(_validationSummary != null);
-        foreach (ValidationSummaryItem ValidationSummaryItem in _validationSummary.Errors)
-        {
-            if (context.Equals(ValidationSummaryItem.Context))
+            if (validationResultsChanged)
             {
-                return ValidationSummaryItem;
+                UpdateValidationStatus();
             }
-        }
-        return null;
-    } */
-
-    /* private void EditingElement_BindingValidationError(object sender, ValidationErrorEventArgs e)
-    {
-        if (e.Action == ValidationErrorEventAction.Added && e.Error.Exception != null && e.Error.ErrorContent != null)
-        {
-            ValidationResult validationResult = new ValidationResult(e.Error.ErrorContent.ToString(), new List<string>() { _updateSourcePath });
-            _bindingValidationResults.AddIfNew(validationResult);
-        }
-    } */
+            if (!IsValid && scrollIntoView)
+            {
+                // Scroll the row with the error into view.
+                int editingRowSlot = EditingRow.Slot;
+                if (_validationSummary != null)
+                {
+                    // If the number of errors has changed, then the ValidationSummary will be a different size,
+                    // and we need to delay our call to ScrollSlotIntoView
+                    InvalidateMeasure();
+                    Dispatcher.BeginInvoke(delegate
+                    {
+                        // It's possible that the DataContext or ItemsSource has changed by the time we reach this code,
+                        // so we need to ensure that the editing row still exists before scrolling it into view
+                        if (!IsSlotOutOfBounds(editingRowSlot))
+                        {
+                            ScrollSlotIntoView(editingRowSlot, scrolledHorizontally: false);
+                        }
+                    });
+                }
+                else
+                {
+                    ScrollSlotIntoView(editingRowSlot, scrolledHorizontally: false);
+                }
+            }
+        }*/
 
-    /*private void ResetValidationStatus()
-    {
-        // Clear the invalid status of the Cell, Row and DataGrid
-        if (EditingRow != null)
+        //TODO Validation UI
+        private void ResetValidationStatus()
         {
-            EditingRow.IsValid = true;
-            if (EditingRow.Index != -1)
+            // Clear the invalid status of the Cell, Row and DataGrid
+            if (EditingRow != null)
             {
-                foreach (DataGridCell cell in EditingRow.Cells)
+                EditingRow.IsValid = true;
+                if (EditingRow.Index != -1)
                 {
-                    if (!cell.IsValid)
+                    foreach (DataGridCell cell in EditingRow.Cells)
                     {
-                        cell.IsValid = true;
-                        cell.ApplyCellState(true);
+                        if (!cell.IsValid)
+                        {
+                            cell.IsValid = true;
+                            cell.UpdatePseudoClasses();
+                        }
                     }
+                    EditingRow.UpdatePseudoClasses();
                 }
-                EditingRow.ApplyState(true);
             }
-        }
-        IsValid = true;
+            IsValid = true;
 
-        // Clear the previous validation results
-        _validationResults.Clear();
+            // Clear the previous validation results
+            //_validationErrors.Clear();
+            _validationSubscription?.Dispose();
+            _validationSubscription = null;
 
-        // Hide the error list if validation succeeded
-        if (_validationSummary != null && _validationSummary.Errors.Count > 0)
+            //_validationResults.Clear();
+
+            // Hide the error list if validation succeeded
+            //if (_validationSummary != null && _validationSummary.Errors.Count > 0)
+            //{
+            //    _validationSummary.Errors.Clear();
+            //    if (EditingRow != null)
+            //    {
+            //        int editingRowSlot = EditingRow.Slot;
+
+            //        InvalidateMeasure();
+            //        Dispatcher.BeginInvoke(delegate
+            //        {
+            //            // It's possible that the DataContext or ItemsSource has changed by the time we reach this code,
+            //            // so we need to ensure that the editing row still exists before scrolling it into view
+            //            if (!IsSlotOutOfBounds(editingRowSlot))
+            //            {
+            //                ScrollSlotIntoView(editingRowSlot, scrolledHorizontally: false);
+            //            }
+            //        });
+            //    }
+            //}
+        }
+
+        /// <summary>
+        /// Updates the IsValid states of the DataGrid, the EditingRow and its cells. All cells related to
+        /// property-level errors are set to Invalid.  If there is an object-level error selected in the
+        /// ValidationSummary, then its associated cells will also be flagged (if there are any).
+        /// </summary>
+        /*private void UpdateValidationStatus()
         {
-            _validationSummary.Errors.Clear();
             if (EditingRow != null)
             {
-                int editingRowSlot = EditingRow.Slot;
-
-                InvalidateMeasure();
-                Dispatcher.BeginInvoke(delegate
+                foreach (DataGridCell cell in EditingRow.Cells)
                 {
-                    // It's possible that the DataContext or ItemsSource has changed by the time we reach this code,
-                    // so we need to ensure that the editing row still exists before scrolling it into view
-                    if (!IsSlotOutOfBounds(editingRowSlot))
+                    bool isCellValid = true;
+
+                    Debug.Assert(cell.OwningColumn != null);
+                    if (!cell.OwningColumn.IsReadOnly)
                     {
-                        ScrollSlotIntoView(editingRowSlot, scrolledHorizontally: false);
+                        foreach (ValidationResult validationResult in _validationResults)
+                        {
+                            if (_propertyValidationResults.ContainsEqualValidationResult(validationResult) ||
+                                _selectedValidationSummaryItem != null && _selectedValidationSummaryItem.Context == validationResult)
+                            {
+                                foreach (string bindingPath in validationResult.MemberNames)
+                                {
+                                    if (cell.OwningColumn.BindingPaths.Contains(bindingPath))
+                                    {
+                                        isCellValid = false;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
                     }
-                });
+                    if (cell.IsValid != isCellValid)
+                    {
+                        cell.IsValid = isCellValid;
+                        cell.UpdatePseudoClasses();
+                    }
+                }
+                bool isRowValid = _validationResults.Count == 0;
+                if (EditingRow.IsValid != isRowValid)
+                {
+                    EditingRow.IsValid = isRowValid;
+                    EditingRow.UpdatePseudoClasses();
+                }
+                IsValid = isRowValid;
+            }
+            else
+            {
+                IsValid = true;
             }
-        }
-    } */
-
-    /// <summary>
-    /// Determines whether or not a specific validation result should be displayed in the ValidationSummary.
-    /// </summary>
-    /// <param name="validationResult">Validation result to display.</param>
-    /// <returns>True if it should be added to the ValidationSummary, false otherwise.</returns>
-    /*private bool ShouldDisplayValidationResult(ValidationResult validationResult)
-    {
-        if (EditingRow != null)
-        {
-            return !_bindingValidationResults.ContainsEqualValidationResult(validationResult) ||
-                EditingRow.DataContext is IDataErrorInfo || EditingRow.DataContext is INotifyDataErrorInfo;
-        }
-        return false;
-    } */
 
-    /// <summary>
-    /// Updates the DataGrid's validation results, modifies the ValidationSummary's items,
-    /// and sets the IsValid states of the UIElements.
-    /// </summary>
-    /// <param name="newValidationResults">New validation results.</param>
-    /// <param name="scrollIntoView">If the validation results have changed, scrolls the editing row into view.</param>
-    /*private void UpdateValidationResults(List<ValidationResult> newValidationResults, bool scrollIntoView)
-    {
-        bool validationResultsChanged = false;
-        Debug.Assert(EditingRow != null);
+        } */
 
-        // Remove the validation results that have been fixed
-        List<ValidationResult> removedValidationResults = new List<ValidationResult>();
-        foreach (ValidationResult oldValidationResult in _validationResults)
+        /* private void EditingElement_BindingValidationError(object sender, ValidationErrorEventArgs e)
         {
-            if (oldValidationResult != null && !newValidationResults.ContainsEqualValidationResult(oldValidationResult))
+            if (e.Action == ValidationErrorEventAction.Added && e.Error.Exception != null && e.Error.ErrorContent != null)
             {
-                removedValidationResults.Add(oldValidationResult);
-                validationResultsChanged = true;
+                ValidationResult validationResult = new ValidationResult(e.Error.ErrorContent.ToString(), new List<string>() { _updateSourcePath });
+                _bindingValidationResults.AddIfNew(validationResult);
             }
-        }
-        foreach (ValidationResult removedValidationResult in removedValidationResults)
+        } */
+
+        /// <summary>
+        /// Determines whether or not a specific validation result should be displayed in the ValidationSummary.
+        /// </summary>
+        /// <param name="validationResult">Validation result to display.</param>
+        /// <returns>True if it should be added to the ValidationSummary, false otherwise.</returns>
+        /*private bool ShouldDisplayValidationResult(ValidationResult validationResult)
         {
-            _validationResults.Remove(removedValidationResult);
-            if (_validationSummary != null)
+            if (EditingRow != null)
             {
-                ValidationSummaryItem removedValidationSummaryItem = FindValidationSummaryItem(removedValidationResult);
-                if (removedValidationSummaryItem != null)
-                {
-                    _validationSummary.Errors.Remove(removedValidationSummaryItem);
-                }
+                return !_bindingValidationResults.ContainsEqualValidationResult(validationResult) ||
+                    EditingRow.DataContext is IDataErrorInfo || EditingRow.DataContext is INotifyDataErrorInfo;
             }
-        }
+            return false;
+        } */
 
-        // Add any validation results that were just introduced
-        foreach (ValidationResult newValidationResult in newValidationResults)
+        /// <summary>
+        /// Handles the asynchronous INDEI errors that occur while the DataGrid is in editing mode.
+        /// </summary>
+        /// <param name="sender">INDEI item whose errors changed.</param>
+        /// <param name="e">Error event arguments.</param>
+        /*private void ValidationItem_ErrorsChanged(object sender, DataErrorsChangedEventArgs e)
         {
-            if (newValidationResult != null && !_validationResults.ContainsEqualValidationResult(newValidationResult))
+            INotifyDataErrorInfo indei = sender as INotifyDataErrorInfo;
+            if (_validationItems.ContainsKey(indei))
             {
-                _validationResults.Add(newValidationResult);
-                if (_validationSummary != null && ShouldDisplayValidationResult(newValidationResult))
+                Debug.Assert(EditingRow != null);
+
+                // Determine the binding path.
+                string bindingPath = _validationItems[indei];
+                if (string.IsNullOrEmpty(bindingPath))
+                {
+                    bindingPath = e.PropertyName;
+                }
+                else if (!string.IsNullOrEmpty(e.PropertyName) && e.PropertyName.IndexOf(TypeHelper.LeftIndexerToken) >= 0)
+                {
+                    bindingPath += TypeHelper.RemoveDefaultMemberName(e.PropertyName);
+                }
+                else
+                {
+                    bindingPath += TypeHelper.PropertyNameSeparator + e.PropertyName;
+                }
+
+                // Remove the old errors.
+                List<ValidationResult> validationResults = new List<ValidationResult>();
+                foreach (ValidationResult validationResult in _validationResults)
                 {
-                    ValidationSummaryItem newValidationSummaryItem = CreateValidationSummaryItem(newValidationResult);
-                    if (newValidationSummaryItem != null)
+                    ValidationResult oldValidationResult = _indeiValidationResults.FindEqualValidationResult(validationResult);
+                    if (oldValidationResult != null && oldValidationResult.ContainsMemberName(bindingPath))
+                    {
+                        _indeiValidationResults.Remove(oldValidationResult);
+                    }
+                    else
                     {
-                        _validationSummary.Errors.Add(newValidationSummaryItem);
+                        validationResults.Add(validationResult);
                     }
                 }
-                validationResultsChanged = true;
+
+                // Find any new errors and update the visuals.
+                //TODO: Validation ParameterNames
+                ValidateIndei(indei, e.PropertyName, bindingPath, null, validationResults, false);
+                //TODO: Validation ParameterNames
+                UpdateValidationResults(validationResults, false);
+
+                // If we're valid now then reset our status.
+                if (IsValid)
+                {
+                    ResetValidationStatus();
+                }
             }
-        }
+            else if (indei != null)
+            {
+                indei.ErrorsChanged -= new EventHandler<DataErrorsChangedEventArgs>(ValidationItem_ErrorsChanged);
+            }
+        }*/
 
-        if (validationResultsChanged)
+        /*private void ValidateIndeiObject(INotifyDataErrorInfo indei, List<Exception> validationErrors)
         {
-            UpdateValidationStatus();
-        }
-        if (!IsValid && scrollIntoView)
-        {
-            // Scroll the row with the error into view.
-            int editingRowSlot = EditingRow.Slot;
-            if (_validationSummary != null)
+            if(indei != null && indei.HasErrors)
             {
-                // If the number of errors has changed, then the ValidationSummary will be a different size,
-                // and we need to delay our call to ScrollSlotIntoView
-                InvalidateMeasure();
-                Dispatcher.BeginInvoke(delegate
+                IEnumerable errors = null;
+                ValidationUtil.CatchNonCriticalExceptions(() => { errors = indei.GetErrors(null); });
+                foreach (var error in errors)
                 {
-                    // It's possible that the DataContext or ItemsSource has changed by the time we reach this code,
-                    // so we need to ensure that the editing row still exists before scrolling it into view
-                    if (!IsSlotOutOfBounds(editingRowSlot))
+                    string errorString = null;
+                    ValidationUtil.CatchNonCriticalExceptions(() => { errorString = error.ToString(); });
+                    if(!String.IsNullOrWhiteSpace(errorString))
                     {
-                        ScrollSlotIntoView(editingRowSlot, scrolledHorizontally: false);
+                        var ex = new ValidationException(errorString);
+                        validationErrors.AddExceptionIfNew(ex);
                     }
-                });
-            }
-            else
-            {
-                ScrollSlotIntoView(editingRowSlot, scrolledHorizontally: false);
+                }
             }
-        }
-    } */
+        }*/
 
-    /// <summary>
-    /// Updates the IsValid states of the DataGrid, the EditingRow and its cells. All cells related to
-    /// property-level errors are set to Invalid.  If there is an object-level error selected in the
-    /// ValidationSummary, then its associated cells will also be flagged (if there are any).
-    /// </summary>
-    /*private void UpdateValidationStatus()
-    {
-        if (EditingRow != null)
+        /// <summary>
+        /// Checks an INDEI data object for errors on the specified path. New errors are added to the
+        /// list of validation results.
+        /// </summary>
+        /// <param name="indei">INDEI object to validate.</param>
+        /// <param name="bindingProperty">Name of the property to validate.</param>
+        /// <param name="bindingPath">Path of the binding.</param>
+        /// <param name="declaringPath">Path of the INDEI object.</param>
+        /// <param name="validationResults">List of results to add to.</param>
+        /// <param name="wireEvents">True if the ErrorsChanged event should be subscribed to.</param>
+        /*private void ValidateIndei(INotifyDataErrorInfo indei, string bindingProperty, string bindingPath, string declaringPath, List<ValidationResult> validationResults, bool wireEvents)
         {
-            foreach (DataGridCell cell in EditingRow.Cells)
+            if (indei != null)
             {
-                bool isCellValid = true;
-
-                Debug.Assert(cell.OwningColumn != null);
-                if (!cell.OwningColumn.IsReadOnly)
+                if (indei.HasErrors)
                 {
-                    foreach (ValidationResult validationResult in _validationResults)
+                    IEnumerable errors = null;
+                    ValidationUtil.CatchNonCriticalExceptions(() => { errors = indei.GetErrors(bindingProperty); });
+                    if (errors != null)
                     {
-                        if (_propertyValidationResults.ContainsEqualValidationResult(validationResult) ||
-                            _selectedValidationSummaryItem != null && _selectedValidationSummaryItem.Context == validationResult)
+                        foreach (object errorItem in errors)
                         {
-                            foreach (string bindingPath in validationResult.MemberNames)
+                            if (errorItem != null)
                             {
-                                if (cell.OwningColumn.BindingPaths.Contains(bindingPath))
+                                string errorString = null;
+                                ValidationUtil.CatchNonCriticalExceptions(() => { errorString = errorItem.ToString(); });
+                                if (!string.IsNullOrEmpty(errorString))
                                 {
-                                    isCellValid = false;
-                                    break;
+                                    ValidationResult validationResult;
+                                    if (!string.IsNullOrEmpty(bindingProperty))
+                                    {
+                                        validationResult = new ValidationResult(errorString, new List<string>() { bindingPath });
+                                        _propertyValidationResults.Add(validationResult);
+                                    }
+                                    else
+                                    {
+                                        Debug.Assert(string.IsNullOrEmpty(bindingPath));
+                                        validationResult = new ValidationResult(errorString);
+                                    }
+                                    validationResults.AddIfNew(validationResult);
+                                    _indeiValidationResults.AddIfNew(validationResult);
                                 }
                             }
                         }
                     }
                 }
-                if (cell.IsValid != isCellValid)
+                if (wireEvents)
                 {
-                    cell.IsValid = isCellValid;
-                    cell.UpdatePseudoClasses();
+                    indei.ErrorsChanged += new EventHandler<DataErrorsChangedEventArgs>(ValidationItem_ErrorsChanged);
+                    if (!_validationItems.ContainsKey(indei))
+                    {
+                        _validationItems.Add(indei, declaringPath);
+                    }
                 }
             }
-            bool isRowValid = _validationResults.Count == 0;
-            if (EditingRow.IsValid != isRowValid)
-            {
-                EditingRow.IsValid = isRowValid;
-                EditingRow.UpdatePseudoClasses();
-            }
-            IsValid = isRowValid;
-        }
-        else
-        {
-            IsValid = true;
-        }
+        }*/
 
-    } */
+        #region Old Validation UI
 
-    /// <summary>
-    /// Handles the asynchronous INDEI errors that occur while the DataGrid is in editing mode.
-    /// </summary>
-    /// <param name="sender">INDEI item whose errors changed.</param>
-    /// <param name="e">Error event arguments.</param>
-    /*private void ValidationItem_ErrorsChanged(object sender, DataErrorsChangedEventArgs e)
-    {
-        INotifyDataErrorInfo indei = sender as INotifyDataErrorInfo;
-        if (_validationItems.ContainsKey(indei))
+
+        /// <summary>
+        /// Create an ValidationSummaryItem for a given ValidationResult, by finding all cells related to the
+        /// validation error and adding them as separate ValidationSummaryItemSources.
+        /// </summary>
+        /// <param name="validationResult">ValidationResult</param>
+        /// <returns>ValidationSummaryItem</returns>
+        /*private ValidationSummaryItem CreateValidationSummaryItem(ValidationResult validationResult)
         {
+            Debug.Assert(validationResult != null);
+            Debug.Assert(_validationSummary != null);
             Debug.Assert(EditingRow != null);
 
-            // Determine the binding path.
-            string bindingPath = _validationItems[indei];
-            if (string.IsNullOrEmpty(bindingPath))
-            {
-                bindingPath = e.PropertyName;
-            }
-            else if (!string.IsNullOrEmpty(e.PropertyName) && e.PropertyName.IndexOf(TypeHelper.LeftIndexerToken) >= 0)
-            {
-                bindingPath += TypeHelper.RemoveDefaultMemberName(e.PropertyName);
-            }
-            else
-            {
-                bindingPath += TypeHelper.PropertyNameSeparator + e.PropertyName;
-            }
+            ValidationSummaryItem validationSummaryItem = new ValidationSummaryItem(validationResult.ErrorMessage);
+            validationSummaryItem.Context = validationResult;
 
-            // Remove the old errors.
-            List<ValidationResult> validationResults = new List<ValidationResult>();
-            foreach (ValidationResult validationResult in _validationResults)
+            string messageHeader = null;
+            foreach (DataGridColumn column in ColumnsInternal.GetDisplayedColumns(c => c.IsVisible && !c.IsReadOnly))
             {
-                ValidationResult oldValidationResult = _indeiValidationResults.FindEqualValidationResult(validationResult);
-                if (oldValidationResult != null && oldValidationResult.ContainsMemberName(bindingPath))
+                foreach (string property in validationResult.MemberNames)
                 {
-                    _indeiValidationResults.Remove(oldValidationResult);
-                }
-                else
-                {
-                    validationResults.Add(validationResult);
+                    if (!string.IsNullOrEmpty(property) && column.BindingPaths.Contains(property))
+                    {
+                        validationSummaryItem.Sources.Add(new ValidationSummaryItemSource(property, EditingRow.Cells[column.Index]));
+                        if (string.IsNullOrEmpty(messageHeader) && column.Header != null)
+                        {
+                            messageHeader = column.Header.ToString();
+                        }
+                    }
                 }
             }
 
-            // Find any new errors and update the visuals.
-            //TODO: Validation ParameterNames
-            ValidateIndei(indei, e.PropertyName, bindingPath, null, validationResults, false);
-            //TODO: Validation ParameterNames
-            UpdateValidationResults(validationResults, false);
-
-            // If we're valid now then reset our status.
-            if (IsValid)
+            Debug.Assert(validationSummaryItem.ItemType == ValidationSummaryItemType.ObjectError);
+            if (_propertyValidationResults.ContainsEqualValidationResult(validationResult))
             {
-                ResetValidationStatus();
+                validationSummaryItem.MessageHeader = messageHeader;
+                validationSummaryItem.ItemType = ValidationSummaryItemType.PropertyError;
             }
-        }
-        else if (indei != null)
-        {
-            indei.ErrorsChanged -= new EventHandler<DataErrorsChangedEventArgs>(ValidationItem_ErrorsChanged);
-        }
-    } */
 
-    /// <summary>
-    /// Validates the current editing row and updates the visual states.
-    /// </summary>
-    /// <param name="scrollIntoView">If true, will scroll the editing row into view when a new error is introduced.</param>
-    /// <param name="wireEvents">If true, subscribes to the asynchronous INDEI ErrorsChanged events.</param>
-    /// <returns>True if the editing row is valid, false otherwise.</returns>
-    /*private bool ValidateEditingRow(bool scrollIntoView, bool wireEvents)
-    {
-        _propertyValidationResults.Clear();
-        _indeiValidationResults.Clear();
+            return validationSummaryItem;
+        } */
 
-        if (EditingRow != null)
+        /// <summary>
+        /// Handles the ValidationSummary's FocusingInvalidControl event and begins edit on the cells
+        /// that are associated with the selected error.
+        /// </summary>
+        /// <param name="sender">ValidationSummary</param>
+        /// <param name="e">FocusingInvalidControlEventArgs</param>
+        /*private void ValidationSummary_FocusingInvalidControl(object sender, FocusingInvalidControlEventArgs e)
         {
-            Object dataItem = EditingRow.DataContext;
-            Debug.Assert(dataItem != null);
-
-            // Validate using the Validator.
-            List<ValidationResult> validationResults = new List<ValidationResult>();
-            ValidationContext context = new ValidationContext(dataItem, null, null);
-            Validator.TryValidateObject(dataItem, context, validationResults, true);
-
-            // Add any existing exception errors (in case we're editing a cell).
-            // Note: these errors will only be displayed in the ValidationSummary if the
-            // editing data item implements IDEI or INDEI.
-            foreach (ValidationResult validationResult in _bindingValidationResults)
+            Debug.Assert(_validationSummary != null);
+            if (EditingRow == null || !ScrollSlotIntoView(EditingRow.Slot, scrolledHorizontally: false))
             {
-                validationResults.AddIfNew(validationResult);
-                _propertyValidationResults.Add(validationResult);
+                return;
             }
 
-            // IDEI entity validation.
-            ValidateIdei(dataItem as IDataErrorInfo, null, null, validationResults);
-
-            // INDEI entity validation.
-            ValidateIndei(dataItem as INotifyDataErrorInfo, null, null, null, validationResults, wireEvents);
-
-            // IDEI and INDEI property validation.
-            foreach (DataGridColumn column in ColumnsInternal.GetDisplayedColumns(c => c.IsVisible && !c.IsReadOnly))
+            // We need to focus the DataGrid in case the focused element gets removed when we end edit.
+            if ((_editingColumnIndex == -1 || (Focus() && EndCellEdit(DataGridEditAction.Commit, true, true, true)))
+                && e.Item != null && e.Target != null && _validationSummary.Errors.Contains(e.Item))
             {
-                foreach (string bindingPath in column.BindingPaths)
+                DataGridCell cell = e.Target.Control as DataGridCell;
+                if (cell != null && cell.OwningGrid == this && cell.OwningColumn != null && cell.OwningColumn.IsVisible)
                 {
-                    string declaringPath = null;
-                    object declaringItem = dataItem;
-                    string bindingProperty = bindingPath;
+                    Debug.Assert(cell.ColumnIndex >= 0 && cell.ColumnIndex < ColumnsInternal.Count);
 
-                    // Check for nested paths.
-                    int lastIndexOfSeparator = bindingPath.LastIndexOfAny(new char[] { TypeHelper.PropertyNameSeparator, TypeHelper.LeftIndexerToken });
-                    if (lastIndexOfSeparator >= 0)
+                    // Begin editing the next relevant cell
+                    UpdateSelectionAndCurrency(cell.ColumnIndex, EditingRow.Slot, DataGridSelectionAction.None, scrollIntoView: true);
+                    if (_successfullyUpdatedSelection)
                     {
-                        declaringPath = bindingPath.Substring(0, lastIndexOfSeparator);
-                        declaringItem = TypeHelper.GetNestedPropertyValue(dataItem, declaringPath);
-                        if (bindingProperty[lastIndexOfSeparator] == TypeHelper.LeftIndexerToken)
-                        {
-                            bindingProperty = TypeHelper.PrependDefaultMemberName(declaringItem, bindingPath.Substring(lastIndexOfSeparator));
-                        }
-                        else
+                        BeginCellEdit(new RoutedEventArgs());
+                        if (!IsColumnDisplayed(CurrentColumnIndex))
                         {
-                            bindingProperty = bindingPath.Substring(lastIndexOfSeparator + 1);
+                            ScrollColumnIntoView(CurrentColumnIndex);
                         }
                     }
-
-                    // IDEI property validation.
-                    ValidateIdei(declaringItem as IDataErrorInfo, bindingProperty, bindingPath, validationResults);
-
-                    // INDEI property validation.
-                    ValidateIndei(declaringItem as INotifyDataErrorInfo, bindingProperty, bindingPath, declaringPath, validationResults, wireEvents);
                 }
+                e.Handled = true;
             }
+        } */
 
-            // Merge the new validation results with the existing ones.
-            UpdateValidationResults(validationResults, scrollIntoView);
-
-            // Return false if there are validation errors.
-            if (!IsValid)
+        /// <summary>
+        /// Handles the ValidationSummary's SelectionChanged event and changes which cells are displayed as invalid.
+        /// </summary>
+        /// <param name="sender">ValidationSummary</param>
+        /// <param name="e">SelectionChangedEventArgs</param>
+        /*private void ValidationSummary_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            // ValidationSummary only supports single-selection mode.
+            if (e.AddedItems.Count == 1)
             {
-                return false;
+                _selectedValidationSummaryItem = e.AddedItems[0] as ValidationSummaryItem;
             }
-        }
 
-        // Return true if there are no errors or there is no editing row.
-        ResetValidationStatus();
-        return true;
-    } */
+            UpdateValidationStatus();
+        } */
 
-    /// <summary>
-    /// Checks an IDEI data object for errors for the specified property. New errors are added to the
-    /// list of validation results.
-    /// </summary>
-    /// <param name="idei">IDEI object to validate.</param>
-    /// <param name="bindingProperty">Name of the property to validate.</param>
-    /// <param name="bindingPath">Path of the binding.</param>
-    /// <param name="validationResults">List of results to add to.</param>
-    /*private void ValidateIdei(IDataErrorInfo idei, string bindingProperty, string bindingPath, List<ValidationResult> validationResults)
-    {
-        if (idei != null)
+        /// <summary>
+        /// Searches through the DataGrid's ValidationSummary for any errors that use the given
+        /// ValidationResult as the ValidationSummaryItem's Context value.
+        /// </summary>
+        /// <param name="context">ValidationResult</param>
+        /// <returns>ValidationSummaryItem or null if not found</returns>
+        /*private ValidationSummaryItem FindValidationSummaryItem(ValidationResult context)
         {
-            string errorString = null;
-            if (string.IsNullOrEmpty(bindingProperty))
-            {
-                Debug.Assert(string.IsNullOrEmpty(bindingPath));
-                ValidationUtil.CatchNonCriticalExceptions(() => { errorString = idei.Error; });
-                if (!string.IsNullOrEmpty(errorString))
-                {
-                    validationResults.AddIfNew(new ValidationResult(errorString));
-                }
-            }
-            else
+            Debug.Assert(context != null);
+            Debug.Assert(_validationSummary != null);
+            foreach (ValidationSummaryItem ValidationSummaryItem in _validationSummary.Errors)
             {
-                ValidationUtil.CatchNonCriticalExceptions(() => { errorString = idei[bindingProperty]; });
-                if (!string.IsNullOrEmpty(errorString))
+                if (context.Equals(ValidationSummaryItem.Context))
                 {
-                    ValidationResult validationResult = new ValidationResult(errorString, new List<string>() { bindingPath });
-                    validationResults.AddIfNew(validationResult);
-                    _propertyValidationResults.Add(validationResult);
+                    return ValidationSummaryItem;
                 }
             }
+            return null;
+        } */
+
+        #endregion
+
+
+        #endregion
+
+
+        /// <summary>
+        /// Raises the AutoGeneratingColumn event.
+        /// </summary>
+        protected virtual void OnAutoGeneratingColumn(DataGridAutoGeneratingColumnEventArgs e)
+        {
+            AutoGeneratingColumn?.Invoke(this, e);
         }
-    } */
+
+    }
+
+    /*
+     
+    [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling")]
+    [TemplatePart(Name = DataGrid.DATAGRID_elementRowsPresenterName, Type = typeof(DataGridRowsPresenter))]
+    [TemplatePart(Name = DataGrid.DATAGRID_elementColumnHeadersPresenterName, Type = typeof(DataGridColumnHeadersPresenter))]
+    [TemplatePart(Name = DataGrid.DATAGRID_elementFrozenColumnScrollBarSpacerName, Type = typeof(FrameworkElement))]
+    [TemplatePart(Name = DataGrid.DATAGRID_elementHorizontalScrollbarName, Type = typeof(ScrollBar))]
+    [TemplatePart(Name = DataGrid.DATAGRID_elementValidationSummary, Type = typeof(ValidationSummary))]
+    [TemplatePart(Name = DataGrid.DATAGRID_elementVerticalScrollbarName, Type = typeof(ScrollBar))]
+    [TemplateVisualState(Name = VisualStates.StateDisabled, GroupName = VisualStates.GroupCommon)]
+    [TemplateVisualState(Name = VisualStates.StateNormal, GroupName = VisualStates.GroupCommon)]
+    [TemplateVisualState(Name = VisualStates.StateInvalid, GroupName = VisualStates.GroupValidation)]
+    [TemplateVisualState(Name = VisualStates.StateValid, GroupName = VisualStates.GroupValidation)]
+    [StyleTypedProperty(Property = "CellStyle", StyleTargetType = typeof(DataGridCell))]
+    [StyleTypedProperty(Property = "ColumnHeaderStyle", StyleTargetType = typeof(DataGridColumnHeader))]
+    [StyleTypedProperty(Property = "DragIndicatorStyle", StyleTargetType = typeof(ContentControl))]
+    [StyleTypedProperty(Property = "DropLocationIndicatorStyle", StyleTargetType = typeof(ContentControl))]
+    [StyleTypedProperty(Property = "RowHeaderStyle", StyleTargetType = typeof(DataGridRowHeader))]
+    [StyleTypedProperty(Property = "RowStyle", StyleTargetType = typeof(DataGridRow))]
+    public partial class DataGrid : Control 
+    
+     */
+
+    #region Automation
+
 
     /// <summary>
-    /// Checks an INDEI data object for errors on the specified path. New errors are added to the
-    /// list of validation results.
+    /// Creates AutomationPeer (<see cref="UIElement.OnCreateAutomationPeer"/>)
     /// </summary>
-    /// <param name="indei">INDEI object to validate.</param>
-    /// <param name="bindingProperty">Name of the property to validate.</param>
-    /// <param name="bindingPath">Path of the binding.</param>
-    /// <param name="declaringPath">Path of the INDEI object.</param>
-    /// <param name="validationResults">List of results to add to.</param>
-    /// <param name="wireEvents">True if the ErrorsChanged event should be subscribed to.</param>
-    /*private void ValidateIndei(INotifyDataErrorInfo indei, string bindingProperty, string bindingPath, string declaringPath, List<ValidationResult> validationResults, bool wireEvents)
+    /*protected override AutomationPeer OnCreateAutomationPeer()
     {
-        if (indei != null)
-        {
-            if (indei.HasErrors)
-            {
-                IEnumerable errors = null;
-                ValidationUtil.CatchNonCriticalExceptions(() => { errors = indei.GetErrors(bindingProperty); });
-                if (errors != null)
-                {
-                    foreach (object errorItem in errors)
-                    {
-                        if (errorItem != null)
-                        {
-                            string errorString = null;
-                            ValidationUtil.CatchNonCriticalExceptions(() => { errorString = errorItem.ToString(); });
-                            if (!string.IsNullOrEmpty(errorString))
-                            {
-                                ValidationResult validationResult;
-                                if (!string.IsNullOrEmpty(bindingProperty))
-                                {
-                                    validationResult = new ValidationResult(errorString, new List<string>() { bindingPath });
-                                    _propertyValidationResults.Add(validationResult);
-                                }
-                                else
-                                {
-                                    Debug.Assert(string.IsNullOrEmpty(bindingPath));
-                                    validationResult = new ValidationResult(errorString);
-                                }
-                                validationResults.AddIfNew(validationResult);
-                                _indeiValidationResults.AddIfNew(validationResult);
-                            }
-                        }
-                    }
-                }
-            }
-            if (wireEvents)
-            {
-                indei.ErrorsChanged += new EventHandler<DataErrorsChangedEventArgs>(ValidationItem_ErrorsChanged);
-                if (!_validationItems.ContainsKey(indei))
-                {
-                    _validationItems.Add(indei, declaringPath);
-                }
-            }
-        }
+        return new DataGridAutomationPeer(this);
     } */
 
+
+    #endregion
+
+    #region Validation
+
     #endregion
 
 
diff --git a/src/Avalonia.DataGrid/DataGridBoundColumn.cs b/src/Avalonia.DataGrid/DataGridBoundColumn.cs
index 30bf89ad94..952baddd36 100644
--- a/src/Avalonia.DataGrid/DataGridBoundColumn.cs
+++ b/src/Avalonia.DataGrid/DataGridBoundColumn.cs
@@ -95,9 +95,11 @@ namespace Avalonia.Controls
         }
 
         //TODO Rename
-        protected sealed override  Control GenerateEditingElement(DataGridCell cell, object dataItem)
+        //TODO Validation
+        protected sealed override Control GenerateEditingElement(DataGridCell cell, object dataItem, out ICellEditBinding editBinding)
         {
             Control element = GenerateEditingElementDirect(cell, dataItem);
+            editBinding = null;
 
             if (Binding != null)
             //if (Binding != null || !DesignerProperties.IsInDesignTool)
@@ -105,7 +107,7 @@ namespace Avalonia.Controls
                 //var t1 = Binding.Initiate(textBox, BindingTarget, anchor: null, enableDataValidation: true);
                 //BindingOperations.Apply(textBox, BindingTarget, t1, null);
 
-                BindEditingElement(element, BindingTarget, Binding);
+                editBinding = BindEditingElement(element, BindingTarget, Binding);
                 //element.Bind(BindingTarget, Binding);
                 //textBox.SetBinding(BindingTarget, Binding);
             }
@@ -113,93 +115,27 @@ namespace Avalonia.Controls
             return element;
         }
 
-        private static IDisposable BindEditingElement(IAvaloniaObject target, AvaloniaProperty property, IBinding binding)
+        private static ICellEditBinding BindEditingElement(IAvaloniaObject target, AvaloniaProperty property, IBinding binding)
         {
             var result = binding.Initiate(target, property, enableDataValidation: true);
 
             if (result != null)
             {
-                //if(result.Subject != null)
-                //{
-                //    var watcher = new BindingWatcher(result.Subject, result);
-                //    result = watcher.InstancedBinding;
-                //}
-
-                return BindingOperations.Apply(target, property, result, null);
-            }
-            else
-            {
-                return Disposable.Empty;
-            }
-        }
-
-        public class LightweightSubject<T> : LightweightObservableBase<T>, ISubject<T>
-        {
-            public void OnCompleted()
-            {
-                PublishCompleted();
-            }
-            public void OnError(Exception error)
-            {
-                PublishError(error);
-            }
-            public void OnNext(T value)
-            {
-                PublishNext(value);
-            }
-
-            protected override void Deinitialize()
-            { }
-            protected override void Initialize()
-            { }
-
-            protected override void Subscribed(IObserver<T> observer, bool first)
-            {
-                base.Subscribed(observer, first);
-            }
-        }
-
-        class BindingWatcher
-        {
-            ISubject<object> _innerSubject;
-            ISubject<object> _wrappedSubject;
-            InstancedBinding _instancedBinding;
-            bool _isWriting = false;
-
-            public BindingWatcher(ISubject<object> innerSubject, InstancedBinding innerBinding)
-            {
-                _innerSubject = innerSubject;
-                _wrappedSubject = new LightweightSubject<object>();
-                _instancedBinding = new InstancedBinding(_wrappedSubject, innerBinding.Mode, innerBinding.Priority);
-
-                _innerSubject.Subscribe(InnerSubjectOnNext);
-                _wrappedSubject.Subscribe(WrappedSubjectOnNext);
-            }
-
-            private void InnerSubjectOnNext(object value)
-            {
-                Debug.WriteLine($"InnerSubject: {value} ({value?.GetType().Name})");
-                if (!_isWriting)
+                if(result.Subject != null)
                 {
-                    _isWriting = true;
-                    _wrappedSubject.OnNext(value);
-                    _isWriting = false;
-                }
-            }
-            private void WrappedSubjectOnNext(object value)
-            {
-                Debug.WriteLine($"WrappedSubject: {value} ({value?.GetType().Name})");
-                if (!_isWriting)
-                {
-                    _isWriting = true;
-                    _innerSubject.OnNext(value);
-                    _isWriting = false;
+                    var bindingHelper = new CellEditBinding(result.Subject);
+                    var instanceBinding = new InstancedBinding(bindingHelper.InternalSubject, result.Mode, result.Priority);
+
+                    BindingOperations.Apply(target, property, instanceBinding, null);
+                    return bindingHelper;
                 }
+
+                BindingOperations.Apply(target, property, result, null);
             }
 
-            public InstancedBinding InstancedBinding => _instancedBinding;
+            return null;
         }
-
+        
         /*
          public static IDisposable Apply(
             IAvaloniaObject target,
@@ -252,7 +188,6 @@ namespace Avalonia.Controls
 
         protected abstract Control GenerateEditingElementDirect(DataGridCell cell, object dataItem);
 
-
         internal AvaloniaProperty BindingTarget { get; set; }
 
         internal void SetHeaderFromBinding()
@@ -268,86 +203,6 @@ namespace Avalonia.Controls
                 }
             }
         }
-
-        private class AdvancedBinding
-        {
-
-            class SubjectWrapper : LightweightObservableBase<object>, ISubject<object>, IDisposable
-            {
-                private readonly ISubject<object> _sourceSubject;
-                private IDisposable _subscription;
-                private object _controlValue;
-                private bool _isControlValueSet = false;
-
-                public SubjectWrapper(ISubject<object> bindingSourceSubject)
-                {
-                    _sourceSubject = bindingSourceSubject;
-                }
-
-                private void SetSourceValue(object value)
-                {
-                    _sourceSubject.OnNext(value);
-                }
-                private void SetControlValue(object value)
-                {
-                    PublishNext(value);
-                }
-
-                private void OnValidationError(BindingNotification notification)
-                {
-
-                }
-                private void OnControlValueUpdated(object value)
-                {
-                    _controlValue = value;
-                    _isControlValueSet = true;
-                }
-                private void OnSourceValueUpdated(object value)
-                {
-                    if(value is BindingNotification notification)
-                    {
-                        if (notification.ErrorType != BindingErrorType.None)
-                            OnValidationError(notification);
-                        else
-                            SetControlValue(value);
-                    }
-                    else
-                    {
-                        SetControlValue(value);
-                    }
-                }
-
-                protected override void Deinitialize()
-                {
-                    _subscription?.Dispose();
-                    _subscription = null;
-                }
-                protected override void Initialize()
-                {
-                    _subscription = _sourceSubject.Subscribe(OnSourceValueUpdated);
-                }
-
-                void IObserver<object>.OnCompleted()
-                {
-                    throw new NotImplementedException();
-                }
-                void IObserver<object>.OnError(Exception error)
-                {
-                    throw new NotImplementedException();
-                }
-                void IObserver<object>.OnNext(object value)
-                {
-                    OnControlValueUpdated(value);
-                }
-
-                public void Dispose()
-                {
-                    _subscription?.Dispose();
-                    _subscription = null;
-                }
-            }
-        }
-
     }
 
     /*
@@ -398,14 +253,7 @@ namespace Avalonia.Controls
 
 
     #endregion
-
-    #region ClipBoard
-
-
-
-    #endregion
-
-
+    
     #region Styles
 
     //TODO Styles
diff --git a/src/Avalonia.DataGrid/DataGridColumn.cs b/src/Avalonia.DataGrid/DataGridColumn.cs
index 0d4caa5087..baadd23b21 100644
--- a/src/Avalonia.DataGrid/DataGridColumn.cs
+++ b/src/Avalonia.DataGrid/DataGridColumn.cs
@@ -37,6 +37,7 @@ namespace Avalonia.Controls
         private object _header;
         private DataGridColumnHeader _headerCell;
         private Control _editingElement;
+        private ICellEditBinding _editBinding;
         private IBinding _clipboardContentBinding;
         private readonly Classes _cellStyleClasses = new Classes();
 
@@ -174,6 +175,11 @@ namespace Avalonia.Controls
             private set;
         }
 
+        internal ICellEditBinding CellEditBinding
+        {
+            get => _editBinding;
+        }
+
         /// <summary>
         /// Determines whether or not this column is visible.
         /// </summary>
@@ -588,8 +594,6 @@ namespace Avalonia.Controls
             return content;
         }
 
-
-
         public Control GetCellContent(DataGridRow dataGridRow)
         {
             Contract.Requires<ArgumentNullException>(dataGridRow != null);
@@ -672,7 +676,7 @@ namespace Avalonia.Controls
         /// <returns>
         /// A new editing element that is bound to the column's <see cref="P:Avalonia.Controls.DataGridBoundColumn.Binding" /> property value.
         /// </returns>
-        protected abstract Control GenerateEditingElement(DataGridCell cell, object dataItem);
+        protected abstract Control GenerateEditingElement(DataGridCell cell, object dataItem, out ICellEditBinding binding);
 
         /// <summary>
         /// When overridden in a derived class, gets a read-only element that is bound to the column's 
@@ -988,7 +992,7 @@ namespace Avalonia.Controls
         {
             if (_editingElement == null)
             {
-                _editingElement = GenerateEditingElement(cell, dataItem);
+                _editingElement = GenerateEditingElement(cell, dataItem, out _editBinding);
             }
             //if (_inputBindings == null && _editingElement != null)
             //{
diff --git a/src/Avalonia.DataGrid/DataGridColumnHeader.cs b/src/Avalonia.DataGrid/DataGridColumnHeader.cs
index 5e882bc566..7c9149bf87 100644
--- a/src/Avalonia.DataGrid/DataGridColumnHeader.cs
+++ b/src/Avalonia.DataGrid/DataGridColumnHeader.cs
@@ -286,7 +286,6 @@ namespace Avalonia.Controls
 
         internal void OnMouseLeftButtonUp_Click(InputModifiers inputModifiers, ref bool handled)
         {
-            Debug.WriteLine(nameof(OnMouseLeftButtonUp_Click));
             // completed a click without dragging, so we're sorting
             InvokeProcessSort(inputModifiers);
             handled = true;
@@ -458,7 +457,6 @@ namespace Avalonia.Controls
 
         internal void OnMouseLeftButtonDown(ref bool handled, PointerEventArgs args, Point mousePosition)
         {
-            Debug.WriteLine(nameof(OnMouseLeftButtonDown));
             IsPressed = true;
 
             if (OwningGrid != null && OwningGrid.ColumnHeaders != null)
@@ -503,7 +501,6 @@ namespace Avalonia.Controls
         internal void OnMouseLeftButtonUp(ref bool handled, PointerEventArgs args, Point mousePosition, Point mousePositionHeaders)
         {
             IsPressed = false;
-            Debug.WriteLine(nameof(OnMouseLeftButtonUp));
 
             if (OwningGrid != null && OwningGrid.ColumnHeaders != null)
             {
diff --git a/src/Avalonia.DataGrid/DataGridFillerColumn.cs b/src/Avalonia.DataGrid/DataGridFillerColumn.cs
index 2d75cc33aa..8007d07890 100644
--- a/src/Avalonia.DataGrid/DataGridFillerColumn.cs
+++ b/src/Avalonia.DataGrid/DataGridFillerColumn.cs
@@ -4,6 +4,7 @@
 // All other rights reserved.
 
 using Avalonia.Interactivity;
+using Avalonia.Utilities;
 
 namespace Avalonia.Controls
 {
@@ -55,8 +56,9 @@ namespace Avalonia.Controls
             return null;
         }
 
-        protected override Control GenerateEditingElement(DataGridCell cell, object dataItem)
+        protected override Control GenerateEditingElement(DataGridCell cell, object dataItem, out ICellEditBinding editBinding)
         {
+            editBinding = null;
             return null;
         } 
 
diff --git a/src/Avalonia.DataGrid/DataGridRow.cs b/src/Avalonia.DataGrid/DataGridRow.cs
index c6c16880f3..1b4134b0eb 100644
--- a/src/Avalonia.DataGrid/DataGridRow.cs
+++ b/src/Avalonia.DataGrid/DataGridRow.cs
@@ -100,7 +100,7 @@ namespace Avalonia.Controls
         public bool IsValid
         {
             get { return _isValid; }
-            private set { SetAndRaise(IsValidProperty, ref _isValid, value); }
+            internal set { SetAndRaise(IsValidProperty, ref _isValid, value); }
         }
 
 
diff --git a/src/Avalonia.DataGrid/Utilities/CellEditBinding.cs b/src/Avalonia.DataGrid/Utilities/CellEditBinding.cs
new file mode 100644
index 0000000000..630d21c7cb
--- /dev/null
+++ b/src/Avalonia.DataGrid/Utilities/CellEditBinding.cs
@@ -0,0 +1,160 @@
+using Avalonia.Data;
+using Avalonia.Reactive;
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.Collections.Generic;
+using System.Reactive.Subjects;
+using System.Text;
+
+namespace Avalonia.Utilities
+{
+    public interface ICellEditBinding
+    {
+        bool IsValid { get; }
+        IEnumerable<Exception> ValidationErrors { get; }
+        IObservable<bool> ValidationChanged { get; }
+        bool CommitEdit();
+    }
+
+    internal class CellEditBinding : ICellEditBinding
+    {
+        private readonly Subject<bool> _changedSubject = new Subject<bool>();
+        private readonly List<Exception> _validationErrors = new List<Exception>();
+        private readonly SubjectWrapper _inner;
+
+        public bool IsValid => _validationErrors.Count <= 0;
+        public IEnumerable<Exception> ValidationErrors => _validationErrors;
+        public IObservable<bool> ValidationChanged => _changedSubject;
+        public ISubject<object> InternalSubject => _inner;
+
+        public CellEditBinding(ISubject<object> bindingSourceSubject)
+        {
+            _inner = new SubjectWrapper(bindingSourceSubject, this);
+        }
+
+        private void AlterValidationErrors(Action<List<Exception>> action)
+        {
+            var wasValid = IsValid;
+            action(_validationErrors);
+            var isValid = IsValid;
+
+            if(!isValid || !wasValid)
+            {
+                _changedSubject.OnNext(isValid);
+            }
+        }
+
+        public bool CommitEdit()
+        {
+            _inner.CommitEdit();
+            return IsValid;
+        }
+
+        class SubjectWrapper : LightweightObservableBase<object>, ISubject<object>, IDisposable
+        {
+            private readonly ISubject<object> _sourceSubject;
+            private readonly CellEditBinding _editBinding;
+            private IDisposable _subscription;
+            private object _controlValue;
+            private bool _isControlValueSet = false;
+            private bool _settingSourceValue = false;
+
+            public SubjectWrapper(ISubject<object> bindingSourceSubject, CellEditBinding editBinding)
+            {
+                _sourceSubject = bindingSourceSubject;
+                _editBinding = editBinding;
+            }
+
+            private void SetSourceValue(object value)
+            {
+                _settingSourceValue = true;
+
+                _sourceSubject.OnNext(value);
+
+                _settingSourceValue = false;
+            }
+            private void SetControlValue(object value)
+            {
+                PublishNext(value);
+            }
+
+            private void OnValidationError(BindingNotification notification)
+            {
+                if(notification.Error != null)
+                {
+                    _editBinding.AlterValidationErrors(errors =>
+                    {
+                        errors.Clear();
+                        var unpackedErrors = ValidationUtil.UnpackException(notification.Error);
+                        if(unpackedErrors != null)
+                            errors.AddRange(unpackedErrors);
+                    });
+                }
+            }
+            private void OnControlValueUpdated(object value)
+            {
+                _controlValue = value;
+                _isControlValueSet = true;
+
+                if(!_editBinding.IsValid)
+                {
+                    SetSourceValue(value);
+                }
+            }
+            private void OnSourceValueUpdated(object value)
+            {
+                void OnValidValue(object val)
+                {
+                    SetControlValue(val);
+                    _editBinding.AlterValidationErrors(errors => errors.Clear());
+                }
+
+                if (value is BindingNotification notification)
+                {
+                    if (notification.ErrorType != BindingErrorType.None)
+                        OnValidationError(notification);
+                    else
+                        OnValidValue(value);
+                }
+                else
+                {
+                    OnValidValue(value);
+                }
+            }
+
+            protected override void Deinitialize()
+            {
+                _subscription?.Dispose();
+                _subscription = null;
+            }
+            protected override void Initialize()
+            {
+                _subscription = _sourceSubject.Subscribe(OnSourceValueUpdated);
+            }
+
+            void IObserver<object>.OnCompleted()
+            {
+                throw new NotImplementedException();
+            }
+            void IObserver<object>.OnError(Exception error)
+            {
+                throw new NotImplementedException();
+            }
+            void IObserver<object>.OnNext(object value)
+            {
+                OnControlValueUpdated(value);
+            }
+
+            public void Dispose()
+            {
+                _subscription?.Dispose();
+                _subscription = null;
+            }
+            public void CommitEdit()
+            {
+                if(_isControlValueSet)
+                    SetSourceValue(_controlValue);
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.DataGrid/Utilities/ValidationUtil.cs b/src/Avalonia.DataGrid/Utilities/ValidationUtil.cs
new file mode 100644
index 0000000000..a7ccc0a901
--- /dev/null
+++ b/src/Avalonia.DataGrid/Utilities/ValidationUtil.cs
@@ -0,0 +1,168 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Text;
+using System.Threading;
+using System.Linq;
+using Avalonia.Data;
+
+namespace Avalonia.Utilities
+{
+    internal static class ValidationUtil
+    {
+        /// <summary>
+        /// Searches a ValidationResult for the specified target member name.  If the target is null
+        /// or empty, this method will return true if there are no member names at all.
+        /// </summary>
+        /// <param name="validationResult">ValidationResult to search.</param>
+        /// <param name="target">Member name to search for.</param>
+        /// <returns>True if found.</returns>
+        public static bool ContainsMemberName(this ValidationResult validationResult, string target)
+        {
+            int memberNameCount = 0;
+            foreach (string memberName in validationResult.MemberNames)
+            {
+                if (string.Equals(target, memberName))
+                {
+                    return true;
+                }
+                memberNameCount++;
+            }
+            return (memberNameCount == 0 && string.IsNullOrEmpty(target));
+        }
+
+        /// <summary>
+        /// Finds an equivalent ValidationResult if one exists.
+        /// </summary>
+        /// <param name="collection">ValidationResults to search through.</param>
+        /// <param name="target">ValidationResult to find.</param>
+        /// <returns>Equal ValidationResult if found, null otherwise.</returns>
+        public static ValidationResult FindEqualValidationResult(this ICollection<ValidationResult> collection, ValidationResult target)
+        {
+            foreach (ValidationResult oldValidationResult in collection)
+            {
+                if (oldValidationResult.ErrorMessage == target.ErrorMessage)
+                {
+                    bool movedOld = true;
+                    bool movedTarget = true;
+                    IEnumerator<string> oldEnumerator = oldValidationResult.MemberNames.GetEnumerator();
+                    IEnumerator<string> targetEnumerator = target.MemberNames.GetEnumerator();
+                    while (movedOld && movedTarget)
+                    {
+                        movedOld = oldEnumerator.MoveNext();
+                        movedTarget = targetEnumerator.MoveNext();
+
+                        if (!movedOld && !movedTarget)
+                        {
+                            return oldValidationResult;
+                        }
+                        if (movedOld != movedTarget || oldEnumerator.Current != targetEnumerator.Current)
+                        {
+                            break;
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+
+        public static bool IsValid(this ValidationResult result)
+        {
+            return result == null || result == ValidationResult.Success;
+        }
+
+        public static IEnumerable<Exception> UnpackException(Exception exception)
+        {
+            if (exception != null)
+            {
+                var aggregate = exception as AggregateException;
+                var exceptions = aggregate == null ?
+                    (IEnumerable<Exception>)new[] { exception } :
+                    aggregate.InnerExceptions;
+                var filtered = exceptions.Where(x => !(x is BindingChainException)).ToList();
+
+                if (filtered.Count > 0)
+                {
+                    return filtered;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Determines whether the collection contains an equivalent ValidationResult
+        /// </summary>
+        /// <param name="collection">ValidationResults to search through</param>
+        /// <param name="target">ValidationResult to search for</param>
+        /// <returns></returns>
+        public static bool ContainsEqualValidationResult(this ICollection<ValidationResult> collection, ValidationResult target)
+        {
+            return (collection.FindEqualValidationResult(target) != null);
+        }
+
+        /// <summary>
+        /// Adds a new ValidationResult to the collection if an equivalent does not exist.
+        /// </summary>
+        /// <param name="collection">ValidationResults to search through</param>
+        /// <param name="value">ValidationResult to add</param>
+        public static void AddIfNew(this ICollection<ValidationResult> collection, ValidationResult value)
+        {
+            if (!collection.ContainsEqualValidationResult(value))
+            {
+                collection.Add(value);
+            }
+        }
+
+        private static bool ExceptionsMatch(Exception e1, Exception e2)
+        {
+            return e1.Message == e2.Message;
+        }
+        public static void AddExceptionIfNew(this ICollection<Exception> collection, Exception value)
+        {
+            if(!collection.Any(e => ExceptionsMatch(e, value)))
+            {
+                collection.Add(value);
+            }
+        }
+
+
+        /// <summary>
+        /// Performs an action and catches any non-critical exceptions.
+        /// </summary>
+        /// <param name="action">Action to perform</param>
+        public static void CatchNonCriticalExceptions(Action action)
+        {
+            try
+            {
+                action();
+            }
+            catch (Exception exception)
+            {
+                if (IsCriticalException(exception))
+                {
+                    throw;
+                }
+                // Catch any non-critical exceptions
+            }
+        }
+        
+        /// <summary>
+        /// Determines if the specified exception is un-recoverable.
+        /// </summary>
+        /// <param name="exception">The exception.</param>
+        /// <returns>True if the process cannot be recovered from the exception.</returns>
+        public static bool IsCriticalException(Exception exception)
+        {
+            return (exception is OutOfMemoryException) ||
+                (exception is StackOverflowException) ||
+                (exception is AccessViolationException) ||
+                (exception is ThreadAbortException);
+        }
+    }
+}