public static void AddProvider(TypeDescriptionProvider provider, object instance)
{
bool flag;
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
lock (_providerTable)
{
flag = _providerTable.ContainsKey(instance);
TypeDescriptionNode node = NodeFor(instance, true);
TypeDescriptionNode node2 = new TypeDescriptionNode(provider) {
Next = node
};
_providerTable.SetWeak(instance, node2);
_providerTypeTable.Clear();
}
if (flag)
{
Refresh(instance, false);
}
}
public ValueBuilder(CultureInfo cultureInfo, ITypeConverter typeConverter)
{
// register custom BooleanTypeConverter, this might be a bad idea.
TypeConverterAttribute converterAttribute = new TypeConverterAttribute(typeof(CustomBooleanConverter));
_typeDescriptorProvider = TypeDescriptor.AddAttributes(typeof(Boolean), converterAttribute);
this._typeConverter = typeConverter;
this._culture = cultureInfo;
this._errorCollector = null;
this._targetType = new Stack<Type>();
this._errorHandlers = new Stack<EventHandler<ErrorEventArg>>();
this.ResolveInterfaceType +=
(sender, args) =>
{
if (args.RealType != null)
return;
if (typeof(IEnumerable) == args.InterfaceType)
args.RealType = typeof(List<object>);
else
{
Type[] genArgs;
if (args.InterfaceType.IsOfGenericType(typeof(IEnumerable<>), out genArgs))
args.RealType = typeof(List<>).MakeGenericType(genArgs);
if (args.InterfaceType.IsOfGenericType(typeof(IList<>), out genArgs))
args.RealType = typeof(List<>).MakeGenericType(genArgs);
else if (args.InterfaceType.IsOfGenericType(typeof(IDictionary<,>), out genArgs))
args.RealType = typeof(Dictionary<,>).MakeGenericType(genArgs);
else if (args.InterfaceType.IsOfGenericType(typeof(ILookup<,>), out genArgs))
args.RealType = typeof(Lookup<,>).MakeGenericType(genArgs);
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="T:DescriptorBase"/> class.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="objectType">Type of the object.</param>
public DescriptorBase(TypeDescriptionProvider provider, Type objectType)
: base()
{
this.provider = provider;
this.type = objectType;
mProperties = new PropertyDescriptorCollection(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:DescriptorBase"/> class.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="parentdescriptor">The parentdescriptor.</param>
/// <param name="objectType">Type of the object.</param>
public DescriptorBase(ShapeProvider provider, ICustomTypeDescriptor parentdescriptor, Type objectType)
: base(parentdescriptor)
{
this.provider = provider;
this.type = objectType;
mProperties = new PropertyDescriptorCollection(null);
}
/// <summary>
/// Initializes a new instance of <see cref="DummyValueInsteadOfNullTypeDescriptionProvider"/>.
/// </summary>
public DummyValueInsteadOfNullTypeDescriptionProvider(TypeDescriptionProvider existingProvider,
string propertyName, object dummyValue)
: base(existingProvider)
{
this._propertyName = propertyName;
this._dummyValue = dummyValue;
}
public ClientBuildManager(string appVirtualDir, string appPhysicalSourceDir, string appPhysicalTargetDir, ClientBuildManagerParameter parameter, TypeDescriptionProvider typeDescriptionProvider)
{
this._lock = new object();
if (parameter == null)
{
parameter = new ClientBuildManagerParameter();
}
this.InitializeCBMTDPBridge(typeDescriptionProvider);
if (!string.IsNullOrEmpty(appPhysicalTargetDir))
{
parameter.PrecompilationFlags |= PrecompilationFlags.Clean;
}
this._hostingParameters = new HostingEnvironmentParameters();
this._hostingParameters.HostingFlags = HostingEnvironmentFlags.ClientBuildManager | HostingEnvironmentFlags.DontCallAppInitialize;
this._hostingParameters.ClientBuildManagerParameter = parameter;
this._hostingParameters.PrecompilationTargetPhysicalDirectory = appPhysicalTargetDir;
if (typeDescriptionProvider != null)
{
this._hostingParameters.HostingFlags |= HostingEnvironmentFlags.SupportsMultiTargeting;
}
if (appVirtualDir[0] != '/')
{
appVirtualDir = "/" + appVirtualDir;
}
if (((appPhysicalSourceDir == null) && appVirtualDir.StartsWith("/IISExpress/", StringComparison.OrdinalIgnoreCase)) && (appVirtualDir.Length > "/IISExpress/".Length))
{
int index = appVirtualDir.IndexOf('/', "/IISExpress/".Length);
if (index > 0)
{
this._hostingParameters.IISExpressVersion = appVirtualDir.Substring("/IISExpress/".Length, index - "/IISExpress/".Length);
appVirtualDir = appVirtualDir.Substring(index);
}
}
this.Initialize(VirtualPath.CreateNonRelative(appVirtualDir), appPhysicalSourceDir);
}
public static object CreateInstance(IServiceProvider provider, Type objectType, Type [] argTypes, object [] args)
{
if (objectType == null)
{
throw new ArgumentNullException("objectType");
}
object instance = null;
if (provider != null)
{
TypeDescriptionProvider typeDescrProvider = provider.GetService(typeof(TypeDescriptionProvider)) as TypeDescriptionProvider;
if (typeDescrProvider != null)
{
instance = typeDescrProvider.CreateInstance(provider, objectType, argTypes, args);
}
}
// TODO: also search and use the internal providers table once Add/RemoveProvider have been implemented
if (instance == null)
{
instance = Activator.CreateInstance(objectType, args);
}
return(instance);
}
private static MethodInfo ChooseMethodByType(TypeDescriptionProvider provider, List<MethodInfo> methods, ICollection values)
{
MethodInfo info = null;
Type c = null;
foreach (object obj2 in values)
{
Type reflectionType = provider.GetReflectionType(obj2);
MethodInfo info2 = null;
Type type3 = null;
if ((info == null) || ((c != null) && !c.IsAssignableFrom(reflectionType)))
{
foreach (MethodInfo info3 in methods)
{
ParameterInfo info4 = info3.GetParameters()[0];
if (info4 != null)
{
Type type4 = info4.ParameterType.IsArray ? info4.ParameterType.GetElementType() : info4.ParameterType;
if ((type4 != null) && type4.IsAssignableFrom(reflectionType))
{
if (info != null)
{
if (!type4.IsAssignableFrom(c))
{
continue;
}
info = info3;
c = type4;
break;
}
if (info2 == null)
{
info2 = info3;
type3 = type4;
}
else
{
bool flag = type3.IsAssignableFrom(type4);
info2 = flag ? info3 : info2;
type3 = flag ? type4 : type3;
}
}
}
}
}
if (info == null)
{
info = info2;
c = type3;
}
}
return info;
}
internal ParameterEditorUserControl(IServiceProvider serviceProvider, System.Web.UI.Control control, System.ComponentModel.TypeDescriptionProvider provider)
{
this._serviceProvider = serviceProvider;
this._control = control;
this._provider = provider;
this.InitializeComponent();
this.InitializeUI();
this.InitializeParameterEditors();
this._parameterTypes = this.CreateParameterList();
foreach (DictionaryEntry entry in this._parameterTypes)
{
this._parameterTypeComboBox.Items.Add(entry.Value);
}
this._parameterTypeComboBox.InvalidateDropDownWidth();
this.UpdateUI(false);
}
public void GetTypeDescriptorShouldReturnExpectedValue()
{
// arrange
Func<ICustomTypeDescriptor, ICustomTypeDescriptor> factory = parent =>
{
var descriptor = new CustomTypeDescriptor<string>( parent );
descriptor.AddExtensionProperty( "Name", s => s.GetType().Name );
return descriptor;
};
var target = new TypeDescriptionProvider<string>( factory );
// act
var actual = target.GetTypeDescriptor( typeof( string ), "" );
// assert
Assert.NotNull( actual );
Assert.IsType( typeof( CustomTypeDescriptor<string> ), actual );
}
public static void AddProvider (TypeDescriptionProvider provider, object instance)
{
if (provider == null)
throw new ArgumentNullException ("provider");
if (instance == null)
throw new ArgumentNullException ("instance");
lock (componentDescriptionProvidersLock) {
LinkedList <TypeDescriptionProvider> plist;
WeakObjectWrapper instanceWrapper = new WeakObjectWrapper (instance);
if (!componentDescriptionProviders.TryGetValue (instanceWrapper, out plist)) {
plist = new LinkedList <TypeDescriptionProvider> ();
componentDescriptionProviders.Add (new WeakObjectWrapper (instance), plist);
}
plist.AddLast (provider);
instanceWrapper = null;
Refresh (instance);
}
}
public static void RemoveProvider(TypeDescriptionProvider provider, Object instance)
{
}
/// <devdoc>
/// Creates a new type description node.
/// </devdoc>
internal TypeDescriptionNode(TypeDescriptionProvider provider)
{
Provider = provider;
}
public static void RemoveProvider(TypeDescriptionProvider provider, object instance)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
// Walk the nodes until we find the right one, and then remove it.
NodeRemove(instance, provider);
RaiseRefresh(instance);
}
public static void AddProvider(TypeDescriptionProvider provider, Type type)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
lock(_providerTable)
{
// Get the root node, hook it up, and stuff it back into
// the provider cache.
TypeDescriptionNode node = NodeFor(type, true);
TypeDescriptionNode head = new TypeDescriptionNode(provider);
head.Next = node;
_providerTable[type] = head;
_providerTypeTable.Clear();
}
Refresh(type);
}
internal ReadonlyTypeDescriptonProvider(TypeDescriptionProvider realProvider)
: base(realProvider)
{
}
public static void AddProvider(TypeDescriptionProvider provider, Type type)
{
}
static void RemoveProvider (TypeDescriptionProvider provider, LinkedList <TypeDescriptionProvider> plist)
{
LinkedListNode <TypeDescriptionProvider> node = plist.Last;
LinkedListNode <TypeDescriptionProvider> first = plist.First;
TypeDescriptionProvider p;
do {
p = node.Value;
if (p == provider) {
plist.Remove (node);
break;
}
if (node == first)
break;
node = node.Previous;
} while (true);
}
public static void RemoveProviderTransparent (TypeDescriptionProvider provider, object instance)
{
RemoveProvider (provider, instance);
}
public static void RemoveProvider (TypeDescriptionProvider provider, object instance)
{
if (provider == null)
throw new ArgumentNullException ("provider");
if (instance == null)
throw new ArgumentNullException ("instance");
//bool removed = false;
lock (componentDescriptionProvidersLock) {
LinkedList <TypeDescriptionProvider> plist;
WeakObjectWrapper instanceWrapper = new WeakObjectWrapper (instance);
if (componentDescriptionProviders.TryGetValue (instanceWrapper, out plist) && plist.Count > 0) {
RemoveProvider (provider, plist);
//removed = true;
}
instanceWrapper = null;
}
var refreshed = Refreshed;
if (refreshed != null)
refreshed (new RefreshEventArgs (instance));
}
public static void AddProviderTransparent(TypeDescriptionProvider provider, Type type)
{
Contract.Requires(type.Assembly != null);
Contract.Requires(type.Assembly.PermissionSet != null);
}
public static void AddProviderTransparent(TypeDescriptionProvider provider, Object instance)
{
}
public static void AddProvider (TypeDescriptionProvider provider, Type type)
{
if (provider == null)
throw new ArgumentNullException ("provider");
if (type == null)
throw new ArgumentNullException ("type");
lock (typeDescriptionProvidersLock) {
LinkedList <TypeDescriptionProvider> plist;
if (!typeDescriptionProviders.TryGetValue (type, out plist)) {
plist = new LinkedList <TypeDescriptionProvider> ();
typeDescriptionProviders.Add (type, plist);
}
plist.AddLast (provider);
Refresh (type);
}
}
public static void Add(Type type)
{
TypeDescriptionProvider parent = TypeDescriptor.GetProvider(type);
TypeDescriptor.AddProvider(new HyperTypeDescriptionProvider(parent), type);
}
public static void AddProviderTransparent (TypeDescriptionProvider provider, Type type)
{
AddProvider (provider, type);
}
public static void RemoveProvider(TypeDescriptionProvider provider, Type type)
{
}
public static void RemoveProvider (TypeDescriptionProvider provider, Type type)
{
if (provider == null)
throw new ArgumentNullException ("provider");
if (type == null)
throw new ArgumentNullException ("type");
lock (typeDescriptionProvidersLock) {
LinkedList <TypeDescriptionProvider> plist;
if (typeDescriptionProviders.TryGetValue (type, out plist) && plist.Count > 0) {
RemoveProvider (provider, plist);
}
}
var refreshed = Refreshed;
if (refreshed != null)
refreshed (new RefreshEventArgs (type));
}
protected TypeDescriptionProvider (TypeDescriptionProvider parent)
{
_parent = parent;
}
public static void RemoveProviderTransparent (TypeDescriptionProvider provider, Type type)
{
RemoveProvider (provider, type);
}
public static void AddProviderTransparent(TypeDescriptionProvider provider, Type type)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
AddProvider(provider, type);
}
/// <devdoc>
/// There are two versions of the constructor for this class. The empty
/// constructor is identical to using TypeDescriptionProvider(null).
/// If a child type description provider is passed into the constructor,
/// the "base" versions of all methods will call to this parent provider.
/// If no such provider is given, the base versions of the methods will
/// return empty, but valid values.
/// </devdoc>
protected TypeDescriptionProvider(TypeDescriptionProvider parent)
{
_parent = parent;
}
public HyperTypeDescriptionProvider(TypeDescriptionProvider parent)
: base(parent)
{
}
public static void RemoveProvider(TypeDescriptionProvider provider, Type type)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
// Walk the nodes until we find the right one, and then remove it.
NodeRemove(type, provider);
RaiseRefresh(type);
}
public static void RemoveProvider(TypeDescriptionProvider provider, object instance)
{
throw new NotImplementedException();
}
public static void AddProviderTransparent(TypeDescriptionProvider provider, object instance)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
Type type = instance.GetType();
AddProvider(provider, instance);
}
public static void RemoveProviderTransparent(TypeDescriptionProvider provider, Type type)
{
throw new NotImplementedException();
}
/// <devdoc>
/// Simple linked list code to remove an element
/// from the list. Returns the new head to the
/// list. If the head points to an instance of
/// DelegatingTypeDescriptionProvider, we clear the
/// node because all it is doing is delegating elsewhere.
///
/// Note that this behaves a little differently from normal
/// linked list code. In a normal linked list, you remove
/// then target node and fixup the links. In this linked
/// list, we remove the node AFTER the target node, fixup
/// the links, and fixup the underlying providers that each
/// node references. The reason for this is that most
/// providers keep a reference to the previous provider,
/// which is exposed as one of these nodes. Therefore,
/// to remove a provider the node following is most likely
/// referenced by that provider
/// </devdoc>
private static void NodeRemove(object key, TypeDescriptionProvider provider)
{
lock(_providerTable)
{
TypeDescriptionNode head = (TypeDescriptionNode)_providerTable[key];
TypeDescriptionNode target = head;
TypeDescriptionNode prev = null;
while(target != null && target.Provider != provider)
{
prev = target;
target = target.Next;
}
if (target != null)
{
// We have our target node. There are three cases
// to consider: the target is in the middle, the head,
// or the end.
if (target.Next != null) {
// If there is a node after the target node,
// steal the node's provider and store it
// at the target location. This removes
// the provider at the target location without
// the need to modify providers which may be
// pointing to "target".
target.Provider = target.Next.Provider;
// Now remove target.Next from the list
target.Next = target.Next.Next;
// If the new provider we got is a delegating
// provider, we can remove this node from
// the list. The delegating provider should
// always be at the end of the node list.
if (target == head && target.Provider is DelegatingTypeDescriptionProvider) {
Debug.Assert(target.Next == null, "Delegating provider should always be the last provider in the chain.");
_providerTable.Remove(key);
}
}
else if (target != head) {
// If target is the last node, we can't
// assign a new provider over to it. What
// we can do, however, is assign a delegating
// provider into the target node. This routes
// requests from the previous provider into
// the next base type provider list.
// We don't do this if the target is the head.
// In that case, we can remove the node
// altogether since no one is pointing to it.
Type keyType = key as Type;
if (keyType == null) keyType = key.GetType();
target.Provider = new DelegatingTypeDescriptionProvider(keyType.BaseType);
}
else {
_providerTable.Remove(key);
}
// Finally, clear our cache of provider types; it might be invalid
// now.
_providerTypeTable.Clear();
}
}
}
public static void AddProvider(TypeDescriptionProvider provider, Type type)
{
throw new NotImplementedException();
}
public static void AddProvider(TypeDescriptionProvider provider, object instance)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
bool refreshNeeded;
// Get the root node, hook it up, and stuff it back into
// the provider cache.
lock(_providerTable)
{
refreshNeeded = _providerTable.ContainsKey(instance);
TypeDescriptionNode node = NodeFor(instance, true);
TypeDescriptionNode head = new TypeDescriptionNode(provider);
head.Next = node;
_providerTable.SetWeak(instance, head);
_providerTypeTable.Clear();
}
if (refreshNeeded)
{
Refresh(instance, false);
}
}
public static void AddProviderTransparent(TypeDescriptionProvider provider, object instance)
{
throw new NotImplementedException();
}
/// <devdoc>
/// Creates a new attribute provider.
/// </devdoc>
internal AttributeProvider(TypeDescriptionProvider existingProvider, params Attribute[] attrs) : base(existingProvider)
{
_attrs = attrs;
}
public DefaultTypeDescriptor (TypeDescriptionProvider owner, Type objectType, object instance)
{
this.owner = owner;
this.objectType = objectType;
this.instance = instance;
}
public static void AddProviderTransparent(TypeDescriptionProvider provider, object instance)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
Type type = instance.GetType();
PermissionSet typeDescriptorPermission = new PermissionSet(PermissionState.None);
typeDescriptorPermission.AddPermission(new TypeDescriptorPermission(TypeDescriptorPermissionFlags.RestrictedRegistrationAccess));
PermissionSet targetPermissions = type.Assembly.PermissionSet;
targetPermissions = targetPermissions.Union(typeDescriptorPermission);
targetPermissions.Demand();
AddProvider(provider, instance);
}
protected TypeDescriptionProvider(TypeDescriptionProvider parent)
{
throw new NotImplementedException();
}