public EventDescriptorCollection GetEvents(Attribute[] attributes) => NativeTypeDesc.GetEvents(attributes, true);
/// <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 object GetEditor(Type editorBaseType) => NativeTypeDesc.GetEditor(_entityType, editorBaseType, true);
public EventDescriptorCollection GetEvents() => NativeTypeDesc.GetEvents(_entityType, true);
/// <summary>
/// Retrieves the editor for the given base type.
/// </summary>
internal object GetEditor(object instance, Type editorBaseType)
{
EditorAttribute typeAttr;
// For instances, the design time object for them may want to redefine the
// attributes. So, we search the attribute here based on the instance. If found,
// we then search on the same attribute based on type. If the two don't match, then
// we cannot cache the value and must re-create every time. It is rare for a designer
// to override these attributes, so we want to be smart here.
//
if (instance != null)
{
typeAttr = GetEditorAttribute(TypeDescriptor.GetAttributes(_type), editorBaseType);
EditorAttribute instanceAttr = GetEditorAttribute(TypeDescriptor.GetAttributes(instance), editorBaseType);
if (typeAttr != instanceAttr)
{
Type editorType = GetTypeFromName(instanceAttr.EditorTypeName);
if (editorType != null && editorBaseType.IsAssignableFrom(editorType))
{
return(ReflectTypeDescriptionProvider.CreateInstance(editorType, _type));
}
}
}
// If we got here, we return our type-based editor.
//
lock (this)
{
for (int idx = 0; idx < _editorCount; idx++)
{
if (_editorTypes[idx] == editorBaseType)
{
return(_editors[idx]);
}
}
}
// Editor is not cached yet. Look in the attributes.
//
object editor = null;
typeAttr = GetEditorAttribute(TypeDescriptor.GetAttributes(_type), editorBaseType);
if (typeAttr != null)
{
Type editorType = GetTypeFromName(typeAttr.EditorTypeName);
if (editorType != null && editorBaseType.IsAssignableFrom(editorType))
{
editor = ReflectTypeDescriptionProvider.CreateInstance(editorType, _type);
}
}
// Editor is not in the attributes. Search intrinsic tables.
//
if (editor == null)
{
Hashtable intrinsicEditors = ReflectTypeDescriptionProvider.GetEditorTable(editorBaseType);
if (intrinsicEditors != null)
{
editor = ReflectTypeDescriptionProvider.SearchIntrinsicTable(intrinsicEditors, _type);
}
// As a quick sanity check, check to see that the editor we got back is of
// the correct type.
//
if (editor != null && !editorBaseType.IsInstanceOfType(editor))
{
Debug.Fail($"Editor {editor.GetType().FullName} is not an instance of {editorBaseType.FullName} but it is in that base types table.");
editor = null;
}
}
if (editor != null)
{
lock (this)
{
if (_editorTypes == null || _editorTypes.Length == _editorCount)
{
int newLength = (_editorTypes == null ? 4 : _editorTypes.Length * 2);
Type[] newTypes = new Type[newLength];
object[] newEditors = new object[newLength];
if (_editorTypes != null)
{
_editorTypes.CopyTo(newTypes, 0);
_editors.CopyTo(newEditors, 0);
}
_editorTypes = newTypes;
_editors = newEditors;
_editorTypes[_editorCount] = editorBaseType;
_editors[_editorCount++] = editor;
}
}
}
return(editor);
}
public PropertyDescriptor GetDefaultProperty() => NativeTypeDesc.GetDefaultProperty(_entityType, true);
public string GetComponentName() => NativeTypeDesc.GetComponentName(_entityType, true);
internal DefaultExtendedTypeDescriptor(TypeDescriptor.TypeDescriptionNode node, object instance)
{
this._node = node;
this._instance = instance;
}
public AttributeCollection GetAttributes() => NativeTypeDesc.GetAttributes(_entityType, true);
public string GetClassName() => NativeTypeDesc.GetClassName(_entityType, true);
internal AttributeCollection(object component, bool noCustomTypeDesc) : this(TypeDescriptor.GetAttributes(component, noCustomTypeDesc).Cast <TAttribute>())
{
}
internal AttributeCollection(object component) : this(TypeDescriptor.GetAttributes(component).Cast <TAttribute>())
{
}
/// <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);
}
/// <summary>
/// Initializes a new instance of the <see cref="NameableConverter"/> class.
/// </summary>
/// <param name="type">The type.</param>
/// <exception cref="System.ArgumentException">NameableConverterBadCtorArg - type</exception>
public NameableConverter(Type type)
{
NameableType = type;
UnderlyingType = Nameable.GetUnderlyingType(type) ?? throw new ArgumentException(nameof(type), "type");
UnderlyingTypeConverter = TypeDescriptor.GetConverter(UnderlyingType);
}
public TypeConverter GetConverter() => NativeTypeDesc.GetConverter(_entityType, true);
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
return(TypeDescriptor.GetProperties(value, attributes));
}
public EventDescriptor GetDefaultEvent() => NativeTypeDesc.GetDefaultEvent(_entityType, true);
internal DefaultTypeDescriptor(TypeDescriptor.TypeDescriptionNode node, Type objectType, object instance)
{
this._node = node;
this._objectType = objectType;
this._instance = instance;
}
/// <summary>
/// This method examines all the resources for the provided culture.
/// When it finds a resource with a key in the format of
/// "[objectName].[property name]" it will apply that resource's value
/// to the corresponding property on the object. If there is no matching
/// property the resource will be ignored.
/// </summary>
public virtual void ApplyResources(object value, string objectName, CultureInfo culture)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (objectName == null)
{
throw new ArgumentNullException(nameof(objectName));
}
if (culture == null)
{
culture = CultureInfo.CurrentUICulture;
}
// The general case here will be to always use the same culture, so optimize for
// that. The resourceSets hashtable uses culture as a key. It's value is
// a sorted dictionary that contains ALL the culture values (so it traverses up
// the parent culture chain) for that culture. This means that if ApplyResources
// is called with different cultures there could be some redundancy in the
// table, but it allows the normal case of calling with a single culture to
// be much faster.
//
// The reason we use a SortedDictionary here is to ensure the resources are applied
// in an order consistent with codedom deserialization.
SortedList<string, object> resources;
if (_resourceSets == null)
{
ResourceSet dummy;
_resourceSets = new Hashtable();
resources = FillResources(culture, out dummy);
_resourceSets[culture] = resources;
}
else
{
resources = (SortedList<string, object>)_resourceSets[culture];
if (resources == null || (resources.Comparer.Equals(StringComparer.OrdinalIgnoreCase) != IgnoreCase))
{
ResourceSet dummy;
resources = FillResources(culture, out dummy);
_resourceSets[culture] = resources;
}
}
BindingFlags flags = BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.Instance;
if (IgnoreCase)
{
flags |= BindingFlags.IgnoreCase;
}
bool componentReflect = false;
if (value is IComponent)
{
ISite site = ((IComponent)value).Site;
if (site != null && site.DesignMode)
{
componentReflect = true;
}
}
foreach (KeyValuePair<string, object> kvp in resources)
{
// See if this key matches our object.
//
string key = kvp.Key;
if (key == null)
{
continue;
}
if (IgnoreCase)
{
if (string.Compare(key, 0, objectName, 0, objectName.Length, StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
}
else
{
if (string.CompareOrdinal(key, 0, objectName, 0, objectName.Length) != 0)
{
continue;
}
}
// Character after objectName.Length should be a ".", or else we should continue.
//
int idx = objectName.Length;
if (key.Length <= idx || key[idx] != '.')
{
continue;
}
// Bypass type descriptor if we are not in design mode. TypeDescriptor does an attribute
// scan which is quite expensive.
//
string propName = key.Substring(idx + 1);
if (componentReflect)
{
PropertyDescriptor prop = TypeDescriptor.GetProperties(value).Find(propName, IgnoreCase);
if (prop != null && !prop.IsReadOnly && (kvp.Value == null || prop.PropertyType.IsInstanceOfType(kvp.Value)))
{
prop.SetValue(value, kvp.Value);
}
}
else
{
PropertyInfo prop = null;
try
{
prop = value.GetType().GetProperty(propName, flags);
}
catch (AmbiguousMatchException)
{
// Looks like we ran into a conflict between a declared property and an inherited one.
// In such cases, we choose the most declared one.
Type t = value.GetType();
do
{
prop = t.GetProperty(propName, flags | BindingFlags.DeclaredOnly);
t = t.BaseType;
} while (prop == null && t != null && t != typeof(object));
}
if (prop != null && prop.CanWrite && (kvp.Value == null || prop.PropertyType.IsInstanceOfType(kvp.Value)))
{
prop.SetValue(value, kvp.Value, null);
}
}
}
}