Improve known color/brush parsing

src/Avalonia.Visuals/Media/Brush.cs

@@ -34,26 +34,21 @@ namespace Avalonia.Media
         /// <returns>The <see cref="Color"/>.</returns>
         public static IBrush Parse(string s)
         {
+            if (s == null) throw new ArgumentNullException(nameof(s));
+            if (s.Length == 0) throw new FormatException();
+
             if (s[0] == '#')
             {
                 return new SolidColorBrush(Color.Parse(s));
             }
-            else
-            {
-                var upper = s.ToUpperInvariant();
-                var member = typeof(Brushes).GetTypeInfo().DeclaredProperties
-                    .FirstOrDefault(x => x.Name.ToUpperInvariant() == upper);
 
-                if (member != null)
-                {
-                    var brush = (ISolidColorBrush)member.GetValue(null);
-                    return new SolidColorBrush(brush.Color, brush.Opacity);
-                }
-                else
-                {
-                    throw new FormatException($"Invalid brush string: '{s}'.");
-                }
+            var brush = KnownColors.GetKnownBrush(s);
+            if (brush != null)
+            {
+                return brush;
             }
+
+            throw new FormatException($"Invalid brush string: '{s}'.");
         }
     }
 }

src/Avalonia.Visuals/Media/Color.cs

