Support both process and surface isolated designers

From 16.4 Visual Studio enables surface isolated designer for XAML projects.
Isolate common code and implement shims to make it work with both designers.

Author: Nirmal4G

Microsoft.Toolkit.Uwp.UI.Controls.DataGrid.Design/Controls/DataGrid.Metadata.cs

@@ -4,15 +4,18 @@
 
 using System;
 using System.Reflection;
-
 using Microsoft.Toolkit.Uwp.Design.Common;
+using Microsoft.Toolkit.Uwp.UI.Controls.Design;
+
+#if VS_DESIGNER_PROCESS_ISOLATION
 using Microsoft.Windows.Design.Metadata;
+#endif
 
-[assembly: ProvideMetadata(typeof(Microsoft.Toolkit.Uwp.UI.Controls.Design.MetadataRegistration))]
+[assembly: ProvideMetadata(typeof(MetadataRegistration))]
 
 namespace Microsoft.Toolkit.Uwp.UI.Controls.Design
 {
-    public class MetadataRegistration : MetadataRegistrationBase, IProvideAttributeTable
+    public class MetadataRegistration : MetadataRegistrationBase
     {
         public MetadataRegistration() : base()
         {
@@ -23,25 +26,12 @@ public MetadataRegistration() : base()
             // (or Default namespace in Project -> Properties -> Application tab)
             // must be the same as runtime assembly's main namespace (t.Namespace)
             // plus .Design.
-            Type t = typeof(Microsoft.Toolkit.Uwp.UI.Controls.DataGrid);
+#if VS_DESIGNER_PROCESS_ISOLATION
+            Type t = typeof(DataGrid);
             AssemblyName an = t.Assembly.GetName();
             AssemblyFullName = ", " + an.FullName;
             XmlResourceName = t.Namespace + ".Design." + an.Name + ".xml";
+#endif
         }
-
-        #region IProvideAttributeTable Members
-
-        /// <summary>
-        /// Gets the AttributeTable for design time metadata.
-        /// </summary>
-        public AttributeTable AttributeTable
-        {
-            get
-            {
-                return BuildAttributeTable();
-            }
-        }
-
-        #endregion
     }
 }

Microsoft.Toolkit.Uwp.UI.Controls.DataGrid.Design/MetadataRegistration.cs

@@ -31,6 +31,7 @@
   </PropertyGroup>
   <PropertyGroup>
     <AssetTargetFallback>$(AssetTargetFallback);uap10.0.16299</AssetTargetFallback>
+    <DefineConstants>$(DefineConstants);VS_DESIGNER_PROCESS_ISOLATION</DefineConstants>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System.Runtime" />

Microsoft.Toolkit.Uwp.UI.Controls.DataGrid.Design/Microsoft.Toolkit.Uwp.UI.Controls.DataGrid.Design.csproj

@@ -7,16 +7,20 @@
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Xml.Linq;
 
+using Microsoft.Toolkit.Uwp.Design.Types;
+
+#if VS_DESIGNER_PROCESS_ISOLATION
+using Microsoft.Windows.Design;
 using Microsoft.Windows.Design.Metadata;
