314 lines
11 KiB
C#
314 lines
11 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="Container.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.ComponentModel {
|
|
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Security.Permissions;
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Encapsulates
|
|
/// zero or more components.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[HostProtection(SharedState = true)]
|
|
public class Container : IContainer
|
|
{
|
|
private ISite[] sites;
|
|
private int siteCount;
|
|
private ComponentCollection components;
|
|
private ContainerFilterService filter;
|
|
private bool checkedFilter;
|
|
|
|
private object syncObj = new Object();
|
|
|
|
~Container() {
|
|
Dispose(false);
|
|
}
|
|
|
|
// Adds a component to the container.
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Adds the specified component to the <see cref='System.ComponentModel.Container'/>
|
|
/// . The component is unnamed.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public virtual void Add(IComponent component) {
|
|
Add(component, null);
|
|
}
|
|
|
|
// Adds a component to the container.
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Adds the specified component to the <see cref='System.ComponentModel.Container'/> and assigns a name to
|
|
/// it.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public virtual void Add(IComponent component, String name) {
|
|
lock (syncObj) {
|
|
if (component == null) {
|
|
return;
|
|
}
|
|
|
|
ISite site = component.Site;
|
|
|
|
if (site != null && site.Container == this) {
|
|
return;
|
|
}
|
|
|
|
if (sites == null) {
|
|
sites = new ISite[4];
|
|
}
|
|
else {
|
|
// Validate that new components
|
|
// have either a null name or a unique one.
|
|
//
|
|
ValidateName(component, name);
|
|
|
|
if (sites.Length == siteCount) {
|
|
ISite[] newSites = new ISite[siteCount * 2];
|
|
Array.Copy(sites, 0, newSites, 0, siteCount);
|
|
sites = newSites;
|
|
}
|
|
}
|
|
|
|
if (site != null) {
|
|
site.Container.Remove(component);
|
|
}
|
|
|
|
ISite newSite = CreateSite(component, name);
|
|
sites[siteCount++] = newSite;
|
|
component.Site = newSite;
|
|
components = null;
|
|
}
|
|
}
|
|
|
|
// Creates a site for the component within the container.
|
|
/// <devdoc>
|
|
/// <para>Creates a Site <see cref='System.ComponentModel.ISite'/> for the given <see cref='System.ComponentModel.IComponent'/>
|
|
/// and assigns the given name to the site.</para>
|
|
/// </devdoc>
|
|
protected virtual ISite CreateSite(IComponent component, string name) {
|
|
return new Site(component, this, name);
|
|
}
|
|
|
|
// Disposes of the container. A call to the Dispose method indicates that
|
|
// the user of the container has no further need for it.
|
|
//
|
|
// The implementation of Dispose must:
|
|
//
|
|
// (1) Remove any references the container is holding to other components.
|
|
// This is typically accomplished by assigning null to any fields that
|
|
// contain references to other components.
|
|
//
|
|
// (2) Release any system resources that are associated with the container,
|
|
// such as file handles, window handles, or database connections.
|
|
//
|
|
// (3) Dispose of child components by calling the Dispose method of each.
|
|
//
|
|
// Ideally, a call to Dispose will revert a container to the state it was
|
|
// in immediately after it was created. However, this is not a requirement.
|
|
// Following a call to its Dispose method, a container is permitted to raise
|
|
// exceptions for operations that cannot meaningfully be performed.
|
|
//
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Disposes of the <see cref='System.ComponentModel.Container'/>
|
|
/// .
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing) {
|
|
if (disposing) {
|
|
lock (syncObj) {
|
|
while (siteCount > 0) {
|
|
ISite site = sites[--siteCount];
|
|
site.Component.Site = null;
|
|
site.Component.Dispose();
|
|
}
|
|
sites = null;
|
|
components = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected virtual object GetService(Type service) {
|
|
return((service == typeof(IContainer)) ? this : null);
|
|
}
|
|
|
|
// The components in the container.
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets all the components in the <see cref='System.ComponentModel.Container'/>
|
|
/// .
|
|
/// </para>
|
|
/// </devdoc>
|
|
public virtual ComponentCollection Components {
|
|
get {
|
|
lock (syncObj) {
|
|
if (components == null) {
|
|
IComponent[] result = new IComponent[siteCount];
|
|
for (int i = 0; i < siteCount; i++) {
|
|
result[i] = sites[i].Component;
|
|
}
|
|
components = new ComponentCollection(result);
|
|
|
|
// At each component add, if we don't yet have a filter, look for one.
|
|
// Components may add filters.
|
|
if (filter == null && checkedFilter) {
|
|
checkedFilter = false;
|
|
}
|
|
}
|
|
|
|
if (!checkedFilter) {
|
|
filter = GetService(typeof(ContainerFilterService)) as ContainerFilterService;
|
|
checkedFilter = true;
|
|
}
|
|
|
|
if (filter != null) {
|
|
ComponentCollection filteredComponents = filter.FilterComponents(components);
|
|
Debug.Assert(filteredComponents != null, "Incorrect ContainerFilterService implementation.");
|
|
if (filteredComponents != null) {
|
|
components = filteredComponents;
|
|
}
|
|
}
|
|
|
|
return components;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Removes a component from the container.
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Removes a component from the <see cref='System.ComponentModel.Container'/>
|
|
/// .
|
|
/// </para>
|
|
/// </devdoc>
|
|
public virtual void Remove(IComponent component) {
|
|
Remove(component, false);
|
|
}
|
|
|
|
private void Remove(IComponent component, bool preserveSite) {
|
|
lock (syncObj) {
|
|
if (component == null)
|
|
return;
|
|
ISite site = component.Site;
|
|
if (site == null || site.Container != this)
|
|
return;
|
|
if (!preserveSite)
|
|
component.Site = null;
|
|
for (int i = 0; i < siteCount; i++) {
|
|
if (sites[i] == site) {
|
|
siteCount--;
|
|
Array.Copy(sites, i + 1, sites, i, siteCount - i);
|
|
sites[siteCount] = null;
|
|
components = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void RemoveWithoutUnsiting(IComponent component) {
|
|
Remove(component, true);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Validates that the given name is valid for a component. The default implementation
|
|
/// verifies that name is either null or unique compared to the names of other
|
|
/// components in the container.
|
|
/// </devdoc>
|
|
protected virtual void ValidateName(IComponent component, string name) {
|
|
|
|
if (component == null) {
|
|
throw new ArgumentNullException("component");
|
|
}
|
|
|
|
if (name != null) {
|
|
for (int i = 0; i < Math.Min(siteCount,sites.Length); i++) {
|
|
ISite s = sites[ i ];
|
|
|
|
if (s != null && s.Name != null
|
|
&& string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase)
|
|
&& s.Component != component) {
|
|
InheritanceAttribute inheritanceAttribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(s.Component)[typeof(InheritanceAttribute)];
|
|
if(inheritanceAttribute.InheritanceLevel != InheritanceLevel.InheritedReadOnly) {
|
|
throw new ArgumentException(SR.GetString(SR.DuplicateComponentName, name));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private class Site : ISite
|
|
{
|
|
private IComponent component;
|
|
private Container container;
|
|
private String name;
|
|
|
|
internal Site(IComponent component, Container 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 {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|