Component.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / CompMod / System / ComponentModel / Component.cs / 1305376 / Component.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.ComponentModel { 
    using System; 
    using System.ComponentModel.Design;
    using System.ComponentModel.Design.Serialization; 
    using System.Runtime.InteropServices;
    using System.Security.Permissions;

    ///  
    ///    Provides the default implementation for the
    ///     
    ///    interface and enables object-sharing between applications. 
    /// 
    [ 
        ComVisible(true),
        ClassInterface(ClassInterfaceType.AutoDispatch),
        DesignerCategory("Component")
    ] 
    public class Component : MarshalByRefObject, IComponent {
 
        ///  
        ///    Static hask key for the Disposed event. This field is read-only.
        ///  
        private static readonly object EventDisposed = new object();

        private ISite site;
        private EventHandlerList events; 

        ~Component() { 
            Dispose(false); 
        }
 
        /// 
        ///     This property returns true if the component is in a mode that supports
        ///     raising events.  By default, components always support raising their events
        ///     and therefore this method always returns true.  You can override this method 
        ///     in a deriving class and change it to return false when needed.  if the return
        ///     value of this method is false, the EventList collection returned by the Events 
        ///     property will always return null for an event.  Events can still be added and 
        ///     removed from the collection, but retrieving them through the collection's Item
        ///     property will always return null. 
        /// 
        protected virtual bool CanRaiseEvents
        {
            get 
            {
                return true; 
            } 
        }
 
        /// 
        ///     Internal API that allows the event handler list class to access the
        ///     CanRaiseEvents property.
        ///  
        internal bool CanRaiseEventsInternal
        { 
            get 
            {
                return CanRaiseEvents; 
            }
        }

        ///  
        ///    Adds a event handler to listen to the Disposed event on the component.
        ///  
        [ 
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Advanced) 
        ]
        public event EventHandler Disposed {
            add {
                Events.AddHandler(EventDisposed, value); 
            }
            remove { 
                Events.RemoveHandler(EventDisposed, value); 
            }
        } 

        /// 
        ///    Gets the list of event handlers that are attached to this component.
        ///  
        protected EventHandlerList Events {
            get { 
                if (events == null) { 
                    events = new EventHandlerList(this);
                } 
                return events;
            }
        }
 
        /// 
        ///     
        ///       Gets or sets the site of the  
        ///       .
        ///     
        /// 
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ]
        public virtual ISite Site { 
            get { return site;} 
            set { site = value;}
        } 

        /// 
        ///    
        ///       Disposes of the  
        ///       .
        ///     
        ///  
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed")]
        public void Dispose() { 
            Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        /// 
        ///     
        ///    Disposes all the resources associated with this component. 
        ///    If disposing is false then you must never touch any other
        ///    managed objects, as they may already be finalized. When 
        ///    in this state you should dispose any native resources
        ///    that you have a reference to.
        ///    
        ///     
        ///    When disposing is true then you should dispose all data
        ///    and objects you have references to. The normal implementation 
        ///    of this method would look something like: 
        ///    
        ///     
        ///    public void Dispose() {
        ///        Dispose(true);
        ///        GC.SuppressFinalize(this);
        ///    } 
        ///
        ///    protected virtual void Dispose(bool disposing) { 
        ///        if (disposing) { 
        ///            if (myobject != null) {
        ///                myobject.Dispose(); 
        ///                myobject = null;
        ///            }
        ///        }
        ///        if (myhandle != IntPtr.Zero) { 
        ///            NativeMethods.Release(myhandle);
        ///            myhandle = IntPtr.Zero; 
        ///        } 
        ///    }
        /// 
        ///    ~MyClass() {
        ///        Dispose(false);
        ///    }
        ///     
        ///    
        ///    For base classes, you should never override the Finalier (~Class in C#) 
        ///    or the Dispose method that takes no arguments, rather you should 
        ///    always override the Dispose method that takes a bool.
        ///     
        ///    
        ///    protected override void Dispose(bool disposing) {
        ///        if (disposing) {
        ///            if (myobject != null) { 
        ///                myobject.Dispose();
        ///                myobject = null; 
        ///            } 
        ///        }
        ///        if (myhandle != IntPtr.Zero) { 
        ///            NativeMethods.Release(myhandle);
        ///            myhandle = IntPtr.Zero;
        ///        }
        ///        base.Dispose(disposing); 
        ///    }
        ///     
        ///  
        protected virtual void Dispose(bool disposing) {
            if (disposing) { 
                lock(this) {
                    if (site != null && site.Container != null) {
                        site.Container.Remove(this);
                    } 
                    if (events != null) {
                        EventHandler handler = (EventHandler)events[EventDisposed]; 
                        if (handler != null) handler(this, EventArgs.Empty); 
                    }
                } 
            }
        }

        // Returns the component's container. 
        //
        ///  
        ///     
        ///       Returns the 
        ///       that contains the  
        ///       .
        ///    
        /// 
        [ 
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
        ] 
        public IContainer Container {
            get { 
                ISite s = site;
                return s == null? null : s.Container;
            }
        } 

        ///  
        ///     
        ///       Returns an object representing a service provided by
        ///       the  
        ///       .
        ///    
        /// 
        protected virtual object GetService(Type service) { 
            ISite s = site;
            return((s== null) ? null : s.GetService(service)); 
        } 

        ///  
        ///    
        ///       Gets a value indicating whether the 
        ///       is currently in design mode.
        ///     
        /// 
        [ 
        Browsable(false), 
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ] 
        protected bool DesignMode {
            get {
                ISite s = site;
                return(s == null) ? false : s.DesignMode; 
            }
        } 
 
        /// 
        ///  
        ///    
        ///       Returns a  containing the name of the  , if any. This method should not be
        ///       overridden. For
        ///       internal use only. 
        ///    
        ///  
        public override String ToString() { 
            ISite s = site;
 
            if (s != null)
                return s.Name + " [" + GetType().FullName + "]";
            else
                return GetType().FullName; 
        }
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK