The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Channels.Http \ DictionaryEnumeratorByKeys

  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. // File: CombinedHttpChannel.cs
  17. //
  18. // Summary: Merges the client and server HTTP channels
  19. //
  20. // Classes: public HttpChannel
  21. //
  22. //==========================================================================
  23. using System;
  24. using System.Collections;
  25. using System.Runtime.Remoting;
  26. using System.Runtime.Remoting.Messaging;
  27. using System.Globalization;
  28. using System.Security.Permissions;
  29. namespace System.Runtime.Remoting.Channels.Http
  30. {
  31.    
  32.     public class HttpChannel : BaseChannelWithProperties, IChannelReceiver, IChannelSender, IChannelReceiverHook, ISecurableChannel
  33.     {
  34.         // Cached key set value
  35.         private static ICollection s_keySet = null;
  36.        
  37.         private HttpClientChannel _clientChannel;
  38.         // client channel
  39.         private HttpServerChannel _serverChannel;
  40.         // server channel
  41.         private int _channelPriority = 1;
  42.         // channel priority
  43.         private string _channelName = "http";
  44.         // channel name
  45.         private bool _secure = false;
  46.        
  47.        
  48.         public HttpChannel()
  49.         {
  50.             _clientChannel = new HttpClientChannel();
  51.             _serverChannel = new HttpServerChannel();
  52.         }
  53.         // HttpChannel
  54.         public HttpChannel(int port)
  55.         {
  56.             _clientChannel = new HttpClientChannel();
  57.             _serverChannel = new HttpServerChannel(port);
  58.         }
  59.         // HttpChannel
  60.         public HttpChannel(IDictionary properties, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider)
  61.         {
  62.             Hashtable clientData = new Hashtable();
  63.             Hashtable serverData = new Hashtable();
  64.            
  65.             // divide properties up for respective channels
  66.             if (properties != null) {
  67.                 foreach (DictionaryEntry entry in properties) {
  68.                     switch ((string)entry.Key) {
  69.                         case "name":
  70.                             // general channel properties
  71.                             _channelName = (string)entry.Value;
  72.                             break;
  73.                         case "priority":
  74.                             _channelPriority = Convert.ToInt32((string)entry.Value, CultureInfo.InvariantCulture);
  75.                             break;
  76.                         case "secure":
  77.                             _secure = Convert.ToBoolean(entry.Value, CultureInfo.InvariantCulture);
  78.                             clientData["secure"] = entry.Value;
  79.                             serverData["secure"] = entry.Value;
  80.                             break;
  81.                         default:
  82.                             clientData[entry.Key] = entry.Value;
  83.                             serverData[entry.Key] = entry.Value;
  84.                             break;
  85.                     }
  86.                 }
  87.             }
  88.            
  89.             _clientChannel = new HttpClientChannel(clientData, clientSinkProvider);
  90.             _serverChannel = new HttpServerChannel(serverData, serverSinkProvider);
  91.         }
  92.         // HttpChannel
  93.        
  94.         //
  95.         // ISecurableChannel implementation
  96.         //
  97.         public bool IsSecured {
  98.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  99.             get {
  100.                 if (_clientChannel != null)
  101.                     return _clientChannel.IsSecured;
  102.                 if (_serverChannel != null)
  103.                     return _serverChannel.IsSecured;
  104.                 return false;
  105.             }
  106.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  107.             set {
  108.                 if (((IList)ChannelServices.RegisteredChannels).Contains(this))
  109.                     throw new InvalidOperationException(CoreChannel.GetResourceString("Remoting_InvalidOperation_IsSecuredCannotBeChangedOnRegisteredChannels"));
  110.                 if (_clientChannel != null)
  111.                     _clientChannel.IsSecured = value;
  112.                 if (_serverChannel != null)
  113.                     _serverChannel.IsSecured = value;
  114.             }
  115.         }
  116.        
  117.         //
  118.         // IChannel implementation
  119.         //
  120.        
  121.         public int ChannelPriority {
  122.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  123.             get { return _channelPriority; }
  124.         }
  125.         // ChannelPriority
  126.         public string ChannelName {
  127.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  128.             get { return _channelName; }
  129.         }
  130.         // ChannelName
  131.         // returns channelURI and places object uri into out parameter
  132.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  133.         public string Parse(string url, out string objectURI)
  134.         {
  135.             return HttpChannelHelper.ParseURL(url, out objectURI);
  136.         }
  137.         // Parse
  138.         //
  139.         // end of IChannel implementation
  140.         //
  141.        
  142.        
  143.         //
  144.         // IChannelSender implementation
  145.         //
  146.        
  147.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  148.         public IMessageSink CreateMessageSink(string url, object remoteChannelData, out string objectURI)
  149.         {
  150.             return _clientChannel.CreateMessageSink(url, remoteChannelData, out objectURI);
  151.         }
  152.         // CreateMessageSink
  153.         //
  154.         // end of IChannelSender implementation
  155.         //
  156.        
  157.        
  158.         //
  159.         // IChannelReceiver implementation
  160.         //
  161.        
  162.         public object ChannelData {
  163.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  164.             get { return _serverChannel.ChannelData; }
  165.         }
  166.         // ChannelData
  167.        
  168.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  169.         public string[] GetUrlsForUri(string objectURI)
  170.         {
  171.             return _serverChannel.GetUrlsForUri(objectURI);
  172.         }
  173.         // GetUrlsForUri
  174.        
  175.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  176.         public void StartListening(object data)
  177.         {
  178.             _serverChannel.StartListening(data);
  179.         }
  180.         // StartListening
  181.        
  182.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  183.         public void StopListening(object data)
  184.         {
  185.             _serverChannel.StopListening(data);
  186.         }
  187.         // StopListening
  188.         //
  189.         // IChannelReceiver implementation
  190.         //
  191.        
  192.         //
  193.         // IChannelReceiverHook implementation
  194.         //
  195.        
  196.         public string ChannelScheme {
  197.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  198.             get { return "http"; }
  199.         }
  200.        
  201.         public bool WantsToListen {
  202.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  203.             get { return _serverChannel.WantsToListen; }
  204.            
  205.             set { _serverChannel.WantsToListen = value; }
  206.         }
  207.         // WantsToListen
  208.         public IServerChannelSink ChannelSinkChain {
  209.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  210.             get { return _serverChannel.ChannelSinkChain; }
  211.         }
  212.         // ChannelSinkChain
  213.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  214.         public void AddHookChannelUri(string channelUri)
  215.         {
  216.             _serverChannel.AddHookChannelUri(channelUri);
  217.         }
  218.         // AddHookChannelUri
  219.         //
  220.         // IChannelReceiverHook implementation
  221.         //
  222.        
  223.        
  224.         //
  225.         // Support for properties (through BaseChannelWithProperties)
  226.         //
  227.        
  228.         public override IDictionary Properties {
  229.             [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure, Infrastructure = true)]
  230.             get {
  231.                 ArrayList dictionaries = new ArrayList(2);
  232.                 dictionaries.Add(_clientChannel.Properties);
  233.                 dictionaries.Add(_serverChannel.Properties);
  234.                
  235.                 // return a dictionary that spans all dictionaries provided
  236.                 return new AggregateDictionary(dictionaries);
  237.             }
  238.         }
  239.         // Properties
  240.        
  241.         public override object this[object key]
  242.         {
  243.             get {
  244.                 if (_clientChannel.Contains(key))
  245.                     return _clientChannel[key];
  246.                 else if (_serverChannel.Contains(key))
  247.                     return _serverChannel[key];
  248.                
  249.                 return null;
  250.             }
  251.            
  252.             set {
  253.                 if (_clientChannel.Contains(key))
  254.                     _clientChannel[key] = value;
  255.                 else if (_serverChannel.Contains(key))
  256.                     _serverChannel[key] = value;
  257.             }
  258.         }
  259.         // this[]
  260.        
  261.         public override ICollection Keys {
  262.             get {
  263.                 if (s_keySet == null) {
  264.                     // Don't need to synchronize. Doesn't matter if the list gets
  265.                     // generated twice.
  266.                     ICollection clientKeys = _clientChannel.Keys;
  267.                     ICollection serverKeys = _serverChannel.Keys;
  268.                    
  269.                     int count = clientKeys.Count + serverKeys.Count;
  270.                     ArrayList keys = new ArrayList(count);
  271.                    
  272.                     foreach (object key in clientKeys) {
  273.                         keys.Add(key);
  274.                     }
  275.                    
  276.                     foreach (object key in serverKeys) {
  277.                         keys.Add(key);
  278.                     }
  279.                    
  280.                     s_keySet = keys;
  281.                 }
  282.                
  283.                 return s_keySet;
  284.             }
  285.         }
  286.         // KeySet
  287.        
  288.         //
  289.         // end of Support for properties
  290.         //
  291.        
  292.     }
  293.     // class HttpChannel
  294.    
  295.    
  296.    
  297.     // an enumerator based off of a key set
  298.     // This is a duplicate of the class in mscorlib.
  299.     internal class DictionaryEnumeratorByKeys : IDictionaryEnumerator
  300.     {
  301.         IDictionary _properties;
  302.         IEnumerator _keyEnum;
  303.        
  304.         public DictionaryEnumeratorByKeys(IDictionary properties)
  305.         {
  306.             _properties = properties;
  307.             _keyEnum = properties.Keys.GetEnumerator();
  308.         }
  309.         // PropertyEnumeratorByKeys
  310.         public bool MoveNext()
  311.         {
  312.             return _keyEnum.MoveNext();
  313.         }
  314.         public void Reset()
  315.         {
  316.             _keyEnum.Reset();
  317.         }
  318.         public object Current {
  319.             get { return Entry; }
  320.         }
  321.        
  322.         public DictionaryEntry Entry {
  323.             get { return new DictionaryEntry(Key, Value); }
  324.         }
  325.        
  326.         public object Key {
  327.             get { return _keyEnum.Current; }
  328.         }
  329.         public object Value {
  330.             get { return _properties[Key]; }
  331.         }
  332.        
  333.     }
  334.     // DictionaryEnumeratorByKeys
  335.    
  336.     // combines multiple dictionaries into one
  337.     // (used for channel sink properties
  338.     // This is a duplicate of the class in mscorlib.
  339.     internal class AggregateDictionary : IDictionary
  340.     {
  341.         private ICollection _dictionaries;
  342.        
  343.         public AggregateDictionary(ICollection dictionaries)
  344.         {
  345.             _dictionaries = dictionaries;
  346.         }
  347.         // AggregateDictionary
  348.         //
  349.         // IDictionary implementation
  350.         //
  351.        
  352.         public virtual object this[object key]
  353.         {
  354.             get {
  355.                 foreach (IDictionary dict in _dictionaries) {
  356.                     if (dict.Contains(key))
  357.                         return dict[key];
  358.                 }
  359.                
  360.                 return null;
  361.             }
  362.            
  363.             set {
  364.                 foreach (IDictionary dict in _dictionaries) {
  365.                     if (dict.Contains(key))
  366.                         dict[key] = value;
  367.                 }
  368.             }
  369.         }
  370.         // Object this[Object key]
  371.         public virtual ICollection Keys {
  372.             get {
  373.                 ArrayList keys = new ArrayList();
  374.                 // add keys from every dictionary
  375.                 foreach (IDictionary dict in _dictionaries) {
  376.                     ICollection dictKeys = dict.Keys;
  377.                     if (dictKeys != null) {
  378.                         foreach (object key in dictKeys) {
  379.                             keys.Add(key);
  380.                         }
  381.                     }
  382.                 }
  383.                
  384.                 return keys;
  385.             }
  386.         }
  387.         // Keys
  388.         public virtual ICollection Values {
  389.             get {
  390.                 ArrayList values = new ArrayList();
  391.                 // add values from every dictionary
  392.                 foreach (IDictionary dict in _dictionaries) {
  393.                     ICollection dictValues = dict.Values;
  394.                     if (dictValues != null) {
  395.                         foreach (object value in dictValues) {
  396.                             values.Add(value);
  397.                         }
  398.                     }
  399.                 }
  400.                
  401.                 return values;
  402.             }
  403.         }
  404.         // Values
  405.         public virtual bool Contains(object key)
  406.         {
  407.             foreach (IDictionary dict in _dictionaries) {
  408.                 if (dict.Contains(key))
  409.                     return true;
  410.             }
  411.            
  412.             return false;
  413.         }
  414.         // Contains
  415.         public virtual bool IsReadOnly {
  416.             get { return false; }
  417.         }
  418.         public virtual bool IsFixedSize {
  419.             get { return true; }
  420.         }
  421.        
  422.         // The following three methods should never be implemented because
  423.         // they don't apply to the way IDictionary is being used in this case
  424.         // (plus, IsFixedSize returns true.)
  425.         public virtual void Add(object key, object value)
  426.         {
  427.             throw new NotSupportedException();
  428.         }
  429.         public virtual void Clear()
  430.         {
  431.             throw new NotSupportedException();
  432.         }
  433.         public virtual void Remove(object key)
  434.         {
  435.             throw new NotSupportedException();
  436.         }
  437.        
  438.         public virtual IDictionaryEnumerator GetEnumerator()
  439.         {
  440.             return new DictionaryEnumeratorByKeys(this);
  441.         }
  442.         // GetEnumerator
  443.        
  444.         //
  445.         // end of IDictionary implementation
  446.         //
  447.        
  448.         //
  449.         // ICollection implementation
  450.         //
  451.        
  452.         //ICollection
  453.        
  454.         public virtual void CopyTo(Array array, int index)
  455.         {
  456.             throw new NotSupportedException();
  457.         }
  458.        
  459.         public virtual int Count {
  460.             get {
  461.                 int count = 0;
  462.                
  463.                 foreach (IDictionary dict in _dictionaries) {
  464.                     count += dict.Count;
  465.                 }
  466.                
  467.                 return count;
  468.             }
  469.         }
  470.         // Count
  471.         public virtual object SyncRoot {
  472.             get { return this; }
  473.         }
  474.         public virtual bool IsSynchronized {
  475.             get { return false; }
  476.         }
  477.        
  478.         //
  479.         // end of ICollection implementation
  480.         //
  481.        
  482.         //IEnumerable
  483.         IEnumerator IEnumerable.GetEnumerator()
  484.         {
  485.             return new DictionaryEnumeratorByKeys(this);
  486.         }
  487.        
  488.     }
  489.     // class AggregateDictionary
  490.    
  491. }
  492. // namespace System.Runtime.Remoting.Channels.Http

Developer Fusion