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 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);
     }
 }

 /// <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 <see cref="DummyValueInsteadOfNullTypeDescriptionProvider"/>.
		/// </summary>
		public DummyValueInsteadOfNullTypeDescriptionProvider(TypeDescriptionProvider existingProvider,
		                                                      string propertyName, object dummyValue)
			: base(existingProvider)
		{
			this._propertyName = propertyName;
			this._dummyValue = dummyValue;
		}

 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 );
        }

 /// <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 AddProviderTransparent(TypeDescriptionProvider provider, Type type)
        {
            if (provider == null)
            {
                throw new ArgumentNullException(nameof(provider));
            }

            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            AddProvider(provider, type);
        }

		protected TypeDescriptionProvider (TypeDescriptionProvider parent)
		{
			_parent = parent;
		}

	public static void RemoveProviderTransparent (TypeDescriptionProvider provider, Type type)
	{
		RemoveProvider (provider, 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 DefaultTypeDescriptor (TypeDescriptionProvider owner, Type objectType, object instance)
		{
			this.owner = owner;
			this.objectType = objectType;
			this.instance = instance;
		}

        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 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);
		}
	}

        /// <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 AddProviderTransparent (TypeDescriptionProvider provider, Type type)
	{
		AddProvider (provider, type);
	}