public static bool IsPropertyWritable(ITypeResolver typeResolver, IProperty propertyKey, bool allowProtectedProperties)
{
MemberAccessTypes allowableMemberAccess = TypeHelper.GetAllowableMemberAccess(typeResolver, propertyKey.DeclaringType);
if (allowProtectedProperties && !propertyKey.IsAttachable || typeResolver.IsCapabilitySet(PlatformCapability.WorkaroundSL12782) && typeResolver.PlatformMetadata.KnownTypes.UserControl.IsAssignableFrom(propertyKey.DeclaringTypeId) && propertyKey.Equals((object)propertyKey.DeclaringType.Metadata.DefaultContentProperty))
{
allowableMemberAccess |= MemberAccessTypes.Protected;
}
MemberAccessType writeAccess = propertyKey.WriteAccess;
return(TypeHelper.IsSet(allowableMemberAccess, writeAccess));
}
public static DependencyPropertyReferenceStep GetReferenceStep(ITypeResolver typeResolver, Type targetType, object dependencyProperty, Type declaringType, string propertyName, Microsoft.Expression.DesignModel.Metadata.MemberType memberTypes)
{
if (typeof(IDesignTimePropertyImplementor).IsAssignableFrom(declaringType))
{
IPropertyId propertyId = DesignTimeProperties.FromName(propertyName, (Microsoft.Expression.DesignModel.Metadata.PlatformTypes)typeResolver.PlatformMetadata, null);
return(propertyId as DependencyPropertyReferenceStep);
}
Microsoft.Expression.DesignModel.Metadata.PlatformTypes platformMetadata = (Microsoft.Expression.DesignModel.Metadata.PlatformTypes)typeResolver.PlatformMetadata;
DependencyPropertyReferenceStep property = platformMetadata.GetProperty(typeResolver, targetType, memberTypes, propertyName) as DependencyPropertyReferenceStep;
if (property != null && property.DependencyProperty == dependencyProperty)
{
return(property);
}
if (!declaringType.IsAssignableFrom(targetType))
{
if (TypeHelper.IsSet(memberTypes, Microsoft.Expression.DesignModel.Metadata.MemberType.AttachedProperty))
{
DependencyPropertyReferenceStep dependencyPropertyReferenceStep = platformMetadata.GetProperty(typeResolver, declaringType, Microsoft.Expression.DesignModel.Metadata.MemberType.AttachedProperty, propertyName) as DependencyPropertyReferenceStep;
property = dependencyPropertyReferenceStep;
if (dependencyPropertyReferenceStep == null)
{
goto Label1;
}
if (property.TargetType.IsAssignableFrom(targetType))
{
return(property);
}
else
{
return(null);
}
}
Label1:
if (TypeHelper.IsSet(memberTypes, Microsoft.Expression.DesignModel.Metadata.MemberType.DependencyProperty))
{
DependencyPropertyReferenceStep property1 = platformMetadata.GetProperty(typeResolver, declaringType, Microsoft.Expression.DesignModel.Metadata.MemberType.DependencyProperty, propertyName) as DependencyPropertyReferenceStep;
property = property1;
if (property1 != null)
{
return(property);
}
}
}
return(null);
}
public Type GetType(string typeName)
{
Type type;
Type type1 = null;
if (this.typeNameCache.TryGetValue(typeName, out type1))
{
return type1;
}
using (IEnumerator<XmlnsDefinitionMap.AssemblyNamespace> enumerator = this.AssemblyNamespaces.GetEnumerator())
{
while (enumerator.MoveNext())
{
XmlnsDefinitionMap.AssemblyNamespace current = enumerator.Current;
IAssembly assembly = current.Assembly;
string str = TypeHelper.CombineNamespaceAndTypeName(current.ClrNamespace, typeName);
try
{
type1 = PlatformTypeHelper.GetType(assembly, str);
if (type1 != null)
{
IType type2 = this.typeResolver.GetType(type1);
if (!this.typeResolver.PlatformMetadata.IsNullType(type2))
{
if (TypeHelper.IsSet((assembly.CompareTo(this.targetAssembly) ? MemberAccessTypes.PublicOrInternal : MemberAccessTypes.Public), PlatformTypeHelper.GetMemberAccess(type1)))
{
this.typeNameCache.Add(typeName, type1);
type = type1;
return type;
}
}
}
}
catch (ArgumentException argumentException)
{
type = null;
return type;
}
}
this.typeNameCache.Add(typeName, null);
return null;
}
return type;
}
internal static IMember GetMember(ITypeResolver typeResolver, Type type, MemberType memberTypes, string memberName)
{
if (TypeHelper.IsSet(memberTypes, MemberType.Property))
{
ITypeId typeId = (ITypeId)typeResolver.GetType(type);
IProperty property = (IProperty)PlatformTypeHelper.GetProperty(typeResolver, typeId, memberTypes & MemberType.Property, memberName);
if (property != null)
{
return((IMember)property);
}
}
if (TypeHelper.IsSet(memberTypes, MemberType.Event))
{
IEvent @event = PlatformTypeHelper.GetEvent(typeResolver, type, memberName);
if (@event != null)
{
return((IMember)@event);
}
}
if (TypeHelper.IsSet(memberTypes, MemberType.Field))
{
FieldInfo fieldInfo = PlatformTypeHelper.GetFieldInfo(type, memberName);
if (fieldInfo != (FieldInfo)null)
{
return((IMember)FieldReferenceStep.GetReferenceStep(typeResolver, fieldInfo));
}
}
if (TypeHelper.IsSet(memberTypes, MemberType.Method))
{
MethodInfo method = PlatformTypeHelper.GetMethod(type, memberName);
if (method != (MethodInfo)null)
{
IType type1 = typeResolver.GetType(method.DeclaringType);
if (type1 == null)
{
return((IMember)null);
}
return((IMember)Method.GetMethod(typeResolver, type1, method));
}
}
return((IMember)null);
}
public static bool IsAccessibleType(ITypeResolver typeResolver, IType typeId)
{
return(TypeHelper.IsSet(TypeHelper.GetAllowableMemberAccess(typeResolver, typeId), typeId.Access));
}