+#endif
 
 namespace Microsoft.Toolkit.Uwp.Design.Common
 {
-    public class MetadataRegistrationBase
+    public abstract class MetadataRegistrationBase : IProvideAttributeTable
     {
         private AttributeTable masterMetadataTable;
 
@@ -28,15 +32,25 @@ internal MetadataRegistrationBase() { }
         /// <returns>Custom attribute table.</returns>
         protected virtual AttributeTable BuildAttributeTable()
         {
-            AttributeTableBuilder builder = new AttributeTableBuilder();
+            var builder = new AttributeTableBuilder();
 
             AddDescriptions(builder);
             AddAttributes(builder);
             AddTables(builder, this);
+
             masterMetadataTable = builder.CreateTable();
             return masterMetadataTable;
         }
 
+        #region IProvideAttributeTable Members
+
+        /// <summary>
+        /// Gets the AttributeTable for design time metadata.
+        /// </summary>
+        public AttributeTable AttributeTable => BuildAttributeTable();
+
+        #endregion
+
         /// <summary>
         /// Find all AttributeTableBuilder subclasses in the assembly
         /// and add their attributes to the assembly attribute table.
@@ -54,7 +68,7 @@ private void AddTables(AttributeTableBuilder builder, object parent)
                 {
                     try
                     {
-                        AttributeTableBuilder atb = (AttributeTableBuilder)Activator.CreateInstance(t);
+                        var atb = (AttributeTableBuilder)Activator.CreateInstance(t);
                         builder.AddTable(atb.CreateTable());
                     }
                     catch (Exception)
@@ -76,44 +90,44 @@ private void AddTables(AttributeTableBuilder builder, object parent)
         protected string AssemblyFullName { get; set; }
 
         /// <summary>
-        /// Create description attribute from run time assembly xml file.
+        /// Create description attribute from run time assembly XML file.
         /// </summary>
         /// <param name="builder">The assembly attribute table builder.</param>
         [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Design time dll should not fail.")]
         private void AddDescriptions(AttributeTableBuilder builder)
         {
             Debug.Assert(builder != null, "AddDescriptions is called with null parameter!");
 
-            if (string.IsNullOrEmpty(XmlResourceName) ||
-                string.IsNullOrEmpty(AssemblyFullName))
-            {
-                return;
-            }
-            XDocument xdoc = null;
+            if (string.IsNullOrEmpty(XmlResourceName) || string.IsNullOrEmpty(AssemblyFullName)) return;
+
+            XDocument xdoc;
             try
             {
-                xdoc = XDocument.Load(new StreamReader(
-                    Assembly.GetExecutingAssembly().GetManifestResourceStream(XmlResourceName)));
+                xdoc = XDocument.Load(Assembly.GetExecutingAssembly().GetManifestResourceStream(XmlResourceName));
             }
-            catch { return; }
-            if (xdoc == null)
+            catch
             {
                 return;
             }
 
+            if (xdoc == null) return;
+
             foreach (XElement member in xdoc.Descendants("member"))
             {
                 try
                 {
                     string name = (string)member.Attribute("name");
-                    if (name == null)
-                        continue;
+
+                    if (name == null) continue;
+
                     bool isType = name.StartsWith("T:", StringComparison.OrdinalIgnoreCase);
-                    if (isType ||
-                        name.StartsWith("P:", StringComparison.OrdinalIgnoreCase))
+                    bool isProperty = name.StartsWith("P:", StringComparison.OrdinalIgnoreCase);
+
+                    if (isType || isProperty)
                     {
                         int lastDot = name.Length;
                         string typeName;
+
                         if (isType)
                         {
                             typeName = name.Substring(2); // skip leading "T:"
@@ -123,86 +137,74 @@ private void AddDescriptions(AttributeTableBuilder builder)
                             lastDot = name.LastIndexOf('.');
                             typeName = name.Substring(2, lastDot - 2);
                         }
-                        typeName += AssemblyFullName;
 
-                        Type t = Type.GetType(typeName);
-                        if (t != null && t.IsPublic && t.IsClass &&
-                            t.IsSubclassOf(Types.PlatformTypes.DependencyObjectType))
+                        var type = Type.GetType(typeName + ", " + AssemblyFullName);
+
+                        if (type != null && type.IsPublic && type.IsClass && type.IsSubclassOf(PlatformTypes.DependencyObject))
                         {
                             string desc = ParseDescription(member);
-                            if (desc == null)
-                                continue;
 
-                            desc = desc.Trim();
-                            desc = string.Join(" ", desc.Split(new char[] { ' ', '\t', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries));
+                            if (desc == null) continue;
+
+                            desc = string.Join(" ", desc.Trim().Split(new char[] { ' ', '\t', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries));
+
                             if (isType)
                             {
-                                bool isBrowsable = true;
-                                try
+                                if (IsBrowsable(type))
                                 {
-                                    isBrowsable = IsBrowsable(t);
+                                    builder.AddCustomAttributes(type, new DescriptionAttribute(desc));
                                 }
-                                catch { isBrowsable = false; }
-                                if (isBrowsable)
-                                    builder.AddCallback(t, b => b.AddCustomAttributes(new DescriptionAttribute(desc)));
                                 else //Hide from intellisense
                                 {
-                                    builder.AddCallback(t, b => b.AddCustomAttributes(
+                                    builder.AddCustomAttributes(type,
                                         new BrowsableAttribute(false),
-                                        new Microsoft.Windows.Design.ToolboxBrowsableAttribute(false),
-                                        new ToolboxItemAttribute(false)));
+                                        new ToolboxBrowsableAttribute(false),
+                                        new ToolboxItemAttribute(false));
                                 }
                             }
                             else
                             {
-                                string propName = name.Substring(lastDot + 1);
-                                PropertyInfo pi = t.GetProperty(propName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+                                var propertyName = name.Substring(lastDot + 1);
+                                PropertyInfo pi = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
                                 if (pi != null)
                                 {
-                                    bool isBrowsable = true;
-                                    try
+                                    if (IsBrowsable(type))
                                     {
-                                        isBrowsable = IsBrowsable(pi);
+                                        builder.AddCustomAttributes(type, propertyName, new DescriptionAttribute(desc));
                                     }
-                                    catch { isBrowsable = false; }
-                                    if (isBrowsable)
-                                        builder.AddCallback(t, b => b.AddCustomAttributes(propName, new DescriptionAttribute(desc)));
                                     else //Hide from intellisense
-                                        builder.AddCallback(t, b => b.AddCustomAttributes(new BrowsableAttribute(false)));
+                                    {
+                                        builder.AddCustomAttributes(type, new BrowsableAttribute(false));
+                                    }
                                 }
                             }
                         }
                     }
                 }
-                catch (Exception)
+                catch
                 {
                 }
             }
         }
-        private static bool IsBrowsable(Type t)
+
+        private static bool IsBrowsable(MemberInfo typeOrMember)
         {
-            var attrs = t.GetCustomAttributes(Types.PlatformTypes.EditorBrowsableAttributeType, false);
-            foreach (var attr in attrs)
+            EditorBrowsableAttribute attribute;
+            try
             {
-                return Types.PlatformTypes.IsBrowsable(attr);
+                attribute = typeOrMember.GetCustomAttribute<EditorBrowsableAttribute>(false);
             }
-            return true;
-        }
-
-        private static bool IsBrowsable(System.Reflection.PropertyInfo pi)
-        {
-            var attrs = pi.GetCustomAttributes(Types.PlatformTypes.EditorBrowsableAttributeType, false);
-            foreach (var attr in attrs)
+            catch
             {
-                return Types.PlatformTypes.IsBrowsable(attr);
+                return true; // If there is no [EditorBrowsable] attribute present, we'll show it by default.
             }
-            return true;
+            return attribute.State != EditorBrowsableState.Never;
         }
 
         /// <summary>
-        /// Create description string from xml doc summary tag.
+        /// Create description string from XML doc summary tag.
         /// </summary>
-        /// <param name="member">A single node of the xml doc.</param>
+        /// <param name="member">A single node of the XML doc.</param>
         /// <returns>Description string.</returns>
         private static string ParseDescription(XElement member)
         {

Microsoft.Toolkit.Uwp.UI.Controls.Design/Common/MetadataRegistrationBase.cs

@@ -3,41 +3,25 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
 
+#if VS_DESIGNER_PROCESS_ISOLATION
 using Microsoft.Windows.Design.Metadata;
-
-using Windows.UI.Xaml;
+#endif
 
 namespace Microsoft.Toolkit.Uwp.Design.Types
 {
     internal class PlatformTypes
     {
-        public static readonly Type DependencyObjectType = typeof(DependencyObject);
-        public static readonly Type UIElementType = typeof(UIElement);
-        public static readonly Type FrameworkElementType = typeof(FrameworkElement);
-        public static readonly Type EditorBrowsableAttributeType = typeof(System.ComponentModel.EditorBrowsableAttribute);
-
-        /// <summary>
-        /// Used by MetadataRegistrationBase to get the browsable state
-        /// </summary>
-        /// <param name="editorBrowsableAttribute">This parameter must be of type 'System.ComponentModel.EditorBrowsableAttribute'</param>
-        /// <returns></returns>
-        public static bool IsBrowsable(object editorBrowsableAttribute)
-        {
-            if (editorBrowsableAttribute is System.ComponentModel.EditorBrowsableAttribute)
-                return (editorBrowsableAttribute as System.ComponentModel.EditorBrowsableAttribute).State !=
-                     System.ComponentModel.EditorBrowsableState.Never;
-            return true;
-        }
-   
-        public static class Control
-        {
-            public static readonly TypeIdentifier TypeId = new TypeIdentifier("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "Control");
-            public static readonly PropertyIdentifier BackgroundProperty = new PropertyIdentifier(TypeId, "Background");
-            public static readonly PropertyIdentifier BorderBrushProperty = new PropertyIdentifier(TypeId, "BorderBrush");
-            public static readonly PropertyIdentifier BorderThicknessProperty = new PropertyIdentifier(TypeId, "BorderThickness");
-        }
+        public static readonly Type DependencyObject = typeof(DependencyObject);
+        public static readonly Type UIElement = typeof(UIElement);
+        public static readonly Type FrameworkElement = typeof(FrameworkElement);
+        public static readonly Type Control = typeof(Control);
+    }
 
+    internal class XamlTypes
+    {
         public static class FrameworkElement
         {
             public static readonly TypeIdentifier TypeId = new TypeIdentifier("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "FrameworkElement");
@@ -47,5 +31,13 @@ public static class FrameworkElement
             public static readonly PropertyIdentifier HeightProperty = new PropertyIdentifier(TypeId, "Height");
             public static readonly PropertyIdentifier WidthProperty = new PropertyIdentifier(TypeId, "Width");
         }
+
+        public static class Control
+        {
+            public static readonly TypeIdentifier TypeId = new TypeIdentifier("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "Control");
+            public static readonly PropertyIdentifier BackgroundProperty = new PropertyIdentifier(TypeId, "Background");
+            public static readonly PropertyIdentifier BorderBrushProperty = new PropertyIdentifier(TypeId, "BorderBrush");
+            public static readonly PropertyIdentifier BorderThicknessProperty = new PropertyIdentifier(TypeId, "BorderThickness");
+        }
     }
 }

Microsoft.Toolkit.Uwp.UI.Controls.Design/Common/PlatformTypes.cs

@@ -2,11 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Diagnostics.CodeAnalysis;
 
 [assembly: SuppressMessage("General", "SWC1001:XmlDocumentationCommentShouldBeSpelledCorrectly", MessageId = "Theming", Justification = "Correct spelling")]
 
-namespace Microsoft.Toolkit.Uwp.UI.Controls.Design.Common
+namespace Microsoft.Toolkit.Uwp.UI.Controls.Design
 {
     /// <summary>
     /// Names for ToolboxCategoryAttribute.