@@ -88,6 +88,9 @@ namespace Avalonia.Media
         /// <returns>The <see cref="Color"/>.</returns>
         public static Color Parse(string s)
         {
+            if (s == null) throw new ArgumentNullException(nameof(s));
+            if (s.Length == 0) throw new FormatException();
+
             if (s[0] == '#')
             {
                 var or = 0u;
@@ -103,21 +106,15 @@ namespace Avalonia.Media
 
                 return FromUInt32(uint.Parse(s.Substring(1), NumberStyles.HexNumber, CultureInfo.InvariantCulture) | or);
             }
-            else
-            {
-                var upper = s.ToUpperInvariant();
-                var member = typeof(Colors).GetTypeInfo().DeclaredProperties
-                    .FirstOrDefault(x => x.Name.ToUpperInvariant() == upper);
 
-                if (member != null)
-                {
-                    return (Color)member.GetValue(null);
-                }
-                else
-                {
-                    throw new FormatException($"Invalid color string: '{s}'.");
-                }
+            var knownColor = KnownColors.GetKnownColor(s);
+
+            if (knownColor != KnownColor.None)
+            {
+                return knownColor.ToColor();
             }
+
+            throw new FormatException($"Invalid color string: '{s}'.");
         }
 
         /// <summary>
@@ -128,8 +125,8 @@ namespace Avalonia.Media
         /// </returns>
         public override string ToString()
         {
-            uint rgb = ((uint)A << 24) | ((uint)R << 16) | ((uint)G << 8) | (uint)B;
-            return $"#{rgb:x8}";
+            uint rgb = ToUint32();
+            return KnownColors.GetKnownColorName(rgb) ?? $"#{rgb:x8}";
         }
 
         /// <summary>

src/Avalonia.Visuals/Media/Colors.cs

@@ -1,6 +1,8 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Linq;
+
 namespace Avalonia.Media
 {
     /// <summary>
@@ -11,706 +13,706 @@ namespace Avalonia.Media
         /// <summary>
         /// Gets a color with an ARGB value of #fff0f8ff.
         /// </summary>
-        public static Color AliceBlue => Color.FromUInt32(0xfff0f8ff);
+        public static Color AliceBlue => KnownColor.AliceBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffaebd7.
         /// </summary>
-        public static Color AntiqueWhite => Color.FromUInt32(0xfffaebd7);
+        public static Color AntiqueWhite => KnownColor.AntiqueWhite.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff00ffff.
         /// </summary>
-        public static Color Aqua => Color.FromUInt32(0xff00ffff);
+        public static Color Aqua => KnownColor.Aqua.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff7fffd4.
         /// </summary>
-        public static Color Aquamarine => Color.FromUInt32(0xff7fffd4);
+        public static Color Aquamarine => KnownColor.Aquamarine.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff0ffff.
         /// </summary>
-        public static Color Azure => Color.FromUInt32(0xfff0ffff);
+        public static Color Azure => KnownColor.Azure.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff5f5dc.
         /// </summary>
-        public static Color Beige => Color.FromUInt32(0xfff5f5dc);
+        public static Color Beige => KnownColor.Beige.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffe4c4.
         /// </summary>
-        public static Color Bisque => Color.FromUInt32(0xffffe4c4);
+        public static Color Bisque => KnownColor.Bisque.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff000000.
         /// </summary>
-        public static Color Black => Color.FromUInt32(0xff000000);
+        public static Color Black => KnownColor.Black.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffebcd.
         /// </summary>
-        public static Color BlanchedAlmond => Color.FromUInt32(0xffffebcd);
+        public static Color BlanchedAlmond => KnownColor.BlanchedAlmond.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff0000ff.
         /// </summary>
-        public static Color Blue => Color.FromUInt32(0xff0000ff);
+        public static Color Blue => KnownColor.Blue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff8a2be2.
         /// </summary>
-        public static Color BlueViolet => Color.FromUInt32(0xff8a2be2);
+        public static Color BlueViolet => KnownColor.BlueViolet.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffa52a2a.
         /// </summary>
-        public static Color Brown => Color.FromUInt32(0xffa52a2a);
+        public static Color Brown => KnownColor.Brown.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffdeb887.
         /// </summary>
-        public static Color BurlyWood => Color.FromUInt32(0xffdeb887);
+        public static Color BurlyWood => KnownColor.BurlyWood.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff5f9ea0.
         /// </summary>
-        public static Color CadetBlue => Color.FromUInt32(0xff5f9ea0);
+        public static Color CadetBlue => KnownColor.CadetBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff7fff00.
         /// </summary>
-        public static Color Chartreuse => Color.FromUInt32(0xff7fff00);
+        public static Color Chartreuse => KnownColor.Chartreuse.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffd2691e.
         /// </summary>
-        public static Color Chocolate => Color.FromUInt32(0xffd2691e);
+        public static Color Chocolate => KnownColor.Chocolate.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff7f50.
         /// </summary>
-        public static Color Coral => Color.FromUInt32(0xffff7f50);
+        public static Color Coral => KnownColor.Coral.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff6495ed.
         /// </summary>
-        public static Color CornflowerBlue => Color.FromUInt32(0xff6495ed);
+        public static Color CornflowerBlue => KnownColor.CornflowerBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffff8dc.
         /// </summary>
-        public static Color Cornsilk => Color.FromUInt32(0xfffff8dc);
+        public static Color Cornsilk => KnownColor.Cornsilk.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffdc143c.
         /// </summary>
-        public static Color Crimson => Color.FromUInt32(0xffdc143c);
+        public static Color Crimson => KnownColor.Crimson.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff00ffff.
         /// </summary>
-        public static Color Cyan => Color.FromUInt32(0xff00ffff);
+        public static Color Cyan => KnownColor.Cyan.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff00008b.
         /// </summary>
-        public static Color DarkBlue => Color.FromUInt32(0xff00008b);
+        public static Color DarkBlue => KnownColor.DarkBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff008b8b.
         /// </summary>
-        public static Color DarkCyan => Color.FromUInt32(0xff008b8b);
+        public static Color DarkCyan => KnownColor.DarkCyan.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffb8860b.
         /// </summary>
-        public static Color DarkGoldenrod => Color.FromUInt32(0xffb8860b);
+        public static Color DarkGoldenrod => KnownColor.DarkGoldenrod.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffa9a9a9.
         /// </summary>
-        public static Color DarkGray => Color.FromUInt32(0xffa9a9a9);
+        public static Color DarkGray => KnownColor.DarkGray.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff006400.
         /// </summary>
-        public static Color DarkGreen => Color.FromUInt32(0xff006400);
+        public static Color DarkGreen => KnownColor.DarkGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffbdb76b.
         /// </summary>
-        public static Color DarkKhaki => Color.FromUInt32(0xffbdb76b);
+        public static Color DarkKhaki => KnownColor.DarkKhaki.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff8b008b.
         /// </summary>
-        public static Color DarkMagenta => Color.FromUInt32(0xff8b008b);
+        public static Color DarkMagenta => KnownColor.DarkMagenta.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff556b2f.
         /// </summary>
-        public static Color DarkOliveGreen => Color.FromUInt32(0xff556b2f);
+        public static Color DarkOliveGreen => KnownColor.DarkOliveGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff8c00.
         /// </summary>
-        public static Color DarkOrange => Color.FromUInt32(0xffff8c00);
+        public static Color DarkOrange => KnownColor.DarkOrange.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff9932cc.
         /// </summary>
-        public static Color DarkOrchid => Color.FromUInt32(0xff9932cc);
+        public static Color DarkOrchid => KnownColor.DarkOrchid.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff8b0000.
         /// </summary>
-        public static Color DarkRed => Color.FromUInt32(0xff8b0000);
+        public static Color DarkRed => KnownColor.DarkRed.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffe9967a.
         /// </summary>
-        public static Color DarkSalmon => Color.FromUInt32(0xffe9967a);
+        public static Color DarkSalmon => KnownColor.DarkSalmon.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff8fbc8f.
         /// </summary>
-        public static Color DarkSeaGreen => Color.FromUInt32(0xff8fbc8f);
+        public static Color DarkSeaGreen => KnownColor.DarkSeaGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff483d8b.
         /// </summary>
-        public static Color DarkSlateBlue => Color.FromUInt32(0xff483d8b);
+        public static Color DarkSlateBlue => KnownColor.DarkSlateBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff2f4f4f.
         /// </summary>
-        public static Color DarkSlateGray => Color.FromUInt32(0xff2f4f4f);
+        public static Color DarkSlateGray => KnownColor.DarkSlateGray.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff00ced1.
         /// </summary>
-        public static Color DarkTurquoise => Color.FromUInt32(0xff00ced1);
+        public static Color DarkTurquoise => KnownColor.DarkTurquoise.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff9400d3.
         /// </summary>
-        public static Color DarkViolet => Color.FromUInt32(0xff9400d3);
+        public static Color DarkViolet => KnownColor.DarkViolet.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff1493.
         /// </summary>
-        public static Color DeepPink => Color.FromUInt32(0xffff1493);
+        public static Color DeepPink => KnownColor.DeepPink.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff00bfff.
         /// </summary>
-        public static Color DeepSkyBlue => Color.FromUInt32(0xff00bfff);
+        public static Color DeepSkyBlue => KnownColor.DeepSkyBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff696969.
         /// </summary>
-        public static Color DimGray => Color.FromUInt32(0xff696969);
+        public static Color DimGray => KnownColor.DimGray.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff1e90ff.
         /// </summary>
-        public static Color DodgerBlue => Color.FromUInt32(0xff1e90ff);
+        public static Color DodgerBlue => KnownColor.DodgerBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffb22222.
         /// </summary>
-        public static Color Firebrick => Color.FromUInt32(0xffb22222);
+        public static Color Firebrick => KnownColor.Firebrick.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffffaf0.
         /// </summary>
-        public static Color FloralWhite => Color.FromUInt32(0xfffffaf0);
+        public static Color FloralWhite => KnownColor.FloralWhite.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff228b22.
         /// </summary>
-        public static Color ForestGreen => Color.FromUInt32(0xff228b22);
+        public static Color ForestGreen => KnownColor.ForestGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff00ff.
         /// </summary>
-        public static Color Fuchsia => Color.FromUInt32(0xffff00ff);
+        public static Color Fuchsia => KnownColor.Fuchsia.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffdcdcdc.
         /// </summary>
-        public static Color Gainsboro => Color.FromUInt32(0xffdcdcdc);
+        public static Color Gainsboro => KnownColor.Gainsboro.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff8f8ff.
         /// </summary>
-        public static Color GhostWhite => Color.FromUInt32(0xfff8f8ff);
+        public static Color GhostWhite => KnownColor.GhostWhite.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffd700.
         /// </summary>
-        public static Color Gold => Color.FromUInt32(0xffffd700);
+        public static Color Gold => KnownColor.Gold.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffdaa520.
         /// </summary>
-        public static Color Goldenrod => Color.FromUInt32(0xffdaa520);
+        public static Color Goldenrod => KnownColor.Goldenrod.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff808080.
         /// </summary>
-        public static Color Gray => Color.FromUInt32(0xff808080);
+        public static Color Gray => KnownColor.Gray.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff008000.
         /// </summary>
-        public static Color Green => Color.FromUInt32(0xff008000);
+        public static Color Green => KnownColor.Green.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffadff2f.
         /// </summary>
-        public static Color GreenYellow => Color.FromUInt32(0xffadff2f);
+        public static Color GreenYellow => KnownColor.GreenYellow.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff0fff0.
         /// </summary>
-        public static Color Honeydew => Color.FromUInt32(0xfff0fff0);
+        public static Color Honeydew => KnownColor.Honeydew.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff69b4.
         /// </summary>
-        public static Color HotPink => Color.FromUInt32(0xffff69b4);
+        public static Color HotPink => KnownColor.HotPink.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffcd5c5c.
         /// </summary>
-        public static Color IndianRed => Color.FromUInt32(0xffcd5c5c);
+        public static Color IndianRed => KnownColor.IndianRed.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff4b0082.
         /// </summary>
-        public static Color Indigo => Color.FromUInt32(0xff4b0082);
+        public static Color Indigo => KnownColor.Indigo.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffffff0.
         /// </summary>
-        public static Color Ivory => Color.FromUInt32(0xfffffff0);
+        public static Color Ivory => KnownColor.Ivory.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff0e68c.
         /// </summary>
-        public static Color Khaki => Color.FromUInt32(0xfff0e68c);
+        public static Color Khaki => KnownColor.Khaki.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffe6e6fa.
         /// </summary>
-        public static Color Lavender => Color.FromUInt32(0xffe6e6fa);
+        public static Color Lavender => KnownColor.Lavender.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffff0f5.
         /// </summary>
-        public static Color LavenderBlush => Color.FromUInt32(0xfffff0f5);
+        public static Color LavenderBlush => KnownColor.LavenderBlush.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff7cfc00.
         /// </summary>
-        public static Color LawnGreen => Color.FromUInt32(0xff7cfc00);
+        public static Color LawnGreen => KnownColor.LawnGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffffacd.
         /// </summary>
-        public static Color LemonChiffon => Color.FromUInt32(0xfffffacd);
+        public static Color LemonChiffon => KnownColor.LemonChiffon.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffadd8e6.
         /// </summary>
-        public static Color LightBlue => Color.FromUInt32(0xffadd8e6);
+        public static Color LightBlue => KnownColor.LightBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff08080.
         /// </summary>
-        public static Color LightCoral => Color.FromUInt32(0xfff08080);
+        public static Color LightCoral => KnownColor.LightCoral.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffe0ffff.
         /// </summary>
-        public static Color LightCyan => Color.FromUInt32(0xffe0ffff);
+        public static Color LightCyan => KnownColor.LightCyan.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffafad2.
         /// </summary>
-        public static Color LightGoldenrodYellow => Color.FromUInt32(0xfffafad2);
+        public static Color LightGoldenrodYellow => KnownColor.LightGoldenrodYellow.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffd3d3d3.
         /// </summary>
-        public static Color LightGray => Color.FromUInt32(0xffd3d3d3);
+        public static Color LightGray => KnownColor.LightGray.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff90ee90.
         /// </summary>
-        public static Color LightGreen => Color.FromUInt32(0xff90ee90);
+        public static Color LightGreen => KnownColor.LightGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffb6c1.
         /// </summary>
-        public static Color LightPink => Color.FromUInt32(0xffffb6c1);
+        public static Color LightPink => KnownColor.LightPink.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffa07a.
         /// </summary>
-        public static Color LightSalmon => Color.FromUInt32(0xffffa07a);
+        public static Color LightSalmon => KnownColor.LightSalmon.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff20b2aa.
         /// </summary>
-        public static Color LightSeaGreen => Color.FromUInt32(0xff20b2aa);
+        public static Color LightSeaGreen => KnownColor.LightSeaGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff87cefa.
         /// </summary>
-        public static Color LightSkyBlue => Color.FromUInt32(0xff87cefa);
+        public static Color LightSkyBlue => KnownColor.LightSkyBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff778899.
         /// </summary>
-        public static Color LightSlateGray => Color.FromUInt32(0xff778899);
+        public static Color LightSlateGray => KnownColor.LightSlateGray.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffb0c4de.
         /// </summary>
-        public static Color LightSteelBlue => Color.FromUInt32(0xffb0c4de);
+        public static Color LightSteelBlue => KnownColor.LightSteelBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffffe0.
         /// </summary>
-        public static Color LightYellow => Color.FromUInt32(0xffffffe0);
+        public static Color LightYellow => KnownColor.LightYellow.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff00ff00.
         /// </summary>
-        public static Color Lime => Color.FromUInt32(0xff00ff00);
+        public static Color Lime => KnownColor.Lime.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff32cd32.
         /// </summary>
-        public static Color LimeGreen => Color.FromUInt32(0xff32cd32);
+        public static Color LimeGreen => KnownColor.LimeGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffaf0e6.
         /// </summary>
-        public static Color Linen => Color.FromUInt32(0xfffaf0e6);
+        public static Color Linen => KnownColor.Linen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff00ff.
         /// </summary>
-        public static Color Magenta => Color.FromUInt32(0xffff00ff);
+        public static Color Magenta => KnownColor.Magenta.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff800000.
         /// </summary>
-        public static Color Maroon => Color.FromUInt32(0xff800000);
+        public static Color Maroon => KnownColor.Maroon.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff66cdaa.
         /// </summary>
-        public static Color MediumAquamarine => Color.FromUInt32(0xff66cdaa);
+        public static Color MediumAquamarine => KnownColor.MediumAquamarine.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff0000cd.
         /// </summary>
-        public static Color MediumBlue => Color.FromUInt32(0xff0000cd);
+        public static Color MediumBlue => KnownColor.MediumBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffba55d3.
         /// </summary>
-        public static Color MediumOrchid => Color.FromUInt32(0xffba55d3);
+        public static Color MediumOrchid => KnownColor.MediumOrchid.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff9370db.
         /// </summary>
-        public static Color MediumPurple => Color.FromUInt32(0xff9370db);
+        public static Color MediumPurple => KnownColor.MediumPurple.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff3cb371.
         /// </summary>
-        public static Color MediumSeaGreen => Color.FromUInt32(0xff3cb371);
+        public static Color MediumSeaGreen => KnownColor.MediumSeaGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff7b68ee.
         /// </summary>
-        public static Color MediumSlateBlue => Color.FromUInt32(0xff7b68ee);
+        public static Color MediumSlateBlue => KnownColor.MediumSlateBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff00fa9a.
         /// </summary>
-        public static Color MediumSpringGreen => Color.FromUInt32(0xff00fa9a);
+        public static Color MediumSpringGreen => KnownColor.MediumSpringGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff48d1cc.
         /// </summary>
-        public static Color MediumTurquoise => Color.FromUInt32(0xff48d1cc);
+        public static Color MediumTurquoise => KnownColor.MediumTurquoise.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffc71585.
         /// </summary>
-        public static Color MediumVioletRed => Color.FromUInt32(0xffc71585);
+        public static Color MediumVioletRed => KnownColor.MediumVioletRed.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff191970.
         /// </summary>
-        public static Color MidnightBlue => Color.FromUInt32(0xff191970);
+        public static Color MidnightBlue => KnownColor.MidnightBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff5fffa.
         /// </summary>
-        public static Color MintCream => Color.FromUInt32(0xfff5fffa);
+        public static Color MintCream => KnownColor.MintCream.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffe4e1.
         /// </summary>
-        public static Color MistyRose => Color.FromUInt32(0xffffe4e1);
+        public static Color MistyRose => KnownColor.MistyRose.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffe4b5.
         /// </summary>
-        public static Color Moccasin => Color.FromUInt32(0xffffe4b5);
+        public static Color Moccasin => KnownColor.Moccasin.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffdead.
         /// </summary>
-        public static Color NavajoWhite => Color.FromUInt32(0xffffdead);
+        public static Color NavajoWhite => KnownColor.NavajoWhite.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff000080.
         /// </summary>
-        public static Color Navy => Color.FromUInt32(0xff000080);
+        public static Color Navy => KnownColor.Navy.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffdf5e6.
         /// </summary>
-        public static Color OldLace => Color.FromUInt32(0xfffdf5e6);
+        public static Color OldLace => KnownColor.OldLace.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff808000.
         /// </summary>
-        public static Color Olive => Color.FromUInt32(0xff808000);
+        public static Color Olive => KnownColor.Olive.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff6b8e23.
         /// </summary>
-        public static Color OliveDrab => Color.FromUInt32(0xff6b8e23);
+        public static Color OliveDrab => KnownColor.OliveDrab.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffa500.
         /// </summary>
-        public static Color Orange => Color.FromUInt32(0xffffa500);
+        public static Color Orange => KnownColor.Orange.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff4500.
         /// </summary>
-        public static Color OrangeRed => Color.FromUInt32(0xffff4500);
+        public static Color OrangeRed => KnownColor.OrangeRed.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffda70d6.
         /// </summary>
-        public static Color Orchid => Color.FromUInt32(0xffda70d6);
+        public static Color Orchid => KnownColor.Orchid.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffeee8aa.
         /// </summary>
-        public static Color PaleGoldenrod => Color.FromUInt32(0xffeee8aa);
+        public static Color PaleGoldenrod => KnownColor.PaleGoldenrod.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff98fb98.
         /// </summary>
-        public static Color PaleGreen => Color.FromUInt32(0xff98fb98);
+        public static Color PaleGreen => KnownColor.PaleGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffafeeee.
         /// </summary>
-        public static Color PaleTurquoise => Color.FromUInt32(0xffafeeee);
+        public static Color PaleTurquoise => KnownColor.PaleTurquoise.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffdb7093.
         /// </summary>
-        public static Color PaleVioletRed => Color.FromUInt32(0xffdb7093);
+        public static Color PaleVioletRed => KnownColor.PaleVioletRed.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffefd5.
         /// </summary>
-        public static Color PapayaWhip => Color.FromUInt32(0xffffefd5);
+        public static Color PapayaWhip => KnownColor.PapayaWhip.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffdab9.
         /// </summary>
-        public static Color PeachPuff => Color.FromUInt32(0xffffdab9);
+        public static Color PeachPuff => KnownColor.PeachPuff.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffcd853f.
         /// </summary>
-        public static Color Peru => Color.FromUInt32(0xffcd853f);
+        public static Color Peru => KnownColor.Peru.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffc0cb.
         /// </summary>
-        public static Color Pink => Color.FromUInt32(0xffffc0cb);
+        public static Color Pink => KnownColor.Pink.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffdda0dd.
         /// </summary>
-        public static Color Plum => Color.FromUInt32(0xffdda0dd);
+        public static Color Plum => KnownColor.Plum.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffb0e0e6.
         /// </summary>
-        public static Color PowderBlue => Color.FromUInt32(0xffb0e0e6);
+        public static Color PowderBlue => KnownColor.PowderBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff800080.
         /// </summary>
-        public static Color Purple => Color.FromUInt32(0xff800080);
+        public static Color Purple => KnownColor.Purple.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff0000.
         /// </summary>
-        public static Color Red => Color.FromUInt32(0xffff0000);
+        public static Color Red => KnownColor.Red.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffbc8f8f.
         /// </summary>
-        public static Color RosyBrown => Color.FromUInt32(0xffbc8f8f);
+        public static Color RosyBrown => KnownColor.RosyBrown.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff4169e1.
         /// </summary>
-        public static Color RoyalBlue => Color.FromUInt32(0xff4169e1);
+        public static Color RoyalBlue => KnownColor.RoyalBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff8b4513.
         /// </summary>
-        public static Color SaddleBrown => Color.FromUInt32(0xff8b4513);
+        public static Color SaddleBrown => KnownColor.SaddleBrown.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffa8072.
         /// </summary>
-        public static Color Salmon => Color.FromUInt32(0xfffa8072);
+        public static Color Salmon => KnownColor.Salmon.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff4a460.
         /// </summary>
-        public static Color SandyBrown => Color.FromUInt32(0xfff4a460);
+        public static Color SandyBrown => KnownColor.SandyBrown.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff2e8b57.
         /// </summary>
-        public static Color SeaGreen => Color.FromUInt32(0xff2e8b57);
+        public static Color SeaGreen => KnownColor.SeaGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffff5ee.
         /// </summary>
-        public static Color SeaShell => Color.FromUInt32(0xfffff5ee);
+        public static Color SeaShell => KnownColor.SeaShell.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffa0522d.
         /// </summary>
-        public static Color Sienna => Color.FromUInt32(0xffa0522d);
+        public static Color Sienna => KnownColor.Sienna.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffc0c0c0.
         /// </summary>
-        public static Color Silver => Color.FromUInt32(0xffc0c0c0);
+        public static Color Silver => KnownColor.Silver.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff87ceeb.
         /// </summary>
-        public static Color SkyBlue => Color.FromUInt32(0xff87ceeb);
+        public static Color SkyBlue => KnownColor.SkyBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff6a5acd.
         /// </summary>
-        public static Color SlateBlue => Color.FromUInt32(0xff6a5acd);
+        public static Color SlateBlue => KnownColor.SlateBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff708090.
         /// </summary>
-        public static Color SlateGray => Color.FromUInt32(0xff708090);
+        public static Color SlateGray => KnownColor.SlateGray.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fffffafa.
         /// </summary>
-        public static Color Snow => Color.FromUInt32(0xfffffafa);
+        public static Color Snow => KnownColor.Snow.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff00ff7f.
         /// </summary>
-        public static Color SpringGreen => Color.FromUInt32(0xff00ff7f);
+        public static Color SpringGreen => KnownColor.SpringGreen.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff4682b4.
         /// </summary>
-        public static Color SteelBlue => Color.FromUInt32(0xff4682b4);
+        public static Color SteelBlue => KnownColor.SteelBlue.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffd2b48c.
         /// </summary>
-        public static Color Tan => Color.FromUInt32(0xffd2b48c);
+        public static Color Tan => KnownColor.Tan.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff008080.
         /// </summary>
-        public static Color Teal => Color.FromUInt32(0xff008080);
+        public static Color Teal => KnownColor.Teal.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffd8bfd8.
         /// </summary>
-        public static Color Thistle => Color.FromUInt32(0xffd8bfd8);
+        public static Color Thistle => KnownColor.Thistle.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffff6347.
         /// </summary>
-        public static Color Tomato => Color.FromUInt32(0xffff6347);
+        public static Color Tomato => KnownColor.Tomato.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #00ffffff.
         /// </summary>
-        public static Color Transparent => Color.FromUInt32(0x00ffffff);
+        public static Color Transparent => KnownColor.Transparent.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff40e0d0.
         /// </summary>
-        public static Color Turquoise => Color.FromUInt32(0xff40e0d0);
+        public static Color Turquoise => KnownColor.Turquoise.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffee82ee.
         /// </summary>
-        public static Color Violet => Color.FromUInt32(0xffee82ee);
+        public static Color Violet => KnownColor.Violet.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff5deb3.
         /// </summary>
-        public static Color Wheat => Color.FromUInt32(0xfff5deb3);
+        public static Color Wheat => KnownColor.Wheat.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffffff.
         /// </summary>
-        public static Color White => Color.FromUInt32(0xffffffff);
+        public static Color White => KnownColor.White.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #fff5f5f5.
         /// </summary>
-        public static Color WhiteSmoke => Color.FromUInt32(0xfff5f5f5);
+        public static Color WhiteSmoke => KnownColor.WhiteSmoke.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ffffff00.
         /// </summary>
-        public static Color Yellow => Color.FromUInt32(0xffffff00);
+        public static Color Yellow => KnownColor.Yellow.ToColor();
 
         /// <summary>
         /// Gets a color with an ARGB value of #ff9acd32.
         /// </summary>
-        public static Color YellowGreen => Color.FromUInt32(0xff9acd32);
+        public static Color YellowGreen => KnownColor.YellowGreen.ToColor();
     }
 }

