[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public class DisplayNameLocalizedAttribute : DisplayNameAttribute
    {
        private Type resourceSource;
        private string resourceName;

        protected DisplayNameLocalizedAttribute()
        {
        }

        public DisplayNameLocalizedAttribute(Type resourceSource, string resourceName)
        {
            this.resourceSource = resourceSource;
            this.resourceName = resourceName;
            UpdateDisplayName();
        }

        public void UpdateDisplayName()
        {
            ResourceManager rm = new ResourceManager(resourceSource);
            DisplayNameValue = rm.GetString(resourceName);
        }
    }

public class YearRequestByMonthConfig : BaseReportConfig
    {
        //YearRequestByMonthRptConfigResources - компонент с ресурсами
        [DisplayNameLocalized(typeof (YearRequestByMonthRptConfigResources), "Department")]
        public string Department
        {
            get { return department; }
            set { department = value; }
        }
}

class BooleanTypeConverter : BooleanConverter
{
  public override object ConvertTo(ITypeDescriptorContext context, 
    CultureInfo culture,
    object value, 
    Type destType)
  {
    return (bool)value ? 
      "Есть" : "Нет";
  }

  public override object ConvertFrom(ITypeDescriptorContext context, 
    CultureInfo culture,
    object value)
  {
    return (string)value == "Есть";
  }
}

Реализовать EnumTypeConverter, осуществляющий преобразование к строке с учетом атрибута Description…

 public override void PaintValue(PaintValueEventArgs e)
  {
    // картинки хранятся в ресурсах с именами, соответствующими
    // именам каждого члена перечисления Sex
    string resourcename = ((Sex)e.Value).ToString();

    // достаем картинку из ресурсов
    Bitmap sexImage =
      (Bitmap)Resources.ResourceManager.GetObject(resourcename);
    Rectangle destRect = e.Bounds;
    sexImage.MakeTransparent();

    // и отрисовываем
    e.Graphics.DrawImage(sexImage, destRect);
  }

Как реализовать отображение составного свойства?

error CS0592: Attribute 'DisplayName' is not valid on this declaration type. It is valid on 'class, method, property, indexer, event' declarations only.

OE>error CS0592: Attribute 'DisplayName' is not valid on this declaration type. It is valid on 'class, method, property, indexer, event' declarations only.

  [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Field)]
  public class LocalisedDisplayNameAttribute : DisplayNameAttribute
  {
    #region Constructors\Destructor

    public LocalisedDisplayNameAttribute(string resourceName) : base(LoadResource(resourceName)) {

    }

    #endregion Constructors\Destructor

    #region Methods

    private static string LoadResource(string resourceName) {
      return Properties.Resources.ResourceManager.GetString(resourceName);
    }

    #endregion Methods
  }

  public enum MyValues
  {
    [LocalisedDisplayName(Resources.Value1)]
    Value1,

    [LocalisedDisplayName(Resources.Value2)]
    Value2,
  }

// для свойства, естесственно, работает

[Category("Category1")]
public int Position
{
  get { return position; }
  set { position = value; }
}

// а вот для события нет...

public delegate void ChangedEventHandler();

[Category("Category2")]
public ChangedEventHandler PositionChanged;

ТВ>// а вот для события нет...
ТВ>public delegate void ChangedEventHandler();

ТВ>[Category("Category2")]
ТВ>public event ChangedEventHandler PositionChanged;

// Принудительно обнновляем грид если редактировалась динамическая структура

