Hide all WPF UserControls from Assembly in Toolbox

Question

I want to hide all written WPF UserControls from several Assemblies in my project inside the Visual Studio Toolbox. I know I can flag the UserControls with the [DesignTimeVisible(false)] attribute to hide each individual control.

Is there another solution to hide all of them with one attribute on the Assembly? I don't want to flag each new Control. Sadly the attribute is not inherited from its parent so I even cannot create a basecontrol with the DesignTimeVisible(false).

Any Ideas?

Answer 1

As the first preference, such controls can be internal if they should be used visible in the container project. You can make them public based on requirements. Also being internal, they can be used in friend assemblies as well.

Anyway to reduce the difficulty of turning on/off of DesignTimeVisible is what you are looking for, you can consider these options:

Option 1

As an option, you can decrease the difficulty of turning on/off the DesignTimeVisible attribute. You can decorate all classes just once with DesignTimeVisible but control its value from a central point.

To do so, create a class to hold setting:

public class MyGlobalSettings
{
    public const bool DesignTimeVisible = false;
}

Then decorate controls this way:

[DesignTimeVisible(MyGlobalSettings.DesignTimeVisible)]
public partial class UserControl1 : UserControl

Then to turn on/off showing controls in toolbox, it's enough to set DesignTimeVisible. This way, it's just a single point setting.

Option 2

An another option you can use a T4 Template to generate partial classes for your controls. In the file you can have a variable which will be used as value of DesignTimeVisible attribute. Then in the T4 template, decorate all partial classes with DesignTimeVisible having specified value. You can simply change the value in a single point.

Class names can be generated automatically using code, but in this example I used static class names:

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#  var designTimeVisibleValue = "false"; #>
using System.Windows.Controls;
using System.ComponentModel;
namespace WpfCustomControlLibrary1
{
    [DesignTimeVisible(<#=designTimeVisibleValue#>)]
    public partial class UserControl1 : UserControl{}

    [DesignTimeVisible(<#=designTimeVisibleValue#>)]
    public partial class UserControl2 : UserControl{}
}

Note

Also as mentioned in comments, you can use tools like Fody, PostSharp, dIHook,... to modify assembly at build time. Using these libraries just for such requirement is too much. Such tools can have lots of benefits but using them just for such requirement is too much and not a good idea.

Answer 2

Maybe I am late, but if:

1. Your controls assembly is not register in the GAC
2. Your controls assembly's project is not in the solution you are working in

then you can use WPF Designer Extensibility. Practically you can extend the visual studio WPF designer by using attributes.

The attribute that we need is ToolboxBrowsableAttribute. The more important feature of this framework is that it allows to define attributes for our controls in a separate assembly (called design assembly).

So let's suppose these are our custom controls:

namespace CustomControls
{
    public class CustomTextBox : TextBox
    {
    }

    public class CustomButton : Button
    {
    }

    public class CustomComboBox : ComboBox
    {
    }
}

The custom controls are in an assembly named CustomControls.dll; for adding the attribute we need to each control, a new assembly called CustomControls.Design.dll should be created. This new assembly has to reference:

• PresentationCore
• PresentationFramework
• System.Xaml
• WindowsBase
• Microsoft.Windows.Design.Extensibility
• Microsoft.Windows.Design.Interaction

In the AssemblyInfo add this line of code:

[assembly: ProvideMetadata(typeof(CustomControls.Design.Metadata))]

That attribute points out which class will provide attribute for the designer. So let's see the code of Metadata class:

namespace CustomControls.Design
{
    public class Metadata : IProvideAttributeTable
    {
        AttributeTable IProvideAttributeTable.AttributeTable
        {
            get
            {
                AttributeTableBuilder builder = new AttributeTableBuilder();
                Assembly assembly = Assembly.GetAssembly(typeof(CustomControls.CustomButton));

                foreach (Type objectType in assembly.GetTypes())
                {
                    if (objectType.IsPublic && typeof(FrameworkElement).IsAssignableFrom(objectType))
                    {
                        builder.AddCustomAttributes(objectType,
                            ToolboxBrowsableAttribute.No);
                    }
                }

                return builder.CreateTable();
            }
        }
    }
}

In this way I am adding the ToolboxBrowsable attribute to each public object of the CustomControl assembly which extends the FrameworkElement class, without the need of decorating each control one by one.

CustomControls.Design.dll must be in the same folder of CustomControls.dll.

You can find useful info here (even that code regards a slightly different argument).

Pay attetion: if condition 1 and condition 2 are not both met, this method does not work and probabily the Reza Aghaei's solution is more suitable.

I hope it can help.