The Labs \ Source Viewer \ SSCLI \ System.Configuration \ CommaDelimitedStringCollection

  1. //------------------------------------------------------------------------------
  2. // <copyright file="CommaDelimitedStringCollection.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. using System;
  16. using System.ComponentModel;
  17. using System.Security.Permissions;
  18. using System.Collections.Generic;
  19. using System.Collections.Specialized;
  20. using System.Reflection;
  21. using System.Text;
  22. namespace System.Configuration
  23. {
  24.    
  25.     public sealed class CommaDelimitedStringCollection : StringCollection
  26.     {
  27.         private bool _Modified;
  28.         private bool _ReadOnly;
  29.         private string _OriginalString;
  30.        
  31.         //
  32.         // Constructor
  33.         //
  34.        
  35.         public CommaDelimitedStringCollection()
  36.         {
  37.             _ReadOnly = false;
  38.             _Modified = false;
  39.             _OriginalString = ToString();
  40.         }
  41.        
  42.         internal void FromString(string list)
  43.         {
  44.             char[] _delimiters = {','};
  45.             if (list != null) {
  46.                 string[] items = list.Split(_delimiters);
  47.                 foreach (string item in items) {
  48.                     string trimmedItem = item.Trim();
  49.                     if (trimmedItem.Length != 0) {
  50.                         Add(item.Trim());
  51.                     }
  52.                 }
  53.             }
  54.             _OriginalString = ToString();
  55.             _ReadOnly = false;
  56.             _Modified = false;
  57.         }
  58.        
  59.         public override string ToString()
  60.         {
  61.             string returnString = null;
  62.            
  63.             if (Count > 0) {
  64.                 StringBuilder sb = new StringBuilder();
  65.                 foreach (string str in this) {
  66.                     ThrowIfContainsDelimiter(str);
  67.                     // Since the add methods are not virtual they could still add bad data
  68.                     // by casting the collection to a string collection. This check will catch
  69.                     // it before serialization, late is better than never.
  70.                     sb.Append(str.Trim());
  71.                     sb.Append(',');
  72.                 }
  73.                 returnString = sb.ToString();
  74.                 if (returnString.Length > 0) {
  75.                     returnString = returnString.Substring(0, returnString.Length - 1);
  76.                 }
  77.                 if (returnString.Length == 0) {
  78.                     returnString = null;
  79.                 }
  80.             }
  81.             return returnString;
  82.         }
  83.        
  84.         private void ThrowIfReadOnly()
  85.         {
  86.             if (IsReadOnly == true) {
  87.                 throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_read_only));
  88.             }
  89.         }
  90.        
  91.         private void ThrowIfContainsDelimiter(string value)
  92.         {
  93.             if (value.Contains(",")) {
  94.                 throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_value_cannot_contain, ","));
  95.             }
  96.         }
  97.        
  98.         public void SetReadOnly()
  99.         {
  100.             _ReadOnly = true;
  101.         }
  102.        
  103.         public bool IsModified {
  104.             get { return _Modified || (ToString() != _OriginalString); }
  105.         }
  106.        
  107.         public new bool IsReadOnly {
  108.             get { return _ReadOnly; }
  109.         }
  110.        
  111.         //
  112.         // Accessors
  113.         //
  114.         public new string this[int index]
  115.         {
  116.             get { return (string)base[index]; }
  117.             set {
  118.                 ThrowIfReadOnly();
  119.                 ThrowIfContainsDelimiter(value);
  120.                 _Modified = true;
  121.                 base[index] = value.Trim();
  122.             }
  123.         }
  124.        
  125.         //
  126.         // Methods
  127.         //
  128.        
  129.         public new void Add(string value)
  130.         {
  131.             ThrowIfReadOnly();
  132.             ThrowIfContainsDelimiter(value);
  133.             _Modified = true;
  134.             base.Add(value.Trim());
  135.         }
  136.        
  137.         public new void AddRange(string[] range)
  138.         {
  139.             ThrowIfReadOnly();
  140.             _Modified = true;
  141.             foreach (string str in range) {
  142.                 ThrowIfContainsDelimiter(str);
  143.                 base.Add(str.Trim());
  144.             }
  145.         }
  146.        
  147.         public new void Clear()
  148.         {
  149.             ThrowIfReadOnly();
  150.             _Modified = true;
  151.             base.Clear();
  152.         }
  153.         public new void Insert(int index, string value)
  154.         {
  155.             ThrowIfReadOnly();
  156.             ThrowIfContainsDelimiter(value);
  157.             _Modified = true;
  158.             base.Insert(index, value.Trim());
  159.         }
  160.        
  161.         public new void Remove(string value)
  162.         {
  163.             ThrowIfReadOnly();
  164.             ThrowIfContainsDelimiter(value);
  165.             _Modified = true;
  166.             base.Remove(value.Trim());
  167.         }
  168.        
  169.         // Clone
  170.         //
  171.         // Clone the object, to get back and object that we can modify
  172.         // without changing the original object
  173.         //
  174.         public CommaDelimitedStringCollection Clone()
  175.         {
  176.             CommaDelimitedStringCollection copy;
  177.            
  178.             copy = new CommaDelimitedStringCollection();
  179.            
  180.             // Copy all values
  181.             foreach (string str in this) {
  182.                 copy.Add(str);
  183.             }
  184.            
  185.             // Copy Attributes
  186.             copy._Modified = false;
  187.             copy._ReadOnly = _ReadOnly;
  188.             copy._OriginalString = _OriginalString;
  189.            
  190.             return copy;
  191.         }
  192.     }
  193. }

Developer Fusion