PropertyGrid* m_propertyGrid =  __try_cast<GlobalizedPropertyGrid::GlobalizedObject*>(context->get_Instance())->PropGrid;
GridItem* gi = m_propertyGrid->SelectedGridItem;
GridItem* parent = NULL;
while (gi != NULL)
{
    parent = gi;
    gi = gi->Parent;
}
if (parent != NULL)
{
    GridItemCollection* coll = parent->get_GridItems();
    for(int i = 0; i < coll->Count; i++)
    {
        GridItem* child    = coll->get_Item(i);
        if (child->GridItemType == GridItemType::Category)
        {
            GridItemCollection* coll2 = child->get_GridItems();
            for(int i = 0; i < coll2->Count; i++)
            {
               coll2->get_Item(i)->Expanded = false;
            }
        }
        else
            child->Expanded = false;
    }                                                                    
}
m_propertyGrid->Refresh();

        // Отображает визальный диалог для редактирования<br> 
        // коллекции соответствующего типа<br>
        // Связь между редактируемым свойством и типом <br>
        // коллекции устанавливается статически в ресурсы <br>
        // программы во время разработки
        public __gc class FieldListCollectionUITypeEditor : public System::Drawing::Design::UITypeEditor 
            {
            public:
            FieldListCollectionUITypeEditor() {}
                        
            System::Drawing::Design::UITypeEditorEditStyle GetEditStyle(System::ComponentModel::ITypeDescriptorContext* context) {
                return UITypeEditorEditStyle::Modal;
            }

            // Редактирует свойство
            Object* EditValue(System::ComponentModel::ITypeDescriptorContext* context, System::IServiceProvider* provider, Object* value) {
                String* ResoursePath = S"NIST.VALUE";
                // Return the value if the value is not of type FieldBase* __gc[].
                
                // Необходимо включить проверку на входные данные
                // if (value->GetType() != __typeof(System::String)&&( value->GetType() != __typeof(System::Int32)))
                //      return value;
                String* propertyName = S"";
                if (context->get_PropertyDescriptor()!=NULL)
                {
                    propertyName = context->get_PropertyDescriptor()->get_Name();                
                }                
                //
                System::Reflection::Assembly* ass = System::Reflection::Assembly::GetEntryAssembly();
                // Now use table name and display name id to access the resources.  
                ResourceManager* rm = new ResourceManager(ResoursePath,ass);
                // Get the string from the resources.         
                System::String* n = rm->GetString(String::Concat(propertyName,S"TYPE"));
                if (n!=NULL)
                {
                    NIST::CollectionEditor* editor = new NIST::CollectionEditor();
                    
                    // инициализируем редактор                    
                    if (n->Equals(S"String"))
                    {    
                        FieldCollectionString* fc = __try_cast<FieldCollectionString*>(value);
                        //Create temp copy of colrction
                        FieldCollection* temp = new FieldCollectionString();
                        for (int i = 0; i < fc->Count; i++)
                        {
                            __try_cast<FieldCollectionString*>(temp)->Add(fc->get_Item(i));
                        }
                        editor->setSource(temp,n);
                    }
                    else if (n->Equals(S"DateTime"))
                    {
                        FieldCollectionDateTime* fc = __try_cast<FieldCollectionDateTime*>(value);
                        //Create temp copy of colrction
                        FieldCollection* temp = new FieldCollectionDateTime();
                        for (int i = 0; i < fc->Count; i++)
                        {
                            __try_cast<FieldCollectionDateTime*>(temp)->Add(fc->get_Item(i));
                        }
                        editor->setSource(temp,n);
                    }
                    else
                    {                    
                        FieldCollection* fc = __try_cast<FieldCollection*>(value);
                        //Create temp copy of colrction
                        FieldCollection* temp;
                        if (n->Equals(S"FieldDAI"))
                        {
                            temp = new FieldCollectionDAI();
                        }
                        else if (n->Equals(S"FieldCNO"))
                        {
                            temp = new FieldCollectionCNO();
                        }
                        else if (n->Equals(S"FieldORN"))
                        {
                            temp = new FieldCollectionORN();
                        }
                        else if (n->Equals(S"FieldNAM"))
                        {
                            temp = new FieldCollectionNAM();
                        }
                        else if (n->Equals(S"FieldGSA"))
                        {
                            temp = new FieldCollectionGSA();
                        }
                        else if (n->Equals(S"FieldFPR"))
                        {
                            temp = new FieldCollectionFPR();
                        }
                        else 
                            return value;

                        for (int i = 0; i < fc->Count; i++)
                        {
                            temp->Add(fc->get_Item(i));
                        }
                        editor->setSource(temp,n);                    
                    }
                    
                    // получаем результат
                    if (editor->ShowDialog()==DialogResult::OK)
                    {        
                        if (n->Equals(S"String"))
                        {    
                            value = __try_cast<FieldCollectionString*>(editor->collection);                        
                        }
                        else if (n->Equals(S"DateTime"))
                        {
                            value = __try_cast<FieldCollectionDateTime*>(editor->collection);
                        }
                        else
                            value = editor->collection;
                    }
                }
                
                // Принудительно обнновляем грид если редактировалась динамическая структура
                

                //if (context->get_Instance()->GetType() == __typeof(GlobalizedPropertyGrid::GlobalizedObject))
                {
                    PropertyGrid* m_propertyGrid =  __try_cast<GlobalizedPropertyGrid::GlobalizedObject*>(context->get_Instance())->PropGrid;
                    GridItem* gi = m_propertyGrid->SelectedGridItem;
                    GridItem* parent = NULL;
                    while (gi != NULL)
                    {
                        parent = gi;
                        gi = gi->Parent;
                    }
                    if (parent != NULL)
                    {
                        GridItemCollection* coll = parent->get_GridItems();
                        for(int i = 0; i < coll->Count; i++)
                        {
                            GridItem* child    = coll->get_Item(i);
                            if (child->GridItemType == GridItemType::Category)
                            {
                                GridItemCollection* coll2 = child->get_GridItems();
                                for(int i = 0; i < coll2->Count; i++)
                                {
                                   coll2->get_Item(i)->Expanded = false;
                                }
                            }
                            else
                                child->Expanded = false;
                        }                                                                    
                    }
                    m_propertyGrid->Refresh(); 
                }
                
                return value;
            }

            
            // Draws a representation of the property's value.
            void PaintValue(System::Drawing::Design::PaintValueEventArgs* e) {
                }

            // Indicates whether the UITypeEditor supports painting a
            // representation of a property's value.
            bool GetPaintValueSupported(System::ComponentModel::ITypeDescriptorContext* context) {
                return false;
            }
            };

