private void CreateReflector()
{
bool isUnknown = LookupIsUnknown();
MemberReflector reflector = isUnknown ? MemberReflector.UnknownReflector : new MemberReflector();
Interlocked.CompareExchange(ref _reflector, reflector, null);
}
internal XamlMember(string attachablePropertyName, MethodInfo getter, MethodInfo setter,
XamlSchemaContext schemaContext, XamlMemberInvoker invoker, MemberReflector reflector)
{
if (attachablePropertyName == null)
{
throw new ArgumentNullException("attachablePropertyName");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
MethodInfo accessor = getter ?? setter;
if (accessor == null)
{
throw new ArgumentNullException(SR.Get(SRID.GetterOrSetterRequired), (Exception)null);
}
ValidateGetter(getter, "getter");
ValidateSetter(setter, "setter");
_name = attachablePropertyName;
_declaringType = schemaContext.GetXamlType(accessor.DeclaringType);
_reflector = reflector;
_memberType = MemberType.Attachable;
_reflector.Invoker = invoker;
_underlyingMember.Value = getter ?? setter;
}
// Directive, only called from XamlDirective
internal XamlMember(string name, MemberReflector reflector)
{
_name = name;
_declaringType = null;
_reflector = reflector ?? MemberReflector.UnknownReflector;
_memberType = MemberType.Directive;
}
internal XamlMember(string attachablePropertyName, MethodInfo getter, MethodInfo setter, XamlSchemaContext schemaContext, XamlMemberInvoker invoker, MemberReflector reflector)
{
if (attachablePropertyName == null)
{
throw new ArgumentNullException("attachablePropertyName");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
MethodInfo info = getter ?? setter;
if (info == null)
{
throw new ArgumentNullException(System.Xaml.SR.Get("GetterOrSetterRequired"), null);
}
ValidateGetter(getter, "getter");
ValidateSetter(setter, "setter");
this._name = attachablePropertyName;
this._declaringType = schemaContext.GetXamlType(info.DeclaringType);
this._reflector = reflector;
this._memberType = MemberType.Attachable;
this._reflector.Invoker = invoker;
this._underlyingMember.Value = getter ?? setter;
}
// See notes on IsReadVisibleTo
internal bool IsWriteVisibleTo(Assembly accessingAssembly, Type accessingType)
{
if (IsWritePublicIgnoringType)
{
return(true);
}
MethodInfo setter = Setter;
if (setter != null)
{
return(MemberReflector.GenericArgumentsAreVisibleTo(setter, accessingAssembly, SchemaContext) &&
(MemberReflector.IsInternalVisibleTo(setter, accessingAssembly, SchemaContext) ||
MemberReflector.IsProtectedVisibleTo(setter, accessingType, SchemaContext)));
}
return(false);
}
internal XamlMember(PropertyInfo propertyInfo, XamlSchemaContext schemaContext, XamlMemberInvoker invoker, MemberReflector reflector)
{
if (propertyInfo == null)
{
throw new ArgumentNullException(nameof(propertyInfo));
}
if (schemaContext == null)
{
throw new ArgumentNullException(nameof(schemaContext));
}
_name = propertyInfo.Name;
_declaringType = schemaContext.GetXamlType(propertyInfo.DeclaringType);
_memberType = MemberType.Instance;
_reflector = reflector;
_reflector.Invoker = invoker;
_underlyingMember.Value = propertyInfo;
}
internal XamlMember(EventInfo eventInfo, XamlSchemaContext schemaContext, XamlMemberInvoker invoker, MemberReflector reflector)
{
if (eventInfo == null)
{
throw new ArgumentNullException("eventInfo");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
_name = eventInfo.Name;
_declaringType = schemaContext.GetXamlType(eventInfo.DeclaringType);
_memberType = MemberType.Instance;
_reflector = reflector;
_reflector.Invoker = invoker;
_underlyingMember.Value = eventInfo;
}
internal XamlMember(string attachableEventName, MethodInfo adder, XamlSchemaContext schemaContext,
XamlMemberInvoker invoker, MemberReflector reflector)
{
if (adder == null)
{
throw new ArgumentNullException(nameof(adder));
}
if (schemaContext == null)
{
throw new ArgumentNullException(nameof(schemaContext));
}
ValidateSetter(adder, "adder");
_name = attachableEventName ?? throw new ArgumentNullException(nameof(attachableEventName));
_declaringType = schemaContext.GetXamlType(adder.DeclaringType);
_reflector = reflector;
_memberType = MemberType.Attachable;
_reflector.Invoker = invoker;
_underlyingMember.Value = adder;
}
internal bool IsWriteVisibleTo(Assembly accessingAssembly, System.Type accessingType)
{
if (!this.IsWritePublicIgnoringType)
{
MethodInfo setter = this.Setter;
if (setter == null)
{
return(false);
}
if (!MemberReflector.GenericArgumentsAreVisibleTo(setter, accessingAssembly, this.SchemaContext))
{
return(false);
}
if (!MemberReflector.IsInternalVisibleTo(setter, accessingAssembly, this.SchemaContext))
{
return(MemberReflector.IsProtectedVisibleTo(setter, accessingType, this.SchemaContext));
}
}
return(true);
}
private static XamlDirective GetXamlDirective(string name, AllowedMemberLocations allowedLocation, MemberReflector reflector)
{
return(new XamlDirective(s_xamlNamespaces, name, allowedLocation, reflector));
}
internal XamlDirective(IEnumerable <string> xamlNamespaces, string name, AllowedMemberLocations allowedLocation, MemberReflector reflector)
: base(name, reflector)
{
_xamlNamespaces = GetReadOnly(xamlNamespaces);
_allowedLocation = allowedLocation;
}
private void CreateReflector()
{
MemberReflector reflector = this.LookupIsUnknown() ? MemberReflector.UnknownReflector : new MemberReflector();
Interlocked.CompareExchange <MemberReflector>(ref this._reflector, reflector, null);
}
