public static bool IsInitiatingOperation(IServiceProvider serviceProvider, MethodInfo methodInfo)
{
if (serviceProvider == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceProvider");
}
if (methodInfo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("methodInfo");
}
bool isInitiating = true;
object[] operationContractAttribs = methodInfo.GetCustomAttributes(typeof(OperationContractAttribute), true);
Fx.Assert(operationContractAttribs != null, "returned attribs list cannot be null");
Fx.Assert(operationContractAttribs.Length > 0, "operation doesnt seem to be a valid operationcontract");
if (operationContractAttribs[0] is OperationContractAttribute)
{
OperationContractAttribute operationContractAttribute = operationContractAttribs[0] as OperationContractAttribute;
isInitiating = operationContractAttribute.IsInitiating;
}
if (operationContractAttribs[0] is AttributeInfoAttribute)
{
AttributeInfoAttribute attribInfoAttrib = operationContractAttribs[0] as AttributeInfoAttribute;
isInitiating = IsInitiatingOperationContract(serviceProvider, attribInfoAttrib.AttributeInfo);
}
return(isInitiating);
}
public static bool IsValidServiceOperation(MethodInfo methodInfo)
{
if (methodInfo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("methodInfo");
}
object[] operationContractAttribs = methodInfo.GetCustomAttributes(typeof(OperationContractAttribute), true);
if (operationContractAttribs != null && operationContractAttribs.Length > 0)
{
if (operationContractAttribs[0] is OperationContractAttribute)
{
return(true);
}
if (operationContractAttribs[0] is AttributeInfoAttribute)
{
AttributeInfoAttribute attribInfoAttrib = operationContractAttribs[0] as AttributeInfoAttribute;
if (typeof(OperationContractAttribute).IsAssignableFrom(attribInfoAttrib.AttributeInfo.AttributeType))
{
return(true);
}
}
}
return(false);
}
public static string GetOperationName(IServiceProvider serviceProvider, MethodInfo methodInfo)
{
Fx.Assert((methodInfo != null), " MethoInfo cannot be null");
string operationName = methodInfo.Name;
object[] operationContractAttribs = methodInfo.GetCustomAttributes(typeof(OperationContractAttribute), true);
if (operationContractAttribs != null && operationContractAttribs.Length > 0)
{
if (operationContractAttribs[0] is OperationContractAttribute)
{
OperationContractAttribute operationContractAttribute = operationContractAttribs[0] as OperationContractAttribute;
if (!String.IsNullOrEmpty(operationContractAttribute.Name))
{
operationName = operationContractAttribute.Name;
}
}
if (operationContractAttribs[0] is AttributeInfoAttribute)
{
AttributeInfoAttribute attribInfoAttrib = operationContractAttribs[0] as AttributeInfoAttribute;
string propertyName = "Name";
string namePropertyValue;
if (TryGetArgumentValueAs <string>(serviceProvider, attribInfoAttrib.AttributeInfo, propertyName, out namePropertyValue))
{
operationName = namePropertyValue;
}
}
}
return(operationName);
}
MethodInfo InternalGetMethodInfo(IServiceProvider provider, Type contractType)
{
MethodInfo methodInfo = null;
if (contractType != null && ServiceOperationHelpers.IsValidServiceContract(contractType))
{
foreach (MethodInfo currentMethodInfo in contractType.GetMethods())
{
object[] operationContractAttribs =
currentMethodInfo.GetCustomAttributes(typeof(OperationContractAttribute), true);
if (operationContractAttribs != null && operationContractAttribs.Length > 0)
{
string operationName = null;
if (operationContractAttribs[0] is OperationContractAttribute)
{
OperationContractAttribute operationContractAttribute =
operationContractAttribs[0] as OperationContractAttribute;
operationName = operationContractAttribute.Name;
}
if (operationContractAttribs[0] is AttributeInfoAttribute)
{
AttributeInfoAttribute attribInfoAttrib =
operationContractAttribs[0] as AttributeInfoAttribute;
operationName = GetAttributePropertyValue <string>(provider,
attribInfoAttrib.AttributeInfo,
"Name");
}
if (string.IsNullOrEmpty(operationName) &&
string.Compare(currentMethodInfo.Name, this.Name, StringComparison.Ordinal) == 0)
{
methodInfo = currentMethodInfo;
break;
}
else if (string.Compare(operationName, this.Name, StringComparison.Ordinal) == 0)
{
methodInfo = currentMethodInfo;
break;
}
}
}
}
if (methodInfo == null)
{
foreach (Type parentContract in contractType.GetInterfaces())
{
methodInfo = this.InternalGetMethodInfo(provider, parentContract);
if (methodInfo != null)
{
break;
}
}
}
return(methodInfo);
}
public static bool IsValidServiceContract(Type contractType)
{
if (contractType == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contractType");
}
object[] contractAttribs = contractType.GetCustomAttributes(typeof(ServiceContractAttribute), false);
if (contractAttribs != null && contractAttribs.Length > 0)
{
if (contractAttribs[0] is ServiceContractAttribute)
{
return(true);
}
if (contractAttribs[0] is AttributeInfoAttribute)
{
AttributeInfoAttribute attribInfoAttrib = contractAttribs[0] as AttributeInfoAttribute;
if (typeof(ServiceContractAttribute).IsAssignableFrom(attribInfoAttrib.AttributeInfo.AttributeType))
{
return(true);
}
}
}
return(false);
}
internal protected override bool GetIsOneWay(IServiceProvider provider)
{
MethodInfo methodInfo = this.GetMethodInfo(provider);
if (methodInfo != null)
{
object[] operationContractAttribs =
methodInfo.GetCustomAttributes(typeof(OperationContractAttribute), true);
if (operationContractAttribs != null && operationContractAttribs.Length > 0)
{
if (operationContractAttribs[0] is OperationContractAttribute)
{
return(((OperationContractAttribute)operationContractAttribs[0]).IsOneWay);
}
if (operationContractAttribs[0] is AttributeInfoAttribute)
{
AttributeInfoAttribute attribInfoAttrib = operationContractAttribs[0] as AttributeInfoAttribute;
return(GetAttributePropertyValue <bool>(provider,
attribInfoAttrib.AttributeInfo,
"IsOneWay"));
}
}
}
return(false);
}
public static TAttribute Find <TAttribute>(this IPersistentMemberInfo persistentMemberInfo) where TAttribute : Attribute
{
AttributeInfoAttribute firstOrDefault =
persistentMemberInfo.TypeAttributes.Select(info => info.Create()).FirstOrDefault(attributeInfo => attributeInfo.Constructor.DeclaringType == typeof(TAttribute));
if (firstOrDefault != null)
{
return((TAttribute)ReflectionHelper.CreateObject(firstOrDefault.Constructor.DeclaringType, firstOrDefault.InitializedArgumentValues));
}
return(null);
}
static string GetPropertiesCode(AttributeInfoAttribute attributeInfoAttribute)
{
if (attributeInfoAttribute.Instance == null)
{
return(null);
}
var typeInfo = XafTypesInfo.CastTypeToTypeInfo(attributeInfoAttribute.Instance.GetType());
var memberInfos = typeInfo.Members.Where(info => info.FindAttribute <AttributeInfoAttribute>() != null);
string Func(string current, IMemberInfo memberInfo) => current + (memberInfo.Name + "=" + GetArgumentCodeCore(memberInfo.GetValue(attributeInfoAttribute.Instance)) + ",");
return(memberInfos.Aggregate(null, (Func <string, IMemberInfo, string>)Func)?.TrimEnd(','));
}
static string GetPropertiesCode(AttributeInfoAttribute attributeInfoAttribute)
{
if (attributeInfoAttribute.Instance == null)
{
return(null);
}
var typeInfo = XafTypesInfo.CastTypeToTypeInfo(attributeInfoAttribute.Instance.GetType());
var memberInfos = typeInfo.Members.Where(info => info.FindAttribute <AttributeInfoAttribute>() != null);
Func <string, IMemberInfo, string> func = (current, memberInfo)
=> current + (memberInfo.Name + "=" + GetArgumentCodeCore(memberInfo.MemberType, memberInfo.GetValue(attributeInfoAttribute.Instance)) + ",");
string code = memberInfos.Aggregate(null, func).TrimEnd(',');
return(string.IsNullOrEmpty(code) ? null : string.Format(",{0}", code));
}
public static string GenerateCode(this IPersistentAttributeCreator persistentAttributeCreator)
{
AttributeInfoAttribute attributeInfoAttribute = persistentAttributeCreator.Create();
var argumentValues = attributeInfoAttribute.InitializedArgumentValues;
var attribute = (Attribute)ReflectionHelper.CreateObject(attributeInfoAttribute.Constructor.DeclaringType, argumentValues);
var args = argumentValues.Length > 0 ? string.Join(",", argumentValues.Select(GetArgumentCode)) : null;
string assemblyDecleration = null;
if (persistentAttributeCreator is IPersistentAssemblyAttributeInfo)
{
assemblyDecleration = "assembly: ";
if (persistentAttributeCreator is IPersistentAssemblyVersionAttributeInfo attributeInfo)
{
args = @"""" + attributeInfo.Owner.Version() + @"""";
}
}
string properties = GetPropertiesCode(attributeInfoAttribute);
args = (args != null && properties != null) ? args + ", " : args;
return($"[{assemblyDecleration}{attribute.GetType().FullName}({args}{properties})]");
}
public static string GenerateCode(IPersistentAttributeCreator persistentAttributeCreator)
{
AttributeInfoAttribute attributeInfoAttribute = persistentAttributeCreator.Create();
var attribute = (Attribute)ReflectionHelper.CreateObject(attributeInfoAttribute.Constructor.DeclaringType, attributeInfoAttribute.InitializedArgumentValues);
Func <object, object> argSelector = GetArgumentCode;
string args = attributeInfoAttribute.InitializedArgumentValues.Length > 0
? attributeInfoAttribute.InitializedArgumentValues.Select(argSelector).Aggregate
<object, string>(null, (current, o) => current + (o + ",")).TrimEnd(',')
: null;
string assemblyDecleration = null;
if (persistentAttributeCreator is IPersistentAssemblyAttributeInfo)
{
assemblyDecleration = "assembly: ";
if (persistentAttributeCreator is IPersistentAssemblyVersionAttributeInfo)
{
////args = CalculateVersion(args);
}
}
string properties = GetPropertiesCode(attributeInfoAttribute);
return(string.Format("[{0}{1}({2}{3})]", assemblyDecleration, attribute.GetType().FullName, args, properties));
}
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();
}
private static CustomProperty CreateCustomProperty(IServiceProvider serviceProvider, Type customActivityType, MemberInfo member, Type propertyType)
{
CustomProperty customProperty = new CustomProperty(serviceProvider);
customProperty.Name = member.Name;
customProperty.IsEvent = (member is EventInfo);
if (propertyType == typeof(ActivityBind))
{
customProperty.GenerateDependencyProperty = false;
customProperty.Type = typeof(ActivityBind).FullName;
}
else
{
string fieldSuffix = (customProperty.IsEvent) ? "Event" : "Property";
FieldInfo fieldInfo = customActivityType.GetField(member.Name + fieldSuffix, BindingFlags.Public | BindingFlags.Static);
if ((fieldInfo != null && fieldInfo.FieldType == typeof(DependencyProperty)))
{
customProperty.GenerateDependencyProperty = true;
}
else
{
customProperty.GenerateDependencyProperty = false;
}
customProperty.Type = propertyType.FullName;
}
customProperty.oldPropertyName = member.Name;
customProperty.oldPropertyType = propertyType.FullName;
object[] hiddenCodeAttributes = member.GetCustomAttributes(typeof(FlagsAttribute), true);
if (hiddenCodeAttributes != null && hiddenCodeAttributes.Length > 0)
{
customProperty.Hidden = true;
}
foreach (object attributeObj in member.GetCustomAttributes(false))
{
AttributeInfoAttribute attribute = attributeObj as AttributeInfoAttribute;
AttributeInfo attributeInfo = (attribute != null) ? attribute.AttributeInfo : null;
if (attributeInfo != null)
{
try
{
if (attributeInfo.AttributeType == typeof(BrowsableAttribute) && attributeInfo.ArgumentValues.Count > 0)
{
customProperty.Browseable = (bool)attributeInfo.GetArgumentValueAs(serviceProvider, 0, typeof(bool));
}
else if (attributeInfo.AttributeType == typeof(CategoryAttribute) && attributeInfo.ArgumentValues.Count > 0)
{
customProperty.Category = attributeInfo.GetArgumentValueAs(serviceProvider, 0, typeof(string)) as string;
}
else if (attributeInfo.AttributeType == typeof(DescriptionAttribute) && attributeInfo.ArgumentValues.Count > 0)
{
customProperty.Description = attributeInfo.GetArgumentValueAs(serviceProvider, 0, typeof(string)) as string;
}
else if (attributeInfo.AttributeType == typeof(DesignerSerializationVisibilityAttribute) && attributeInfo.ArgumentValues.Count > 0)
{
customProperty.DesignerSerializationVisibility = (DesignerSerializationVisibility)attributeInfo.GetArgumentValueAs(serviceProvider, 0, typeof(DesignerSerializationVisibility));
}
else if (attributeInfo.AttributeType == typeof(EditorAttribute) && attributeInfo.ArgumentValues.Count > 1)
{
Type editorType = attributeInfo.GetArgumentValueAs(serviceProvider, 1, typeof(Type)) as Type;
if (editorType == typeof(UITypeEditor))
{
Type uiTypeEditorType = attributeInfo.GetArgumentValueAs(serviceProvider, 0, typeof(Type)) as Type;
if (uiTypeEditorType != null)
{
customProperty.UITypeEditor = uiTypeEditorType.FullName;
}
if (String.IsNullOrEmpty(customProperty.UITypeEditor))
{
customProperty.UITypeEditor = attributeInfo.GetArgumentValueAs(serviceProvider, 0, typeof(string)) as string;
}
}
}
}
catch
{
// Catch and ignore all attribute value conversion errors
}
}
}
return(customProperty);
}
private static CustomProperty CreateCustomProperty(IServiceProvider serviceProvider, System.Type customActivityType, MemberInfo member, System.Type propertyType)
{
CustomProperty property = new CustomProperty(serviceProvider)
{
Name = member.Name,
IsEvent = member is EventInfo
};
if (propertyType == typeof(ActivityBind))
{
property.GenerateDependencyProperty = false;
property.Type = typeof(ActivityBind).FullName;
}
else
{
FieldInfo field = customActivityType.GetField(member.Name + (property.IsEvent ? "Event" : "Property"), BindingFlags.Public | BindingFlags.Static);
if ((field != null) && (field.FieldType == typeof(DependencyProperty)))
{
property.GenerateDependencyProperty = true;
}
else
{
property.GenerateDependencyProperty = false;
}
property.Type = propertyType.FullName;
}
property.oldPropertyName = member.Name;
property.oldPropertyType = propertyType.FullName;
object[] customAttributes = member.GetCustomAttributes(typeof(FlagsAttribute), true);
if ((customAttributes != null) && (customAttributes.Length > 0))
{
property.Hidden = true;
}
foreach (object obj2 in member.GetCustomAttributes(false))
{
AttributeInfoAttribute attribute = obj2 as AttributeInfoAttribute;
AttributeInfo info2 = (attribute != null) ? attribute.AttributeInfo : null;
if (info2 != null)
{
try
{
if ((info2.AttributeType == typeof(BrowsableAttribute)) && (info2.ArgumentValues.Count > 0))
{
property.Browseable = (bool)info2.GetArgumentValueAs(serviceProvider, 0, typeof(bool));
}
else if ((info2.AttributeType == typeof(CategoryAttribute)) && (info2.ArgumentValues.Count > 0))
{
property.Category = info2.GetArgumentValueAs(serviceProvider, 0, typeof(string)) as string;
}
else if ((info2.AttributeType == typeof(DescriptionAttribute)) && (info2.ArgumentValues.Count > 0))
{
property.Description = info2.GetArgumentValueAs(serviceProvider, 0, typeof(string)) as string;
}
else if ((info2.AttributeType == typeof(DesignerSerializationVisibilityAttribute)) && (info2.ArgumentValues.Count > 0))
{
property.DesignerSerializationVisibility = (DesignerSerializationVisibility)info2.GetArgumentValueAs(serviceProvider, 0, typeof(DesignerSerializationVisibility));
}
else if ((info2.AttributeType == typeof(EditorAttribute)) && (info2.ArgumentValues.Count > 1))
{
System.Type type = info2.GetArgumentValueAs(serviceProvider, 1, typeof(System.Type)) as System.Type;
if (type == typeof(UITypeEditor))
{
System.Type type2 = info2.GetArgumentValueAs(serviceProvider, 0, typeof(System.Type)) as System.Type;
if (type2 != null)
{
property.UITypeEditor = type2.FullName;
}
if (string.IsNullOrEmpty(property.UITypeEditor))
{
property.UITypeEditor = info2.GetArgumentValueAs(serviceProvider, 0, typeof(string)) as string;
}
}
}
}
catch
{
}
}
}
return(property);
}
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());
}