src/Avalonia.Visuals/Media/KnownColors.cs

@@ -0,0 +1,224 @@
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+
+namespace Avalonia.Media
+{
+    internal static class KnownColors
+    {
+        private static readonly IReadOnlyDictionary<string, KnownColor> _knownColorNames;
+        private static readonly IReadOnlyDictionary<uint, string> _knownColors;
+        private static readonly Dictionary<KnownColor, ISolidColorBrush> _knownBrushes;
+
+        static KnownColors()
+        {
+            var knownColorNames = new Dictionary<string, KnownColor>(StringComparer.OrdinalIgnoreCase);
+            var knownColors = new Dictionary<uint, string>();
+
+            foreach (var field in typeof(KnownColor).GetRuntimeFields())
+            {
+                if (field.FieldType != typeof(KnownColor)) continue;
+                var knownColor = (KnownColor)field.GetValue(null);
+                if (knownColor == KnownColor.None) continue;
+
+                knownColorNames.Add(field.Name, knownColor);
+
+                // some known colors have the same value, so use the first
+                if (!knownColors.ContainsKey((uint)knownColor))
+                {
+                    knownColors.Add((uint)knownColor, field.Name);
+                }
+            }
+
+            _knownColorNames = knownColorNames;
+            _knownColors = knownColors;
+            _knownBrushes = new Dictionary<KnownColor, ISolidColorBrush>();
+        }
+
+        public static ISolidColorBrush GetKnownBrush(string s)
+        {
+            var color = GetKnownColor(s);
+            return color != KnownColor.None ? color.ToBrush() : null;
+        }
+
+        public static KnownColor GetKnownColor(string s)
+        {
+            if (_knownColorNames.TryGetValue(s, out var color))
+            {
+                return color;
+            }
+
+            return KnownColor.None;
+        }
+
+        public static string GetKnownColorName(uint rgb)
+        {
+            return _knownColors.TryGetValue(rgb, out var name) ? name : null;
+        }
+
+        public static Color ToColor(this KnownColor color)
+        {
+            return Color.FromUInt32((uint)color);
+        }
+
+        public static ISolidColorBrush ToBrush(this KnownColor color)
+        {
+            lock (_knownBrushes)
+            {
+                if (!_knownBrushes.TryGetValue(color, out var brush))
+                {
+                    brush = new Immutable.ImmutableSolidColorBrush(color.ToColor());
+                    _knownBrushes.Add(color, brush);
+                }
+
+                return brush;
+            }
+        }
+    }
+
+    internal enum KnownColor : uint
+    {
+        None,
+        AliceBlue = 0xfff0f8ff,
+        AntiqueWhite = 0xfffaebd7,
+        Aqua = 0xff00ffff,
+        Aquamarine = 0xff7fffd4,
+        Azure = 0xfff0ffff,
+        Beige = 0xfff5f5dc,
+        Bisque = 0xffffe4c4,
+        Black = 0xff000000,
+        BlanchedAlmond = 0xffffebcd,
+        Blue = 0xff0000ff,
+        BlueViolet = 0xff8a2be2,
+        Brown = 0xffa52a2a,
+        BurlyWood = 0xffdeb887,
+        CadetBlue = 0xff5f9ea0,
+        Chartreuse = 0xff7fff00,
+        Chocolate = 0xffd2691e,
+        Coral = 0xffff7f50,
+        CornflowerBlue = 0xff6495ed,
+        Cornsilk = 0xfffff8dc,
+        Crimson = 0xffdc143c,
+        Cyan = 0xff00ffff,
+        DarkBlue = 0xff00008b,
+        DarkCyan = 0xff008b8b,
+        DarkGoldenrod = 0xffb8860b,
+        DarkGray = 0xffa9a9a9,
+        DarkGreen = 0xff006400,
+        DarkKhaki = 0xffbdb76b,
+        DarkMagenta = 0xff8b008b,
+        DarkOliveGreen = 0xff556b2f,
+        DarkOrange = 0xffff8c00,
+        DarkOrchid = 0xff9932cc,
+        DarkRed = 0xff8b0000,
+        DarkSalmon = 0xffe9967a,
+        DarkSeaGreen = 0xff8fbc8f,
+        DarkSlateBlue = 0xff483d8b,
+        DarkSlateGray = 0xff2f4f4f,
+        DarkTurquoise = 0xff00ced1,
+        DarkViolet = 0xff9400d3,
+        DeepPink = 0xffff1493,
+        DeepSkyBlue = 0xff00bfff,
+        DimGray = 0xff696969,
+        DodgerBlue = 0xff1e90ff,
+        Firebrick = 0xffb22222,
+        FloralWhite = 0xfffffaf0,
+        ForestGreen = 0xff228b22,
+        Fuchsia = 0xffff00ff,
+        Gainsboro = 0xffdcdcdc,
+        GhostWhite = 0xfff8f8ff,
+        Gold = 0xffffd700,
+        Goldenrod = 0xffdaa520,
+        Gray = 0xff808080,
+        Green = 0xff008000,
+        GreenYellow = 0xffadff2f,
+        Honeydew = 0xfff0fff0,
+        HotPink = 0xffff69b4,
+        IndianRed = 0xffcd5c5c,
+        Indigo = 0xff4b0082,
+        Ivory = 0xfffffff0,
+        Khaki = 0xfff0e68c,
+        Lavender = 0xffe6e6fa,
+        LavenderBlush = 0xfffff0f5,
+        LawnGreen = 0xff7cfc00,
+        LemonChiffon = 0xfffffacd,
+        LightBlue = 0xffadd8e6,
+        LightCoral = 0xfff08080,
+        LightCyan = 0xffe0ffff,
+        LightGoldenrodYellow = 0xfffafad2,
+        LightGreen = 0xff90ee90,
+        LightGray = 0xffd3d3d3,
+        LightPink = 0xffffb6c1,
+        LightSalmon = 0xffffa07a,
+        LightSeaGreen = 0xff20b2aa,
+        LightSkyBlue = 0xff87cefa,
+        LightSlateGray = 0xff778899,
+        LightSteelBlue = 0xffb0c4de,
+        LightYellow = 0xffffffe0,
+        Lime = 0xff00ff00,
+        LimeGreen = 0xff32cd32,
+        Linen = 0xfffaf0e6,
+        Magenta = 0xffff00ff,
+        Maroon = 0xff800000,
+        MediumAquamarine = 0xff66cdaa,
+        MediumBlue = 0xff0000cd,
+        MediumOrchid = 0xffba55d3,
+        MediumPurple = 0xff9370db,
+        MediumSeaGreen = 0xff3cb371,
+        MediumSlateBlue = 0xff7b68ee,
+        MediumSpringGreen = 0xff00fa9a,
+        MediumTurquoise = 0xff48d1cc,
+        MediumVioletRed = 0xffc71585,
+        MidnightBlue = 0xff191970,
+        MintCream = 0xfff5fffa,
+        MistyRose = 0xffffe4e1,
+        Moccasin = 0xffffe4b5,
+        NavajoWhite = 0xffffdead,
+        Navy = 0xff000080,
+        OldLace = 0xfffdf5e6,
+        Olive = 0xff808000,
+        OliveDrab = 0xff6b8e23,
+        Orange = 0xffffa500,
+        OrangeRed = 0xffff4500,
+        Orchid = 0xffda70d6,
+        PaleGoldenrod = 0xffeee8aa,
+        PaleGreen = 0xff98fb98,
+        PaleTurquoise = 0xffafeeee,
+        PaleVioletRed = 0xffdb7093,
+        PapayaWhip = 0xffffefd5,
+        PeachPuff = 0xffffdab9,
+        Peru = 0xffcd853f,
+        Pink = 0xffffc0cb,
+        Plum = 0xffdda0dd,
+        PowderBlue = 0xffb0e0e6,
+        Purple = 0xff800080,
+        Red = 0xffff0000,
+        RosyBrown = 0xffbc8f8f,
+        RoyalBlue = 0xff4169e1,
+        SaddleBrown = 0xff8b4513,
+        Salmon = 0xfffa8072,
+        SandyBrown = 0xfff4a460,
+        SeaGreen = 0xff2e8b57,
+        SeaShell = 0xfffff5ee,
+        Sienna = 0xffa0522d,
+        Silver = 0xffc0c0c0,
+        SkyBlue = 0xff87ceeb,
+        SlateBlue = 0xff6a5acd,
+        SlateGray = 0xff708090,
+        Snow = 0xfffffafa,
+        SpringGreen = 0xff00ff7f,
+        SteelBlue = 0xff4682b4,
+        Tan = 0xffd2b48c,
+        Teal = 0xff008080,
+        Thistle = 0xffd8bfd8,
+        Tomato = 0xffff6347,
+        Transparent = 0x00ffffff,
+        Turquoise = 0xff40e0d0,
+        Violet = 0xffee82ee,
+        Wheat = 0xfff5deb3,
+        White = 0xffffffff,
+        WhiteSmoke = 0xfff5f5f5,
+        Yellow = 0xffffff00,
+        YellowGreen = 0xff9acd32
+    }
+}

