Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System/compmod/system/componentmodel/NestedContainer.cs

@@ -0,0 +1,188 @@
+//------------------------------------------------------------------------------
+// <copyright file="NestedContainer.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+namespace System.ComponentModel {
+
+    using System;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Security.Permissions;
+    
+    /// <devdoc>
+    ///     A nested container is a container that is owned by another component.  Nested
+    ///     containers can be found by querying a component site's services for NestedConainter.
+    ///     Nested containers are a useful tool to establish owner relationships among components.
+    ///     All components within a nested container are named with the owning component's name
+    ///     as a prefix.
+    /// </devdoc>
+    [HostProtection(SharedState = true)]
+    public class NestedContainer : Container, INestedContainer {
+
+        private IComponent _owner;
+
+        /// <devdoc>
+        ///     Creates a new NestedContainer.
+        /// </devdoc>
+        public NestedContainer(IComponent owner) {
+            if (owner == null) {
+                throw new ArgumentNullException("owner");
+            }
+            _owner = owner;
+            _owner.Disposed += new EventHandler(OnOwnerDisposed);
+        }
+
+        /// <devdoc>
+        ///     The component that owns this nested container.
+        /// </devdoc>
+        public IComponent Owner {
+            get {
+                return _owner;
+            }
+        }
+
+        /// <devdoc>
+        ///     Retrieves the name of the owning component.  This may be overridden to
+        ///     provide a custom owner name.  The default searches the owner's site for
+        ///     INestedSite and calls FullName, or ISite.Name if there is no nested site.
+        ///     If neither is available, this returns null.
+        /// </devdoc>
+        protected virtual string OwnerName {
+            get {
+                string ownerName = null;
+                if (_owner != null && _owner.Site != null) {
+                    INestedSite nestedOwnerSite = _owner.Site as INestedSite;
+                    if (nestedOwnerSite != null) {
+                        ownerName = nestedOwnerSite.FullName;
+                    }
+                    else {
+                        ownerName = _owner.Site.Name;
+                    }
+                }
+
+                return ownerName;
+            }
+        }
+
+        /// <devdoc>
+        ///     Creates a site for the component within the container.
+        /// </devdoc>
+        protected override ISite CreateSite(IComponent component, string name) {
+            if (component == null) {
+                throw new ArgumentNullException("component");
+            }
+            return new Site(component, this, name);
+        }
+
+        /// <devdoc>
+        ///    Override of Container's dispose.
+        /// </devdoc>
+        protected override void Dispose(bool disposing) {
+            if (disposing) {
+                _owner.Disposed -= new EventHandler(OnOwnerDisposed);
+            }
+            base.Dispose(disposing);
+        }
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        protected override object GetService(Type service) {
+            if (service == typeof(INestedContainer)) {
+                return this;
+            }
+            else {
+                return base.GetService(service);
+            }
+        }
+
+        /// <devdoc>
+        ///     Called when our owning component is destroyed.
+        /// </devdoc>
+        private void OnOwnerDisposed(object sender, EventArgs e) {
+            Dispose();
+        }
+
+        /// <devdoc>
+        ///     Simple site implementation.  We do some special processing to name the site, but 
+        ///     that's about it.
+        /// </devdoc>
+        private class Site : INestedSite
+        {
+            private IComponent component;
+            private NestedContainer container;
+            private string name;
+
+            internal Site(IComponent component, NestedContainer container, string name) {
+                this.component = component;
+                this.container = container;
+                this.name = name;
+            }
+
+            // The component sited by this component site.
+            public IComponent Component {
+                get {
+                    return component;
+                }
+            }
+
+            // The container in which the component is sited.
+            public IContainer Container {
+                get {
+                    return container;
+                }
+            }
+
+            public Object GetService(Type service) {
+
+                return((service == typeof(ISite)) ? this : container.GetService(service));
+            }
+
+            // Indicates whether the component is in design mode.
+            public bool DesignMode {
+                get {
+                    IComponent owner = container.Owner;
+                    if (owner != null && owner.Site != null) {
+                        return owner.Site.DesignMode;
+                    }
+                    return false;
+                }
+            }
+
+            public string FullName {
+                get {
+                    if (name != null) {
+                        string ownerName = container.OwnerName;
+                        string childName = name;
+                        if (ownerName != null) {
+                            childName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", ownerName, childName);
+                        }
+
+                        return childName;
+                    }
+
+                    return name;
+                }
+            }
+
+            // The name of the component.
+            //
+            public String Name 
+            {
+                get { 
+                    return name;
+                }
+                set { 
+                    if (value == null || name == null || !value.Equals(name)) {
+                        container.ValidateName(component, value);
+                        name = value;
+                    }
+                }
+            }
+        }
+    }
+}
+