DynamicPropertyHolder.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 / clr / src / BCL / System / Runtime / Remoting / DynamicPropertyHolder.cs / 1305376 / DynamicPropertyHolder.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
//
//   DynamicPropertyHolder manages the dynamically registered properties 
//   and the sinks contributed by them. Dynamic properties may be registered 
//   to contribute sinks on a per-object basis (on the proxy or server side)
//   or on a per-Context basis (in both the client and server contexts). 
//
//   See also: RemotingServices.RegisterDynamicSink() API
//
 
namespace System.Runtime.Remoting.Contexts {
    using System.Runtime.Remoting; 
    using System.Runtime.Remoting.Messaging; 
    using System;
    using System.Collections; 
    using System.Globalization;
    internal class DynamicPropertyHolder
    {
        private const int GROW_BY                        = 0x8; 

        private IDynamicProperty[] _props; 
        private int _numProps; 
        private IDynamicMessageSink[] _sinks;
 
        [System.Security.SecurityCritical]  // auto-generated
        internal virtual bool AddDynamicProperty(IDynamicProperty prop)
        {
            lock(this) { 
                // We have to add a sink specific to the given context
                CheckPropertyNameClash(prop.Name, _props, _numProps); 
 
                // check if we need to grow the array.
                bool bGrow=false; 
                if (_props == null || _numProps == _props.Length)
                {
                    _props = GrowPropertiesArray(_props);
                    bGrow = true; 
                }
                // now add the property 
                _props[_numProps++] = prop; 

                // we need to grow the sinks if we grew the props array or we had thrown 
                // away the sinks array due to a recent removal!
                if (bGrow)
                {
                    _sinks = GrowDynamicSinksArray(_sinks); 
                }
 
                if (_sinks == null) 
                {
                    // Some property got unregistered -- we need to recreate 
                    // the list of sinks.
                    _sinks = new IDynamicMessageSink[_props.Length];
                    for (int i=0; i<_numProps; i++)
                    { 
                        _sinks[i] =
                                ((IContributeDynamicSink)_props[i]).GetDynamicSink(); 
                    } 
                }
                else 
                {
                    // append the Sink to the existing array of Sinks
                    _sinks[_numProps-1] =
                                        ((IContributeDynamicSink)prop).GetDynamicSink(); 
                }
 
                return true; 

            } 
        }

        [System.Security.SecurityCritical]  // auto-generated
        internal virtual bool RemoveDynamicProperty(String name) 
        {
            lock(this) { 
                // We have to remove a property for a specific context 
                for (int i=0; i<_numProps; i++)
                { 
                    if (_props[i].Name.Equals(name))
                    {
                        _props[i] = _props[_numProps-1];
                        _numProps--; 
                        // throw away the dynamic sink list
                        _sinks = null; 
                        return true; 
                    }
                } 
                throw new RemotingException(
                    String.Format(
                        CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Contexts_NoProperty"),
                        name)); 
            }
        } 
 
        internal virtual IDynamicProperty[] DynamicProperties
        { 
            get
            {
                if (_props == null)
                { 
                    return null;
                } 
                lock (this) 
                {
                    IDynamicProperty[] retProps = new IDynamicProperty[_numProps]; 
                    Array.Copy(_props, retProps, _numProps);
                    return retProps;
                }
            } 
        }
 
        // We have to do this ArrayWithSize thing instead of 
        // separately providing the Array and a Count ... since they
        // may not be in synch with multiple threads changing things 
        // We do not want to provide a copy of the array for each
        // call for perf reasons. Besides this is used internally anyways.
        internal virtual ArrayWithSize DynamicSinks
        { 
            [System.Security.SecurityCritical]  // auto-generated
            get 
            { 
                if (_numProps == 0)
                { 
                    return null;
                }
                lock (this)
                { 
                    if (_sinks == null)
                    { 
                        // Some property got unregistered -- we need to recreate 
                        // the list of sinks.
                        _sinks = new IDynamicMessageSink[_numProps+GROW_BY]; 
                        for (int i=0; i<_numProps; i++)
                        {
                            _sinks[i] =
                                    ((IContributeDynamicSink)_props[i]).GetDynamicSink(); 
                        }
                    } 
                } 
                return new ArrayWithSize(_sinks, _numProps);
            } 
        }

        private static IDynamicMessageSink[] GrowDynamicSinksArray(IDynamicMessageSink[] sinks)
        { 
            // grow the array
            int newSize = (sinks != null ? sinks.Length : 0)  + GROW_BY; 
            IDynamicMessageSink[] newSinks = new IDynamicMessageSink[newSize]; 
            if (sinks != null)
            { 
                // Copy existing properties over
                // Initial size should be chosen so that this rarely happens
                Array.Copy(sinks, newSinks, sinks.Length);
            } 
            return newSinks;
        } 
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static void NotifyDynamicSinks(IMessage msg, 
            ArrayWithSize dynSinks, bool bCliSide, bool bStart, bool bAsync)
        {
            for (int i=0; i

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