/// <summary>
///
/// </summary>
/// <param name="attributeProvider"></param>
/// <param name="definitionType"></param>
/// <returns></returns>
public static bool IsSpecificTypeDefined(ICustomAttributeProvider attributeProvider, Type definitionType, bool inherit)
{
if (null == attributeProvider)
{
throw new ArgumentNullException("attributeProvider");
}
if (ObjectUtils.IsAttributeType(definitionType))
{
return(attributeProvider.IsDefined(definitionType, inherit));
}
else if (ObjectUtils.IsInterfaceType(definitionType))
{
var _attrs = attributeProvider.GetCustomAttributes(inherit);
foreach (var _attr in _attrs)
{
if (AttributeMemberHelpers.IsSpecificTypeDefined(_attr as Attribute, definitionType))
{
return(true);
}
}
}
return(false);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TDescriptor"></typeparam>
/// <typeparam name="TCollection"></typeparam>
/// <param name="instance"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static TCollection RetrieveMemberDescriptors <TDescriptor, TCollection>(object instance, bool inherit = false)
where TDescriptor : AttributeMemberDescriptor
where TCollection : ReadOnlyListCollection <TDescriptor>
{
var _descriptors = AttributeMemberHelpers.RetrieveMembers(instance, inherit)
.Select(attr => AttributeMemberDescriptor.Initializer.Initialize <TDescriptor>(attr));
return(ReadOnlyListCollection <TDescriptor> .Initializer.Initialize <TCollection>(_descriptors));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TDescriptor"></typeparam>
/// <typeparam name="TCollection"></typeparam>
/// <param name="attributeProvider"></param>
/// <param name="comparisonType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static TCollection RetrieveMemberDescriptors <TDescriptor, TCollection>(ICustomAttributeProvider attributeProvider, Type comparisonType, bool inherit = false)
where TDescriptor : AttributeMemberDescriptor
where TCollection : ReadOnlyListCollection <TDescriptor>
{
var _descriptors = AttributeMemberHelpers.RetrieveMembers(attributeProvider, comparisonType, inherit)
.Select(attr => AttributeMemberDescriptor.Initializer.Initialize <TDescriptor>(attr));
return(ReadOnlyListCollection <TDescriptor> .Initializer.Initialize <TCollection>(_descriptors));
}
/// <summary>
///
/// </summary>
/// <param name="instance"></param>
/// <param name="comparisonType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static Attribute[] RetrieveMembers(object instance, Type comparisonType, bool inherit = false)
{
if (null == instance)
{
throw new ArgumentNullException("instance");
}
return(AttributeMemberHelpers.RetrieveMembers(instance.GetType(), comparisonType, inherit));
}
/// <summary>
///
/// </summary>
/// <param name="attribute"></param>
/// <param name="definitionType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static bool IsSpecificTypeDefined(Attribute attribute, Type definitionType)
{
if (null == attribute)
{
throw new ArgumentNullException("attribute");
}
return(AttributeMemberHelpers.IsSpecificTypeDefined(attribute.GetType(), definitionType));
}
/// <summary>
///
/// </summary>
/// <param name="attributeProvider"></param>
/// <param name="comparisonType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static Attribute RetrieveMember(ICustomAttributeProvider attributeProvider, Type comparisonType, bool inherit = false)
{
var _attrs = AttributeMemberHelpers.RetrieveMembers(attributeProvider, comparisonType, inherit);
if (null != _attrs && 0 < _attrs.Length)
{
return(_attrs[0]);
}
throw new NullReferenceException(string.Format("A '{0}' attribute does not exist.", comparisonType.FullName));
}
/// <summary>
///
/// </summary>
/// <param name="attributeType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public TDescriptor GetDescriptorByAttributeType(Type attributeType)
{
foreach (var _descriptor in this)
{
var _originType = _descriptor.Member.GetType();
if (AttributeMemberHelpers.IsSpecificTypeDefined(_originType, attributeType))
{
return(_descriptor);
}
}
return(default(TDescriptor));
}
/// <summary>
///
/// </summary>
/// <param name="attributeProvider"></param>
/// <param name="definitionTypes"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static bool IsSpecificTypeDefined(ICustomAttributeProvider attributeProvider, Type[] definitionTypes, bool inherit)
{
if (null == definitionTypes)
{
throw new ArgumentNullException("definitionTypes");
}
foreach (var _definitionType in definitionTypes)
{
return(AttributeMemberHelpers.IsSpecificTypeDefined(attributeProvider, _definitionType, inherit));
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="attributeType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public TCollection GetDescriptorsByAttributeType(Type attributeType)
{
var _dummy = new List <TDescriptor>();
foreach (var _descriptor in this)
{
var _originType = _descriptor.Member.GetType();
if (AttributeMemberHelpers.IsSpecificTypeDefined(_originType, attributeType))
{
_dummy.Add(_descriptor);
}
}
return(ReadOnlyListCollection <TDescriptor> .Initializer.Initialize <TCollection>(_dummy));
}
/// <summary>
///
/// </summary>
/// <param name="declaringType"></param>
/// <param name="nonPublic"></param>
/// <param name="attributeTypes"></param>
/// <param name="inherit"></param>
/// <param name="canWrite"></param>
/// <param name="canRead"></param>
/// <returns></returns>
public static PropertyInfo[] RetrieveMembers(Type declaringType, bool nonPublic, Type[] attributeTypes, bool inherit, bool?canWrite, bool?canRead)
{
if (null == attributeTypes)
{
throw new ArgumentNullException("attributeTypes");
}
var _dummy = new ListCollection <PropertyInfo>();
var _properties = PropertyMemberHelpers.RetrieveMembers(declaringType, nonPublic, canWrite, canRead);
foreach (var _property in _properties)
{
if (AttributeMemberHelpers.IsSpecificTypeDefined(_property, attributeTypes, inherit))
{
_dummy.Add(_property);
}
}
return(_dummy.ToArray());
}
/// <summary>
///
/// </summary>
/// <typeparam name="TAttribute"></typeparam>
/// <param name="selector"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public TCollection GetDescriptorsByAttribute <TAttribute>(Expression <Func <TAttribute, bool> > selector, bool inherit = false)
where TAttribute : Attribute
{
var _type = typeof(TAttribute);
var _dummy = new List <TDescriptor>();
var _selector = selector.Compile();
foreach (var _descriptor in this)
{
var _origin = _descriptor.Member;
var _originType = _origin.GetType();
if (AttributeMemberHelpers.IsSpecificTypeDefined(_originType, _type) && _selector((TAttribute)_origin))
{
_dummy.Add(_descriptor);
}
}
return(ReadOnlyListCollection <TDescriptor> .Initializer.Initialize <TCollection>(_dummy));
}
/// <summary>
///
/// </summary>
/// <param name="declaringType"></param>
/// <param name="nonPublic"></param>
/// <param name="attributeType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static MethodInfo[] RetrieveMembers(Type declaringType, bool nonPublic, Type attributeType, bool inherit)
{
if (null == declaringType)
{
throw new ArgumentNullException("declaringType");
}
else if (null == attributeType)
{
throw new ArgumentNullException("attributeType");
}
var _flag = (!nonPublic) ? BindingFlags.Public : BindingFlags.NonPublic;
if (ObjectUtils.IsAttributeType(attributeType))
{
var _methods = declaringType.GetMethods(_flag | BindingFlags.Instance);
if (null != _methods && 0 < _methods.Length)
{
return(_methods.Where(x => x.IsDefined(attributeType, inherit)).ToArray());
}
}
else if (ObjectUtils.IsClassType(attributeType) || ObjectUtils.IsInterfaceType(attributeType))
{
var _dummy = new ListCollection <MethodInfo>();
var _methods = declaringType.GetMethods(_flag | BindingFlags.Instance);
foreach (var _method in _methods)
{
if (AttributeMemberHelpers.IsSpecificTypeDefined(_method, attributeType, inherit))
{
_dummy.Add(_method);
}
}
return(_dummy.ToArray());
}
return(new MethodInfo[0]);
}
/// <summary>
///
/// </summary>
/// <param name="attributeProvider"></param>
/// <param name="comparisonType"></param>
/// <returns></returns>
public static Attribute[] RetrieveMembers(ICustomAttributeProvider attributeProvider, Type comparisonType, bool inherit = false)
{
if (null == attributeProvider)
{
throw new ArgumentNullException("attributeProvider");
}
else if (null == comparisonType)
{
throw new ArgumentNullException("comparisonType");
}
var _dummy = new ListCollection <Attribute>();
if (ObjectUtils.IsAttributeType(comparisonType))
{
var _attrs = attributeProvider.GetCustomAttributes(comparisonType, inherit);
foreach (var _attr in _attrs)
{
_dummy.Add(_attr as Attribute);
}
return(_dummy.ToArray());
}
else if (ObjectUtils.IsInterfaceType(comparisonType))
{
var _attrs = attributeProvider.GetCustomAttributes(inherit);
foreach (var _attr in _attrs)
{
if (AttributeMemberHelpers.IsSpecificTypeDefined(_attr as Attribute, comparisonType))
{
_dummy.Add(_attr as Attribute);
}
}
}
return(_dummy.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="instance"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static AttributeMemberDescriptors RetrieveMemberDescriptors(object instance, bool inherit = false)
{
return(AttributeMemberHelpers.RetrieveMemberDescriptors <AttributeMemberDescriptor, AttributeMemberDescriptors>(instance, inherit));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TDescriptor"></typeparam>
/// <param name="instance"></param>
/// <param name="comparisonType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static TDescriptor RetrieveMemberDescriptor <TDescriptor>(object instance, Type comparisonType, bool inherit = false)
where TDescriptor : AttributeMemberDescriptor
{
return(AttributeMemberDescriptor.Initializer.Initialize <TDescriptor>(AttributeMemberHelpers.RetrieveMember(instance, comparisonType, inherit)));
}
/// <summary>
///
/// </summary>
/// <param name="instance"></param>
/// <param name="attributeType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static AttributeMemberDescriptor RetrieveMemberDescriptor(object instance, Type attributeType, bool inherit = false)
{
return(AttributeMemberHelpers.RetrieveMemberDescriptor <AttributeMemberDescriptor>(instance, attributeType, inherit));
}
/// <summary>
///
/// </summary>
/// <param name="attributeProvider"></param>
/// <param name="comparisonType"></param>
/// <param name="inherit"></param>
/// <returns></returns>
public static AttributeMemberDescriptors RetrieveMemberDescriptors(ICustomAttributeProvider attributeProvider, Type comparisonType, bool inherit = false)
{
return(AttributeMemberHelpers.RetrieveMemberDescriptors <AttributeMemberDescriptor, AttributeMemberDescriptors>(attributeProvider, comparisonType, inherit));
}
