public static bool ExcludeKnownAttrsFilter(Attribute x)
{
return x.GetType() != typeof(RouteAttribute)
&& x.GetType() != typeof(DescriptionAttribute)
&& x.GetType().Name != "DataContractAttribute" //Type equality issues with Mono .NET 3.5/4
&& x.GetType().Name != "DataMemberAttribute";
}
public ClientValidationRule Translate(Attribute attribute)
{
Type type = attribute.GetType();
if (type == typeof(RegexValidatorAttribute))
{
return new RegexClientValidationRule((attribute as RegexValidatorAttribute).Pattern);
}
#pragma warning disable 0612
else if (type == typeof(StringLengthValidatorAttribute))
{
return new StringLengthClientValidationRule((attribute as StringLengthValidatorAttribute).LowerBound, (attribute as StringLengthValidatorAttribute).UpperBound);
}
#pragma warning restore 0612
else if (type == typeof(StringSizeValidatorAttribute))
{
return new StringLengthClientValidationRule((attribute as StringSizeValidatorAttribute).LowerBound, (attribute as StringSizeValidatorAttribute).UpperBound);
}
else if (type == typeof(Microsoft.Practices.EnterpriseLibrary.Validation.Validators.NotNullValidatorAttribute))
{
return new NotNullClientValidationRule();
}
else
{
throw new InvalidOperationException(string.Format("The attribute type '{0}' is not supported", attribute.GetType()));
}
}
internal static string BuildResourceKey(string keyPrefix, Attribute attribute)
{
if(attribute == null)
throw new ArgumentNullException(nameof(attribute));
var result = BuildResourceKey(keyPrefix, attribute.GetType());
if(attribute.GetType().IsAssignableFrom(typeof(DataTypeAttribute)))
result += ((DataTypeAttribute) attribute).DataType;
return result;
}
public static CustomAttributeBuilder CreateCustomAttribute(Attribute attribute)
{
Type attType = attribute.GetType();
ConstructorInfo ci;
object[] ctorArgs = GetConstructorAndArgs(attType, attribute, out ci);
PropertyInfo[] properties;
object[] propertyValues = GetPropertyValues(attType, out properties, attribute);
FieldInfo[] fields;
object[] fieldValues = GetFieldValues(attType, out fields, attribute);
// here we are going to try to initialize the attribute with the collected arguments
// if we are good (created successfuly) we return it, otherwise, it is ignored.
try
{
Activator.CreateInstance(attType, ctorArgs);
return new CustomAttributeBuilder(ci, ctorArgs, properties, propertyValues, fields, fieldValues);
}
catch
{
// there is no real way to log a warning here...
Trace.WriteLine(@"Dynamic Proxy 2: Unable to find matching parameters for replicating attribute " + attType.FullName +
".");
return null;
}
}
public static AttributeDeclaration GetAttributeDeclaration(Attribute attribute, ClientCodeGenerator textTemplateClientCodeGenerator, bool forcePropagation)
{
Type attributeType = attribute.GetType();
// Check if this attribute should be blocked
if (IsAttributeBlocked(attributeType))
{
return null;
}
ICustomAttributeBuilder cab = GetCustomAttributeBuilder(attributeType);
AttributeDeclaration attributeDeclaration = null;
if (cab != null)
{
try
{
attributeDeclaration = cab.GetAttributeDeclaration(attribute);
}
catch (AttributeBuilderException)
{
return null;
}
if (attributeDeclaration != null)
{
if (!forcePropagation)
{
// Verify attribute's shared type|property|method requirements are met
ValidateAttributeDeclarationRequirements(attributeDeclaration, textTemplateClientCodeGenerator);
}
}
}
return attributeDeclaration;
}
// public methods
/// <summary>
/// Apply an attribute to these serialization options and modify the options accordingly.
/// </summary>
/// <param name="serializer">The serializer that these serialization options are for.</param>
/// <param name="attribute">The serialization options attribute.</param>
public override void ApplyAttribute(IBsonSerializer serializer, Attribute attribute)
{
EnsureNotFrozen();
var itemSerializer = serializer.GetItemSerializationInfo().Serializer;
if (_itemSerializationOptions == null)
{
var itemDefaultSerializationOptions = itemSerializer.GetDefaultSerializationOptions();
// special case for legacy collections: allow BsonRepresentation on object
if (itemDefaultSerializationOptions == null &&
(serializer.GetType() == typeof(EnumerableSerializer) || serializer.GetType() == typeof(QueueSerializer) || serializer.GetType() == typeof(StackSerializer)) &&
attribute.GetType() == typeof(BsonRepresentationAttribute))
{
itemDefaultSerializationOptions = new RepresentationSerializationOptions(BsonType.Null); // will be modified later by ApplyAttribute
}
if (itemDefaultSerializationOptions == null)
{
var message = string.Format(
"A serialization options attribute of type {0} cannot be used when the serializer is of type {1} and the item serializer is of type {2}.",
BsonUtils.GetFriendlyTypeName(attribute.GetType()),
BsonUtils.GetFriendlyTypeName(serializer.GetType()),
BsonUtils.GetFriendlyTypeName(itemSerializer.GetType()));
throw new NotSupportedException(message);
}
_itemSerializationOptions = itemDefaultSerializationOptions.Clone();
}
_itemSerializationOptions.ApplyAttribute(itemSerializer, attribute);
}
public void Initialize(Attribute attribute)
{
//Get all parametters of the Attribute: the name and their values.
//For example:
//In LengthAttribute the parametter are Min and Max.
System.Type clazz = attribute.GetType();
IRuleArgs ruleArgs = attribute as IRuleArgs;
if (ruleArgs == null)
{
throw new ArgumentException("Attribute " + clazz + " doesn't implement IRuleArgs interface.");
}
else
{
if (ruleArgs.Message == null)
{
throw new ArgumentException(string.Format("The value of the message in {0} attribute is null (nothing for VB.Net Users). Add some message ", clazz) +
"on the attribute to solve this issue. For Example:\n" +
"- private string message = \"Error on property Foo\";\n" +
"Or you can use interpolators with resources files:\n" +
"-private string message = \"{validator.MyValidatorMessage}\";");
}
attributeMessage = ruleArgs.Message;
}
foreach (PropertyInfo property in clazz.GetProperties())
{
attributeParameters.Add(property.Name.ToLowerInvariant(), property.GetValue(attribute, null));
}
}
public int CompareTo(Attribute t)
{
if (t.GetType() == typeof(DateAttribute))
return this._date.CompareTo((DateTime)t.Value);
else
return -1;
}
public CustomAttributeBuilder Disassemble(Attribute attribute)
{
var type = attribute.GetType();
try
{
IConstructorInfo ctor;
var ctorArgs = GetConstructorAndArgs(type, attribute, out ctor);
var replicated = (Attribute)Activator.CreateInstance(type, ctorArgs);
IPropertyInfo[] properties;
var propertyValues = GetPropertyValues(type, out properties, attribute, replicated);
IFieldInfo[] fields;
var fieldValues = GetFieldValues(type, out fields, attribute, replicated);
#if !NETFX_CORE
return new CustomAttributeBuilder(ctor.AsConstructorInfo(), ctorArgs,
DotNetFixup.AsPropertyInfos(properties).ToArray(), propertyValues,
DotNetFixup.AsFieldInfos(fields).ToArray(), fieldValues);
#else
return new CustomAttributeBuilder(ctor, ctorArgs, properties, propertyValues, fields, fieldValues);
#endif
}
catch (Exception ex)
{
// there is no real way to log a warning here...
return HandleError(type, ex);
}
}
public Mapping(PropertyInfo propertyInfo, IGenerator <T> generator)
{
PropertyName = propertyInfo.Name;
PropertyInfo = propertyInfo;
object[] a = propertyInfo.GetCustomAttributes(false);
foreach (var item in a)
{
try
{
System.Attribute attr = (System.Attribute)item;
//TODO: Refactor this out to be more flexible and support more annotations
if (attr.GetType() == typeof(System.ComponentModel.DataAnnotations.StringLengthAttribute))
{
System.ComponentModel.DataAnnotations.StringLengthAttribute sla = (System.ComponentModel.DataAnnotations.StringLengthAttribute)attr;
if (generator.GetType() == typeof(Generators.TextGenerator))
{
generator = (IGenerator <T>) new Generators.TextGenerator(sla.MaximumLength);
}
}
}
catch (Exception)
{
throw;
}
}
Generator = generator;
}
public NavigationTypeNotSupportedException(Attribute attribute, string elementName)
: base(string.Format(@"A navigation attribute of '{0}' was found on your page object, " +
"but your driver doesn't currently support this navigation method.\r\n" +
"Navigating to the element identified by the property '{1}' failed.",
attribute.GetType().Name, elementName))
{
Attribute = attribute;
}
internal override void ProcessMethod(XElement element, MethodInfo method, Attribute annotation)
{
ProcessorBase processor;
if (processors.TryGetValue(annotation.GetType().Name, out processor))
{
processor.ProcessMethod(element, method, annotation);
}
}
public bool Contains (Attribute attr)
{
Attribute at = this [attr.GetType ()];
if (at != null)
return attr.Equals (at);
else
return false;
}
internal override void ProcessProperty(XElement element, PropertyInfo property, Attribute annotation)
{
ProcessorBase processor;
if (processors.TryGetValue(annotation.GetType().Name, out processor))
{
processor.ProcessProperty(element, property, annotation);
}
}
internal override void ProcessType(XElement element, Type type, Attribute annotation)
{
ProcessorBase processor;
if (processors.TryGetValue(annotation.GetType().Name, out processor))
{
processor.ProcessType(element, type, annotation);
}
}
internal override void ProcessParameter(XElement parent, ParameterInfo parameter, Attribute annotation)
{
ProcessorBase processor;
if (processors.TryGetValue(annotation.GetType().Name, out processor))
{
processor.ProcessParameter(parent, parameter, annotation);
}
}
private IEnumerable GetActionFilters(Attribute attribute)
{
var filterType = typeof(IActionFilter<>).MakeGenericType(attribute.GetType());
var filters = this.container.Invoke(filterType);
return filters;
}
private DriverBindings.IHandle SelectHandlerForNavigationAttribute(Attribute attr, PropertyInfo property)
{
var attributeHandler = _driver.NavigationHandlers.SingleOrDefault(map => attr.GetType() == map.AttributeType);
if (attributeHandler == null)
{
throw new NavigationTypeNotSupportedException(attr, property.Name);
}
return attributeHandler;
}
/// <summary>
/// Get all attribute properties with values for a specific attribute type
/// </summary>
/// <param name="attribute">attribute to check against</param>
/// <returns>collection of all properties with values</returns>
public static IDictionary<string, object> GetAttributeProperties(Attribute attribute)
{
Type attributeType = attribute.GetType();
IDictionary<string, object> attributes = new Dictionary<string, object>();
foreach(var property in attributeType.GetProperties())
{
object value = property.GetValue(attribute, null);
attributes.Add(property.Name, value);
}
return attributes;
}
private IEnumerable<object> GetMappers(Attribute attribute)
{
ConcurrentBag<object> mappers;
if (_mappersByAttrType.TryGetValue(attribute.GetType(), out mappers))
{
return mappers.ToList();
}
return Enumerable.Empty<object>();
}
private static IRegExFacet Create(Attribute attribute, IFacetHolder holder) {
if (attribute == null) {
return null;
}
if (attribute is RegularExpressionAttribute) {
return Create((RegularExpressionAttribute) attribute, holder);
}
if (attribute is RegExAttribute) {
return Create((RegExAttribute) attribute, holder);
}
throw new ArgumentException("Unexpected attribute type: " + attribute.GetType());
}
private static IDescribedAsFacet Create(Attribute attribute, IFacetHolder holder) {
if (attribute == null) {
return null;
}
if (attribute is DescribedAsAttribute) {
return Create((DescribedAsAttribute) attribute, holder);
}
if (attribute is DescriptionAttribute) {
return Create((DescriptionAttribute) attribute, holder);
}
throw new ArgumentException("Unexpected attribute type: " + attribute.GetType());
}
private INamedFacet Create(Attribute attribute, IFacetHolder holder) {
if (attribute == null) {
return null;
}
if (attribute is NamedAttribute) {
return new NamedFacetAnnotation(((NamedAttribute) attribute).Value, holder);
}
if (attribute is DisplayNameAttribute) {
return new NamedFacetAnnotation(((DisplayNameAttribute) attribute).DisplayName, holder);
}
throw new ArgumentException("Unexpected attribute type: " + attribute.GetType());
}
ServiceScope ServiceNameToEnum(Attribute serviceAttr)
{
//if (typeName.StartsWith("IClient"))
//{
// return ServiceScope.ServerToClient;
//}
//if (typeName.EndsWith("ClientService"))
//{
// return ServiceScope.ClientToServer;
//}
return (ServiceScope)serviceAttr.GetType().GetProperty("ServiceScope").GetValue(serviceAttr, null);
}
private INamedFacet CreateProperty(Attribute attribute, IFacetHolder holder) {
if (attribute == null) {
return SaveDefaultName(holder);
}
if (attribute is NamedAttribute) {
return Create((NamedAttribute) attribute, holder);
}
if (attribute is DisplayNameAttribute) {
return Create((DisplayNameAttribute) attribute, holder);
}
throw new ArgumentException("Unexpected attribute type: " + attribute.GetType());
}
private static IMaxLengthFacet Create(Attribute attribute, IFacetHolder holder) {
if (attribute == null) {
return null;
}
if (attribute is StringLengthAttribute) {
return Create((StringLengthAttribute) attribute, holder);
}
if (attribute is MaxLengthAttribute) {
return Create((MaxLengthAttribute) attribute, holder);
}
throw new ArgumentException("Unexpected attribute type: " + attribute.GetType());
}
protected int GetArgumentSemantic(MethodInfo p)
{
if (p == null)
{
return(0);
}
System.Attribute attr = System.Attribute.GetCustomAttributes(p).FirstOrDefault(x => x.GetType().Name == "ExportAttribute");
if (attr != null)
{
return((int)attr.GetType().GetProperty("ArgumentSemantic").GetValue(attr, null));
}
return(0);
}
private INamedFacet Create(Attribute attribute, ISpecification holder) {
if (attribute == null) {
return null;
}
var namedAttribute = attribute as NamedAttribute;
if (namedAttribute != null) {
return new NamedFacetAnnotation(namedAttribute.Value, holder);
}
var nameAttribute = attribute as DisplayNameAttribute;
if (nameAttribute != null) {
return new NamedFacetAnnotation(nameAttribute.DisplayName, holder);
}
throw new ArgumentException(Log.LogAndReturn($"Unexpected attribute type: {attribute.GetType()}"));
}
private static IDescribedAsFacet Create(Attribute attribute, ISpecification holder) {
if (attribute == null) {
return null;
}
var asAttribute = attribute as DescribedAsAttribute;
if (asAttribute != null) {
return Create(asAttribute, holder);
}
var descriptionAttribute = attribute as DescriptionAttribute;
if (descriptionAttribute != null) {
return Create(descriptionAttribute, holder);
}
throw new ArgumentException(Log.LogAndReturn($"Unexpected attribute type: {attribute.GetType()}"));
}
private static IRegExFacet Create(Attribute attribute, ISpecification holder) {
if (attribute == null) {
return null;
}
var expressionAttribute = attribute as RegularExpressionAttribute;
if (expressionAttribute != null) {
return Create(expressionAttribute, holder);
}
var exAttribute = attribute as RegExAttribute;
if (exAttribute != null) {
return Create(exAttribute, holder);
}
throw new ArgumentException(Log.LogAndReturn($"Unexpected attribute type: {attribute.GetType()}"));
}
protected string GetSelector(MethodInfo p)
{
if (p == null)
{
return(null);
}
System.Attribute attr = System.Attribute.GetCustomAttributes(p).FirstOrDefault(x => x.GetType().Name == "ExportAttribute");
if (attr != null)
{
return((string)attr.GetType().GetProperty("Selector").GetValue(attr, null));
}
return(null);
}
private static IMaxLengthFacet Create(Attribute attribute, ISpecification holder) {
if (attribute == null) {
return null;
}
var lengthAttribute = attribute as StringLengthAttribute;
if (lengthAttribute != null) {
return Create(lengthAttribute, holder);
}
var maxLengthAttribute = attribute as MaxLengthAttribute;
if (maxLengthAttribute != null) {
return Create(maxLengthAttribute, holder);
}
throw new ArgumentException("Unexpected attribute type: " + attribute.GetType());
}
/// <summary>
/// Get the default name value of an attribute and a specific property
/// </summary>
/// <param name="attribute">attribute from where to get the default value</param>
/// <param name="propertyName">property to get the default value</param>
/// <returns></returns>
public static object GetDefaultValue(Attribute attribute, string propertyName)
{
Type attributeType = attribute.GetType();
try
{
var property = attributeType.GetProperty(propertyName);
if (property == null)
return null;
var instance = Activator.CreateInstance(attributeType);
return property.GetValue(instance, null);
}
catch (Exception)
{
return null;
}
}
private void AnalyzeRelation(FieldInfo fi, XmlElement pc, XmlDocument doc, System.Attribute attr, IList relations)
{
XmlElement fn = doc.CreateElement("Relation");
bool isElement = false;
if (fi.FieldType.Name == "IList" || fi.FieldType.GetInterface("IList") != null)
{
fn.SetAttribute("Type", "Liste");
}
else
{
fn.SetAttribute("Type", "Element");
isElement = true;
}
fn.SetAttribute("DataType", MakeElementTypeName(fi.FieldType));
if (fi.DeclaringType != fi.ReflectedType)
{
fn.SetAttribute("DeclaringType", MakeElementTypeName(fi.DeclaringType));
}
fn.SetAttribute("Name", fi.Name);
Type attrType = attr.GetType();
string relName = string.Empty;
string relTypeName = string.Empty;
FieldInfo[] fields = attrType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
foreach (FieldInfo attrf in fields)
{
Type fieldType = attrf.FieldType;
// RelationName auslesen
if (fieldType == typeof(string))
{
if (null != attrf)
{
relName = (string)attrf.GetValue(attr);
}
fn.SetAttribute("RelationName", relName);
}
if (fieldType.Name == "RelationInfo")
{
// RelationInfo auslesen
object relationInfo = attrf.GetValue(attr);
FieldInfo riValue = relationInfo.GetType().GetField("value__", BindingFlags.Public | BindingFlags.Instance);
int val = (Int16)riValue.GetValue(relationInfo);
fn.SetAttribute("RelationInfo", val.ToString());
}
if (fieldType.Name == "Type")
{
Type theType;
string assName;
if (isElement)
{
theType = fi.FieldType;
}
else
{
theType = (Type)attrf.GetValue(attr);
}
if (theType != null)
{
assName = theType.Assembly.FullName;
assName = assName.Substring(0, assName.IndexOf(","));
if (assName != this.assShortName)
{
relTypeName = "[" + assName + "]" + theType.FullName;
}
else
{
relTypeName = theType.FullName;
}
fn.SetAttribute("RelatedType", relTypeName);
}
}
}
System.Diagnostics.Debug.WriteLine("Field: " + fi.Name + " Type: " + relTypeName + " Name: " + fn.Attributes["RelationName"].Value);
System.Diagnostics.Debug.Indent();
int nr = 1;
bool repeat = true;
while (repeat)
{
repeat = false;
foreach (XmlElement rel in relations)
{
System.Diagnostics.Debug.WriteLine("Name: " + rel.Attributes["Name"].Value + " RelType: " + rel.Attributes["RelatedType"].Value + " Name: " + rel.Attributes["RelationName"].Value);
if (rel.Attributes["RelatedType"].Value == relTypeName && rel.Attributes["RelationName"].Value == fn.Attributes["RelationName"].Value)
{
fn.SetAttribute("RelationName", relName + nr.ToString());
nr++;
repeat = true;
break;
}
}
}
System.Diagnostics.Debug.Unindent();
relations.Add(fn);
pc.AppendChild(fn);
}
//Insere tabela e retorna Id da linha adicionada
public int Insert(T obj)
{
try
{
//Abre conexão e define variaveis iniciais
conexao.Open();
Type tipo = typeof(T);
string pk = "";
string tableName = "";
string query = "";
string fields = "";
string values = "";
//Verifica quantos objetos a excluir existem para tirar isso de virgulas da query
int objectCount = 0;
foreach (PropertyInfo info in tipo.GetProperties())
{
System.Attribute tipoAtributo = info.GetCustomAttributes().FirstOrDefault();
if (tipoAtributo != null && tipoAtributo.GetType().ToString().Contains("AttributeExcluir"))
{
objectCount++;
}
}
for (int i = 0; i < tipo.GetProperties().Count(); i++)
{
//Verifica se atributo é PK e armazena para dar select depois de inserir
System.Attribute tipoAtributo = tipo.GetProperties()[i].GetCustomAttributes().FirstOrDefault();
if (tipoAtributo != null && tipoAtributo.GetType().ToString().Contains("KeyAttribute"))
{
pk = tipo.GetProperties()[i].Name;
}
else if (tipoAtributo != null && tipoAtributo.GetType().ToString().Contains("AttributeTable"))
{
tableName = tipo.GetProperties()[i].Name;
}
else
{
//Verifica atributo excluir, o mesmo não é para inserir no banco
if (tipoAtributo != null && tipoAtributo.GetType().ToString().Contains("AttributeExcluir"))
{
continue;
}
//Preenche campos da tabela
fields += tipo.GetProperties()[i].Name;
//Preenche valores a inserir
values += formatValue(tipo.GetProperties()[i].GetValue(obj), tipo.GetProperties()[i].PropertyType);
//Adiciona virgula entre os valores ( -2 pois existem dois atributos não utilizados ID e table name) + Objetos não inseridos na query
if (i != tipo.GetProperties().Count() - (2 + objectCount))
{
fields += ",";
values += ",";
}
}
}
//Escreve a query para execução
query += "Insert into " + tableName + "(" + fields + ") values(" + values + ")";
//Executa query
conexao.Execute(query);
//Seleciona ID da linha adicionada
query = "Select MAX(" + pk + ") from " + tableName;
return(conexao.Query <int>(query).FirstOrDefault());
}
catch
{
return(-1);
}
}
//Da update no objeto e retorna true or false
public bool Update(T obj)
{
//Abre conexão e define variaveis iniciais
try
{
conexao.Open();
Type tipo = typeof(T);
string pk = "";
string tableName = "";
string query = "";
string pkValue = "";
string values = "";
//Verifica quantos objetos a excluir existem para tirar isso de virgulas da query
int objectCount = 0;
foreach (PropertyInfo info in tipo.GetProperties())
{
System.Attribute tipoAtributo = info.GetCustomAttributes().FirstOrDefault();
if (tipoAtributo != null && tipoAtributo.GetType().ToString().Contains("AttributeExcluir"))
{
objectCount++;
}
}
for (int i = 0; i < tipo.GetProperties().Count(); i++)
{
//Verifica se atributo é PK para usar na query
System.Attribute tipoAtributo = tipo.GetProperties()[i].GetCustomAttributes().FirstOrDefault();
if (tipoAtributo != null && tipoAtributo.GetType().ToString().Contains("KeyAttribute"))
{
pk = tipo.GetProperties()[i].Name;
pkValue = formatValue(tipo.GetProperties()[i].GetValue(obj), tipo.GetProperties()[i].GetValue(obj).GetType());
}
else if (tipoAtributo != null && tipoAtributo.GetType().ToString().Contains("AttributeTable"))
{
tableName = tipo.GetProperties()[i].Name;
}
else
{
//Verifica atributo excluir, o mesmo não é para inserir no banco
if (tipoAtributo != null && tipoAtributo.GetType().ToString().Contains("AttributeExcluir"))
{
continue;
}
//Preenche valores a inserir
values += tipo.GetProperties()[i].Name + "=" + formatValue(tipo.GetProperties()[i].GetValue(obj), tipo.GetProperties()[i].GetValue(obj).GetType());
//Adiciona virgula entre os valores ( -2 pois existem dois atributos não utilizados ID e table name) + Objetos não inseridos na query
if (i != tipo.GetProperties().Count() - (2 + objectCount))
{
values += ", ";
}
}
}
//Escreve a query para execução
query += "Update " + tableName + " SET " + values + " WHERE " + pk + "=" + pkValue;
//Executa query
if (conexao.Execute(query) != 0)
{
return(true);
}
return(false);
}
catch
{
return(false);
}
}
private static void InternalSetAttribute(System.ComponentModel.MemberDescriptor memb, string property, System.Attribute newattrib, bool on)
{
System.Attribute oldattrib = memb.Attributes[newattrib.GetType()];
System.Reflection.BindingFlags getflags = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField | System.Reflection.BindingFlags.DeclaredOnly | System.Reflection.BindingFlags.Instance;
System.Reflection.BindingFlags setflags = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.SetField | System.Reflection.BindingFlags.DeclaredOnly | System.Reflection.BindingFlags.Instance;
System.Attribute[] oldattribs = (System.Attribute[]) typeof(System.ComponentModel.MemberDescriptor).InvokeMember("attributes", getflags, null, memb, null);
if (oldattrib != null)
{
if (on)
{
for (int i = 0; i < oldattribs.Length; i++)
{
if (oldattribs[i].GetType().FullName == newattrib.GetType().FullName)
{
oldattribs[i] = newattrib;
break;
}
}
typeof(System.ComponentModel.MemberDescriptor).InvokeMember("attributeCollection", setflags, null, memb, new object[] { new System.ComponentModel.AttributeCollection(oldattribs) });
typeof(System.ComponentModel.MemberDescriptor).InvokeMember("originalAttributes", setflags, null, memb, new object[] { oldattribs });
if (newattrib is System.ComponentModel.EditorAttribute)
{
object[] editors = new object[1];
System.ComponentModel.EditorAttribute editor = (System.ComponentModel.EditorAttribute)newattrib;
editors[0] = Type.GetType(editor.EditorTypeName).GetConstructors()[0].Invoke(new object[] { });
typeof(System.ComponentModel.PropertyDescriptor).InvokeMember("editors", setflags, null, memb, new object[] { editors });
typeof(System.ComponentModel.PropertyDescriptor).InvokeMember("editorCount", setflags, null, memb, new object[] { 1 });
Type[] editorTypes = new Type[1] {
Type.GetType(editor.EditorBaseTypeName)
};
typeof(System.ComponentModel.PropertyDescriptor).InvokeMember("editorTypes", setflags, null, memb, new object[] { editorTypes });
}
}
else
{
System.Attribute[] newattribs = new System.Attribute[oldattribs.Length - 1];
int i = 0;
foreach (System.Attribute a in oldattribs)
{
if (a.GetType().FullName != newattrib.GetType().FullName)
{
newattribs[i++] = a;
}
}
typeof(System.ComponentModel.MemberDescriptor).InvokeMember("attributes", setflags, null, memb, new object[] { newattribs });
typeof(System.ComponentModel.MemberDescriptor).InvokeMember("originalAttributes", setflags, null, memb, new object[] { newattribs });
typeof(System.ComponentModel.MemberDescriptor).InvokeMember("attributeCollection", setflags, null, memb, new object[] { new System.ComponentModel.AttributeCollection(newattribs) });
}
}
else if (on)
{
System.Attribute[] newattribs = new System.Attribute[oldattribs.Length + 1];
int i = 0;
foreach (System.Attribute a in oldattribs)
{
newattribs[i++] = a;
}
newattribs[i++] = newattrib;
typeof(System.ComponentModel.MemberDescriptor).InvokeMember("attributes", setflags, null, memb, new object[] { newattribs });
typeof(System.ComponentModel.MemberDescriptor).InvokeMember("originalAttributes", setflags, null, memb, new object[] { newattribs });
typeof(System.ComponentModel.MemberDescriptor).InvokeMember("attributeCollection", setflags, null, memb, new object[] { new System.ComponentModel.AttributeCollection(newattribs) });
}
}
private static Attribute Instantiate(this CustomAttributeData cad)
{
return /*cad.Instantiate ()*/ ((Attribute)Activator.CreateInstance(cad.GetType()));
}
