Merge branch 'master' into perf-avoid-repeated-checks-in-getvalue

src/Avalonia.Base/Data/Core/Plugins/IndeiValidationPlugin.cs

@@ -90,8 +90,9 @@ namespace Avalonia.Data.Core.Plugins
                 if (target != null)
                 {
                     var errors = target.GetErrors(_name)?
-                        .Cast<String>()
-                        .Where(x => x != null).ToList();
+                        .Cast<object>()
+                        .Where(x => x != null)
+                        .ToList();
 
                     if (errors?.Count > 0)
                     {
@@ -112,16 +113,16 @@ namespace Avalonia.Data.Core.Plugins
                 return target;
             }
 
-            private Exception GenerateException(IList<string> errors)
+            private Exception GenerateException(IList<object> errors)
             {
                 if (errors.Count == 1)
                 {
-                    return new Exception(errors[0]);
+                    return new DataValidationException(errors[0]);
                 }
                 else
                 {
                     return new AggregateException(
-                        errors.Select(x => new Exception(x)));
+                        errors.Select(x => new DataValidationException(x)));
                 }
             }
         }

src/Avalonia.Base/Data/DataValidationException.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Avalonia.Data
+{
+    /// <summary>
+    /// Exception, which wrap validation errors.
+    /// </summary>
+    public class DataValidationException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataValidationException"/> class.
+        /// </summary>
+        /// <param name="errorData">Data of validation error.</param>
+        public DataValidationException(object errorData) : base(errorData?.ToString())
+        {
+            ErrorData = errorData;
+        }
+
+        public object ErrorData { get; }
+    }
+}

src/Avalonia.Controls/DataValidationErrors.cs

@@ -22,8 +22,8 @@ namespace Avalonia.Controls
         /// <summary>
         /// Defines the DataValidationErrors.Errors attached property.
         /// </summary>
-        public static readonly AttachedProperty<IEnumerable<Exception>> ErrorsProperty =
-            AvaloniaProperty.RegisterAttached<DataValidationErrors, Control, IEnumerable<Exception>>("Errors");
+        public static readonly AttachedProperty<IEnumerable<object>> ErrorsProperty =
+            AvaloniaProperty.RegisterAttached<DataValidationErrors, Control, IEnumerable<object>>("Errors");
 
         /// <summary>
         /// Defines the DataValidationErrors.HasErrors attached property.
@@ -76,7 +76,7 @@ namespace Avalonia.Controls
         private static void ErrorsChanged(AvaloniaPropertyChangedEventArgs e)
         {
             var control = (Control)e.Sender;
-            var errors = (IEnumerable<Exception>)e.NewValue;
+            var errors = (IEnumerable<object>)e.NewValue;
 
             var hasErrors = false;
             if (errors != null && errors.Any())
@@ -91,11 +91,11 @@ namespace Avalonia.Controls
             classes.Set(":error", (bool)e.NewValue);
         }
 
-        public static IEnumerable<Exception> GetErrors(Control control)
+        public static IEnumerable<object> GetErrors(Control control)
         {
             return control.GetValue(ErrorsProperty);
         }
-        public static void SetErrors(Control control, IEnumerable<Exception> errors)
+        public static void SetErrors(Control control, IEnumerable<object> errors)
         {
             control.SetValue(ErrorsProperty, errors);
         }
@@ -112,14 +112,14 @@ namespace Avalonia.Controls
             return control.GetValue(HasErrorsProperty);
         }
 
-        private static IEnumerable<Exception> UnpackException(Exception exception)
+        private static IEnumerable<object> UnpackException(Exception exception)
         {
             if (exception != null)
             {
                 var aggregate = exception as AggregateException;
                 var exceptions = aggregate == null ?
-                    (IEnumerable<Exception>)new[] { exception } :
-                    aggregate.InnerExceptions;
+                    new[] { GetExceptionData(exception) } :
+                    aggregate.InnerExceptions.Select(GetExceptionData).ToArray();
                 var filtered = exceptions.Where(x => !(x is BindingChainException)).ToList();
 
                 if (filtered.Count > 0)
@@ -130,5 +130,13 @@ namespace Avalonia.Controls
 
             return null;
         }
+
+        private static object GetExceptionData(Exception exception)
+        {
+            if (exception is DataValidationException dataValidationException)
+                return dataValidationException.ErrorData;
+
+            return exception;
+        }
     }
 }

src/Avalonia.Controls/TextBox.cs

@@ -59,6 +59,9 @@ namespace Avalonia.Controls
                 o => o.SelectionEnd,
                 (o, v) => o.SelectionEnd = v);
 
