We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Contexts \ ArrayWithSize

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //
  16. // DynamicPropertyHolder manages the dynamically registered properties
  17. // and the sinks contributed by them. Dynamic properties may be registered
  18. // to contribute sinks on a per-object basis (on the proxy or server side)
  19. // or on a per-Context basis (in both the client and server contexts).
  20. //
  21. // See also: RemotingServices.RegisterDynamicSink() API
  22. //
  24. namespace System.Runtime.Remoting.Contexts
  25. {
  26.     using System.Runtime.Remoting;
  27.     using System.Runtime.Remoting.Messaging;
  28.     using System;
  29.     using System.Collections;
  30.     using System.Globalization;
  31.     internal class DynamicPropertyHolder
  32.     {
  33.         private const int GROW_BY = 8;
  34.        
  35.         private IDynamicProperty[] _props;
  36.         private int _numProps;
  37.         private IDynamicMessageSink[] _sinks;
  38.        
  39.         internal virtual bool AddDynamicProperty(IDynamicProperty prop)
  40.         {
  41.             lock (this) {
  42.                 // We have to add a sink specific to the given context
  43.                 CheckPropertyNameClash(prop.Name, _props, _numProps);
  44.                
  45.                 // check if we need to grow the array.
  46.                 bool bGrow = false;
  47.                 if (_props == null || _numProps == _props.Length) {
  48.                     _props = GrowPropertiesArray(_props);
  49.                     bGrow = true;
  50.                 }
  51.                 // now add the property
  52.                 _props[_numProps++] = prop;
  53.                
  54.                 // we need to grow the sinks if we grew the props array or we had thrown
  55.                 // away the sinks array due to a recent removal!
  56.                 if (bGrow) {
  57.                     _sinks = GrowDynamicSinksArray(_sinks);
  58.                 }
  59.                
  60.                 if (_sinks == null) {
  61.                     // Some property got unregistered -- we need to recreate
  62.                     // the list of sinks.
  63.                     _sinks = new IDynamicMessageSink[_props.Length];
  64.                     for (int i = 0; i < _numProps; i++) {
  65.                         _sinks[i] = ((IContributeDynamicSink)_props[i]).GetDynamicSink();
  66.                     }
  67.                 }
  68.                 else {
  69.                     // append the Sink to the existing array of Sinks
  70.                     _sinks[_numProps - 1] = ((IContributeDynamicSink)prop).GetDynamicSink();
  71.                 }
  72.                
  73.                 return true;
  74.                
  75.             }
  76.         }
  77.        
  78.         internal virtual bool RemoveDynamicProperty(string name)
  79.         {
  80.             lock (this) {
  81.                 // We have to remove a property for a specific context
  82.                 for (int i = 0; i < _numProps; i++) {
  83.                     if (_props[i].Name.Equals(name)) {
  84.                         _props[i] = _props[_numProps - 1];
  85.                         _numProps--;
  86.                         // throw away the dynamic sink list
  87.                         _sinks = null;
  88.                         return true;
  89.                     }
  90.                 }
  91.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Contexts_NoProperty"), name));
  92.             }
  93.         }
  94.        
  95.         internal virtual IDynamicProperty[] DynamicProperties {
  96.             get {
  97.                 if (_props == null) {
  98.                     return null;
  99.                 }
  100.                 lock (this) {
  101.                     IDynamicProperty[] retProps = new IDynamicProperty[_numProps];
  102.                     Array.Copy(_props, retProps, _numProps);
  103.                     return retProps;
  104.                 }
  105.             }
  106.         }
  107.        
  108.         // We have to do this ArrayWithSize thing instead of
  109.         // separately providing the Array and a Count ... since they
  110.         // may not be in synch with multiple threads changing things
  111.         // We do not want to provide a copy of the array for each
  112.         // call for perf reasons. Besides this is used internally anyways.
  113.         internal virtual ArrayWithSize DynamicSinks {
  114.             get {
  115.                 if (_numProps == 0) {
  116.                     return null;
  117.                 }
  118.                 lock (this) {
  119.                     if (_sinks == null) {
  120.                         // Some property got unregistered -- we need to recreate
  121.                         // the list of sinks.
  122.                         _sinks = new IDynamicMessageSink[_numProps + GROW_BY];
  123.                         for (int i = 0; i < _numProps; i++) {
  124.                             _sinks[i] = ((IContributeDynamicSink)_props[i]).GetDynamicSink();
  125.                         }
  126.                     }
  127.                 }
  128.                 return new ArrayWithSize(_sinks, _numProps);
  129.             }
  130.         }
  131.        
  132.         private static IDynamicMessageSink[] GrowDynamicSinksArray(IDynamicMessageSink[] sinks)
  133.         {
  134.             // grow the array
  135.             int newSize = (sinks != null ? sinks.Length : 0) + GROW_BY;
  136.             IDynamicMessageSink[] newSinks = new IDynamicMessageSink[newSize];
  137.             if (sinks != null) {
  138.                 // Copy existing properties over
  139.                 // Initial size should be chosen so that this rarely happens
  140.                 Array.Copy(sinks, newSinks, sinks.Length);
  141.             }
  142.             return newSinks;
  143.         }
  144.        
  145.         static internal void NotifyDynamicSinks(IMessage msg, ArrayWithSize dynSinks, bool bCliSide, bool bStart, bool bAsync)
  146.         {
  147.             for (int i = 0; i < dynSinks.Count; i++) {
  148.                 if (bStart == true) {
  149.                     dynSinks.Sinks[i].ProcessMessageStart(msg, bCliSide, bAsync);
  150.                 }
  151.                 else {
  152.                     dynSinks.Sinks[i].ProcessMessageFinish(msg, bCliSide, bAsync);
  153.                 }
  154.             }
  155.         }
  156.        
  157.         static internal void CheckPropertyNameClash(string name, IDynamicProperty[] props, int count)
  158.         {
  159.             for (int i = 0; i < count; i++) {
  160.                 if (props[i].Name.Equals(name)) {
  161.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_DuplicatePropertyName"));
  162.                 }
  163.             }
  164.         }
  165.        
  166.         static internal IDynamicProperty[] GrowPropertiesArray(IDynamicProperty[] props)
  167.         {
  168.             // grow the array of IContextProperty objects
  169.             int newSize = (props != null ? props.Length : 0) + GROW_BY;
  170.             IDynamicProperty[] newProps = new IDynamicProperty[newSize];
  171.             if (props != null) {
  172.                 // Copy existing properties over.
  173.                 Array.Copy(props, newProps, props.Length);
  174.             }
  175.             return newProps;
  176.         }
  177.        
  178.     }
  179.     //class DynamicPropertyHolder
  180.     // Used to return a reference to an array and the current fill size
  181.     // in cases where it is not thread safe to provide this info as two
  182.     // separate properties. This is for internal use only.
  183.     internal class ArrayWithSize
  184.     {
  185.         internal IDynamicMessageSink[] Sinks;
  186.         internal int Count;
  187.         internal ArrayWithSize(IDynamicMessageSink[] sinks, int count)
  188.         {
  189.             Sinks = sinks;
  190.             Count = count;
  191.         }
  192.     }
  193.    
  194. }

Developer Fusion