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());
}