tests/Avalonia.Visuals.UnitTests/Media/BrushTests.cs

@@ -12,7 +12,7 @@ namespace Avalonia.Visuals.UnitTests.Media
         [Fact]
         public void Parse_Parses_RGB_Hash_Brush()
         {
-            var result = (SolidColorBrush)Brush.Parse("#ff8844");
+            var result = (ISolidColorBrush)Brush.Parse("#ff8844");
 
             Assert.Equal(0xff, result.Color.R);
             Assert.Equal(0x88, result.Color.G);
@@ -23,7 +23,7 @@ namespace Avalonia.Visuals.UnitTests.Media
         [Fact]
         public void Parse_Parses_ARGB_Hash_Brush()
         {
-            var result = (SolidColorBrush)Brush.Parse("#40ff8844");
+            var result = (ISolidColorBrush)Brush.Parse("#40ff8844");
 
             Assert.Equal(0xff, result.Color.R);
             Assert.Equal(0x88, result.Color.G);
@@ -34,7 +34,7 @@ namespace Avalonia.Visuals.UnitTests.Media
         [Fact]
         public void Parse_Parses_Named_Brush_Lowercase()
         {
-            var result = (SolidColorBrush)Brush.Parse("red");
+            var result = (ISolidColorBrush)Brush.Parse("red");
 
             Assert.Equal(0xff, result.Color.R);
             Assert.Equal(0x00, result.Color.G);
@@ -45,7 +45,7 @@ namespace Avalonia.Visuals.UnitTests.Media
         [Fact]
         public void Parse_Parses_Named_Brush_Uppercase()
         {
-            var result = (SolidColorBrush)Brush.Parse("RED");
+            var result = (ISolidColorBrush)Brush.Parse("RED");
 
             Assert.Equal(0xff, result.Color.R);
             Assert.Equal(0x00, result.Color.G);
@@ -53,6 +53,16 @@ namespace Avalonia.Visuals.UnitTests.Media
             Assert.Equal(0xff, result.Color.A);
         }
 
+        [Fact]
+        public void Parse_ToString_Named_Brush_Roundtrip()
+        {
+            const string expectedName = "Red";
+            var brush = (ISolidColorBrush)Brush.Parse(expectedName);
+            var name = brush.ToString();
+
+            Assert.Equal(expectedName, name);
+        }
+
         [Fact]
         public void Parse_Hex_Value_Doesnt_Accept_Too_Few_Chars()
         {