The Labs \ Source Viewer \ SSCLI \ System.Collections.Specialized \ NameValueCollection

  1. //------------------------------------------------------------------------------
  2. // <copyright file="NameValueCollection.cs" company="Microsoft">
  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. // </copyright>
  14. //------------------------------------------------------------------------------
  15. /*
  16. * Ordered String/String[] collection of name/value pairs with support for null key
  17. * Wraps NameObject collection
  18. *
  19. * Copyright (c) 2000 Microsoft Corporation
  20. */
  21. namespace System.Collections.Specialized
  22. {
  23.    
  24.     using Microsoft.Win32;
  25.     using System.Collections;
  26.     using System.Runtime.Serialization;
  27.     using System.Text;
  28.     using System.Globalization;
  29.    
  30.     /// <devdoc>
  31.     /// <para>Represents a sorted collection of associated <see cref='System.String' qualify='true'/> keys and <see cref='System.String' qualify='true'/> values that
  32.     /// can be accessed either with the hash code of the key or with the index.</para>
  33.     /// </devdoc>
  34.     [Serializable()]
  35.     public class NameValueCollection : NameObjectCollectionBase
  36.     {
  37.        
  38.         private string[] _all;
  39.         private string[] _allKeys;
  40.        
  41.         //
  42.         // Constructors
  43.         //
  44.        
  45.         /// <devdoc>
  46.         /// <para>Creates an empty <see cref='System.Collections.Specialized.NameValueCollection'/> with the default initial capacity
  47.         /// and using the default case-insensitive hash code provider and the default
  48.         /// case-insensitive comparer.</para>
  49.         /// </devdoc>
  50.         public NameValueCollection() : base()
  51.         {
  52.         }
  53.        
  54.         /// <devdoc>
  55.         /// <para>Copies the entries from the specified <see cref='System.Collections.Specialized.NameValueCollection'/> to a new <see cref='System.Collections.Specialized.NameValueCollection'/> with the same initial capacity as
  56.         /// the number of entries copied and using the default case-insensitive hash code
  57.         /// provider and the default case-insensitive comparer.</para>
  58.         /// </devdoc>
  59.         public NameValueCollection(NameValueCollection col) : base(col != null ? col.Comparer : null)
  60.         {
  61.             Add(col);
  62.         }
  63.        
  64.         /// <devdoc>
  65.         /// <para>Creates an empty <see cref='System.Collections.Specialized.NameValueCollection'/> with the default initial capacity
  66.         /// and using the specified case-insensitive hash code provider and the specified
  67.         /// case-insensitive comparer.</para>
  68.         /// </devdoc>
  69.         #pragma warning disable 618
  70.         [Obsolete("Please use NameValueCollection(IEqualityComparer) instead.")]
  71.         public NameValueCollection(IHashCodeProvider hashProvider, IComparer comparer) : base(hashProvider, comparer)
  72.         {
  73.         }
  74.         #pragma warning restore 618
  75.        
  76.         /// <devdoc>
  77.         /// <para>Creates an empty <see cref='System.Collections.Specialized.NameValueCollection'/> with
  78.         /// the specified initial capacity and using the default case-insensitive hash code
  79.         /// provider and the default case-insensitive comparer.</para>
  80.         /// </devdoc>
  81.         public NameValueCollection(int capacity) : base(capacity)
  82.         {
  83.         }
  84.        
  85.         public NameValueCollection(IEqualityComparer equalityComparer) : base(equalityComparer)
  86.         {
  87.         }
  88.        
  89.         public NameValueCollection(Int32 capacity, IEqualityComparer equalityComparer) : base(capacity, equalityComparer)
  90.         {
  91.         }
  92.        
  93.         /// <devdoc>
  94.         /// <para>Copies the entries from the specified <see cref='System.Collections.Specialized.NameValueCollection'/> to a new <see cref='System.Collections.Specialized.NameValueCollection'/> with the specified initial capacity or the
  95.         /// same initial capacity as the number of entries copied, whichever is greater, and
  96.         /// using the default case-insensitive hash code provider and the default
  97.         /// case-insensitive comparer.</para>
  98.         /// </devdoc>
  99.         public NameValueCollection(int capacity, NameValueCollection col) : base(capacity, (col != null ? col.Comparer : null))
  100.         {
  101.             if (col == null) {
  102.                 throw new ArgumentNullException("col");
  103.             }
  104.            
  105.             this.Comparer = col.Comparer;
  106.             Add(col);
  107.         }
  108.        
  109.         /// <devdoc>
  110.         /// <para>Creates an empty <see cref='System.Collections.Specialized.NameValueCollection'/> with the specified initial capacity and
  111.         /// using the specified case-insensitive hash code provider and the specified
  112.         /// case-insensitive comparer.</para>
  113.         /// </devdoc>
  114.         #pragma warning disable 618
  115.         [Obsolete("Please use NameValueCollection(Int32, IEqualityComparer) instead.")]
  116.         public NameValueCollection(int capacity, IHashCodeProvider hashProvider, IComparer comparer) : base(capacity, hashProvider, comparer)
  117.         {
  118.         }
  119.         #pragma warning restore 618
  120.        
  121.         // Allow internal extenders to avoid creating the hashtable/arraylist.
  122.         internal NameValueCollection(DBNull dummy) : base(dummy)
  123.         {
  124.         }
  125.        
  126.        
  127.         //
  128.         // Serialization support
  129.         //
  130.        
  131.         /// <devdoc>
  132.         /// <para>[To be supplied.]</para>
  133.         /// </devdoc>
  134.         protected NameValueCollection(SerializationInfo info, StreamingContext context) : base(info, context)
  135.         {
  136.         }
  137.        
  138.         //
  139.         // Helper methods
  140.         //
  141.        
  142.         /// <devdoc>
  143.         /// <para> Resets the cached arrays of the collection to <see langword='null'/>.</para>
  144.         /// </devdoc>
  145.         protected void InvalidateCachedArrays()
  146.         {
  147.             _all = null;
  148.             _allKeys = null;
  149.         }
  150.        
  151.         private static string GetAsOneString(ArrayList list)
  152.         {
  153.             int n = (list != null) ? list.Count : 0;
  154.            
  155.             if (n == 1) {
  156.                 return (string)list[0];
  157.             }
  158.             else if (n > 1) {
  159.                 StringBuilder s = new StringBuilder((string)list[0]);
  160.                
  161.                 for (int i = 1; i < n; i++) {
  162.                     s.Append(',');
  163.                     s.Append((string)list[i]);
  164.                 }
  165.                
  166.                 return s.ToString();
  167.             }
  168.             else {
  169.                 return null;
  170.             }
  171.         }
  172.        
  173.         private static string[] GetAsStringArray(ArrayList list)
  174.         {
  175.             int n = (list != null) ? list.Count : 0;
  176.             if (n == 0)
  177.                 return null;
  178.            
  179.             string[] array = new string[n];
  180.             list.CopyTo(0, array, 0, n);
  181.             return array;
  182.         }
  183.        
  184.         //
  185.         // Misc public APIs
  186.         //
  187.        
  188.         /// <devdoc>
  189.         /// <para>Copies the entries in the specified <see cref='System.Collections.Specialized.NameValueCollection'/> to the current <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  190.         /// </devdoc>
  191.         public void Add(NameValueCollection c)
  192.         {
  193.             if (c == null) {
  194.                 throw new ArgumentNullException("c");
  195.             }
  196.            
  197.             InvalidateCachedArrays();
  198.            
  199.             int n = c.Count;
  200.            
  201.             for (int i = 0; i < n; i++) {
  202.                 string key = c.GetKey(i);
  203.                 string[] values = c.GetValues(i);
  204.                
  205.                 if (values != null) {
  206.                     for (int j = 0; j < values.Length; j++)
  207.                         Add(key, values[j]);
  208.                 }
  209.                 else {
  210.                     Add(key, null);
  211.                 }
  212.             }
  213.         }
  214.        
  215.         /// <devdoc>
  216.         /// <para>Invalidates the cached arrays and removes all entries
  217.         /// from the <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  218.         /// </devdoc>
  219.         public virtual void Clear()
  220.         {
  221.             if (IsReadOnly)
  222.                 throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));
  223.            
  224.             InvalidateCachedArrays();
  225.             BaseClear();
  226.         }
  227.        
  228.         public void CopyTo(Array dest, int index)
  229.         {
  230.             if (dest == null) {
  231.                 throw new ArgumentNullException("dest");
  232.             }
  233.            
  234.             if (dest.Rank != 1) {
  235.                 throw new ArgumentException(SR.GetString(SR.Arg_MultiRank));
  236.             }
  237.            
  238.             if (index < 0) {
  239.                 throw new ArgumentOutOfRangeException("index", SR.GetString(SR.IndexOutOfRange, index.ToString(CultureInfo.CurrentCulture)));
  240.             }
  241.            
  242.             if (dest.Length - index < Count) {
  243.                 throw new ArgumentException(SR.GetString(SR.Arg_InsufficientSpace));
  244.             }
  245.            
  246.             int n = Count;
  247.             if (_all == null) {
  248.                 _all = new string[n];
  249.                 for (int i = 0; i < n; i++) {
  250.                     _all[i] = Get(i);
  251.                     dest.SetValue(_all[i], i + index);
  252.                 }
  253.             }
  254.             else {
  255.                 for (int i = 0; i < n; i++) {
  256.                     dest.SetValue(_all[i], i + index);
  257.                 }
  258.             }
  259.         }
  260.        
  261.         /// <devdoc>
  262.         /// <para>Gets a value indicating whether the <see cref='System.Collections.Specialized.NameValueCollection'/> contains entries whose keys are not <see langword='null'/>.</para>
  263.         /// </devdoc>
  264.         public bool HasKeys()
  265.         {
  266.             return InternalHasKeys();
  267.         }
  268.        
  269.         /// <devdoc>
  270.         /// <para>Allows derived classes to alter HasKeys().</para>
  271.         /// </devdoc>
  272.         internal virtual bool InternalHasKeys()
  273.         {
  274.             return BaseHasKeys();
  275.         }
  276.        
  277.         //
  278.         // Access by name
  279.         //
  280.        
  281.         /// <devdoc>
  282.         /// <para>Adds an entry with the specified name and value into the
  283.         /// <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  284.         /// </devdoc>
  285.         public virtual void Add(string name, string value)
  286.         {
  287.             if (IsReadOnly)
  288.                 throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));
  289.            
  290.             InvalidateCachedArrays();
  291.            
  292.             ArrayList values = (ArrayList)BaseGet(name);
  293.            
  294.             if (values == null) {
  295.                 // new key - add new key with single value
  296.                 values = new ArrayList(1);
  297.                 if (value != null)
  298.                     values.Add(value);
  299.                 BaseAdd(name, values);
  300.             }
  301.             else {
  302.                 // old key -- append value to the list of values
  303.                 if (value != null)
  304.                     values.Add(value);
  305.             }
  306.         }
  307.        
  308.         /// <devdoc>
  309.         /// <para> Gets the values associated with the specified key from the <see cref='System.Collections.Specialized.NameValueCollection'/> combined into one comma-separated list.</para>
  310.         /// </devdoc>
  311.         public virtual string Get(string name)
  312.         {
  313.             ArrayList values = (ArrayList)BaseGet(name);
  314.             return GetAsOneString(values);
  315.         }
  316.        
  317.         /// <devdoc>
  318.         /// <para>Gets the values associated with the specified key from the <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  319.         /// </devdoc>
  320.         public virtual string[] GetValues(string name)
  321.         {
  322.             ArrayList values = (ArrayList)BaseGet(name);
  323.             return GetAsStringArray(values);
  324.         }
  325.        
  326.         /// <devdoc>
  327.         /// <para>Adds a value to an entry in the <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  328.         /// </devdoc>
  329.         public virtual void Set(string name, string value)
  330.         {
  331.             if (IsReadOnly)
  332.                 throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));
  333.            
  334.             InvalidateCachedArrays();
  335.            
  336.             ArrayList values = new ArrayList(1);
  337.             values.Add(value);
  338.             BaseSet(name, values);
  339.         }
  340.        
  341.         /// <devdoc>
  342.         /// <para>Removes the entries with the specified key from the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
  343.         /// </devdoc>
  344.         public virtual void Remove(string name)
  345.         {
  346.             InvalidateCachedArrays();
  347.             BaseRemove(name);
  348.         }
  349.        
  350.         /// <devdoc>
  351.         /// <para> Represents the entry with the specified key in the
  352.         /// <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  353.         /// </devdoc>
  354.         public string this[string name]
  355.         {
  356.             get { return Get(name); }
  357.            
  358.             set { Set(name, value); }
  359.         }
  360.        
  361.         //
  362.         // Indexed access
  363.         //
  364.        
  365.         /// <devdoc>
  366.         /// <para>
  367.         /// Gets the values at the specified index of the <see cref='System.Collections.Specialized.NameValueCollection'/> combined into one
  368.         /// comma-separated list.</para>
  369.         /// </devdoc>
  370.         public virtual string Get(int index)
  371.         {
  372.             ArrayList values = (ArrayList)BaseGet(index);
  373.             return GetAsOneString(values);
  374.         }
  375.        
  376.         /// <devdoc>
  377.         /// <para> Gets the values at the specified index of the <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  378.         /// </devdoc>
  379.         public virtual string[] GetValues(int index)
  380.         {
  381.             ArrayList values = (ArrayList)BaseGet(index);
  382.             return GetAsStringArray(values);
  383.         }
  384.        
  385.         /// <devdoc>
  386.         /// <para>Gets the key at the specified index of the <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  387.         /// </devdoc>
  388.         public virtual string GetKey(int index)
  389.         {
  390.             return BaseGetKey(index);
  391.         }
  392.        
  393.         /// <devdoc>
  394.         /// <para>Represents the entry at the specified index of the <see cref='System.Collections.Specialized.NameValueCollection'/>.</para>
  395.         /// </devdoc>
  396.         public string this[int index]
  397.         {
  398.             get { return Get(index); }
  399.         }
  400.        
  401.         //
  402.         // Access to keys and values as arrays
  403.         //
  404.        
  405.         /// <devdoc>
  406.         /// <para>Gets all the keys in the <see cref='System.Collections.Specialized.NameValueCollection'/>. </para>
  407.         /// </devdoc>
  408.         public virtual string[] AllKeys {
  409.             get {
  410.                 if (_allKeys == null)
  411.                     _allKeys = BaseGetAllKeys();
  412.                 return _allKeys;
  413.             }
  414.         }
  415.     }
  416.    
  417. }

Developer Fusion