Ejemplo n.º 1
0
 /// <devdoc>
 ///     Creates a new WalkingExtendedTypeDescriptor.
 /// </devdoc>
 internal DefaultExtendedTypeDescriptor(TypeDescriptionNode node, object instance)
 {
     _node = node;
     _instance = instance;
 }
Ejemplo n.º 2
0
 /// <devdoc>
 ///     Creates a new WalkingTypeDescriptor.
 /// </devdoc>
 internal DefaultTypeDescriptor(TypeDescriptionNode node, Type objectType, object instance)
 {
     _node = node;
     _objectType = objectType;
     _instance = instance;
 }
Ejemplo n.º 3
0
        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);
        }
Ejemplo n.º 4
0
        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);
            }
        }
Ejemplo n.º 5
0
        /// <devdoc>
        ///     Retrieves the head type description node for an instance.
        ///     Instance-based node lists are rare.  If a node list is not
        ///     available for a given instance, this will return the head node
        ///     for the instance's type.  This variation offers a bool called
        ///     createDelegator.  If true and there is no node list for this
        ///     instance, NodeFor will create a temporary "delegator node" that,
        ///     when queried, will delegate to the type stored in the instance.
        ///     This is done on demand, which means if someone else added a
        ///     type description provider for the instance's type the delegator
        ///     would pick up the new type.  If a query is being made that does
        ///     not involve publicly exposing the type description provider for
        ///     the instance, the query should pass in fase (the default) for
        ///     createDelegator because no object will be created.
        /// </devdoc>
        private static TypeDescriptionNode NodeFor(object instance, bool createDelegator)
        {
            // For object instances, the provider cache key is not the object (that
            // would keep it in memory).  Instead, it is a subclass of WeakReference
            // that overrides GetHashCode and Equals to make it appear to be the
            // object it is wrapping.  A GC'd object causes WeakReference to return
            // false for all .Equals, but it always returns a valid hash code.

            Debug.Assert(instance != null, "Caller should validate");

            TypeDescriptionNode node = (TypeDescriptionNode)_providerTable[instance];
            if (node == null)
            {
                Type type = instance.GetType();

                if (type.IsCOMObject)
                {
                    type = ComObjectType;
                }

                if (createDelegator)
                {
                    node = new TypeDescriptionNode(new DelegatingTypeDescriptionProvider(type));
                    Trace("Nodes : Allocated new instance node for {0}.  Now {1} nodes", type.Name, _providerTable.Count);
                }
                else
                {
                    node = NodeFor(type);
                }
            }

            return node;
        }
Ejemplo n.º 6
0
        /// <devdoc>
        ///     Retrieves the head type description node for a type.
        ///     A head node pointing to a reflection based type description
        ///     provider will be created on demand.
        ///
        ///     If createDelegator is true, this method will create a delegation
        ///     node for a type if the type has no node of its own.  Delegation
        ///     nodes should be created if you are going to hand this node
        ///     out to a user.  Without a delegation node, user code could
        ///     skip providers that are added after their call.  Delegation
        ///     nodes solve that problem.
        ///
        ///     If createDelegator is false, this method will recurse up the
        ///     base type chain looking for nodes.  
        /// </devdoc>
        private static TypeDescriptionNode NodeFor(Type type, bool createDelegator) {
            Debug.Assert(type != null, "Caller should validate");
            CheckDefaultProvider(type);

            // First, check our provider type table to see if we have a matching
            // provider for this type.  The provider type table is a cache that
            // matches types to providers.  When a new provider is added or
            // an existing one removed, the provider type table is torn
            // down and automatically rebuilt on demand.
            //
            TypeDescriptionNode node = null;
            Type searchType = type;
            
            while (node == null) {
                    node = (TypeDescriptionNode)_providerTypeTable[searchType];
                    if (node == null) {
                        node = (TypeDescriptionNode)_providerTable[searchType];
                    }
            
                    if (node == null) {
                        Type baseType = GetNodeForBaseType(searchType);
                    
                        if (searchType == typeof(object) || baseType == null) {
                        
                            lock (_providerTable) {
                                node = (TypeDescriptionNode)_providerTable[searchType];
                                
                                if (node == null) {
                                    // The reflect type description provider is a default provider that
                                    // can provide type information for all objects.
                                    node = new TypeDescriptionNode(new ReflectTypeDescriptionProvider());
                                    _providerTable[searchType] = node;
                                    Trace("Nodes : Allocated new type node.  Now {0} nodes", _providerTable.Count);
                                }     
                            }
                            
                        }
                        else if (createDelegator) {
                            node = new TypeDescriptionNode(new DelegatingTypeDescriptionProvider(baseType));
                            lock (_providerTable) {
                                _providerTypeTable[searchType] = node;
                            }
                        }
                        else {
                            // Continue our search
                            searchType = baseType;
                        }    
                    }
                }

            return node;
        }
 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);
     }
 }
 private static TypeDescriptionNode NodeFor(Type type, bool createDelegator)
 {
     CheckDefaultProvider(type);
     TypeDescriptionNode node = null;
     Type searchType = type;
     while (node == null)
     {
         node = (TypeDescriptionNode) _providerTypeTable[searchType];
         if (node == null)
         {
             node = (TypeDescriptionNode) _providerTable[searchType];
         }
         if (node == null)
         {
             Type nodeForBaseType = GetNodeForBaseType(searchType);
             if ((searchType == typeof(object)) || (nodeForBaseType == null))
             {
                 lock (_providerTable)
                 {
                     node = (TypeDescriptionNode) _providerTable[searchType];
                     if (node == null)
                     {
                         node = new TypeDescriptionNode(new ReflectTypeDescriptionProvider());
                         _providerTable[searchType] = node;
                     }
                     continue;
                 }
             }
             if (createDelegator)
             {
                 node = new TypeDescriptionNode(new DelegatingTypeDescriptionProvider(nodeForBaseType));
                 _providerTypeTable[searchType] = node;
             }
             else
             {
                 searchType = nodeForBaseType;
             }
         }
     }
     return node;
 }
 public static void AddProvider(TypeDescriptionProvider provider, Type type)
 {
     if (provider == null)
     {
         throw new ArgumentNullException("provider");
     }
     if (type == null)
     {
         throw new ArgumentNullException("type");
     }
     lock (_providerTable)
     {
         TypeDescriptionNode node = NodeFor(type, true);
         TypeDescriptionNode node2 = new TypeDescriptionNode(provider) {
             Next = node
         };
         _providerTable[type] = node2;
         _providerTypeTable.Clear();
     }
     Refresh(type);
 }