IComponentChangeService ccs = provider.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
ccs.OnComponentChanged(..);

public CollectionEditor (Type collection_type)

public MyCollectionEditor (Type collection_type, SomeType additional_data)

public class Unit
{
private decimal unitId;


public decimal UnitId
{
   get{return unitId;}
   set{unitId = value;}
}
}

public class YearRequestByMonthConfig : BaseReportConfig
    {
        public class EntityHolder
        {
            public EntityHolder()
            {
            }

            public EntityHolder(decimal id, string name)
            {
                this.id = id;
                this.name = name;
            }

            public decimal Id
            {
                get { return id; }
                set { id = value; }
            }

            private decimal id;

            public string Name
            {
                get { return name; }
                set { name = value; }
            }
           
            public override string ToString()
            {
                return Name;
            }

            private string name;
        }

internal class DepartmentSelectEditor : UITypeEditor
        {
            public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
            {
                return UITypeEditorEditStyle.Modal;
            }

            private object value;


            /// <summary>
            /// Реализация метода редактирования
            /// </summary>
            public override Object EditValue(
                ITypeDescriptorContext context,
                IServiceProvider provider,
                Object value)
            {
                this.value = value;
                if ((provider != null) &&
                    (((IWindowsFormsEditorService) provider.GetService(typeof (IWindowsFormsEditorService))) != null))
                {
                    IDepartmentExplorerPresenter dex = BLHelper.GetDepartmentExplorerPresenter();
                    dex.DepartmentSelect +=
                        delegate(object sender, DepartmentExplorerSelectionEventArgs args)
                            {
                                string name = DataProviderHelper.EnterpriseDAL.GetEnterpriseName(args.EnterpriseId);
                                this.value = new EntityHolder(args.EnterpriseId, name);
                            };

                    dex.ShowDepartmentExplorer();
                }
                value = this.value;
                this.value = null;
                return value;
            }
        }

        [Browsable(true)]
        [DisplayNameLocalized(typeof (YearRequestByMonthRptConfigResources), "Department")]        
        [Editor(typeof (DepartmentSelectEditor), typeof (UITypeEditor))]        
            public EntityHolder Department
        {
            get { return department; }
            set { department = value; }
        }

  public class MySectionConfiguration : ConfigurationSection
  {
        //...

    [ConfigurationProperty("sex")]
    [DisplayName("Пол")]
    [Description("Пол")]
    [Category("2. Общие")]
    [TypeConverter(typeof(EnumTypeConverter))]
    public SEX Sex
    {
      get { return (SEX)this["sex"]; }
      set { this["sex"] = value; }
    }
        //...
  }

  cfg.Sex = SEX.Unknown;

_FR>Всё необходимое в посте есть В чём сложности?

[TypeConverter(typeof(PropertySorter))] -- для управления сортировкой
[TypeConverter(typeof(ComponentTypeConverter))] -- для управления видимостью и редактированием
public class MyClass : Component
{
...
}

public class ComponentTypeConverter : CustomPropertiesTypeConverter<MyClass>
{
...
}

class PropertySorter : ExpandableObjectConverter

var converter = TypeConverter.GetConverter(typeof(MyClass));

_FR>var converter = TypeConverter.GetConverter(typeof(MyClass));
_FR>

    [TypeConverter(typeof(ComponentTypeConverter))]
    [TypeConverter(typeof(PropertySorter))]
    public class MyClass

    [TypeConverter(typeof(ComponentTypeConverter), (typeof(PropertySorter))]
    public class MyClass

    [TypeConverter(typeof(PropertySorter))]
    public class MyClass

    ...
  
    [TypeConverter(typeof(ComponentTypeConverter))]
    public class MyClassChild : MyClass

    [Serializable]
    public enum TestEnum
    {
        Value1,
        Value2
    }

    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class C1
    {
        private string s1 = "", s2 = "";
        public string S1
        {
            get { return s1; }
            set { s1 = value; }
        }
        public string S2
        {
            get { return s2; }
            set { s2 = value; }
        }
    }

    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class C2
    {
        private int n1 = 0, n2 = 0;
        public int N1
        {
            get { return n1; }
            set { n1 = value; }
        }
        public int N2
        {
            get { return n2; }
            set { n2 = value; }
        }
    }

    public partial class Activity1 : Activity, ICustomTypeDescriptor

    {
        public Activity1()
        {
            InitializeComponent();
            Param1 = new C1();
            Param2 = new C2();
        }

        public static DependencyProperty ZZEnumValueProperty =
            DependencyProperty.Register("ZZEnumValue", typeof(TestEnum), typeof(Activity1));

        [TypeConverter(typeof(EnumTypeConverter))]
        public TestEnum ZZEnumValue
        {
            get
            {
                return ((TestEnum)(GetValue(ZZEnumValueProperty)));
            }
            set
            {
                SetValue(ZZEnumValueProperty, value);
            }
        }

        public static DependencyProperty Param1Property =
            DependencyProperty.Register("Param1", typeof(C1), typeof(Activity1));
        [DynamicPropertyFilter("ZZEnumValue", "Value1")]
        public C1 Param1
        {
            get
            {
                
                return ((C1)(GetValue(Param1Property)));
            }
            set
            {
                SetValue(Param1Property, value);
            }
        }

        public static DependencyProperty Param2Property =
            DependencyProperty.Register("Param2", typeof(C2), typeof(Activity1));
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        [DynamicPropertyFilter("ZZEnumValue", "Value2")]
        public C2 Param2
        {
            get
            {
                return ((C2)(GetValue(Param2Property)));
            }
            set
            {
                SetValue(Param2Property, value);
            }
        }
        #region ICustomTypeDescriptor Members
        private PropertyDescriptorCollection GetFilteredProperties(Attribute[] attributes)
        {
            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(this, attributes, true);
            PropertyDescriptorCollection finalProps = 
                new PropertyDescriptorCollection(new PropertyDescriptor[0]);
            foreach (PropertyDescriptor pd in pdc)
            {
                bool include = false;
                bool dynamic = false;
                foreach (Attribute a in pd.Attributes)
                {
                    DynamicPropertyFilterAttribute dpf = a as DynamicPropertyFilterAttribute;
                    if (dpf != null)
                    {
                        dynamic = true;
                        PropertyDescriptor temp = pdc[dpf.PropertyName];
                        if (dpf.ShowOn.IndexOf(temp.GetValue(this).ToString()) > -1)
                        {
                            include = true;
                        }
                    }
                }
                if (!dynamic || include)
                {
                    finalProps.Add(pd);
                }
            }
            return finalProps;
        }

        public AttributeCollection GetAttributes()
        {
            return TypeDescriptor.GetAttributes(this, true);
        }

        public string GetClassName()
        {
            return TypeDescriptor.GetClassName(this, true);
        }

        public string GetComponentName()
        {
            return TypeDescriptor.GetComponentName(this, true);
        }

        public TypeConverter GetConverter()
        {
            return TypeDescriptor.GetConverter(this, true);
        }

        public EventDescriptor GetDefaultEvent()
        {
            return TypeDescriptor.GetDefaultEvent(this, true);
        }

        public PropertyDescriptor GetDefaultProperty()
        {
            return TypeDescriptor.GetDefaultProperty(this, true);
        }

        public object GetEditor(Type editorBaseType)
        {
            return TypeDescriptor.GetEditor(this, editorBaseType, true);
        }

        public EventDescriptorCollection GetEvents(Attribute[] attributes)
        {
            return TypeDescriptor.GetEvents(this, attributes, true);
        }

        public EventDescriptorCollection GetEvents()
        {
            return TypeDescriptor.GetEvents(this, true);
        }

        public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
        {
            return GetFilteredProperties(attributes);
        }

        public PropertyDescriptorCollection GetProperties()
        {
            return GetFilteredProperties(new Attribute[0]);
        }

        public object GetPropertyOwner(PropertyDescriptor pd)
        {
            return this;
        }

        #endregion
    }

Error Loading Workflow .... The type Activity1 has no property named Param2

        private void InitializeComponent()
        {
            this.CanModifyActivities = true;
            ActivityLibrary1.C2 c21 = new ActivityLibrary1.C2();
            this.activity11 = new ActivityLibrary1.Activity1();
            // 
            // activity11
            // 
            this.activity11.Name = "activity11";
            c21.N1 = 23;
            c21.N2 = 44;
            this.activity11.Param2 = c21;
            this.activity11.ZZEnumValue = ActivityLibrary1.TestEnum.Value2;
            // 
            // Workflow1
            // 
            this.Activities.Add(this.activity11);
            this.Name = "Workflow1";
            this.CanModifyActivities = false;

        }

this.activity11.Param2 = c21;

    public enum TestEnum
    {
        GetValue,
        GetValuesCount,
                GetValuesList
        }

if (dpf.ShowOn.IndexOf(temp.GetValue(this).ToString()) > -1)

        private PropertyDescriptorCollection GetFilteredProperties(Attribute[] attributes)
        {
            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(this, attributes, true);
            PropertyDescriptorCollection finalProps = 
                new PropertyDescriptorCollection(new PropertyDescriptor[0]);
            foreach (PropertyDescriptor pd in pdc)
            {
                bool include = false;
                bool dynamic = false;
                foreach (Attribute a in pd.Attributes)
                {
                    DynamicPropertyFilterAttribute dpf = a as DynamicPropertyFilterAttribute;
                    if (dpf != null)
                    {
                        dynamic = true;
                        PropertyDescriptor temp = pdc[dpf.PropertyName];
                        string[] values = dpf.ShowOn.Split(',');
                        string currentValue = temp.GetValue(this).ToString();
                        foreach (string avalue in values)
                        {
                            if (avalue.Trim()==currentValue)
                            {
                                include = true;
                                break;
                            }
                        }
                        break;
                    }
                }
                if (!dynamic || include)
                {
                    finalProps.Add(pd);
                }
            }
            return finalProps;
        }

selectedGridValue.GetType().ToString().Equals("System.Single")