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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="ConfigurationSchemaErrors.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. namespace System.Configuration
  16. {
  17.     using System.Collections;
  18.     using System.Collections.Generic;
  19.     using System.Collections.Specialized;
  20.     using System.Text;
  21.    
  22.     internal class ConfigurationSchemaErrors
  23.     {
  24.         // Errors with ExceptionAction.Local are logged to this list.
  25.         // This list is reset when processing of a section is complete.
  26.         // Errors on this list may be added to the _errorsAll list
  27.         // when RetrieveAndResetLocalErrors is called.
  28.         private List<ConfigurationException> _errorsLocal;
  29.        
  30.         // Errors with ExceptionAction.Global are logged to this list.
  31.         private List<ConfigurationException> _errorsGlobal;
  32.        
  33.         // All errors related to a config file are logged to this list.
  34.         // This includes all global errors, all non-specific errors,
  35.         // and local errors for input that applies to this config file.
  36.         private List<ConfigurationException> _errorsAll;
  37.        
  38.         internal ConfigurationSchemaErrors()
  39.         {
  40.         }
  41.        
  42.         internal bool HasLocalErrors {
  43.             get { return ErrorsHelper.GetHasErrors(_errorsLocal); }
  44.         }
  45.        
  46.         internal bool HasGlobalErrors {
  47.             get { return ErrorsHelper.GetHasErrors(_errorsGlobal); }
  48.         }
  49.        
  50.         private bool HasAllErrors {
  51.             get { return ErrorsHelper.GetHasErrors(_errorsAll); }
  52.         }
  53.        
  54.         internal int GlobalErrorCount {
  55.             get { return ErrorsHelper.GetErrorCount(_errorsGlobal); }
  56.         }
  57.        
  58.         //
  59.         // Add a configuration Error.
  60.         //
  61.         internal void AddError(ConfigurationException ce, ExceptionAction action)
  62.         {
  63.             switch (action) {
  64.                 case ExceptionAction.Global:
  65.                     ErrorsHelper.AddError(ref _errorsAll, ce);
  66.                     ErrorsHelper.AddError(ref _errorsGlobal, ce);
  67.                     break;
  68.                 case ExceptionAction.NonSpecific:
  69.                    
  70.                     ErrorsHelper.AddError(ref _errorsAll, ce);
  71.                     break;
  72.                 case ExceptionAction.Local:
  73.                    
  74.                     ErrorsHelper.AddError(ref _errorsLocal, ce);
  75.                     break;
  76.             }
  77.         }
  78.        
  79.         internal void SetSingleGlobalError(ConfigurationException ce)
  80.         {
  81.             _errorsAll = null;
  82.             _errorsLocal = null;
  83.             _errorsGlobal = null;
  84.            
  85.             AddError(ce, ExceptionAction.Global);
  86.         }
  87.        
  88.         internal bool HasErrors(bool ignoreLocal)
  89.         {
  90.             if (ignoreLocal) {
  91.                 return HasGlobalErrors;
  92.             }
  93.             else {
  94.                 return HasAllErrors;
  95.             }
  96.         }
  97.        
  98.         // ThrowIfErrors
  99.         //
  100.         // Throw if Errors were detected and remembered.
  101.         //
  102.         // Parameters:
  103.         // IgnoreLocal - Should we be using the local errors also to
  104.         // detemine if we should throw?
  105.         //
  106.         // Note: We will always return all the errors, no matter what
  107.         // IgnoreLocal is.
  108.         //
  109.         internal void ThrowIfErrors(bool ignoreLocal)
  110.         {
  111.             if (HasErrors(ignoreLocal)) {
  112.                 if (HasGlobalErrors) {
  113.                     // Throw just the global errors, as they invalidate
  114.                     // all other config file parsing.
  115.                     throw new ConfigurationErrorsException(_errorsGlobal);
  116.                 }
  117.                 else {
  118.                     // Throw all errors no matter what
  119.                     throw new ConfigurationErrorsException(_errorsAll);
  120.                 }
  121.             }
  122.         }
  123.        
  124.         // RetrieveAndResetLocalErrors
  125.         //
  126.         // Retrieve the Local Errors, and Reset them to none.
  127.         //
  128.         internal List<ConfigurationException> RetrieveAndResetLocalErrors(bool keepLocalErrors)
  129.         {
  130.             List<ConfigurationException> list = _errorsLocal;
  131.             _errorsLocal = null;
  132.            
  133.             if (keepLocalErrors) {
  134.                 ErrorsHelper.AddErrors(ref _errorsAll, list);
  135.             }
  136.            
  137.             return list;
  138.         }
  139.        
  140.         //
  141.         // Add errors that have been saved for a specific section.
  142.         //
  143.         internal void AddSavedLocalErrors(ICollection<ConfigurationException> coll)
  144.         {
  145.             ErrorsHelper.AddErrors(ref _errorsAll, coll);
  146.         }
  147.        
  148.         // ResetLocalErrors
  149.         //
  150.         // Remove all the Local Errors, so we can start from scratch
  151.         //
  152.         internal void ResetLocalErrors()
  153.         {
  154.             RetrieveAndResetLocalErrors(false);
  155.         }
  156.     }
  157. }

Developer Fusion