/// <include file='doc\RepeaterDesigner.uex' path='docs/doc[@for="RepeaterDesigner.PreFilterProperties"]/*' />
/// <devdoc>
/// Filter the properties to replace the runtime DataSource property
/// descriptor with the designer's.
/// </devdoc>
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
PropertyDescriptor prop;
prop = (PropertyDescriptor)properties["DataSource"];
Debug.Assert(prop != null);
// we can't create the designer DataSource property based on the runtime property since theie
// types do not match. Therefore, we have to copy over all the attributes from the runtime
// and use them that way.
AttributeCollection runtimeAttributes = prop.Attributes;
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new TypeConverterAttribute(typeof(DataSourceConverter));
prop = TypeDescriptor.CreateProperty(this.GetType(), "DataSource", typeof(string),
attrs);
properties["DataSource"] = prop;
prop = (PropertyDescriptor)properties["DataMember"];
Debug.Assert(prop != null);
prop = TypeDescriptor.CreateProperty(this.GetType(), prop,
new Attribute[] {
new TypeConverterAttribute(typeof(DataMemberConverter))
});
properties["DataMember"] = prop;
}
private static void OutputAttributes(AttributeCollection attributeCollection)
{
foreach (Attribute attribute in attributeCollection)
{
Console.WriteLine("Attribute: {0}", attribute.ToString());
}
}
internal static void AddAttributesToPropertiesOfDifferentType(
Type designerType,
Type newType,
IDictionary properties,
String propertyName,
Attribute newAttribute)
{
Debug.Assert(propertyName != null &&
propertyName.Length != 0);
PropertyDescriptor prop = (PropertyDescriptor)properties[propertyName];
Debug.Assert(prop != null);
// we can't create the designer DataSource property based on the runtime property since their
// types do not match. Therefore, we have to copy over all the attributes from the runtime
// and use them that way.
System.ComponentModel.AttributeCollection runtimeAttributes = prop.Attributes;
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = newAttribute;
prop = TypeDescriptor.CreateProperty(
designerType,
propertyName,
newType,
attrs);
properties[propertyName] = prop;
}
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
PropertyDescriptor propertyDescriptor = (PropertyDescriptor)properties["DataSource"];
if (null != propertyDescriptor)
{
System.ComponentModel.AttributeCollection runtimeAttributes = propertyDescriptor.Attributes;
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new TypeConverterAttribute(typeof(DataSourceConverter));
propertyDescriptor = TypeDescriptor.CreateProperty(this.GetType(), "DataSource", typeof(string),
attrs);
properties["DataSource"] = propertyDescriptor;
}
propertyDescriptor = (PropertyDescriptor)properties["DataMember"];
if (null != propertyDescriptor)
{
System.ComponentModel.AttributeCollection runtimeAttributes = propertyDescriptor.Attributes;
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new TypeConverterAttribute(typeof(DataMemberConverter));
propertyDescriptor = TypeDescriptor.CreateProperty(this.GetType(), "DataMember", typeof(string),
attrs);
properties["DataMember"] = propertyDescriptor;
}
}
AttributeCollection ICustomTypeDescriptor.GetAttributes()
{
if (_attributes == null)
_attributes = _typeDescriptionProvider.GetAttributes();
return _attributes;
}
private List <PropertyDescriptor> GetPropertyDescriptor(SearchHelper helper)
{
List <PropertyDescriptor> returnProp = new List <PropertyDescriptor>();
var properties = TypeDescriptor.GetProperties(helper.SearchType);
foreach (PropertyDescriptor propDes in properties)
{
PropertyDescriptor property = propDes;
if (helper.HideColumns.Contains(propDes.Name))
{
if (property != null)
{
System.ComponentModel.AttributeCollection runtimeAttributes = property.Attributes;
// make a copy of the original attributes
// but make room for one extra attribute
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new BrowsableAttribute(false);
// makes this Property hidden in PropertyGrid
property = TypeDescriptor.CreateProperty(this.GetType(), property.Name, property.PropertyType, attrs);
}
}
returnProp.Add(property);
}
return(returnProp);
}
protected override void PreFilterProperties(IDictionary properties)
{
int num2;
base.PreFilterProperties(properties);
PropertyDescriptor oldPropertyDescriptor = (PropertyDescriptor)properties["DataSource"];
System.ComponentModel.AttributeCollection attributes = oldPropertyDescriptor.Attributes;
int index = -1;
int count = attributes.Count;
string dataSource = this.DataSource;
if (dataSource.Length > 0)
{
this._keepDataSourceBrowsable = true;
}
for (int i = 0; i < attributes.Count; i++)
{
if (attributes[i] is BrowsableAttribute)
{
index = i;
break;
}
}
if (((index == -1) && (dataSource.Length == 0)) && !this._keepDataSourceBrowsable)
{
num2 = count + 2;
}
else
{
num2 = count + 1;
}
Attribute[] array = new Attribute[num2];
attributes.CopyTo(array, 0);
array[count] = new TypeConverterAttribute(typeof(DataSourceConverter));
if ((dataSource.Length == 0) && !this._keepDataSourceBrowsable)
{
if (index == -1)
{
array[count + 1] = BrowsableAttribute.No;
}
else
{
array[index] = BrowsableAttribute.No;
}
}
oldPropertyDescriptor = TypeDescriptor.CreateProperty(base.GetType(), "DataSource", typeof(string), array);
properties["DataSource"] = oldPropertyDescriptor;
oldPropertyDescriptor = (PropertyDescriptor)properties["DataMember"];
oldPropertyDescriptor = TypeDescriptor.CreateProperty(base.GetType(), oldPropertyDescriptor, new Attribute[] { new TypeConverterAttribute(typeof(DataMemberConverter)) });
properties["DataMember"] = oldPropertyDescriptor;
oldPropertyDescriptor = (PropertyDescriptor)properties["DataKeyField"];
oldPropertyDescriptor = TypeDescriptor.CreateProperty(base.GetType(), oldPropertyDescriptor, new Attribute[] { new TypeConverterAttribute(typeof(DataFieldConverter)) });
properties["DataKeyField"] = oldPropertyDescriptor;
oldPropertyDescriptor = (PropertyDescriptor)properties["DataSourceID"];
oldPropertyDescriptor = TypeDescriptor.CreateProperty(base.GetType(), oldPropertyDescriptor, new Attribute[] { new TypeConverterAttribute(typeof(DataSourceIDConverter)) });
properties["DataSourceID"] = oldPropertyDescriptor;
}
public SettingsForm()
{
InitializeComponent();
pgSettings.SelectedObject = _appSettings;
System.Configuration.UserScopedSettingAttribute userAttr = new System.Configuration.UserScopedSettingAttribute();
System.ComponentModel.AttributeCollection attrs = new System.ComponentModel.AttributeCollection(userAttr);
pgSettings.BrowsableAttributes = attrs;
}
/// <summary>
/// Initializes a new instance of the <see cref="AttributesContainer"/> class.
/// </summary>
/// <param name="attributes">The collection of attributes.</param>
public AttributesContainer(AttributeCollection attributes)
{
if (attributes == null) throw new ArgumentNullException("attributes");
this.attributes = attributes;
foreach (Type type in from Attribute attr in this.attributes select attr.GetType())
RegisterAttribute(type.Name, type);
}
public void CanGetEditorAttributeFromCollection()
{
BindableAttribute bindableAttribute = new BindableAttribute(false);
EditorAttribute editorAttribute = new EditorAttribute();
Attribute[] attributes = new Attribute[] { bindableAttribute, editorAttribute };
AttributeCollection attributeCollection = new AttributeCollection(attributes);
Assert.AreSame(editorAttribute, WixBindingTestsHelper.GetEditorAttribute(attributeCollection));
}
public static AttributeCollection FromExisting (AttributeCollection existing, params Attribute [] newAttributes)
{
if (existing == null)
throw new ArgumentNullException ("existing");
AttributeCollection ret = new AttributeCollection ();
ret.attrList.AddRange (existing.attrList);
if (newAttributes != null)
ret.attrList.AddRange (newAttributes);
return ret;
}
private void frmSettings_Load(object sender, EventArgs e)
{
System.Configuration.UserScopedSettingAttribute userAttr = new System.Configuration.UserScopedSettingAttribute();
System.ComponentModel.AttributeCollection attrs = new System.ComponentModel.AttributeCollection(userAttr);
propertyGrid1.BrowsableAttributes = attrs;
propertyGrid1.SelectedObject = Properties.Settings.Default;
cboCompany.Items.AddRange(hc.getAllCompanies());
}
internal static bool IsEnabled(Type type)
{
if (!_viewStateIdTypes.ContainsKey(type))
{
System.ComponentModel.AttributeCollection attrs = TypeDescriptor.GetAttributes(type);
ViewStateModeByIdAttribute attr = (ViewStateModeByIdAttribute)attrs[typeof(ViewStateModeByIdAttribute)];
_viewStateIdTypes[type] = (attr != null);
}
return((bool)_viewStateIdTypes[type]);
}
/// <summary>
/// Returns the EditorAttribute in the AttributeCollection.
/// </summary>
public static EditorAttribute GetEditorAttribute(AttributeCollection attributes)
{
foreach (Attribute attribute in attributes) {
EditorAttribute editorAttribute = attribute as EditorAttribute;
if (editorAttribute != null) {
return editorAttribute;
}
}
return null;
}
private static EditorOptions GetEditorOptionsAttribute(System.ComponentModel.AttributeCollection attribCollection)
{
foreach (Attribute attrib in attribCollection)
{
if (attrib is EditorOptions)
{
return(attrib as EditorOptions);
}
}
return(null);
}
/// <summary>
/// Constructs a description based on the specified <see cref="DomainServiceDescription"/>.
/// </summary>
/// <param name="baseDescription">The base <see cref="DomainServiceDescription"/></param>
internal DomainServiceDescription(DomainServiceDescription baseDescription)
{
if (baseDescription == null)
{
throw new ArgumentNullException("baseDescription");
}
this._domainServiceType = baseDescription._domainServiceType;
this._attributes = baseDescription._attributes;
this._operationEntries.AddRange(baseDescription._operationEntries);
}
private void CheckAndAddProperty(PSPropertyInfo propertyInfo, Attribute[] attributes, ref PropertyDescriptorCollection returnValue)
{
using (typeDescriptor.TraceScope("Checking property \"{0}\".", new object[] { propertyInfo.Name }))
{
if (!propertyInfo.IsGettable)
{
typeDescriptor.WriteLine("Property \"{0}\" is write-only so it has been skipped.", new object[] { propertyInfo.Name });
}
else
{
AttributeCollection propertyAttributes = null;
Type propertyType = typeof(object);
if ((attributes != null) && (attributes.Length != 0))
{
PSProperty property = propertyInfo as PSProperty;
if (property != null)
{
DotNetAdapter.PropertyCacheEntry adapterData = property.adapterData as DotNetAdapter.PropertyCacheEntry;
if (adapterData == null)
{
typeDescriptor.WriteLine("Skipping attribute check for property \"{0}\" because it is an adapted property (not a .NET property).", new object[] { property.Name });
}
else if (property.isDeserialized)
{
typeDescriptor.WriteLine("Skipping attribute check for property \"{0}\" because it has been deserialized.", new object[] { property.Name });
}
else
{
propertyType = adapterData.propertyType;
propertyAttributes = adapterData.Attributes;
foreach (Attribute attribute in attributes)
{
if (!propertyAttributes.Contains(attribute))
{
typeDescriptor.WriteLine("Property \"{0}\" does not contain attribute \"{1}\" so it has been skipped.", new object[] { property.Name, attribute });
return;
}
}
}
}
}
if (propertyAttributes == null)
{
propertyAttributes = new AttributeCollection(new Attribute[0]);
}
typeDescriptor.WriteLine("Adding property \"{0}\".", new object[] { propertyInfo.Name });
PSObjectPropertyDescriptor descriptor = new PSObjectPropertyDescriptor(propertyInfo.Name, propertyType, !propertyInfo.IsSettable, propertyAttributes);
descriptor.SettingValueException += this.SettingValueException;
descriptor.GettingValueException += this.GettingValueException;
returnValue.Add(descriptor);
}
}
}
/// <summary>
/// Used to modify the Attributes of the 'Data' related fields such that
/// the correct TypeConverters are added to the Attributes. For some reason
/// adding the attributes directly doesn't work.
/// </summary>
/// <param name="properties">The dictionary</param>
protected override void PreFilterProperties(IDictionary properties)
{
base.PreFilterProperties(properties);
PropertyDescriptor prop = (PropertyDescriptor)properties["DataSource"];
if (prop != null)
{
System.ComponentModel.AttributeCollection runtimeAttributes = prop.Attributes;
// make a copy of the original attributes but make room for one extra attribute ie the TypeConverter attribute
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new TypeConverterAttribute(typeof(DataSourceConverter));
prop = TypeDescriptor.CreateProperty(this.GetType(), "DataSource", typeof(string), attrs);
properties["DataSource"] = prop;
}
prop = (PropertyDescriptor)properties["DataMember"];
if (prop != null)
{
System.ComponentModel.AttributeCollection runtimeAttributes = prop.Attributes;
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
// make a copy of the original attributes but make room for one extra attribute ie the TypeConverter attribute
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new TypeConverterAttribute(typeof(DataMemberConverter));
prop = TypeDescriptor.CreateProperty(this.GetType(), "DataMember", typeof(string), attrs);
properties["DataMember"] = prop;
}
prop = (PropertyDescriptor)properties["DataValueField"];
if (prop != null)
{
System.ComponentModel.AttributeCollection runtimeAttributes = prop.Attributes;
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
// make a copy of the original attributes but make room for one extra attribute ie the TypeConverter attribute
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new TypeConverterAttribute(typeof(DataFieldConverter));
prop = TypeDescriptor.CreateProperty(this.GetType(), "DataValueField", typeof(string), attrs);
properties["DataValueField"] = prop;
}
prop = (PropertyDescriptor)properties["DataTextField"];
if (prop != null)
{
System.ComponentModel.AttributeCollection runtimeAttributes = prop.Attributes;
Attribute[] attrs = new Attribute[runtimeAttributes.Count + 1];
// make a copy of the original attributes but make room for one extra attribute ie the TypeConverter attribute
runtimeAttributes.CopyTo(attrs, 0);
attrs[runtimeAttributes.Count] = new TypeConverterAttribute(typeof(DataFieldConverter));
prop = TypeDescriptor.CreateProperty(this.GetType(), "DataTextField", typeof(string), attrs);
properties["DataTextField"] = prop;
}
}
private void InitializePanelControls()
{
this._selectLabel.Text = System.Design.SR.GetString("CreateDataSource_SelectType");
this._idLabel.Text = System.Design.SR.GetString("CreateDataSource_ID");
base.OKButton.Enabled = false;
this.Text = System.Design.SR.GetString("CreateDataSource_Title");
this._descriptionBox.Text = System.Design.SR.GetString("CreateDataSource_SelectTypeDesc");
base.AccessibleDescription = System.Design.SR.GetString("CreateDataSource_Description");
base.CaptionLabel.Text = System.Design.SR.GetString("CreateDataSource_Caption");
this.UpdateFonts();
ISite site = this.GetSite();
if (site != null)
{
IComponentDiscoveryService service = (IComponentDiscoveryService)site.GetService(typeof(IComponentDiscoveryService));
IDesignerHost designerHost = (IDesignerHost)site.GetService(typeof(IDesignerHost));
if (service != null)
{
ICollection componentTypes = service.GetComponentTypes(designerHost, this._dataSourceType);
if (componentTypes != null)
{
ImageList list = new ImageList {
ColorDepth = ColorDepth.Depth32Bit
};
System.Type[] array = new System.Type[componentTypes.Count];
componentTypes.CopyTo(array, 0);
foreach (System.Type type in array)
{
System.ComponentModel.AttributeCollection attributes = TypeDescriptor.GetAttributes(type);
Bitmap image = null;
if (attributes != null)
{
ToolboxBitmapAttribute attribute = attributes[typeof(ToolboxBitmapAttribute)] as ToolboxBitmapAttribute;
if ((attribute != null) && !attribute.Equals(ToolboxBitmapAttribute.Default))
{
image = attribute.GetImage(type, true) as Bitmap;
}
}
if (image == null)
{
image = new Bitmap(base.GetType(), "CustomDataSource.bmp");
}
list.ImageSize = new Size(0x20, 0x20);
list.Images.Add(type.FullName, image);
this._dataSourceTypesListView.Items.Add(new DataSourceListViewItem(type));
}
this._dataSourceTypesListView.Sort();
this._dataSourceTypesListView.LargeImageList = list;
}
}
}
}
/// <summary>
/// Перевести атрибуты заданного типа
/// </summary>
/// <remarks>Используется словарь с ключём, совпадающим с полным именем типа</remarks>
public void TranslateAttrs(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
string dictKey = type.FullName;
Localization.Dict dict;
if (Localization.Dictionaries.TryGetValue(dictKey, out dict))
{
Dictionary <string, PropAttrs> propAttrsDict = GetPropAttrsDict(dict);
CM.PropertyDescriptorCollection allProps = CM.TypeDescriptor.GetProperties(type);
foreach (CM.PropertyDescriptor prop in allProps)
{
PropAttrs propAttrs;
if (propAttrsDict.TryGetValue(prop.Name, out propAttrs))
{
CM.AttributeCollection attrs = prop.Attributes;
foreach (Attribute attr in attrs)
{
if (attr is DisplayNameAttribute)
{
if (!string.IsNullOrEmpty(propAttrs.DisplayName))
{
((DisplayNameAttribute)attr).DisplayNameValue = propAttrs.DisplayName;
}
}
else if (attr is CategoryAttribute)
{
if (!string.IsNullOrEmpty(propAttrs.Category))
{
((CategoryAttribute)attr).CategoryName = propAttrs.Category;
}
}
else if (attr is DescriptionAttribute)
{
if (!string.IsNullOrEmpty(propAttrs.Description))
{
((DescriptionAttribute)attr).DescriptionValue = propAttrs.Description;
}
}
}
}
}
}
}
public string GetDescriptionText()
{
System.ComponentModel.AttributeCollection attributes = TypeDescriptor.GetAttributes(this._dataSourceType);
if (attributes != null)
{
DescriptionAttribute attribute = attributes[typeof(DescriptionAttribute)] as DescriptionAttribute;
if (attribute != null)
{
return(attribute.Description);
}
}
return(string.Empty);
}
internal static AttributeCollection AddDisplayName(string name, AttributeCollection attributes) {
var displayNameAttrib = attributes.OfType<DisplayNameAttribute>().FirstOrDefault();
// If there is already a display name attribute, don't change anything
if (displayNameAttrib != null) {
return attributes;
}
// Add a friendlier display name attribute
return AttributeCollection.FromExisting(
attributes,
new DisplayNameAttribute(MakeFriendlyName(name)));
}
private void LoadIndexes()
{
if ((_Indexes == null) || (_Indexes.Count == 0))
{
IRepository <IIndexDefinition> rep = EntityFactory.GetRepository <IIndexDefinition>();
IQueryable qry = (IQueryable)rep;
IExpressionFactory ef = qry.GetExpressionFactory();
ICriteria crit = qry.CreateCriteria();
IExpression accessExp = ef.Le("UserAccess", _UserType);
crit.Add(ef.And(accessExp, ef.Eq("Enabled", true)));
crit.AddOrder(ef.Asc("IndexName"));
IList <IIndexDefinition> tempIndexes = crit.List <IIndexDefinition>();
//c.Add(NHibernate.Expression.Expression.Eq("Enabled", true));
//c.Add(Expression.Le("UserAccess", _UserType));
//c.AddOrder(Order.Asc("IndexName"));
//List<IndexDefinition> tempIndexes = (List<IndexDefinition>)c.List<IndexDefinition>();
Assembly interfaceAsm = Assembly.GetAssembly(typeof(IIndexDefinition));
Type[] types = interfaceAsm.GetTypes();
_TablesEntities = new Dictionary <string, Type>();
foreach (Type entity in types)
{
AttributeCollection attrs = TypeDescriptor.GetAttributes(entity);
foreach (Attribute attr in attrs)
{
ActiveRecordAttribute activeRecord = attr as ActiveRecordAttribute;
if (activeRecord != null)
{
_TablesEntities.Add(activeRecord.Table.ToUpper(), entity);
}
}
}
_Indexes = new List <IIndexDefinition>();
foreach (IIndexDefinition index in tempIndexes)
{
if (index.Type == 1) // database index
{
DBIndexDefinition dbid = DBIndexDefinition.SetFromString(index.MetaData);
if (_TablesEntities.ContainsKey(dbid.MainTable.ToUpper()))
{
_Indexes.Add(index);
}
}
else
{
_Indexes.Add(index);
}
}
}
}
public static void Main()
{
System.ComponentModel.AttributeCollection myAttributes =
TypeDescriptor.GetAttributes(typeof(SimpleWebControl));
DataBindingHandlerAttribute myDataBindingHandlerAttribute =
myAttributes[typeof(DataBindingHandlerAttribute)] as DataBindingHandlerAttribute;
if (myDataBindingHandlerAttribute != null)
{
Console.Write("DataBindingHandlerAttribute's HandlerTypeName is : " +
myDataBindingHandlerAttribute.HandlerTypeName);
}
}
protected override void PreFilterProperties(IDictionary properties)
{
int num2;
base.PreFilterProperties(properties);
PropertyDescriptor descriptor = (PropertyDescriptor)properties["DataSource"];
System.ComponentModel.AttributeCollection attributes = descriptor.Attributes;
int index = -1;
int count = attributes.Count;
string dataSource = this.DataSource;
bool flag = (dataSource != null) && (dataSource.Length > 0);
if (flag)
{
this._keepDataSourceBrowsable = true;
}
for (int i = 0; i < attributes.Count; i++)
{
if (attributes[i] is BrowsableAttribute)
{
index = i;
break;
}
}
if (((index == -1) && !flag) && !this._keepDataSourceBrowsable)
{
num2 = count + 1;
}
else
{
num2 = count;
}
Attribute[] array = new Attribute[num2];
attributes.CopyTo(array, 0);
if (!flag && !this._keepDataSourceBrowsable)
{
if (index == -1)
{
array[count] = BrowsableAttribute.No;
}
else
{
array[index] = BrowsableAttribute.No;
}
}
descriptor = TypeDescriptor.CreateProperty(base.GetType(), "DataSource", typeof(string), array);
properties["DataSource"] = descriptor;
}
/// <summary>
/// 添加标签属性时的触发事件函数.用于设置自身的某些属性值
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnAddingAttribute(object sender, AttributeCollection.AttributeAddingEventArgs e)
{
string name = e.Item.Name.ToLower();
switch (name)
{
case "id":
this.Id = e.Item.Text.Trim();
break;
case "name":
this.Name = e.Item.Text.Trim();
break;
}
OnAddingAttribute(name, e.Item);
}
public static AttributeCollection DeleteNonRelevatAttributes(AttributeCollection collection)
{
ArrayList attributes = GetAttributes(collection);
ArrayList newAttributes = new ArrayList();
foreach (Attribute attr in attributes)
{
if (acceptableAttributes.ContainsKey(attr.GetType())
|| acceptableAttributes.ContainsKey(attr.GetType().BaseType))
{
newAttributes.Add(attr);
}
}
return GetAttributes(newAttributes);
}
public static bool IsPropertyFilterable(PropertyDescriptor propDesc)
{
System.ComponentModel.AttributeCollection attributes = propDesc.Attributes;
if (attributes.Count != 0)
{
foreach (Attribute attrib in attributes)
{
if (attrib is FilterableAttribute)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// 设置对象的只读属性
/// </summary>
/// <param name="myobj">需设置的属性表</param>
/// <param name="Readonly">只读为true，可写为false</param>f
void SetClassReadonly(ReflectoreTest myobj, bool Readonly)
{
if (myobj == null)
{
return; //myobj就是类TaoNei的一个实例
}
var readOnlyAttribute = myobj.GetType().GetCustomAttribute <ReadOnlyAttribute>();
Type readonlyType = typeof(ReadOnlyAttribute);
FieldInfo fld = readonlyType.GetField("isReadOnly", BindingFlags.Instance | BindingFlags.NonPublic);
System.ComponentModel.AttributeCollection attrs = TypeDescriptor.GetAttributes(myobj);
fld.SetValue(attrs[typeof(ReadOnlyAttribute)], Readonly);
}
public static AttributeCollection FromExisting(AttributeCollection existing, params Attribute[] newAttributes)
{
if (existing == null)
{
throw new ArgumentNullException("existing");
}
if (newAttributes == null)
{
newAttributes = new Attribute[0];
}
Attribute[] array = new Attribute[existing.Count + newAttributes.Length];
int count = existing.Count;
existing.CopyTo(array, 0);
for (int i = 0; i < newAttributes.Length; i++)
{
if (newAttributes[i] == null)
{
throw new ArgumentNullException("newAttributes");
}
bool flag = false;
for (int j = 0; j < existing.Count; j++)
{
if (array[j].TypeId.Equals(newAttributes[i].TypeId))
{
flag = true;
array[j] = newAttributes[i];
break;
}
}
if (!flag)
{
array[count++] = newAttributes[i];
}
}
Attribute[] destinationArray = null;
if (count < array.Length)
{
destinationArray = new Attribute[count];
Array.Copy(array, 0, destinationArray, 0, count);
}
else
{
destinationArray = array;
}
return new AttributeCollection(destinationArray);
}
/// <summary>
/// Initializes a new instance of the DomainOperationParameter class
/// </summary>
/// <param name="name">The name of the parameter</param>
/// <param name="parameterType">The Type of the parameter</param>
/// <param name="attributes">The set of attributes for the parameter</param>
public DomainOperationParameter(string name, Type parameterType, AttributeCollection attributes)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
if (parameterType == null)
{
throw new ArgumentNullException("parameterType");
}
if (attributes == null)
{
throw new ArgumentNullException("attributes");
}
this._name = name;
this._parameterType = parameterType;
this._attributes = attributes;
}
public SYNamePropertyDescriptor(PropertyDescriptor descr):base(descr)
{
_d = descr;
int count = _d.Attributes.Count;
Attribute[] attrs = new Attribute[count];
Attribute vis_att = new System.ComponentModel.BrowsableAttribute(true);
for (int i = 0; i < count; ++i)
{
if (_d.Attributes[i].TypeId == vis_att.TypeId)
{
attrs[i] = vis_att;
}
else
{
attrs[i] = _d.Attributes[i];
}
}
_ac = new AttributeCollection(attrs);
//Array.Resize(attrs, attrs.Length + 1);
//attrs[attrs.Length - 1] = new System.ComponentModel.BrowsableAttribute(true);
}
public override AttributeCollection GetAttributes()
{
if (_finalAttributeCollection == null)
{
lock (_lockAttributeGetter)
{
if (_finalAttributeCollection == null)
{
bool metadataModified;
Type reflectedType = TypeDescriptor.GetReflectionType(_configuration.ComponentType);
Attribute[] originalAttributes =
reflectedType.GetCustomAttributes(true).Cast<Attribute>().ToArray();
Attribute[] finalAttributes = GetAttributes(originalAttributes, _configuration,
out metadataModified);
_finalAttributeCollection = new AttributeCollection(finalAttributes);
}
}
}
return _finalAttributeCollection;
}
public string GetDisplayName()
{
if (this._displayName == null)
{
System.ComponentModel.AttributeCollection attributes = TypeDescriptor.GetAttributes(this._dataSourceType);
this._displayName = string.Empty;
if (attributes != null)
{
DisplayNameAttribute attribute = attributes[typeof(DisplayNameAttribute)] as DisplayNameAttribute;
if (attribute != null)
{
this._displayName = attribute.DisplayName;
}
}
if (string.IsNullOrEmpty(this._displayName))
{
this._displayName = this._dataSourceType.Name;
}
}
return(this._displayName);
}
public static bool IsTypeFilterable(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
object result = _filterableTypes[type];
if (result != null)
{
return((bool)result);
}
System.ComponentModel.AttributeCollection attrs = TypeDescriptor.GetAttributes(type);
FilterableAttribute attr = (FilterableAttribute)attrs[typeof(FilterableAttribute)];
result = (attr != null) && attr.Filterable;
_filterableTypes[type] = result;
return((bool)result);
}
public WrappedProperty(MemberDescriptor descr, PropertyView propertyView, Attribute[] attrs)
: base(descr, attrs)
{
this.realPropertyDescriptor = (PropertyDescriptor) descr;
this.name = propertyView.Name;
this.displayName = propertyView.DisplayName;
Attribute[] attribs = new Attribute[descr.Attributes.Count + 4];
int i = 0;
foreach (Attribute attrib in descr.Attributes)
{
attribs[i] = attrib;
i++;
}
attribs[i] = new DescriptionAttribute(propertyView.Description);
attribs[i + 1] = new CategoryAttribute(propertyView.Category);
attribs[i + 2] = new DescriptionAttribute(propertyView.Description);
attribs[i + 3] = new ReadOnlyAttribute(propertyView.IsReadOnly);
attributes = new AttributeCollection(attribs);
}
public ObjectPropertyDescriptor(MemberDescriptor descr, IContext context, IPropertyMap propertyMap, object obj, Attribute[] attrs)
: base(descr, attrs)
{
this.realPropertyDescriptor = (PropertyDescriptor) descr;
this.name = propertyMap.Name;
this.displayName = propertyMap.Name;
Attribute[] attribs = new Attribute[descr.Attributes.Count + 4];
int i = 0;
foreach (Attribute attrib in descr.Attributes)
{
attribs[i] = attrib;
i++;
}
attribs[i] = new DescriptionAttribute(propertyMap.Name + " is a property.");
attribs[i + 1] = new CategoryAttribute("");
attribs[i + 2] = new DefaultValueAttribute(context.ObjectManager.GetOriginalPropertyValue(obj, propertyMap.Name));
attribs[i + 3] = new ReadOnlyAttribute(propertyMap.IsReadOnly);
attributes = new AttributeCollection(attribs);
}
protected static AttributeCollection AddDefaultAttributes(ColumnProvider columnProvider, AttributeCollection attributes) {
List<Attribute> extraAttributes = new List<Attribute>();
// If there is no required attribute and the Provider says required, add one
var requiredAttribute = attributes.FirstOrDefault<RequiredAttribute>();
if (requiredAttribute == null && !columnProvider.Nullable) {
extraAttributes.Add(new RequiredAttribute());
}
// If there is no StringLength attribute and it's a string, add one
var stringLengthAttribute = attributes.FirstOrDefault<StringLengthAttribute>();
int maxLength = columnProvider.MaxLength;
if (stringLengthAttribute == null && columnProvider.ColumnType == typeof(String) && maxLength > 0) {
extraAttributes.Add(new StringLengthAttribute(maxLength));
}
// If we need any extra attributes, create a new collection
if (extraAttributes.Count > 0) {
attributes = AttributeCollection.FromExisting(attributes, extraAttributes.ToArray());
}
return attributes;
}
// In the future, we may want to add Color, Date, etc.
private bool CanEditProperty(PropertyDescriptor property)
{
// Don't show readonly properties
if (property.IsReadOnly)
{
return(false);
}
// Don't show Shared personalizable properties in User mode
if (WebPartManager != null &&
WebPartManager.Personalization != null &&
WebPartManager.Personalization.Scope == PersonalizationScope.User)
{
AttributeCollection attributes = property.Attributes;
if (attributes.Contains(PersonalizableAttribute.SharedPersonalizable))
{
return(false);
}
}
// Only show properties that can be converted to/from string
return(Util.CanConvertToFrom(property.Converter, typeof(string)));
}
public static AttributeCollection GetAttributes(object component, bool noCustomTypeDesc)
{
if (component == null)
{
Debug.Fail("COMPAT: Returning an empty collection, but you should not pass null here");
return new AttributeCollection((Attribute[])null);
}
// We create a sort of pipeline for mucking with metadata. The pipeline
// goes through the following process:
//
// 1. Merge metadata from extenders.
// 2. Allow services to filter the metadata
// 3. If an attribute filter was specified, apply that.
//
// The goal here is speed. We get speed by not copying or
// allocating memory. We do this by allowing each phase of the
// pipeline to cache its data in the object cache. If
// a phase makes a change to the results, this change must cause
// successive phases to recompute their results as well. "Results" is
// always a collection, and the various stages of the pipeline may
// replace or modify this collection (depending on if it's a
// read-only IList or not). It is possible for the orignal
// descriptor or attribute collection to pass through the entire
// pipeline without modification.
//
ICustomTypeDescriptor typeDesc = GetDescriptor(component, noCustomTypeDesc);
ICollection results = typeDesc.GetAttributes();
// If we are handed a custom type descriptor we have several choices of action
// we can take. If noCustomTypeDesc is true, it means that the custom type
// descriptor is trying to find a baseline set of properties. In this case
// we should merge in extended properties, but we do not let designers filter
// because we're not done with the property set yet. If noCustomTypeDesc
// is false, we don't do extender properties because the custom type descriptor
// has already added them. In this case, we are doing a final pass so we
// want to apply filtering. Finally, if the incoming object is not a custom
// type descriptor, we do extenders and the filter.
//
if (component is ICustomTypeDescriptor)
{
if (noCustomTypeDesc)
{
ICustomTypeDescriptor extDesc = GetExtendedDescriptor(component);
if (extDesc != null)
{
ICollection extResults = extDesc.GetAttributes();
results = PipelineMerge(PIPELINE_ATTRIBUTES, results, extResults, component, null);
}
}
else
{
results = PipelineFilter(PIPELINE_ATTRIBUTES, results, component, null);
}
}
else
{
IDictionary cache = GetCache(component);
results = PipelineInitialize(PIPELINE_ATTRIBUTES, results, cache);
ICustomTypeDescriptor extDesc = GetExtendedDescriptor(component);
if (extDesc != null)
{
ICollection extResults = extDesc.GetAttributes();
results = PipelineMerge(PIPELINE_ATTRIBUTES, results, extResults, component, cache);
}
results = PipelineFilter(PIPELINE_ATTRIBUTES, results, component, cache);
}
AttributeCollection attrs = results as AttributeCollection;
if (attrs == null)
{
Trace("Attributes : Allocated new attribute collection for {0}", component.GetType().Name);
Attribute[] attrArray = new Attribute[results.Count];
results.CopyTo(attrArray, 0);
attrs = new AttributeCollection(attrArray);
}
DebugValidate(attrs, component, noCustomTypeDesc);
return attrs;
}
/// <devdoc>
/// Metdata filtering is the third stage of our pipeline.
/// In this stage we check to see if the given object is a
/// sited component that provides the ITypeDescriptorFilterService
/// object. If it does, we allow the TDS to filter the metadata.
/// This will use the cache, if available, to store filtered
/// metdata.
/// </devdoc>
private static ICollection PipelineFilter(int pipelineType, ICollection members, object instance, IDictionary cache)
{
IComponent component = instance as IComponent;
ITypeDescriptorFilterService componentFilter = null;
if (component != null)
{
ISite site = component.Site;
if (site != null)
{
componentFilter = site.GetService(typeof(ITypeDescriptorFilterService)) as ITypeDescriptorFilterService;
}
}
// If we have no filter, there is nothing for us to do.
//
IList list = members as ArrayList;
if (componentFilter == null)
{
Debug.Assert(cache == null || list == null || !cache.Contains(_pipelineFilterKeys[pipelineType]), "Earlier pipeline stage should have removed our cache");
return members;
}
// Now, check our cache. The cache state is only valid
// if the data coming into us is read-only. If it is read-write,
// that means something higher in the pipeline has already changed
// it so we must recompute anyway.
//
if (cache != null && (list == null || list.IsReadOnly))
{
FilterCacheItem cacheItem = cache[_pipelineFilterKeys[pipelineType]] as FilterCacheItem;
if (cacheItem != null && cacheItem.IsValid(componentFilter)) {
return cacheItem.FilteredMembers;
}
}
// Cache either is dirty or doesn't exist. Re-filter the members.
// We need to build an IDictionary of key->value pairs and invoke
// Filter* on the filter service.
//
OrderedDictionary filterTable = new OrderedDictionary(members.Count);
bool cacheResults;
switch(pipelineType)
{
case PIPELINE_ATTRIBUTES:
foreach(Attribute attr in members)
{
filterTable[attr.TypeId] = attr;
}
cacheResults = componentFilter.FilterAttributes(component, filterTable);
break;
case PIPELINE_PROPERTIES:
case PIPELINE_EVENTS:
foreach(MemberDescriptor desc in members)
{
string descName = desc.Name;
// We must handle the case of duplicate property names
// because extender providers can provide any arbitrary
// name. Our rule for this is simple: If we find a
// duplicate name, resolve it back to the extender
// provider that offered it and append "_" + the
// provider name. If the provider has no name,
// then append the object hash code.
//
if (filterTable.Contains(descName))
{
// First, handle the new property. Because
// of the order in which we added extended
// properties earlier in the pipeline, we can be
// sure that the new property is an extender. We
// cannot be sure that the existing property
// in the table is an extender, so we will
// have to check.
//
string suffix = GetExtenderCollisionSuffix(desc);
Debug.Assert(suffix != null, "Name collision with non-extender property.");
if (suffix != null)
{
filterTable[descName + suffix] = desc;
}
// Now, handle the original property.
//
MemberDescriptor origDesc = (MemberDescriptor)filterTable[descName];
suffix = GetExtenderCollisionSuffix(origDesc);
if (suffix != null)
{
filterTable.Remove(descName);
filterTable[origDesc.Name + suffix] = origDesc;
}
}
else
{
filterTable[descName] = desc;
}
}
if (pipelineType == PIPELINE_PROPERTIES)
{
cacheResults = componentFilter.FilterProperties(component, filterTable);
}
else
{
cacheResults = componentFilter.FilterEvents(component, filterTable);
}
break;
default:
Debug.Fail("unknown pipeline type");
cacheResults = false;
break;
}
// See if we can re-use the IList were were passed. If we can,
// it is more efficient to re-use its slots than to generate new ones.
//
if (list == null || list.IsReadOnly)
{
Trace("Pipeline : Filter needs to create member list for {0}", instance.GetType().Name);
list = new ArrayList(filterTable.Values);
}
else
{
list.Clear();
foreach(object obj in filterTable.Values)
{
list.Add(obj);
}
}
// Component filter has requested that we cache these
// new changes. We store them as a correctly typed collection
// so on successive invocations we can simply return. Note that
// we always return the IList so that successive stages in the
// pipeline can modify it.
//
if (cacheResults && cache != null)
{
ICollection cacheValue;
switch(pipelineType)
{
case PIPELINE_ATTRIBUTES:
Attribute[] attrArray = new Attribute[list.Count];
try
{
list.CopyTo(attrArray, 0);
}
catch(InvalidCastException)
{
throw new ArgumentException(SR.GetString(SR.TypeDescriptorExpectedElementType, typeof(Attribute).FullName));
}
cacheValue = new AttributeCollection(attrArray);
break;
case PIPELINE_PROPERTIES:
PropertyDescriptor[] propArray = new PropertyDescriptor[list.Count];
try
{
list.CopyTo(propArray, 0);
}
catch(InvalidCastException)
{
throw new ArgumentException(SR.GetString(SR.TypeDescriptorExpectedElementType, typeof(PropertyDescriptor).FullName));
}
cacheValue = new PropertyDescriptorCollection(propArray, true);
break;
case PIPELINE_EVENTS:
EventDescriptor[] eventArray = new EventDescriptor[list.Count];
try
{
list.CopyTo(eventArray, 0);
}
catch(InvalidCastException)
{
throw new ArgumentException(SR.GetString(SR.TypeDescriptorExpectedElementType, typeof(EventDescriptor).FullName));
}
cacheValue = new EventDescriptorCollection(eventArray, true);
break;
default:
Debug.Fail("unknown pipeline type");
cacheValue = null;
break;
}
Trace("Pipeline : Filter results being cached for {0}", instance.GetType().Name);
FilterCacheItem cacheItem = new FilterCacheItem(componentFilter, cacheValue);
cache[_pipelineFilterKeys[pipelineType]] = cacheItem;
cache.Remove(_pipelineAttributeFilterKeys[pipelineType]);
}
return list;
}
/// <devdoc>
/// Helper method to return an editor attribute of the correct base type.
/// </devdoc>
private static EditorAttribute GetEditorAttribute(AttributeCollection attributes, Type editorBaseType)
{
foreach(Attribute attr in attributes)
{
EditorAttribute edAttr = attr as EditorAttribute;
if (edAttr != null)
{
Type attrEditorBaseType = Type.GetType(edAttr.EditorBaseTypeName);
if (attrEditorBaseType != null && attrEditorBaseType == editorBaseType)
{
return edAttr;
}
}
}
return null;
}
/// <devdoc>
/// Refreshes the contents of this type descriptor. This does not
/// actually requery, but it will clear our state so the next
/// query re-populates.
/// </devdoc>
internal void Refresh()
{
_attributes = null;
_events = null;
_properties = null;
_converter = null;
_editors = null;
_editorTypes = null;
_editorCount = 0;
}
public AttributeListTest()
{
_testAttributes = new Attribute[] { new TestAttribute(), new DerivedAttribute(), new DerivedDerivedAttribute() };
_collection = new AttributeCollection(_testAttributes);
_list = new AttributeList(_collection);
}
/// <devdoc>
/// Retrieves custom attributes.
/// </devdoc>
internal AttributeCollection GetAttributes()
{
// Worst case collision scenario: we don't want the perf hit
// of taking a lock, so if we collide we will query for
// attributes twice. Not a big deal.
//
if (_attributes == null)
{
TypeDescriptor.Trace("Attributes : Building collection for {0}", _type.Name);
// Obtaining attributes follows a very critical order: we must take care that
// we merge attributes the right way. Consider this:
//
// [A4]
// interface IBase;
//
// [A3]
// interface IDerived;
//
// [A2]
// class Base : IBase;
//
// [A1]
// class Derived : Base, IDerived
//
// Calling GetAttributes on type Derived must merge attributes in the following
// order: A1 - A4. Interfaces always lose to types, and interfaces and types
// must be merged in the same order. At the same time, we must be careful
// that we don't always go through reflection here, because someone could have
// created a custom provider for a type. Because there is only one instance
// of ReflectTypeDescriptionProvider created for typeof(object), if our code
// is invoked here we can be sure that there is no custom provider for
// _type all the way up the base class chain.
// We cannot be sure that there is no custom provider for
// interfaces that _type implements, however, because they are not derived
// from _type. So, for interfaces, we must go through TypeDescriptor
// again to get the interfaces attributes.
// Get the type's attributes. This does not recurse up the base class chain.
// We append base class attributes to this array so when walking we will
// walk from Length - 1 to zero.
//
Attribute[] attrArray = ReflectTypeDescriptionProvider.ReflectGetAttributes(_type);
Type baseType = _type.BaseType;
while (baseType != null && baseType != typeof(object))
{
Attribute[] baseArray = ReflectTypeDescriptionProvider.ReflectGetAttributes(baseType);
Attribute[] temp = new Attribute[attrArray.Length + baseArray.Length];
Array.Copy(attrArray, 0, temp, 0, attrArray.Length);
Array.Copy(baseArray, 0, temp, attrArray.Length, baseArray.Length);
attrArray = temp;
baseType = baseType.BaseType;
}
// Next, walk the type's interfaces. We append these to
// the attribute array as well.
//
int ifaceStartIdx = attrArray.Length;
Type[] interfaces = _type.GetInterfaces();
TypeDescriptor.Trace("Attributes : Walking {0} interfaces", interfaces.Length);
for(int idx = 0; idx < interfaces.Length; idx++)
{
Type iface = interfaces[idx];
// only do this for public interfaces.
//
if ((iface.Attributes & (TypeAttributes.Public | TypeAttributes.NestedPublic)) != 0) {
// No need to pass an instance into GetTypeDescriptor here because, if someone provided a custom
// provider based on object, it already would have hit.
AttributeCollection ifaceAttrs = TypeDescriptor.GetAttributes(iface);
if (ifaceAttrs.Count > 0) {
Attribute[] temp = new Attribute[attrArray.Length + ifaceAttrs.Count];
Array.Copy(attrArray, 0, temp, 0, attrArray.Length);
ifaceAttrs.CopyTo(temp, attrArray.Length);
attrArray = temp;
}
}
}
// Finally, put all these attributes in a dictionary and filter out the duplicates.
//
OrderedDictionary attrDictionary = new OrderedDictionary(attrArray.Length);
for (int idx = 0; idx < attrArray.Length; idx++)
{
bool addAttr = true;
if (idx >= ifaceStartIdx) {
for (int ifaceSkipIdx = 0; ifaceSkipIdx < _skipInterfaceAttributeList.Length; ifaceSkipIdx++)
{
if (_skipInterfaceAttributeList[ifaceSkipIdx].IsInstanceOfType(attrArray[idx]))
{
addAttr = false;
break;
}
}
}
if (addAttr && !attrDictionary.Contains(attrArray[idx].TypeId)) {
attrDictionary[attrArray[idx].TypeId] = attrArray[idx];
}
}
attrArray = new Attribute[attrDictionary.Count];
attrDictionary.Values.CopyTo(attrArray, 0);
_attributes = new AttributeCollection(attrArray);
}
return _attributes;
}
private static void DebugValidate(AttributeCollection attributes, AttributeCollection debugAttributes)
{
#if DEBUG
if (attributes.Count >= debugAttributes.Count)
{
foreach(Attribute a in attributes)
{
if (!(a is GuidAttribute) && !(a is ComVisibleAttribute))
{
bool found = false;
bool typeFound = false;
// Many attributes don't implement .Equals correctly,
// so they will fail an equality check. But we want to
// make sure that common ones like Browsable and ReadOnly
// were correctly picked up. So only check the ones in
// component model.
if (!a.GetType().FullName.StartsWith("System.Component"))
{
found = true;
break;
}
if (!found)
{
foreach(Attribute b in debugAttributes)
{
if (!typeFound && a.GetType() == b.GetType())
{
typeFound = true;
}
// Semitrust may throw here.
try
{
if (a.Equals(b))
{
found = true;
break;
}
}
catch
{
found = true;
break;
}
}
}
if (!found && !a.IsDefaultAttribute())
{
if (typeFound)
{
Debug.Fail(string.Format(CultureInfo.InvariantCulture, "TypeDescriptor engine Validation Failure. Attribute {0} was found but failed equality. Perhaps attribute .Equals is not implemented correctly?", a.GetType().Name));
}
else
{
Debug.Fail(string.Format(CultureInfo.InvariantCulture, "TypeDescriptor engine Validation Failure. Attribute {0} should not exist", a.GetType().Name));
}
}
}
}
}
else
{
foreach(Attribute b in debugAttributes)
{
// We skip all interop attributes because interface merging has changed on purpose.
if (!(b is GuidAttribute) && !(b is ComVisibleAttribute) && !(b is InterfaceTypeAttribute) && !(b is ReadOnlyAttribute))
{
bool found = false;
bool typeFound = false;
// Many attributes don't implement .Equals correctly,
// so they will fail an equality check. But we want to
// make sure that common ones like Browsable and ReadOnly
// were correctly picked up. So only check the ones in
// component model.
if (!b.GetType().FullName.StartsWith("System.Component"))
{
found = true;
break;
}
if (!found)
{
foreach(Attribute a in attributes)
{
if (!typeFound && a.GetType() == b.GetType())
{
typeFound = true;
}
// Semitrust may throw here.
try
{
if (b.Equals(a))
{
found = true;
break;
}
}
catch
{
found = true;
break;
}
}
}
if (!found && !b.IsDefaultAttribute())
{
if (!typeFound)
{
Debug.Fail(string.Format(CultureInfo.InvariantCulture, "TypeDescriptor engine Validation Failure. Attribute {0} should exist", b.GetType().Name));
}
}
}
}
}
#endif
}
private static void DebugValidate(AttributeCollection attributes, object instance, bool noCustomTypeDesc)
{
#if DEBUG
if (!DebugShouldValidate(instance)) return;
AttributeCollection debugAttributes = DebugTypeDescriptor.GetAttributes(instance, noCustomTypeDesc);
DebugValidate(attributes, debugAttributes);
#endif
}
/// <devdoc>
/// Metadata merging is the second stage of our metadata pipeline. This stage
/// merges extended metdata with primary metadata, and stores it in
/// the cache if it is available.
/// </devdoc>
private static ICollection PipelineMerge(int pipelineType, ICollection primary, ICollection secondary, object instance, IDictionary cache)
{
// If there is no secondary collection, there is nothing to merge.
//
if (secondary == null || secondary.Count == 0)
{
return primary;
}
// Next, if we were given a cache, see if it has accurate data.
//
if (cache != null)
{
ICollection mergeCache = cache[_pipelineMergeKeys[pipelineType]] as ICollection;
if (mergeCache != null && mergeCache.Count == (primary.Count + secondary.Count))
{
// Walk the merge cache.
IEnumerator mergeEnum = mergeCache.GetEnumerator();
IEnumerator primaryEnum = primary.GetEnumerator();
bool match = true;
while(primaryEnum.MoveNext() && mergeEnum.MoveNext())
{
if (primaryEnum.Current != mergeEnum.Current)
{
match = false;
break;
}
}
if (match)
{
IEnumerator secondaryEnum = secondary.GetEnumerator();
while(secondaryEnum.MoveNext() && mergeEnum.MoveNext())
{
if (secondaryEnum.Current != mergeEnum.Current)
{
match = false;
break;
}
}
}
if (match)
{
return mergeCache;
}
}
}
// Our cache didn't match. We need to merge metadata and return
// the merged copy. We create an array list here, rather than
// an array, because we want successive sections of the
// pipeline to be able to modify it.
//
ArrayList list = new ArrayList(primary.Count + secondary.Count);
foreach(object obj in primary)
{
list.Add(obj);
}
foreach(object obj in secondary)
{
list.Add(obj);
}
if (cache != null)
{
ICollection cacheValue;
switch(pipelineType)
{
case PIPELINE_ATTRIBUTES:
Attribute[] attrArray = new Attribute[list.Count];
list.CopyTo(attrArray, 0);
cacheValue = new AttributeCollection(attrArray);
break;
case PIPELINE_PROPERTIES:
PropertyDescriptor[] propArray = new PropertyDescriptor[list.Count];
list.CopyTo(propArray, 0);
cacheValue = new PropertyDescriptorCollection(propArray, true);
break;
case PIPELINE_EVENTS:
EventDescriptor[] eventArray = new EventDescriptor[list.Count];
list.CopyTo(eventArray, 0);
cacheValue = new EventDescriptorCollection(eventArray, true);
break;
default:
Debug.Fail("unknown pipeline type");
cacheValue = null;
break;
}
Trace("Pipeline : Merge results being cached for {0}", instance.GetType().Name);
cache[_pipelineMergeKeys[pipelineType]] = cacheValue;
cache.Remove(_pipelineFilterKeys[pipelineType]);
cache.Remove(_pipelineAttributeFilterKeys[pipelineType]);
}
return list;
}
public static void DescribeComponent(object instance, ScriptComponentDescriptor descriptor, IUrlResolutionService urlResolver, IControlResolver controlResolver)
{
// validate preconditions
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
if (urlResolver == null)
{
urlResolver = instance as IUrlResolutionService;
}
if (controlResolver == null)
{
controlResolver = instance as IControlResolver;
}
// describe properties
// PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(instance);
PropertyInfo[] properties = instance.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (PropertyInfo prop in properties)
{
ScriptControlPropertyAttribute propAttr = null;
ScriptControlEventAttribute eventAttr = null;
string propertyName = prop.Name;
System.ComponentModel.AttributeCollection attribs = new System.ComponentModel.AttributeCollection(Attribute.GetCustomAttributes(prop, false));
// Try getting a property attribute
propAttr = (ScriptControlPropertyAttribute)attribs[typeof(ScriptControlPropertyAttribute)];
if (propAttr == null || !propAttr.IsScriptProperty)
{
// Try getting an event attribute
eventAttr = (ScriptControlEventAttribute)attribs[typeof(ScriptControlEventAttribute)];
if (eventAttr == null || !eventAttr.IsScriptEvent)
{
continue;
}
}
// attempt to rename the property/event
ClientPropertyNameAttribute nameAttr = (ClientPropertyNameAttribute)attribs[typeof(ClientPropertyNameAttribute)];
if (nameAttr != null && !string.IsNullOrEmpty(nameAttr.PropertyName))
{
propertyName = nameAttr.PropertyName;
}
// determine whether to serialize the value of a property. readOnly properties should always be serialized
//bool serialize = true;// prop.ShouldSerializeValue(instance) || prop.IsReadOnly;
//if (serialize)
//{
// get the value of the property, skip if it is null
Control c = null;
object value = prop.GetValue(instance, new object[0] {
});
if (value == null)
{
continue;
}
// convert and resolve the value
if (eventAttr != null && prop.PropertyType != typeof(String))
{
throw new InvalidOperationException("ScriptControlEventAttribute can only be applied to a property with a PropertyType of System.String.");
}
else
{
if (!prop.PropertyType.IsPrimitive && !prop.PropertyType.IsEnum)
{
if (prop.PropertyType == typeof(Color))
{
value = ColorTranslator.ToHtml((Color)value);
}
else
{
// TODO: Determine if we should let ASP.NET AJAX handle this type of conversion, as it supports JSON serialization
//TypeConverter conv = prop.Converter;
//value = conv.ConvertToString(null, CultureInfo.InvariantCulture, value);
//if (prop.PropertyType == typeof(CssStyleCollection))
// value = (new CssStyleCollectionJSCoverter()).Serialize(value, new JavaScriptSerializer());
//if (prop.PropertyType == typeof(Style))
// value = (new CssStyleCollectionJSCoverter()).Serialize(((Style)value).GetStyleAttributes(null), new JavaScriptSerializer());
Type valueType = value.GetType();
JavaScriptConverterAttribute attr = (JavaScriptConverterAttribute)attribs[typeof(JavaScriptConverterAttribute)];
JavaScriptConverter converter = attr != null ?
(JavaScriptConverter)TypeCreator.CreateInstance(attr.ConverterType) :
JSONSerializerFactory.GetJavaScriptConverter(valueType);
if (converter != null)
{
value = converter.Serialize(value, JSONSerializerFactory.GetJavaScriptSerializer());
}
else
{
value = JSONSerializerExecute.PreSerializeObject(value);
}
//Dictionary<string, object> dict = value as Dictionary<string, object>;
//if (dict != null && !dict.ContainsKey("__type"))
// dict["__type"] = valueType.AssemblyQualifiedName;
}
}
if (attribs[typeof(IDReferencePropertyAttribute)] != null && controlResolver != null)
{
c = controlResolver.ResolveControl((string)value);
}
if (attribs[typeof(UrlPropertyAttribute)] != null && urlResolver != null)
{
value = urlResolver.ResolveClientUrl((string)value);
}
}
// add the value as an appropriate description
if (eventAttr != null)
{
if (!string.IsNullOrEmpty((string)value))
{
descriptor.AddEvent(propertyName, (string)value);
}
}
else if (attribs[typeof(ElementReferenceAttribute)] != null)
{
if (c == null && controlResolver != null)
{
c = controlResolver.ResolveControl((string)value);
}
if (c != null)
{
value = c.ClientID;
}
descriptor.AddElementProperty(propertyName, (string)value);
}
else if (attribs[typeof(ComponentReferenceAttribute)] != null)
{
if (c == null && controlResolver != null)
{
c = controlResolver.ResolveControl((string)value);
}
if (c != null)
{
//ExtenderControlBase ex = c as ExtenderControlBase;
//if (ex != null && ex.BehaviorID.Length > 0)
// value = ex.BehaviorID;
//else
value = c.ClientID;
}
descriptor.AddComponentProperty(propertyName, (string)value);
}
else
{
if (c != null)
{
value = c.ClientID;
}
descriptor.AddProperty(propertyName, value);
}
}
//}
// determine if we should describe methods
foreach (MethodInfo method in instance.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public))
{
ScriptControlMethodAttribute methAttr = (ScriptControlMethodAttribute)Attribute.GetCustomAttribute(method, typeof(ScriptControlMethodAttribute));
if (methAttr == null || !methAttr.IsScriptMethod)
{
continue;
}
// We only need to support emitting the callback target and registering the WebForms.js script if there is at least one valid method
Control control = instance as Control;
if (control != null)
{
// Force WebForms.js
control.Page.ClientScript.GetCallbackEventReference(control, null, null, null);
// Add the callback target
descriptor.AddProperty("_callbackTarget", control.UniqueID);
}
break;
}
}
/// <devdoc>
/// Creates a new AttributeCollection from an existing AttributeCollection
/// </devdoc>
public static AttributeCollection FromExisting(AttributeCollection existing, params Attribute[] newAttributes)
{
// VSWhidbey #75418
// This method should be a constructor, but making it one introduces a breaking change.
//
if (existing == null)
{
throw new ArgumentNullException("existing");
}
if (newAttributes == null)
{
newAttributes = new Attribute[0];
}
Attribute[] newArray = new Attribute[existing.Count + newAttributes.Length];
int actualCount = existing.Count;
existing.CopyTo(newArray, 0);
for (int idx = 0; idx < newAttributes.Length; idx++)
{
if (newAttributes[idx] == null)
{
throw new ArgumentNullException("newAttributes");
}
// We must see if this attribute is already in the existing
// array. If it is, we replace it.
bool match = false;
for (int existingIdx = 0; existingIdx < existing.Count; existingIdx++)
{
if (newArray[existingIdx].TypeId.Equals(newAttributes[idx].TypeId))
{
match = true;
newArray[existingIdx] = newAttributes[idx];
break;
}
}
if (!match)
{
newArray[actualCount++] = newAttributes[idx];
}
}
// Now, if we collapsed some attributes, create a new array.
//
Attribute[] attributes = null;
if (actualCount < newArray.Length)
{
attributes = new Attribute[actualCount];
Array.Copy(newArray, 0, attributes, 0, actualCount);
}
else
{
attributes = newArray;
}
return(new AttributeCollection(attributes));
}
/// <summary>
/// Gets an editor of the specified type.
/// </summary>
public virtual object GetEditor(Type editorBaseType)
{
object editor = null;
// Always grab the attribute collection first here, because if the metadata version
// changes it will invalidate our editor cache.
AttributeCollection attrs = Attributes;
// Check the editors we've already created for this type.
if (_editorTypes != null)
{
for (int i = 0; i < _editorCount; i++)
{
if (_editorTypes[i] == editorBaseType)
{
return _editors[i];
}
}
}
// If one wasn't found, then we must go through the attributes.
if (editor == null)
{
for (int i = 0; i < attrs.Count; i++)
{
if (!(attrs[i] is EditorAttribute attr))
{
continue;
}
Type editorType = GetTypeFromName(attr.EditorBaseTypeName);
if (editorBaseType == editorType)
{
Type type = GetTypeFromName(attr.EditorTypeName);
if (type != null)
{
editor = CreateInstance(type);
break;
}
}
}
// Now, if we failed to find it in our own attributes, go to the
// component descriptor.
if (editor == null)
{
editor = TypeDescriptor.GetEditor(PropertyType, editorBaseType);
}
// Now, another slot in our editor cache for next time
if (_editorTypes == null)
{
_editorTypes = new Type[5];
_editors = new object[5];
}
if (_editorCount >= _editorTypes.Length)
{
Type[] newTypes = new Type[_editorTypes.Length * 2];
object[] newEditors = new object[_editors.Length * 2];
Array.Copy(_editorTypes, newTypes, _editorTypes.Length);
Array.Copy(_editors, newEditors, _editors.Length);
_editorTypes = newTypes;
_editors = newEditors;
}
_editorTypes[_editorCount] = editorBaseType;
_editors[_editorCount++] = editor;
}
return editor;
}
public AttributeList(AttributeCollection attributes)
{
Contract.Assert(attributes != null);
_attributes = attributes;
}
private static void DebugValidate(Type type, AttributeCollection attributes, AttributeCollection debugAttributes)
{
#if DEBUG
if (!DebugShouldValidate(type)) return;
DebugValidate(attributes, debugAttributes);
#endif
}
/// <summary>
/// Retrieves custom attributes.
/// </summary>
internal AttributeCollection GetAttributes()
{
// Worst case collision scenario: we don't want the perf hit
// of taking a lock, so if we collide we will query for
// attributes twice. Not a big deal.
//
if (_attributes == null)
{
// Obtaining attributes follows a very critical order: we must take care that
// we merge attributes the right way. Consider this:
//
// [A4]
// interface IBase;
//
// [A3]
// interface IDerived;
//
// [A2]
// class Base : IBase;
//
// [A1]
// class Derived : Base, IDerived
//
// Calling GetAttributes on type Derived must merge attributes in the following
// order: A1 - A4. Interfaces always lose to types, and interfaces and types
// must be merged in the same order. At the same time, we must be careful
// that we don't always go through reflection here, because someone could have
// created a custom provider for a type. Because there is only one instance
// of ReflectTypeDescriptionProvider created for typeof(object), if our code
// is invoked here we can be sure that there is no custom provider for
// _type all the way up the base class chain.
// We cannot be sure that there is no custom provider for
// interfaces that _type implements, however, because they are not derived
// from _type. So, for interfaces, we must go through TypeDescriptor
// again to get the interfaces attributes.
// Get the type's attributes. This does not recurse up the base class chain.
// We append base class attributes to this array so when walking we will
// walk from Length - 1 to zero.
//
Attribute[] attrArray = ReflectTypeDescriptionProvider.ReflectGetAttributes(_type);
Type baseType = _type.BaseType;
while (baseType != null && baseType != typeof(object))
{
Attribute[] baseArray = ReflectTypeDescriptionProvider.ReflectGetAttributes(baseType);
Attribute[] temp = new Attribute[attrArray.Length + baseArray.Length];
Array.Copy(attrArray, 0, temp, 0, attrArray.Length);
Array.Copy(baseArray, 0, temp, attrArray.Length, baseArray.Length);
attrArray = temp;
baseType = baseType.BaseType;
}
// Next, walk the type's interfaces. We append these to
// the attribute array as well.
//
int ifaceStartIdx = attrArray.Length;
Type[] interfaces = _type.GetInterfaces();
for (int idx = 0; idx < interfaces.Length; idx++)
{
Type iface = interfaces[idx];
// only do this for public interfaces.
//
if ((iface.Attributes & (TypeAttributes.Public | TypeAttributes.NestedPublic)) != 0)
{
// No need to pass an instance into GetTypeDescriptor here because, if someone provided a custom
// provider based on object, it already would have hit.
AttributeCollection ifaceAttrs = TypeDescriptor.GetAttributes(iface);
if (ifaceAttrs.Count > 0)
{
Attribute[] temp = new Attribute[attrArray.Length + ifaceAttrs.Count];
Array.Copy(attrArray, 0, temp, 0, attrArray.Length);
ifaceAttrs.CopyTo(temp, attrArray.Length);
attrArray = temp;
}
}
}
// Finally, put all these attributes in a dictionary and filter out the duplicates.
//
OrderedDictionary attrDictionary = new OrderedDictionary(attrArray.Length);
for (int idx = 0; idx < attrArray.Length; idx++)
{
bool addAttr = true;
if (idx >= ifaceStartIdx)
{
for (int ifaceSkipIdx = 0; ifaceSkipIdx < s_skipInterfaceAttributeList.Length; ifaceSkipIdx++)
{
if (s_skipInterfaceAttributeList[ifaceSkipIdx].IsInstanceOfType(attrArray[idx]))
{
addAttr = false;
break;
}
}
}
if (addAttr && !attrDictionary.Contains(attrArray[idx].TypeId))
{
attrDictionary[attrArray[idx].TypeId] = attrArray[idx];
}
}
attrArray = new Attribute[attrDictionary.Count];
attrDictionary.Values.CopyTo(attrArray, 0);
_attributes = new AttributeCollection(attrArray);
}
return(_attributes);
}
private static void DebugValidate(AttributeCollection attributes, Type type)
{
#if DEBUG
if (!DebugShouldValidate(type)) return;
AttributeCollection debugAttributes = DebugTypeDescriptor.GetAttributes(type);
DebugValidate(attributes, debugAttributes);
#endif
}
internal AttributeCollection GetAttributes()
{
// Worst case collision scenario: we don't want the perf hit
// of taking a lock, so if we collide we will query for
// attributes twice. Not a big deal.
if (_attributes == null)
{
// Obtaining attributes follows a very critical order: we must take care that
// we merge attributes the right way. Consider this:
//
// [A4]
// interface IBase;
//
// [A3]
// interface IDerived;
//
// [A2]
// class Base : IBase;
//
// [A1]
// class Derived : Base, IDerived
//
// Calling GetAttributes on type Derived must merge attributes in the following
// order: A1 - A4. Interfaces always lose to types, and interfaces and types
// must be merged in the same order. At the same time, we must be careful
// that we don't always go through reflection here, because someone could have
// created a custom provider for a type. Because there is only one instance
// of ReflectTypeDescriptionProvider created for typeof(object), if our code
// is invoked here we can be sure that there is no custom provider for
// _type all the way up the base class chain.
// We cannot be sure that there is no custom provider for
// interfaces that _type implements, however, because they are not derived
// from _type. So, for interfaces, we must go through TypeDescriptor
// again to get the interfaces attributes.
// Get the type's attributes. This does not recurse up the base class chain.
// We append base class attributes to this array so when walking we will
// walk from Length - 1 to zero.
//
var attributes = new List <Attribute>(ReflectGetAttributes(_type));
Type baseType = _type.BaseType;
while (baseType != null && baseType != typeof(object))
{
attributes.AddRange(ReflectGetAttributes(baseType));
baseType = baseType.BaseType;
}
// Next, walk the type's interfaces. We append these to
// the attribute array as well.
int ifaceStartIdx = attributes.Count;
Type[] interfaces = _type.GetInterfaces();
for (int idx = 0; idx < interfaces.Length; idx++)
{
// Only do this for public interfaces.
Type iface = interfaces[idx];
if ((iface.Attributes & (TypeAttributes.Public | TypeAttributes.NestedPublic)) != 0)
{
// No need to pass an instance into GetTypeDescriptor here because, if someone provided a custom
// provider based on object, it already would have hit.
attributes.AddRange(TypeDescriptor.GetAttributes(iface).Attributes);
}
}
// Finally, filter out duplicates.
if (attributes.Count != 0)
{
var filter = new HashSet <object>(attributes.Count);
int next = 0;
for (int idx = 0; idx < attributes.Count; idx++)
{
Attribute attr = attributes[idx];
bool addAttr = true;
if (idx >= ifaceStartIdx)
{
for (int ifaceSkipIdx = 0; ifaceSkipIdx < s_skipInterfaceAttributeList.Length; ifaceSkipIdx++)
{
if (s_skipInterfaceAttributeList[ifaceSkipIdx].IsInstanceOfType(attr))
{
addAttr = false;
break;
}
}
}
if (addAttr && filter.Add(attr.TypeId))
{
attributes[next++] = attributes[idx];
}
}
attributes.RemoveRange(next, attributes.Count - next);
}
_attributes = new AttributeCollection(attributes.ToArray());
}
return(_attributes);
}
public static bool ContainsAttributeType <TAttribute>(this AttributeCollection attributes) where TAttribute : Attribute
{
return(attributes.Cast <Attribute>().Any(a => a.GetType() == typeof(TAttribute)));
}
public override AttributeCollection GetAttributes()
{
ArrayList collection = new ArrayList();
foreach (Attribute attribute in base.GetAttributes())
{
//should not have any editor attribute and only one readonly attribute
if (!(attribute is EditorAttribute || attribute is ReadOnlyAttribute))
collection.Add(attribute);
}
collection.Add(new ReadOnlyAttribute(true));
AttributeCollection newCollection = new AttributeCollection((Attribute[])collection.ToArray(typeof(Attribute)));
return newCollection;
}