+        public static readonly StyledProperty<int> MaxLengthProperty =
+            AvaloniaProperty.Register<TextBox, int>(nameof(MaxLength), defaultValue: 0);
+
         public static readonly DirectProperty<TextBox, string> TextProperty =
             TextBlock.TextProperty.AddOwner<TextBox>(
                 o => o.Text,
@@ -232,6 +235,12 @@ namespace Avalonia.Controls
             }
         }
 
+        public int MaxLength
+        {
+            get { return GetValue(MaxLengthProperty); }
+            set { SetValue(MaxLengthProperty, value); }
+        }
+
         [Content]
         public string Text
         {
@@ -345,7 +354,7 @@ namespace Avalonia.Controls
                 input = RemoveInvalidCharacters(input);
                 string text = Text ?? string.Empty;
                 int caretIndex = CaretIndex;
-                if (!string.IsNullOrEmpty(input))
+                if (!string.IsNullOrEmpty(input) && (MaxLength == 0 || input.Length + text.Length - (Math.Abs(SelectionStart - SelectionEnd)) <= MaxLength))
                 {
                     DeleteSelection();
                     caretIndex = CaretIndex;

tests/Avalonia.Base.UnitTests/Data/Core/ExpressionObserverTests_DataValidation.cs

@@ -100,7 +100,7 @@ namespace Avalonia.Base.UnitTests.Data.Core
 
                 // Value is first signalled without an error as validation hasn't been updated.
                 new BindingNotification(-5),
-                new BindingNotification(new Exception("Must be positive"), BindingErrorType.DataValidationError, -5),
+                new BindingNotification(new DataValidationException("Must be positive"), BindingErrorType.DataValidationError, -5),
 
                 // Exception is thrown by trying to set value to "foo".
                 new BindingNotification(
@@ -108,7 +108,7 @@ namespace Avalonia.Base.UnitTests.Data.Core
                     BindingErrorType.DataValidationError),
 
                 // Value is set then validation is updated.
-                new BindingNotification(new Exception("Must be positive"), BindingErrorType.DataValidationError, 5),
+                new BindingNotification(new DataValidationException("Must be positive"), BindingErrorType.DataValidationError, 5),
                 new BindingNotification(5),
             }, result);
 

tests/Avalonia.Base.UnitTests/Data/Core/Plugins/IndeiValidationPluginTests.cs

@@ -37,13 +37,13 @@ namespace Avalonia.Base.UnitTests.Data.Core.Plugins
                 new BindingNotification(6),
                 
                 // Then the ErrorsChanged event is fired.
-                new BindingNotification(new Exception("Must be less than Maximum"), BindingErrorType.DataValidationError, 6),
+                new BindingNotification(new DataValidationException("Must be less than Maximum"), BindingErrorType.DataValidationError, 6),
 
                 // Maximum is changed to 10 so value is now valid.
                 new BindingNotification(6),
 
                 // And Maximum is changed back to 5.
-                new BindingNotification(new Exception("Must be less than Maximum"), BindingErrorType.DataValidationError, 6),
+                new BindingNotification(new DataValidationException("Must be less than Maximum"), BindingErrorType.DataValidationError, 6),
             }, result);
         }
 

tests/Avalonia.Controls.UnitTests/TextBoxTests.cs

@@ -460,6 +460,24 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Text_Box_MaxLength_Work_Properly()
+        {
+            using (UnitTestApplication.Start(Services))
+            {
+                var target = new TextBox
+                {
+                    Template = CreateTemplate(),
+                    Text = "abc",
+                    MaxLength = 3,
+                };
+
+                RaiseKeyEvent(target, Key.D, KeyModifiers.None);
+
+                Assert.Equal("abc", target.Text);
+            }
+        }
+
         private static TestServices FocusServices => TestServices.MockThreadingInterface.With(
             focusManager: new FocusManager(),
             keyboardDevice: () => new KeyboardDevice(),

tests/Avalonia.Controls.UnitTests/TextBoxTests_DataValidation.cs

@@ -58,7 +58,7 @@ namespace Avalonia.Controls.UnitTests
                 Assert.Null(DataValidationErrors.GetErrors(target));
                 target.Text = "20";
 
-                IEnumerable<Exception> errors = DataValidationErrors.GetErrors(target);
+                IEnumerable<object> errors = DataValidationErrors.GetErrors(target);
                 Assert.Single(errors);
                 Assert.IsType<InvalidOperationException>(errors.Single());
                 target.Text = "1";