public override void SetValue(object component, object value)
        {
            Activity activity = component as Activity;

            if (activity != null)
            {
                IIdentifierCreationService service = activity.Site.GetService(typeof(IIdentifierCreationService)) as IIdentifierCreationService;
                if (service == null)
                {
                    throw new Exception(SR.GetString("General_MissingService", new object[] { typeof(IIdentifierCreationService).FullName }));
                }
                string identifier = value as string;
                service.ValidateIdentifier(activity, identifier);
                bool ignoreCase      = CompilerHelpers.GetSupportedLanguage(activity.Site) == SupportedLanguages.VB;
                Type dataSourceClass = Helpers.GetDataSourceClass(Helpers.GetRootActivity(activity), activity.Site);
                if ((dataSourceClass != null) && (ActivityBindPropertyDescriptor.FindMatchingMember(identifier, dataSourceClass, ignoreCase) != null))
                {
                    throw new ArgumentException(SR.GetString("Error_ActivityNameExist", new object[] { identifier }));
                }
                IMemberCreationService service2 = activity.Site.GetService(typeof(IMemberCreationService)) as IMemberCreationService;
                if (service2 == null)
                {
                    throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(IMemberCreationService).FullName }));
                }
                IDesignerHost host = activity.Site.GetService(typeof(IDesignerHost)) as IDesignerHost;
                if (host == null)
                {
                    throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(IDesignerHost).FullName }));
                }
                string newClassName = identifier;
                int    num          = host.RootComponentClassName.LastIndexOf('.');
                if (num > 0)
                {
                    newClassName = host.RootComponentClassName.Substring(0, num + 1) + identifier;
                }
                service2.UpdateTypeName(((Activity)host.RootComponent).GetValue(WorkflowMarkupSerializer.XClassProperty) as string, newClassName);
                ((Activity)host.RootComponent).SetValue(WorkflowMarkupSerializer.XClassProperty, newClassName);
                base.SetValue(component, value);
                DesignerHelpers.UpdateSiteName((Activity)host.RootComponent, identifier);
            }
        }
 internal static IList<MemberInfo> GetBindableMembers(object obj, ITypeDescriptorContext context)
 {
     List<MemberInfo> list = new List<MemberInfo>();
     IDesignerHost service = context.GetService(typeof(IDesignerHost)) as IDesignerHost;
     Activity activity = (service != null) ? (service.RootComponent as Activity) : null;
     Type type = (obj == activity) ? Helpers.GetDataSourceClass(activity, context) : obj.GetType();
     Type toType = PropertyDescriptorUtils.GetBaseType(context.PropertyDescriptor, context.Instance, context);
     if ((type != null) && (toType != null))
     {
         DependencyProperty property = DependencyProperty.FromName(context.PropertyDescriptor.Name, context.PropertyDescriptor.ComponentType);
         bool flag = (property != null) && property.IsEvent;
         BindingFlags bindingAttr = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
         if (obj == activity)
         {
             bindingAttr |= BindingFlags.NonPublic;
         }
         foreach (MemberInfo info in type.GetMembers(bindingAttr))
         {
             object[] customAttributes = info.GetCustomAttributes(typeof(DebuggerNonUserCodeAttribute), false);
             if (((customAttributes == null) || (customAttributes.Length <= 0)) || !(customAttributes[0] is DebuggerNonUserCodeAttribute))
             {
                 object[] objArray2 = info.GetCustomAttributes(typeof(BrowsableAttribute), false);
                 if (objArray2.Length > 0)
                 {
                     bool browsable = false;
                     BrowsableAttribute attribute = objArray2[0] as BrowsableAttribute;
                     if (attribute != null)
                     {
                         browsable = attribute.Browsable;
                     }
                     else
                     {
                         try
                         {
                             AttributeInfoAttribute attribute2 = objArray2[0] as AttributeInfoAttribute;
                             if ((attribute2 != null) && (attribute2.AttributeInfo.ArgumentValues.Count > 0))
                             {
                                 browsable = (bool) attribute2.AttributeInfo.GetArgumentValueAs(context, 0, typeof(bool));
                             }
                         }
                         catch
                         {
                         }
                     }
                     if (!browsable)
                     {
                         continue;
                     }
                 }
                 if ((info.DeclaringType != typeof(object)) || (!string.Equals(info.Name, "Equals", StringComparison.Ordinal) && !string.Equals(info.Name, "ReferenceEquals", StringComparison.Ordinal)))
                 {
                     bool flag3 = false;
                     bool flag4 = false;
                     bool isAssembly = false;
                     if (flag && (info is EventInfo))
                     {
                         EventInfo info2 = info as EventInfo;
                         MethodInfo addMethod = info2.GetAddMethod();
                         MethodInfo removeMethod = info2.GetRemoveMethod();
                         flag4 = ((((addMethod != null) && addMethod.IsFamily) || ((removeMethod != null) && removeMethod.IsFamily)) || ((addMethod != null) && addMethod.IsPublic)) || ((removeMethod != null) && removeMethod.IsPublic);
                         isAssembly = ((addMethod != null) && addMethod.IsAssembly) || ((removeMethod != null) && removeMethod.IsAssembly);
                         flag3 = TypeProvider.IsAssignable(toType, info2.EventHandlerType);
                     }
                     else if (info is FieldInfo)
                     {
                         FieldInfo info5 = info as FieldInfo;
                         flag4 = info5.IsFamily || info5.IsPublic;
                         isAssembly = info5.IsAssembly;
                         flag3 = TypeProvider.IsAssignable(toType, info5.FieldType);
                     }
                     else if (info is PropertyInfo)
                     {
                         PropertyInfo info6 = info as PropertyInfo;
                         MethodInfo getMethod = info6.GetGetMethod();
                         MethodInfo setMethod = info6.GetSetMethod();
                         flag4 = ((((getMethod != null) && getMethod.IsFamily) || ((setMethod != null) && setMethod.IsFamily)) || ((getMethod != null) && getMethod.IsPublic)) || ((setMethod != null) && setMethod.IsPublic);
                         isAssembly = ((getMethod != null) && getMethod.IsAssembly) || ((setMethod != null) && setMethod.IsAssembly);
                         flag3 = (getMethod != null) && TypeProvider.IsAssignable(toType, info6.PropertyType);
                     }
                     if (((info.DeclaringType != type) && !flag4) && ((info.DeclaringType.Assembly != null) || !isAssembly))
                     {
                         flag3 = false;
                     }
                     if (flag3)
                     {
                         list.Add(info);
                     }
                 }
             }
         }
     }
     return list.AsReadOnly();
 }
 internal static bool CreateField(ITypeDescriptorContext context, ActivityBind activityBind, bool throwOnError)
 {
     if (!string.IsNullOrEmpty(activityBind.Path))
     {
         Type toType = PropertyDescriptorUtils.GetBaseType(context.PropertyDescriptor, context.Instance, context);
         Activity component = PropertyDescriptorUtils.GetComponent(context) as Activity;
         if ((component != null) && (toType != null))
         {
             component = Helpers.ParseActivityForBind(component, activityBind.Name);
             if (component == Helpers.GetRootActivity(component))
             {
                 bool ignoreCase = CompilerHelpers.GetSupportedLanguage(context) == SupportedLanguages.VB;
                 Type dataSourceClass = Helpers.GetDataSourceClass(component, context);
                 if (dataSourceClass != null)
                 {
                     string path = activityBind.Path;
                     int length = path.IndexOfAny(new char[] { '.', '/', '[' });
                     if (length != -1)
                     {
                         path = path.Substring(0, length);
                     }
                     MemberInfo info = FindMatchingMember(path, dataSourceClass, ignoreCase);
                     if (info != null)
                     {
                         Type fromType = null;
                         bool isPrivate = false;
                         if (info is FieldInfo)
                         {
                             isPrivate = ((FieldInfo) info).IsPrivate;
                             fromType = ((FieldInfo) info).FieldType;
                         }
                         else if (info is PropertyInfo)
                         {
                             MethodInfo getMethod = ((PropertyInfo) info).GetGetMethod();
                             MethodInfo setMethod = ((PropertyInfo) info).GetSetMethod();
                             isPrivate = ((getMethod != null) && getMethod.IsPrivate) || ((setMethod != null) && setMethod.IsPrivate);
                         }
                         else if (info is MethodInfo)
                         {
                             isPrivate = ((MethodInfo) info).IsPrivate;
                         }
                         if (length != -1)
                         {
                             PathWalker walker = new PathWalker();
                             PathMemberInfoEventArgs finalEventArgs = null;
                             walker.MemberFound = (EventHandler<PathMemberInfoEventArgs>) Delegate.Combine(walker.MemberFound, delegate (object sender, PathMemberInfoEventArgs eventArgs) {
                                 finalEventArgs = eventArgs;
                             });
                             if (!walker.TryWalkPropertyPath(dataSourceClass, activityBind.Path))
                             {
                                 if (throwOnError)
                                 {
                                     throw new InvalidOperationException(SR.GetString("Error_MemberWithSameNameExists", new object[] { activityBind.Path, dataSourceClass.FullName }));
                                 }
                                 return false;
                             }
                             fromType = BindHelpers.GetMemberType(finalEventArgs.MemberInfo);
                         }
                         if (((info.DeclaringType == dataSourceClass) || !isPrivate) && ((info is FieldInfo) && TypeProvider.IsAssignable(toType, fromType)))
                         {
                             return true;
                         }
                         if (throwOnError)
                         {
                             throw new InvalidOperationException(SR.GetString("Error_MemberWithSameNameExists", new object[] { activityBind.Path, dataSourceClass.FullName }));
                         }
                         return false;
                     }
                     Activity activity2 = null;
                     if (string.Compare(component.Name, path, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) == 0)
                     {
                         activity2 = component;
                     }
                     else if ((component is CompositeActivity) && (component is CompositeActivity))
                     {
                         foreach (Activity activity3 in Helpers.GetAllNestedActivities(component as CompositeActivity))
                         {
                             if (string.Compare(activity3.Name, path, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) == 0)
                             {
                                 activity2 = activity3;
                             }
                         }
                     }
                     if (activity2 != null)
                     {
                         if (TypeProvider.IsAssignable(toType, activity2.GetType()))
                         {
                             return true;
                         }
                         if (throwOnError)
                         {
                             throw new InvalidOperationException(SR.GetString("Error_MemberWithSameNameExists", new object[] { activityBind.Path, dataSourceClass.FullName }));
                         }
                         return false;
                     }
                     IMemberCreationService service = context.GetService(typeof(IMemberCreationService)) as IMemberCreationService;
                     if (service != null)
                     {
                         IDesignerHost host = context.GetService(typeof(IDesignerHost)) as IDesignerHost;
                         if (host != null)
                         {
                             service.CreateField(host.RootComponentClassName, activityBind.Path, toType, null, MemberAttributes.Public, null, false);
                             return true;
                         }
                         if (throwOnError)
                         {
                             throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(IDesignerHost).FullName }));
                         }
                     }
                     else if (throwOnError)
                     {
                         throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(IMemberCreationService).FullName }));
                     }
                 }
             }
         }
         else
         {
             if ((component == null) && throwOnError)
             {
                 throw new InvalidOperationException(SR.GetString("Error_InvalidActivityIdentifier", new object[] { activityBind.Name }));
             }
             if ((toType == null) && throwOnError)
             {
                 throw new InvalidOperationException(SR.GetString("Error_PropertyTypeNotDefined", new object[] { context.PropertyDescriptor.Name, typeof(ActivityBind).Name, typeof(IDynamicPropertyTypeProvider).Name }));
             }
         }
     }
     return false;
 }
        internal static string CreateUniqueMethodName(IComponent component, string propName, System.Type delegateType)
        {
            IServiceProvider serviceProvider = component.Site;

            if (serviceProvider == null)
            {
                throw new ArgumentException("component");
            }
            IDesignerHost host = serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;

            if (host == null)
            {
                throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(IDesignerHost).FullName }));
            }
            if (((ITypeProvider)serviceProvider.GetService(typeof(ITypeProvider))) == null)
            {
                throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
            }
            string            name    = null;
            IReferenceService service = serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;

            if (service != null)
            {
                name = service.GetName(component);
            }
            else
            {
                ISite site = component.Site;
                if (site != null)
                {
                    name = site.Name;
                }
            }
            if (name == null)
            {
                name = component.GetType().Name;
            }
            name = (name.Replace('.', '_').Replace('/', '_') + "_" + propName).Replace('(', '_').Replace(')', '_').Replace(" ", "");
            DelegateTypeInfo info          = new DelegateTypeInfo(delegateType);
            Activity         rootComponent = host.RootComponent as Activity;

            if (rootComponent == null)
            {
                Activity activity2 = component as Activity;
                throw new InvalidOperationException(SR.GetString("Error_CantCreateMethod", new object[] { (activity2 != null) ? activity2.QualifiedName : string.Empty }));
            }
            System.Type dataSourceClass = Helpers.GetDataSourceClass(rootComponent, serviceProvider);
            if (dataSourceClass == null)
            {
                throw new InvalidOperationException(SR.GetString("Error_CantCreateMethod", new object[] { rootComponent.QualifiedName }));
            }
            BindingFlags bindingAttr = BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;

            MethodInfo[] methods = dataSourceClass.GetMethods(bindingAttr);
            ArrayList    list    = new ArrayList();

            foreach (MethodInfo info2 in methods)
            {
                if (info2.GetParameters().Length != info.Parameters.Length)
                {
                    continue;
                }
                bool flag = true;
                for (int i = 0; i < info.Parameters.Length; i++)
                {
                    ParameterInfo info3 = info2.GetParameters()[i];
                    CodeParameterDeclarationExpression expression = info.Parameters[i];
                    FieldDirection direction = expression.Direction;
                    if ((((direction == FieldDirection.In) && !info3.IsIn) || ((direction == FieldDirection.Out) && !info3.IsOut)) || (((direction == FieldDirection.Ref) && (!info3.IsIn || !info3.IsOut)) || !Helpers.TypesEqual(expression.Type, info3.ParameterType)))
                    {
                        flag = false;
                        break;
                    }
                }
                if (flag)
                {
                    list.Add(info2.Name);
                }
            }
            int    num2  = 0;
            bool   flag2 = true;
            string strB  = name;

            MemberInfo[] members = dataSourceClass.GetMembers();
            while (flag2 && (num2 < 0x7fffffff))
            {
                flag2 = false;
                foreach (string str3 in list)
                {
                    if (string.Compare(str3, strB, StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        flag2 = true;
                        break;
                    }
                }
                if (!flag2)
                {
                    foreach (MemberInfo info4 in members)
                    {
                        if (!(info4 is MethodInfo) && (string.Compare(info4.Name, strB, StringComparison.OrdinalIgnoreCase) == 0))
                        {
                            flag2 = true;
                            break;
                        }
                    }
                }
                if (!flag2)
                {
                    MethodInfo info5 = host.RootComponent.GetType().GetMethod(strB, bindingAttr, null, info.ParameterTypes, null);
                    if ((info5 != null) && !info5.IsPrivate)
                    {
                        flag2 = true;
                    }
                }
                if (flag2)
                {
                    strB = name + "_" + ++num2.ToString(CultureInfo.InvariantCulture);
                }
            }
            return(strB);
        }
        public override void SetValue(object component, object value)
        {
            Activity activity = component as Activity;

            if (activity != null)
            {
                // validate the identifier
                IIdentifierCreationService identifierCreationService = activity.Site.GetService(typeof(IIdentifierCreationService)) as IIdentifierCreationService;
                if (identifierCreationService == null)
                {
                    throw new Exception(SR.GetString(SR.General_MissingService, typeof(IIdentifierCreationService).FullName));
                }

                string name = value as string;
                identifierCreationService.ValidateIdentifier(activity, name);

                bool isVB         = (CompilerHelpers.GetSupportedLanguage(activity.Site) == SupportedLanguages.VB);
                Type designedType = Helpers.GetDataSourceClass(Helpers.GetRootActivity(activity), activity.Site);
                if (designedType != null)
                {
                    MemberInfo matchingMember = ActivityBindPropertyDescriptor.FindMatchingMember(name, designedType, isVB);
                    if (matchingMember != null)
                    {
                        throw new ArgumentException(SR.GetString(SR.Error_ActivityNameExist, name));
                    }
                }
                IMemberCreationService memberCreationService = activity.Site.GetService(typeof(IMemberCreationService)) as IMemberCreationService;
                if (memberCreationService == null)
                {
                    throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(IMemberCreationService).FullName));
                }

                IDesignerHost host = activity.Site.GetService(typeof(IDesignerHost)) as IDesignerHost;
                if (host == null)
                {
                    throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(IDesignerHost).FullName));
                }

                // We need to update the activityType's name before trying to update the type because
                // updating the type causes a flush, which access the custom activity's properties, and
                // doing so requires the new type name
                string newClassName = name;
                int    indexOfDot   = host.RootComponentClassName.LastIndexOf('.');
                if (indexOfDot > 0)
                {
                    newClassName = host.RootComponentClassName.Substring(0, indexOfDot + 1) + name;
                }

                // IMPORTANT: You must update the class name in code before renaming the site, since
                // VS's OnComponentRename updates the RootComponentClassName, so the flush code called
                // in our OnComponentRename tries to access the new class for information.
                memberCreationService.UpdateTypeName(((Activity)host.RootComponent).GetValue(WorkflowMarkupSerializer.XClassProperty) as string, newClassName);

                //((Activity)host.RootComponent).Name = name;
                ((Activity)host.RootComponent).SetValue(WorkflowMarkupSerializer.XClassProperty, newClassName);
                base.SetValue(component, value);

                // Update the site name so the component name shows up correctly in the designer
                DesignerHelpers.UpdateSiteName((Activity)host.RootComponent, name);
            }
        }
        internal static bool CreateField(ITypeDescriptorContext context, ActivityBind activityBind, bool throwOnError)
        {
            //Check if the activity is root activity and has valid design time type
            if (!String.IsNullOrEmpty(activityBind.Path))
            {
                Type     boundType = PropertyDescriptorUtils.GetBaseType(context.PropertyDescriptor, context.Instance, context);
                Activity activity  = PropertyDescriptorUtils.GetComponent(context) as Activity;
                if (activity != null && boundType != null)
                {
                    activity = Helpers.ParseActivityForBind(activity, activityBind.Name);
                    if (activity == Helpers.GetRootActivity(activity))
                    {
                        bool isVB         = (CompilerHelpers.GetSupportedLanguage(context) == SupportedLanguages.VB);
                        Type designedType = Helpers.GetDataSourceClass(activity, context);
                        if (designedType != null)
                        {
                            //field path could be nested too.
                            //need to find field only with the name up to the first dot (CimplexTypeField in the example below)
                            //and the right type (that would be tricky if the field doesnt exist yet)
                            //example: CimplexTypeField.myIDictionary_int_string[10].someOtherGood2

                            string fieldName  = activityBind.Path;
                            int    indexOfDot = fieldName.IndexOfAny(new char[] { '.', '/', '[' });
                            if (indexOfDot != -1)
                            {
                                fieldName = fieldName.Substring(0, indexOfDot); //path is a nested field access
                            }
                            MemberInfo matchingMember = ActivityBindPropertyDescriptor.FindMatchingMember(fieldName, designedType, isVB);
                            if (matchingMember != null)
                            {
                                Type memberType = null;
                                bool isPrivate  = false;
                                if (matchingMember is FieldInfo)
                                {
                                    isPrivate  = ((FieldInfo)matchingMember).IsPrivate;
                                    memberType = ((FieldInfo)matchingMember).FieldType;
                                }
                                else if (matchingMember is PropertyInfo)
                                {
                                    MethodInfo getMethod = ((PropertyInfo)matchingMember).GetGetMethod();
                                    MethodInfo setMethod = ((PropertyInfo)matchingMember).GetSetMethod();
                                    isPrivate = ((getMethod != null && getMethod.IsPrivate) || (setMethod != null && setMethod.IsPrivate));
                                }
                                else if (matchingMember is MethodInfo)
                                {
                                    isPrivate = ((MethodInfo)matchingMember).IsPrivate;
                                }

                                if (indexOfDot != -1)
                                { //need to find the type of the member the path references (and if the path is valid at all)
                                    PathWalker pathWalker = new PathWalker();
                                    PathMemberInfoEventArgs finalEventArgs = null;
                                    pathWalker.MemberFound += delegate(object sender, PathMemberInfoEventArgs eventArgs)
                                    { finalEventArgs = eventArgs; };

                                    if (pathWalker.TryWalkPropertyPath(designedType, activityBind.Path))
                                    {
                                        //successfully walked the entire path
                                        memberType = BindHelpers.GetMemberType(finalEventArgs.MemberInfo);
                                    }
                                    else
                                    {
                                        //the path is invalid
                                        if (throwOnError)
                                        {
                                            throw new InvalidOperationException(SR.GetString(SR.Error_MemberWithSameNameExists, activityBind.Path, designedType.FullName));
                                        }

                                        return(false);
                                    }
                                }

                                if ((matchingMember.DeclaringType == designedType || !isPrivate) &&
                                    matchingMember is FieldInfo &&
                                    TypeProvider.IsAssignable(boundType, memberType))
                                {
                                    return(true);
                                }
                                else
                                {
                                    if (throwOnError)
                                    {
                                        throw new InvalidOperationException(SR.GetString(SR.Error_MemberWithSameNameExists, activityBind.Path, designedType.FullName));
                                    }
                                    return(false);
                                }
                            }
                            else
                            {
                                // Find out if the name conflicts with an existing activity that has not be flushed in to the
                                // code beside.  An activity bind can bind to this field only if the type of the property
                                // is the assignable from the activity type.
                                Activity matchingActivity = null;
                                if (string.Compare(activity.Name, fieldName, isVB ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) == 0)
                                {
                                    matchingActivity = activity;
                                }
                                else if (activity is CompositeActivity)
                                {
                                    if (activity is CompositeActivity)
                                    {
                                        foreach (Activity existingActivity in Helpers.GetAllNestedActivities(activity as CompositeActivity))
                                        {
                                            if (string.Compare(existingActivity.Name, fieldName, isVB ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) == 0)
                                            {
                                                matchingActivity = existingActivity;
                                            }
                                        }
                                    }
                                }

                                if (matchingActivity != null)
                                {
                                    if (TypeProvider.IsAssignable(boundType, matchingActivity.GetType()))
                                    {
                                        return(true);
                                    }
                                    else
                                    {
                                        if (throwOnError)
                                        {
                                            throw new InvalidOperationException(SR.GetString(SR.Error_MemberWithSameNameExists, activityBind.Path, designedType.FullName));
                                        }
                                        return(false);
                                    }
                                }
                            }

                            IMemberCreationService memberCreationService = context.GetService(typeof(IMemberCreationService)) as IMemberCreationService;
                            if (memberCreationService == null)
                            {
                                if (throwOnError)
                                {
                                    throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(IMemberCreationService).FullName));
                                }
                            }
                            else
                            {
                                IDesignerHost designerHost = context.GetService(typeof(IDesignerHost)) as IDesignerHost;
                                if (designerHost == null)
                                {
                                    if (throwOnError)
                                    {
                                        throw new InvalidOperationException(SR.GetString("General_MissingService", typeof(IDesignerHost).FullName));
                                    }
                                }
                                else
                                {
                                    memberCreationService.CreateField(designerHost.RootComponentClassName, activityBind.Path, boundType, null, MemberAttributes.Public, null, false);
                                    return(true);
                                }
                            }
                        }
                    }
                }
                else
                {
                    if (activity == null && throwOnError)
                    {
                        throw new InvalidOperationException(SR.GetString(SR.Error_InvalidActivityIdentifier, activityBind.Name));
                    }

                    if (boundType == null && throwOnError)
                    {
                        throw new InvalidOperationException(SR.GetString(SR.Error_PropertyTypeNotDefined, context.PropertyDescriptor.Name, typeof(ActivityBind).Name, typeof(IDynamicPropertyTypeProvider).Name));
                    }
                }
            }

            return(false);
        }
        internal static IList <MemberInfo> GetBindableMembers(object obj, ITypeDescriptorContext context)
        {
            List <MemberInfo> memberInfos = new List <MemberInfo>();

            IDesignerHost designerHost = context.GetService(typeof(IDesignerHost)) as IDesignerHost;
            Activity      rootActivity = (designerHost != null) ? designerHost.RootComponent as Activity : null;
            Type          objectType   = (obj == rootActivity) ? Helpers.GetDataSourceClass(rootActivity, context) : obj.GetType();

            Type memberType = PropertyDescriptorUtils.GetBaseType(context.PropertyDescriptor, context.Instance, context);

            if (objectType != null && memberType != null)
            {
                DependencyProperty dependencyProperty = DependencyProperty.FromName(context.PropertyDescriptor.Name, context.PropertyDescriptor.ComponentType);
                bool includeEvents = (dependencyProperty != null && dependencyProperty.IsEvent);

                BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.FlattenHierarchy;
                if (obj == rootActivity)
                {
                    bindingFlags |= BindingFlags.NonPublic;
                }

                foreach (MemberInfo memberInfo in objectType.GetMembers(bindingFlags))
                {
                    //filter our methods with System.Diagnostics.DebuggerNonUserCodeAttribute
                    object[] nonUserCodeAttributes = memberInfo.GetCustomAttributes(typeof(System.Diagnostics.DebuggerNonUserCodeAttribute), false);
                    if (nonUserCodeAttributes != null && nonUserCodeAttributes.Length > 0 && nonUserCodeAttributes[0] is System.Diagnostics.DebuggerNonUserCodeAttribute)
                    {
                        continue;
                    }

                    object[] browsableAttributes = memberInfo.GetCustomAttributes(typeof(BrowsableAttribute), false);
                    if (browsableAttributes.Length > 0)
                    {
                        bool browsable = false;

                        BrowsableAttribute browsableAttribute = browsableAttributes[0] as BrowsableAttribute;
                        if (browsableAttribute != null)
                        {
                            browsable = browsableAttribute.Browsable;
                        }
                        else
                        {
                            try
                            {
                                AttributeInfoAttribute attributeInfoAttribute = browsableAttributes[0] as AttributeInfoAttribute;
                                if (attributeInfoAttribute != null && attributeInfoAttribute.AttributeInfo.ArgumentValues.Count > 0)
                                {
                                    browsable = (bool)attributeInfoAttribute.AttributeInfo.GetArgumentValueAs(context, 0, typeof(bool));
                                }
                            }
                            catch
                            {
                            }
                        }

                        if (!browsable)
                        {
                            continue;
                        }
                    }

                    if (memberInfo.DeclaringType == typeof(System.Object) && (string.Equals(memberInfo.Name, "Equals", StringComparison.Ordinal) || string.Equals(memberInfo.Name, "ReferenceEquals", StringComparison.Ordinal)))
                    {
                        continue;
                    }

                    bool addMember = false;
                    bool isProtectedOrPublicMember = false;
                    bool isInternalMember          = false;
                    if (includeEvents && memberInfo is EventInfo)
                    {
                        EventInfo eventInfo = memberInfo as EventInfo;

                        MethodInfo addAccessor    = eventInfo.GetAddMethod();
                        MethodInfo removeAccessor = eventInfo.GetRemoveMethod();

                        isProtectedOrPublicMember = ((addAccessor != null && addAccessor.IsFamily) || (removeAccessor != null && removeAccessor.IsFamily) ||
                                                     (addAccessor != null && addAccessor.IsPublic) || (removeAccessor != null && removeAccessor.IsPublic));
                        isInternalMember = ((addAccessor != null && addAccessor.IsAssembly) || (removeAccessor != null && removeAccessor.IsAssembly));

                        addMember = TypeProvider.IsAssignable(memberType, eventInfo.EventHandlerType);
                    }
                    else if (memberInfo is FieldInfo)
                    {
                        FieldInfo fieldInfo = memberInfo as FieldInfo;
                        isProtectedOrPublicMember = (fieldInfo.IsFamily || fieldInfo.IsPublic);
                        isInternalMember          = fieldInfo.IsAssembly;
                        addMember = TypeProvider.IsAssignable(memberType, fieldInfo.FieldType);
                    }
                    else if (memberInfo is PropertyInfo)
                    {
                        PropertyInfo propertyInfo = memberInfo as PropertyInfo;

                        MethodInfo getAccessor = propertyInfo.GetGetMethod();
                        MethodInfo setAccessor = propertyInfo.GetSetMethod();

                        isProtectedOrPublicMember = ((getAccessor != null && getAccessor.IsFamily) || (setAccessor != null && setAccessor.IsFamily) ||
                                                     (getAccessor != null && getAccessor.IsPublic) || (setAccessor != null && setAccessor.IsPublic));
                        isInternalMember = ((getAccessor != null && getAccessor.IsAssembly) || (setAccessor != null && setAccessor.IsAssembly));
                        addMember        = (getAccessor != null && TypeProvider.IsAssignable(memberType, propertyInfo.PropertyType));
                    }

                    //We only want to allow binding to protected, public and internal members of baseType
                    if (memberInfo.DeclaringType != objectType && !isProtectedOrPublicMember && !(memberInfo.DeclaringType.Assembly == null && isInternalMember))
                    {
                        addMember = false;
                    }

                    if (addMember)
                    {
                        memberInfos.Add(memberInfo);
                    }
                }
            }

            return(memberInfos.AsReadOnly());
        }