The Labs \ Source Viewer \ SSCLI \ System.Xml \ ExceptionType

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlConvert.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.Xml
  16. {
  17.     using System.IO;
  18.     using System.Text;
  19.     using System.Text.RegularExpressions;
  20.     using System.Globalization;
  21.     using System.Xml.Schema;
  22.     using System.Diagnostics;
  23.     using System.Collections;
  24.    
  25.     // ExceptionType enum is used inside XmlConvert to specify which type of exception should be thrown at some of the verification and exception creating methods
  26.     internal enum ExceptionType
  27.     {
  28.         ArgumentException,
  29.         XmlException
  30.     }
  31.    
  32.     public enum XmlDateTimeSerializationMode
  33.     {
  34.         Local,
  35.         Utc,
  36.         Unspecified,
  37.         RoundtripKind
  38.     }
  39.    
  40.     /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert"]/*' />
  41.     /// <devdoc>
  42.     /// Encodes and decodes XML names according to
  43.     /// the "Encoding of arbitrary Unicode Characters in XML Names" specification.
  44.     /// </devdoc>
  45.     public class XmlConvert
  46.     {
  47.         internal const int SurHighStart = 55296;
  48.         // 1101 10xx
  49.         internal const int SurHighEnd = 56319;
  50.         internal const int SurLowStart = 56320;
  51.         // 1101 11xx
  52.         internal const int SurLowEnd = 57343;
  53.         internal const int SurMask = 64512;
  54.         // 1111 11xx
  55.         static internal char[] crt = new char[] {'\n', '\r', '\t'};
  56.        
  57.         /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.EncodeName"]/*' />
  58.         /// <devdoc>
  59.         /// <para>
  60.         /// Converts names, such
  61.         /// as DataTable or
  62.         /// DataColumn names, that contain characters that are not permitted in
  63.         /// XML names to valid names.</para>
  64.         /// </devdoc>
  65.         public static string EncodeName(string name)
  66.         {
  67.                 /*Name_not_NmToken*/                /*Local?*/            return EncodeName(name, true, false);
  68.         }
  69.        
  70.         /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.EncodeNmToken"]/*' />
  71.         /// <devdoc>
  72.         /// <para> Verifies the name is valid
  73.         /// according to production [7] in the XML spec.</para>
  74.         /// </devdoc>
  75.         public static string EncodeNmToken(string name)
  76.         {
  77.                 /*Name_not_NmToken*/                /*Local?*/            return EncodeName(name, false, false);
  78.         }
  79.         /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.EncodeLocalName"]/*' />
  80.         /// <devdoc>
  81.         /// <para>Converts names, such as DataTable or DataColumn names, that contain
  82.         /// characters that are not permitted in XML names to valid names.</para>
  83.         /// </devdoc>
  84.         public static string EncodeLocalName(string name)
  85.         {
  86.                 /*Name_not_NmToken*/                /*Local?*/            return EncodeName(name, true, true);
  87.         }
  88.        
  89.         /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.DecodeName"]/*' />
  90.         /// <devdoc>
  91.         /// <para>
  92.         /// Transforms an XML name into an object name (such as DataTable or DataColumn).</para>
  93.         /// </devdoc>
  94.        
  95.         public static string DecodeName(string name)
  96.         {
  97.             if (name == null || name.Length == 0)
  98.                 return name;
  99.            
  100.             StringBuilder bufBld = null;
  101.            
  102.             int length = name.Length;
  103.             int copyPosition = 0;
  104.            
  105.             int underscorePos = name.IndexOf('_');
  106.             MatchCollection mc = null;
  107.             IEnumerator en = null;
  108.             if (underscorePos >= 0) {
  109.                 if (c_DecodeCharPattern == null) {
  110.                     c_DecodeCharPattern = new Regex("_[Xx]([0-9a-fA-F]{4}|[0-9a-fA-F]{8})_");
  111.                 }
  112.                 mc = c_DecodeCharPattern.Matches(name, underscorePos);
  113.                 en = mc.GetEnumerator();
  114.             }
  115.             else {
  116.                 return name;
  117.             }
  118.             int matchPos = -1;
  119.             if (en != null && en.MoveNext()) {
  120.                 Match m = (Match)en.Current;
  121.                 matchPos = m.Index;
  122.             }
  123.            
  124.             for (int position = 0; position < length - c_EncodedCharLength + 1; position++) {
  125.                 if (position == matchPos) {
  126.                     if (en.MoveNext()) {
  127.                         Match m = (Match)en.Current;
  128.                         matchPos = m.Index;
  129.                     }
  130.                    
  131.                     if (bufBld == null) {
  132.                         bufBld = new StringBuilder(length + 20);
  133.                     }
  134.                     bufBld.Append(name, copyPosition, position - copyPosition);
  135.                    
  136.                     if (name[position + 6] != '_') {
  137.                         //_x1234_
  138.                            
  139.                         Int32 u = FromHex(name[position + 2]) * 268435456 + FromHex(name[position + 3]) * 16777216 + FromHex(name[position + 4]) * 1048576 + FromHex(name[position + 5]) * 65536 + FromHex(name[position + 6]) * 4096 + FromHex(name[position + 7]) * 256 + FromHex(name[position + 8]) * 16 + FromHex(name[position + 9]);
  140.                        
  141.                         if (u >= 65536) {
  142.                             if (u <= 1114111) {
  143.                                 //convert to two chars
  144.                                 copyPosition = position + c_EncodedCharLength + 4;
  145.                                 char x = (char)(((u - 65536) / 1024) + 55296);
  146.                                 char y = (char)((u - ((x - 55296) * 1024)) - 65536 + 56320);
  147.                                 bufBld.Append(x);
  148.                                 bufBld.Append(y);
  149.                             }
  150.                             //else bad ucs-4 char dont convert
  151.                         }
  152.                         else {
  153.                             //convert to single char
  154.                             copyPosition = position + c_EncodedCharLength + 4;
  155.                             bufBld.Append((char)u);
  156.                         }
  157.                         position += c_EncodedCharLength - 1 + 4;
  158.                         //just skip
  159.                     }
  160.                     else {
  161.                         copyPosition = position + c_EncodedCharLength;
  162.                         bufBld.Append((char)(FromHex(name[position + 2]) * 4096 + FromHex(name[position + 3]) * 256 + FromHex(name[position + 4]) * 16 + FromHex(name[position + 5])));
  163.                         position += c_EncodedCharLength - 1;
  164.                     }
  165.                 }
  166.             }
  167.             if (copyPosition == 0) {
  168.                 return name;
  169.             }
  170.             else {
  171.                 if (copyPosition < length) {
  172.                     bufBld.Append(name, copyPosition, length - copyPosition);
  173.                 }
  174.                 return bufBld.ToString();
  175.             }
  176.         }
  177.        
  178.         private static string EncodeName(string name, bool first, bool local)
  179.         {
  180.             if (name == null)
  181.                 return name;
  182.            
  183.             if (name.Length == 0) {
  184.                 if (!first)
  185.                     throw new XmlException(Res.Xml_InvalidNmToken, name);
  186.                 return name;
  187.             }
  188.            
  189.             StringBuilder bufBld = null;
  190.             int length = name.Length;
  191.             int copyPosition = 0;
  192.             int position = 0;
  193.             XmlCharType xmlCharType = XmlCharType.Instance;
  194.            
  195.             int underscorePos = name.IndexOf('_');
  196.             MatchCollection mc = null;
  197.             IEnumerator en = null;
  198.             if (underscorePos >= 0) {
  199.                 if (c_EncodeCharPattern == null) {
  200.                     c_EncodeCharPattern = new Regex("(?<=_)[Xx]([0-9a-fA-F]{4}|[0-9a-fA-F]{8})_");
  201.                 }
  202.                 mc = c_EncodeCharPattern.Matches(name, underscorePos);
  203.                 en = mc.GetEnumerator();
  204.             }
  205.            
  206.             int matchPos = -1;
  207.             if (en != null && en.MoveNext()) {
  208.                 Match m = (Match)en.Current;
  209.                 matchPos = m.Index - 1;
  210.             }
  211.             if (first) {
  212.                 if ((!xmlCharType.IsStartNCNameChar(name[0]) && (local || (!local && name[0] != ':'))) || matchPos == 0) {
  213.                    
  214.                     if (bufBld == null) {
  215.                         bufBld = new StringBuilder(length + 20);
  216.                     }
  217.                     bufBld.Append("_x");
  218.                     if (length > 1 && name[0] >= 55296 && name[0] <= 56319 && name[1] >= 56320 && name[1] <= 57343) {
  219.                         int x = name[0];
  220.                         int y = name[1];
  221.                         Int32 u = (x - 55296) * 1024 + (y - 56320) + 65536;
  222.                         bufBld.Append(u.ToString("X8", CultureInfo.InvariantCulture));
  223.                         position++;
  224.                         copyPosition = 2;
  225.                     }
  226.                     else {
  227.                         bufBld.Append(((Int32)name[0]).ToString("X4", CultureInfo.InvariantCulture));
  228.                         copyPosition = 1;
  229.                     }
  230.                    
  231.                     bufBld.Append("_");
  232.                     position++;
  233.                    
  234.                     if (matchPos == 0)
  235.                         if (en.MoveNext()) {
  236.                             Match m = (Match)en.Current;
  237.                             matchPos = m.Index - 1;
  238.                         }
  239.                 }
  240.                
  241.             }
  242.             for (; position < length; position++) {
  243.                 if ((local && !xmlCharType.IsNCNameChar(name[position])) || (!local && !xmlCharType.IsNameChar(name[position])) || (matchPos == position)) {
  244.                     if (bufBld == null) {
  245.                         bufBld = new StringBuilder(length + 20);
  246.                     }
  247.                     if (matchPos == position)
  248.                         if (en.MoveNext()) {
  249.                             Match m = (Match)en.Current;
  250.                             matchPos = m.Index - 1;
  251.                         }
  252.                    
  253.                     bufBld.Append(name, copyPosition, position - copyPosition);
  254.                     bufBld.Append("_x");
  255.                     if ((length > position + 1) && name[position] >= 55296 && name[position] <= 56319 && name[position + 1] >= 56320 && name[position + 1] <= 57343) {
  256.                         int x = name[position];
  257.                         int y = name[position + 1];
  258.                         Int32 u = (x - 55296) * 1024 + (y - 56320) + 65536;
  259.                         bufBld.Append(u.ToString("X8", CultureInfo.InvariantCulture));
  260.                         copyPosition = position + 2;
  261.                         position++;
  262.                     }
  263.                     else {
  264.                         bufBld.Append(((Int32)name[position]).ToString("X4", CultureInfo.InvariantCulture));
  265.                         copyPosition = position + 1;
  266.                     }
  267.                     bufBld.Append("_");
  268.                 }
  269.             }
  270.             if (copyPosition == 0) {
  271.                 return name;
  272.             }
  273.             else {
  274.                 if (copyPosition < length) {
  275.                     bufBld.Append(name, copyPosition, length - copyPosition);
  276.                 }
  277.                 return bufBld.ToString();
  278.             }
  279.         }
  280.        
  281.         private static readonly int c_EncodedCharLength = 7;
  282.         // ("_xFFFF_".Length);
  283.         private static Regex c_EncodeCharPattern;
  284.         private static Regex c_DecodeCharPattern;
  285.         private static int FromHex(char digit)
  286.         {
  287.             return (digit <= '9') ? ((int)digit - (int)'0') : (((digit <= 'F') ? ((int)digit - (int)'A') : ((int)digit - (int)'a')) + 10);
  288.         }
  289.        
  290.         static internal byte[] FromBinHexString(string s)
  291.         {
  292.             return FromBinHexString(s, true);
  293.         }
  294.        
  295.         static internal byte[] FromBinHexString(string s, bool allowOddCount)
  296.         {
  297.             return BinHexDecoder.Decode(s.ToCharArray(), allowOddCount);
  298.         }
  299.        
  300.         static internal string ToBinHexString(byte[] inArray)
  301.         {
  302.             return BinHexEncoder.Encode(inArray, 0, inArray.Length);
  303.         }
  304.        
  305.        
  306.         /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.VerifyName"]/*' />
  307.         /// <devdoc>
  308.         /// <para>
  309.         /// </para>
  310.         /// </devdoc>
  311.         unsafe public static string VerifyName(string name)
  312.         {
  313.             if (name == null || name.Length == 0) {
  314.                 throw new ArgumentNullException("name");
  315.             }
  316.            
  317.             XmlCharType xmlCharType = XmlCharType.Instance;
  318.             char ch = name[0];
  319.             if ((xmlCharType.charProperties[ch] & XmlCharType.fNCStartName) == 0 && ch != ':') {
  320.                 // if (!xmlCharType.IsStartNameChar(name[0])) {
  321.                 throw new XmlException(Res.Xml_BadStartNameChar, XmlException.BuildCharExceptionStr(ch));
  322.             }
  323.            
  324.             for (int i = 1; i < name.Length; i++) {
  325.                 if ((xmlCharType.charProperties[name[i]] & XmlCharType.fNCName) == 0 && name[i] != ':') {
  326.                     // if (!xmlCharType.IsNameChar(name[i])) {
  327.                     throw new XmlException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(name[i]));
  328.                 }
  329.             }
  330.             return name;
  331.         }
  332.        
  333.         static internal Exception TryVerifyName(string name)
  334.         {
  335.             if (name == null || name.Length == 0) {
  336.                 return new XmlException(Res.Xml_EmptyName, string.Empty);
  337.             }
  338.            
  339.             XmlCharType xmlCharType = XmlCharType.Instance;
  340.             char ch = name[0];
  341.             if (!xmlCharType.IsStartNameChar(ch) && ch != ':') {
  342.                 return new XmlException(Res.Xml_BadStartNameChar, XmlException.BuildCharExceptionStr(ch));
  343.             }
  344.            
  345.             for (int i = 1; i < name.Length; i++) {
  346.                 ch = name[i];
  347.                 if (!xmlCharType.IsNameChar(ch) && ch != ':') {
  348.                     return new XmlException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(ch));
  349.                 }
  350.             }
  351.             return null;
  352.         }
  353.        
  354.         static internal string VerifyQName(string name)
  355.         {
  356.             return VerifyQName(name, ExceptionType.XmlException);
  357.         }
  358.        
  359.         unsafe static internal string VerifyQName(string name, ExceptionType exceptionType)
  360.         {
  361.             if (name == null || name.Length == 0) {
  362.                 throw new ArgumentException("name");
  363.             }
  364.            
  365.             XmlCharType xmlCharType = XmlCharType.Instance;
  366.             int nameLength = name.Length;
  367.             int position = 0;
  368.             int colonPosition = -1;
  369.             Continue:
  370.            
  371.             if ((xmlCharType.charProperties[name[position]] & XmlCharType.fNCStartName) != 0) {
  372.                 // if (xmlCharType.IsStartNCNameChar(name[position])) {
  373.                 position++;
  374.                 while (position < nameLength && (xmlCharType.charProperties[name[position]] & XmlCharType.fNCName) != 0) {
  375.                     // xmlCharType.IsNCNameChar(name[position])) {
  376.                     position++;
  377.                 }
  378.                 if (position == nameLength) {
  379.                     return name;
  380.                 }
  381.                 if (name[position] == ':') {
  382.                     if (colonPosition == -1) {
  383.                         if (position + 1 < nameLength) {
  384.                             colonPosition = position;
  385.                             position++;
  386.                             goto Continue;
  387.                         }
  388.                     }
  389.                 }
  390.             }
  391.             throw CreateException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(name[position]), exceptionType);
  392.         }
  393.        
  394.         /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.VerifyNCName"]/*' />
  395.         /// <devdoc>
  396.         /// <para>
  397.         /// </para>
  398.         /// </devdoc>
  399.         public static string VerifyNCName(string name)
  400.         {
  401.             if (name == null || name.Length == 0) {
  402.                 throw new ArgumentNullException("name");
  403.             }
  404.             return ValidateNames.ParseNCNameThrow(name);
  405.         }
  406.        
  407.         static internal Exception TryVerifyNCName(string name)
  408.         {
  409.             int len = ValidateNames.ParseNCName(name, 0);
  410.            
  411.             if (len == 0 || len != name.Length) {
  412.                 return ValidateNames.GetInvalidNameException(name, 0, len);
  413.             }
  414.             return null;
  415.         }
  416.        
  417.         /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.VerifyTOKEN"]/*' />
  418.         /// <devdoc>
  419.         /// <para>
  420.         /// </para>
  421.         /// </devdoc>
  422.         public static string VerifyTOKEN(string token)
  423.         {
  424.             if (token == null || token.Length == 0) {
  425.                 return token;
  426.             }
  427.             if (token[0] == ' ' || token[token.Length - 1] == ' ' || token.IndexOfAny(crt) != -1 || token.IndexOf(" ", StringComparison.Ordinal) != -1) {
  428.                 throw new XmlException(Res.Sch_NotTokenString, token);
  429.             }
  430.             return token;
  431.         }
  432.        
  433.         static internal Exception TryVerifyTOKEN(string token)
  434.         {
  435.             if (token == null || token.Length == 0) {
  436.                 return null;
  437.             }
  438.             if (token[0] == ' ' || token[token.Length - 1] == ' ' || token.IndexOfAny(crt) != -1 || token.IndexOf(" ", StringComparison.Ordinal) != -1) {
  439.                 return new XmlException(Res.Sch_NotTokenString, token);
  440.             }
  441.             return null;
  442.         }
  443.        
  444.         /// <include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.VerifyNMTOKEN"]/*' />
  445.         /// <devdoc>
  446.         /// <para>
  447.         /// </para>
  448.         /// </devdoc>
  449.         public static string VerifyNMTOKEN(string name)
  450.         {
  451.             return VerifyNMTOKEN(name, ExceptionType.XmlException);
  452.         }
  453.        
  454.         static internal string VerifyNMTOKEN(string name, ExceptionType exceptionType)
  455.         {
  456.             if (name == null) {
  457.                 throw new ArgumentNullException("name");
  458.             }
  459.             if (name.Length == 0) {
  460.                 throw CreateException(Res.Xml_InvalidNmToken, name, exceptionType);
  461.             }
  462.             XmlCharType xmlCharType = XmlCharType.Instance;
  463.             for (int i = 0; i < name.Length; i++) {
  464.                 if (!xmlCharType.IsNameChar(name[i])) {
  465.                     throw CreateException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(name[i]), exceptionType);
  466.                 }
  467.             }
  468.             return name;
  469.         }
  470.        
  471.         static internal Exception TryVerifyNMTOKEN(string name)
  472.         {
  473.             if (name == null || name.Length == 0) {
  474.                 return new XmlException(Res.Xml_EmptyName, string.Empty);
  475.             }
  476.             XmlCharType xmlCharType = XmlCharType.Instance;
  477.             for (int i = 0; i < name.Length; i++) {
  478.                 if (!xmlCharType.IsNameChar(name[i])) {
  479.                     return new XmlException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(name[i]));
  480.                 }
  481.             }
  482.             return null;
  483.         }
  484.        
  485.         static internal string VerifyNormalizedString(string str)
  486.         {
  487.             if (str.IndexOfAny(crt) != -1) {
  488.                 throw new XmlSchemaException(Res.Sch_NotNormalizedString, str);
  489.             }
  490.             return str;
  491.         }
  492.        
  493.         static internal Exception TryVerifyNormalizedString(string str)
  494.         {
  495.             if (str.IndexOfAny(crt) != -1) {
  496.                 return new XmlSchemaException(Res.Sch_NotNormalizedString, str);
  497.             }
  498.             return null;
  499.         }
  500.        
  501.        
  502.         // Value convertors:
  503.         //
  504.         // String representation of Base types in XML (xsd) sometimes differ from
  505.         // one common language runtime offer and for all types it has to be locale independent.
  506.         // o -- means that XmlConvert pass through to common language runtime converter with InvariantInfo FormatInfo
  507.         // x -- means we doing something special to make a convertion.
  508.         //
  509.         // From: To: Bol Chr SBy Byt I16 U16 I32 U32 I64 U64 Sgl Dbl Dec Dat Tim Str uid
  510.         // ------------------------------------------------------------------------------
  511.         // Boolean x
  512.         // Char o
  513.         // SByte o
  514.         // Byte o
  515.         // Int16 o
  516.         // UInt16 o
  517.         // Int32 o
  518.         // UInt32 o
  519.         // Int64 o
  520.         // UInt64 o
  521.         // Single x
  522.         // Double x
  523.         // Decimal o
  524.         // DateTime x
  525.         // String x o o o o o o o o o o x x o o x
  526.         // Guid x
  527.         // -----------------------------------------------------------------------------
  528.        
  529.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString"]/*' />
  530.         /// <devdoc>
  531.         /// <para>[To be supplied.]</para>
  532.         /// </devdoc>
  533.         public static string ToString(bool value)
  534.         {
  535.             return value ? "true" : "false";
  536.         }
  537.        
  538.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString1"]/*' />
  539.         /// <devdoc>
  540.         /// <para>[To be supplied.]</para>
  541.         /// </devdoc>
  542.         public static string ToString(char value)
  543.         {
  544.             return value.ToString(null);
  545.         }
  546.        
  547.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString2"]/*' />
  548.         /// <devdoc>
  549.         /// <para>[To be supplied.]</para>
  550.         /// </devdoc>
  551.         public static string ToString(decimal value)
  552.         {
  553.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  554.         }
  555.        
  556.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString3"]/*' />
  557.         /// <devdoc>
  558.         /// <para>[To be supplied.]</para>
  559.         /// </devdoc>
  560.         [CLSCompliant(false)]
  561.         public static string ToString(sbyte value)
  562.         {
  563.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  564.         }
  565.        
  566.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString4"]/*' />
  567.         /// <devdoc>
  568.         /// <para>[To be supplied.]</para>
  569.         /// </devdoc>
  570.         public static string ToString(Int16 value)
  571.         {
  572.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  573.         }
  574.        
  575.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString5"]/*' />
  576.         /// <devdoc>
  577.         /// <para>[To be supplied.]</para>
  578.         /// </devdoc>
  579.         public static string ToString(Int32 value)
  580.         {
  581.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  582.         }
  583.        
  584.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString15"]/*' />
  585.         /// <devdoc>
  586.         /// <para>[To be supplied.]</para>
  587.         /// </devdoc>
  588.         public static string ToString(Int64 value)
  589.         {
  590.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  591.         }
  592.        
  593.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString6"]/*' />
  594.         /// <devdoc>
  595.         /// <para>[To be supplied.]</para>
  596.         /// </devdoc>
  597.         public static string ToString(byte value)
  598.         {
  599.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  600.         }
  601.        
  602.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString7"]/*' />
  603.         /// <devdoc>
  604.         /// <para>[To be supplied.]</para>
  605.         /// </devdoc>
  606.         [CLSCompliant(false)]
  607.         public static string ToString(UInt16 value)
  608.         {
  609.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  610.         }
  611.        
  612.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString8"]/*' />
  613.         /// <devdoc>
  614.         /// <para>[To be supplied.]</para>
  615.         /// </devdoc>
  616.         [CLSCompliant(false)]
  617.         public static string ToString(UInt32 value)
  618.         {
  619.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  620.         }
  621.        
  622.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString16"]/*' />
  623.         /// <devdoc>
  624.         /// <para>[To be supplied.]</para>
  625.         /// </devdoc>
  626.         [CLSCompliant(false)]
  627.         public static string ToString(UInt64 value)
  628.         {
  629.             return value.ToString(null, NumberFormatInfo.InvariantInfo);
  630.         }
  631.        
  632.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString9"]/*' />
  633.         /// <devdoc>
  634.         /// <para>[To be supplied.]</para>
  635.         /// </devdoc>
  636.         public static string ToString(float value)
  637.         {
  638.             if (Single.IsNegativeInfinity(value))
  639.                 return "-INF";
  640.             if (Single.IsPositiveInfinity(value))
  641.                 return "INF";
  642.             if (IsNegativeZero((double)value)) {
  643.                 return ("-0");
  644.             }
  645.             return value.ToString("R", NumberFormatInfo.InvariantInfo);
  646.         }
  647.        
  648.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString10"]/*' />
  649.         /// <devdoc>
  650.         /// <para>[To be supplied.]</para>
  651.         /// </devdoc>
  652.         public static string ToString(double value)
  653.         {
  654.             if (Double.IsNegativeInfinity(value))
  655.                 return "-INF";
  656.             if (Double.IsPositiveInfinity(value))
  657.                 return "INF";
  658.             if (IsNegativeZero(value)) {
  659.                 return ("-0");
  660.             }
  661.             return value.ToString("R", NumberFormatInfo.InvariantInfo);
  662.         }
  663.        
  664.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString11"]/*' />
  665.         /// <devdoc>
  666.         /// <para>[To be supplied.]</para>
  667.         /// </devdoc>
  668.         public static string ToString(TimeSpan value)
  669.         {
  670.             return new XsdDuration(value).ToString();
  671.         }
  672.        
  673.        
  674.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString12"]/*' />
  675.         /// <devdoc>
  676.         /// <para>[To be supplied.]</para>
  677.         /// </devdoc>
  678.         [Obsolete("Use XmlConvert.ToString() that takes in XmlDateTimeSerializationMode")]
  679.         public static string ToString(DateTime value)
  680.         {
  681.             return ToString(value, "yyyy-MM-ddTHH:mm:ss.fffffffzzzzzz");
  682.         }
  683.        
  684.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString13"]/*' />
  685.         /// <devdoc>
  686.         /// <para>[To be supplied.]</para>
  687.         /// </devdoc>
  688.         public static string ToString(DateTime value, string format)
  689.         {
  690.             return value.ToString(format, DateTimeFormatInfo.InvariantInfo);
  691.         }
  692.        
  693.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString14"]/*' />
  694.         /// <devdoc>
  695.         /// <para>[To be supplied.]</para>
  696.         /// </devdoc>
  697.         public static string ToString(DateTime value, XmlDateTimeSerializationMode dateTimeOption)
  698.         {
  699.             switch (dateTimeOption) {
  700.                 case XmlDateTimeSerializationMode.Local:
  701.                     value = SwitchToLocalTime(value);
  702.                     break;
  703.                 case XmlDateTimeSerializationMode.Utc:
  704.                    
  705.                     value = SwitchToUtcTime(value);
  706.                     break;
  707.                 case XmlDateTimeSerializationMode.Unspecified:
  708.                    
  709.                     value = new DateTime(value.Ticks, DateTimeKind.Unspecified);
  710.                     break;
  711.                 case XmlDateTimeSerializationMode.RoundtripKind:
  712.                    
  713.                     break;
  714.                 default:
  715.                    
  716.                     throw new ArgumentException(Res.GetString(Res.Sch_InvalidDateTimeOption, dateTimeOption));
  717.                     break;
  718.             }
  719.             XsdDateTime xsdDateTime = new XsdDateTime(value, XsdDateTimeFlags.DateTime);
  720.             return xsdDateTime.ToString();
  721.         }
  722.        
  723.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToString15"]/*' />
  724.         /// <devdoc>
  725.         /// <para>[To be supplied.]</para>
  726.         /// </devdoc>
  727.         public static string ToString(Guid value)
  728.         {
  729.             return value.ToString();
  730.         }
  731.        
  732.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToBoolean"]/*' />
  733.         /// <devdoc>
  734.         /// <para>[To be supplied.]</para>
  735.         /// </devdoc>
  736.         public static bool ToBoolean(string s)
  737.         {
  738.             s = TrimString(s);
  739.             if (s == "1" || s == "true")
  740.                 return true;
  741.             if (s == "0" || s == "false")
  742.                 return false;
  743.             throw new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Boolean"));
  744.         }
  745.        
  746.         static internal Exception TryToBoolean(string s, out bool result)
  747.         {
  748.             s = TrimString(s);
  749.             if (s == "0" || s == "false") {
  750.                 result = false;
  751.                 return null;
  752.             }
  753.             else if (s == "1" || s == "true") {
  754.                 result = true;
  755.                 return null;
  756.             }
  757.             result = false;
  758.             return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Boolean"));
  759.         }
  760.        
  761.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToChar"]/*' />
  762.         /// <devdoc>
  763.         /// <para>[To be supplied.]</para>
  764.         /// </devdoc>
  765.         public static char ToChar(string s)
  766.         {
  767.             return Char.Parse(s);
  768.         }
  769.        
  770.         static internal Exception TryToChar(string s, out char result)
  771.         {
  772.             if (!Char.TryParse(s, out result)) {
  773.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Char"));
  774.             }
  775.             return null;
  776.         }
  777.        
  778.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToDecimal"]/*' />
  779.         /// <devdoc>
  780.         /// <para>[To be supplied.]</para>
  781.         /// </devdoc>
  782.         public static decimal ToDecimal(string s)
  783.         {
  784.             return Decimal.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  785.         }
  786.        
  787.         static internal Exception TryToDecimal(string s, out decimal result)
  788.         {
  789.             if (!Decimal.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  790.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Decimal"));
  791.             }
  792.             return null;
  793.         }
  794.        
  795.         static internal decimal ToInteger(string s)
  796.         {
  797.             return Decimal.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  798.         }
  799.        
  800.         static internal Exception TryToInteger(string s, out decimal result)
  801.         {
  802.             if (!Decimal.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  803.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Integer"));
  804.             }
  805.             return null;
  806.         }
  807.        
  808.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToSByte"]/*' />
  809.         /// <devdoc>
  810.         /// <para>[To be supplied.]</para>
  811.         /// </devdoc>
  812.         [CLSCompliant(false)]
  813.         public static sbyte ToSByte(string s)
  814.         {
  815.             return SByte.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  816.         }
  817.        
  818.         static internal Exception TryToSByte(string s, out sbyte result)
  819.         {
  820.             if (!SByte.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  821.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "SByte"));
  822.             }
  823.             return null;
  824.         }
  825.        
  826.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToInt16"]/*' />
  827.         /// <devdoc>
  828.         /// <para>[To be supplied.]</para>
  829.         /// </devdoc>
  830.         public static Int16 ToInt16(string s)
  831.         {
  832.             return Int16.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  833.         }
  834.        
  835.         static internal Exception TryToInt16(string s, out Int16 result)
  836.         {
  837.             if (!Int16.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  838.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Int16"));
  839.             }
  840.             return null;
  841.         }
  842.        
  843.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToInt32"]/*' />
  844.         /// <devdoc>
  845.         /// <para>[To be supplied.]</para>
  846.         /// </devdoc>
  847.         public static Int32 ToInt32(string s)
  848.         {
  849.             return Int32.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  850.         }
  851.        
  852.         static internal Exception TryToInt32(string s, out Int32 result)
  853.         {
  854.             if (!Int32.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  855.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Int32"));
  856.             }
  857.             return null;
  858.         }
  859.        
  860.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToInt64"]/*' />
  861.         /// <devdoc>
  862.         /// <para>[To be supplied.]</para>
  863.         /// </devdoc>
  864.         public static Int64 ToInt64(string s)
  865.         {
  866.             return Int64.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  867.         }
  868.        
  869.         static internal Exception TryToInt64(string s, out Int64 result)
  870.         {
  871.             if (!Int64.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  872.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Int64"));
  873.             }
  874.             return null;
  875.         }
  876.        
  877.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToByte"]/*' />
  878.         /// <devdoc>
  879.         /// <para>[To be supplied.]</para>
  880.         /// </devdoc>
  881.         public static byte ToByte(string s)
  882.         {
  883.             return Byte.Parse(s, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  884.         }
  885.        
  886.         static internal Exception TryToByte(string s, out byte result)
  887.         {
  888.             if (!Byte.TryParse(s, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  889.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Byte"));
  890.             }
  891.             return null;
  892.         }
  893.        
  894.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToUInt16"]/*' />
  895.         /// <devdoc>
  896.         /// <para>[To be supplied.]</para>
  897.         /// </devdoc>
  898.         [CLSCompliant(false)]
  899.         public static UInt16 ToUInt16(string s)
  900.         {
  901.             return UInt16.Parse(s, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  902.         }
  903.        
  904.         static internal Exception TryToUInt16(string s, out UInt16 result)
  905.         {
  906.             if (!UInt16.TryParse(s, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  907.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "UInt16"));
  908.             }
  909.             return null;
  910.         }
  911.        
  912.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToUInt32"]/*' />
  913.         /// <devdoc>
  914.         /// <para>[To be supplied.]</para>
  915.         /// </devdoc>
  916.         [CLSCompliant(false)]
  917.         public static UInt32 ToUInt32(string s)
  918.         {
  919.             return UInt32.Parse(s, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  920.         }
  921.        
  922.         static internal Exception TryToUInt32(string s, out UInt32 result)
  923.         {
  924.             if (!UInt32.TryParse(s, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  925.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "UInt32"));
  926.             }
  927.             return null;
  928.         }
  929.        
  930.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToUInt64"]/*' />
  931.         /// <devdoc>
  932.         /// <para>[To be supplied.]</para>
  933.         /// </devdoc>
  934.         [CLSCompliant(false)]
  935.         public static UInt64 ToUInt64(string s)
  936.         {
  937.             return UInt64.Parse(s, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  938.         }
  939.        
  940.         static internal Exception TryToUInt64(string s, out UInt64 result)
  941.         {
  942.             if (!UInt64.TryParse(s, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
  943.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "UInt64"));
  944.             }
  945.             return null;
  946.         }
  947.        
  948.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToSingle"]/*' />
  949.         /// <devdoc>
  950.         /// <para>[To be supplied.]</para>
  951.         /// </devdoc>
  952.         public static float ToSingle(string s)
  953.         {
  954.             s = TrimString(s);
  955.             if (s == "-INF")
  956.                 return Single.NegativeInfinity;
  957.             if (s == "INF")
  958.                 return Single.PositiveInfinity;
  959.             float f = Single.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo);
  960.             if (f == 0 && s[0] == '-') {
  961.                 return -0f;
  962.             }
  963.             return f;
  964.         }
  965.        
  966.         static internal Exception TryToSingle(string s, out float result)
  967.         {
  968.             s = TrimString(s);
  969.             if (s == "-INF") {
  970.                 result = Single.NegativeInfinity;
  971.                 return null;
  972.             }
  973.             else if (s == "INF") {
  974.                 result = Single.PositiveInfinity;
  975.                 return null;
  976.             }
  977.             else if (!Single.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo, out result)) {
  978.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Single"));
  979.             }
  980.             if (result == 0 && s[0] == '-') {
  981.                 result = -0f;
  982.             }
  983.             return null;
  984.         }
  985.        
  986.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToDouble"]/*' />
  987.         /// <devdoc>
  988.         /// <para>[To be supplied.]</para>
  989.         /// </devdoc>
  990.         public static double ToDouble(string s)
  991.         {
  992.             s = TrimString(s);
  993.             if (s == "-INF")
  994.                 return Double.NegativeInfinity;
  995.             if (s == "INF")
  996.                 return Double.PositiveInfinity;
  997.             double dVal = Double.Parse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
  998.             if (dVal == 0 && s[0] == '-') {
  999.                 return -0.0;
  1000.             }
  1001.             return dVal;
  1002.         }
  1003.        
  1004.         static internal Exception TryToDouble(string s, out double result)
  1005.         {
  1006.             s = TrimString(s);
  1007.             if (s == "-INF") {
  1008.                 result = Double.NegativeInfinity;
  1009.                 return null;
  1010.             }
  1011.             else if (s == "INF") {
  1012.                 result = Double.PositiveInfinity;
  1013.                 return null;
  1014.             }
  1015.             else if (!Double.TryParse(s, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo, out result)) {
  1016.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Double"));
  1017.             }
  1018.             if (result == 0 && s[0] == '-') {
  1019.                 result = -0.0;
  1020.             }
  1021.             return null;
  1022.         }
  1023.        
  1024.         static internal double ToXPathDouble(object o)
  1025.         {
  1026.             string str = o as string;
  1027.             if (str != null) {
  1028.                 str = TrimString(str);
  1029.                 if (str.Length != 0 && str[0] != '+') {
  1030.                     double d;
  1031.                     if (Double.TryParse(str, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out d)) {
  1032.                         return d;
  1033.                     }
  1034.                 }
  1035.                 return Double.NaN;
  1036.             }
  1037.             if (o is double) {
  1038.                 return (double)o;
  1039.             }
  1040.             if (o is bool) {
  1041.                 return ((bool)o) ? 1.0 : 0.0;
  1042.             }
  1043.             try {
  1044.                 return Convert.ToDouble(o, NumberFormatInfo.InvariantInfo);
  1045.             }
  1046.             catch (FormatException) {
  1047.             }
  1048.             catch (OverflowException) {
  1049.             }
  1050.             catch (ArgumentNullException) {
  1051.             }
  1052.             return Double.NaN;
  1053.         }
  1054.        
  1055.         static internal string ToXPathString(object value)
  1056.         {
  1057.             string s = value as string;
  1058.             if (s != null) {
  1059.                 return s;
  1060.             }
  1061.             else if (value is double) {
  1062.                 return ((double)value).ToString("R", NumberFormatInfo.InvariantInfo);
  1063.             }
  1064.             else if (value is bool) {
  1065.                 return (bool)value ? "true" : "false";
  1066.             }
  1067.             else {
  1068.                 return Convert.ToString(value, NumberFormatInfo.InvariantInfo);
  1069.             }
  1070.         }
  1071.        
  1072.         static internal double XPathRound(double value)
  1073.         {
  1074.             double temp = Math.Round(value);
  1075.             return (value - temp == 0.5) ? temp + 1 : temp;
  1076.         }
  1077.        
  1078.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToTimeSpan"]/*' />
  1079.         /// <devdoc>
  1080.         /// <para>[To be supplied.]</para>
  1081.         /// </devdoc>
  1082.         public static TimeSpan ToTimeSpan(string s)
  1083.         {
  1084.             XsdDuration duration;
  1085.             TimeSpan timeSpan;
  1086.            
  1087.             try {
  1088.                 duration = new XsdDuration(s);
  1089.             }
  1090.             catch (Exception) {
  1091.                 // Remap exception for v1 compatibility
  1092.                 throw new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "TimeSpan"));
  1093.             }
  1094.            
  1095.             timeSpan = duration.ToTimeSpan();
  1096.            
  1097.             return timeSpan;
  1098.         }
  1099.        
  1100.         static internal Exception TryToTimeSpan(string s, out TimeSpan result)
  1101.         {
  1102.             XsdDuration duration;
  1103.             Exception exception;
  1104.            
  1105.             exception = XsdDuration.TryParse(s, out duration);
  1106.             if (exception != null) {
  1107.                 result = TimeSpan.MinValue;
  1108.                 return exception;
  1109.             }
  1110.             else {
  1111.                 return duration.TryToTimeSpan(out result);
  1112.             }
  1113.         }
  1114.        
  1115.         // use AllDateTimeFormats property to access the formats
  1116.         static string[] s_allDateTimeFormats;
  1117.        
  1118.         // NOTE: Do not use this property for reference comparison. It may not be unique.
  1119.         static string[] AllDateTimeFormats {
  1120.             get {
  1121.                 if (s_allDateTimeFormats == null) {
  1122.                     CreateAllDateTimeFormats();
  1123.                 }
  1124.                 return s_allDateTimeFormats;
  1125.             }
  1126.         }
  1127.        
  1128.         static void CreateAllDateTimeFormats()
  1129.         {
  1130.             if (s_allDateTimeFormats == null) {
  1131.                 // no locking; the array is immutable so it's not a problem that it may get initialized more than once
  1132.                 s_allDateTimeFormats = new string[] {"yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz", "yyyy-MM-ddTHH:mm:ss.FFFFFFF", "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ", "HH:mm:ss.FFFFFFF", "HH:mm:ss.FFFFFFFZ", "HH:mm:ss.FFFFFFFzzzzzz", "yyyy-MM-dd", "yyyy-MM-ddZ", "yyyy-MM-ddzzzzzz", "yyyy-MM",
  1133.                 "yyyy-MMZ", "yyyy-MMzzzzzz", "yyyy", "yyyyZ", "yyyyzzzzzz", "--MM-dd", "--MM-ddZ", "--MM-ddzzzzzz", "---dd", "---ddZ",
  1134.                     //dateTime
  1135.                     //time
  1136.                     // date
  1137.                     // yearMonth
  1138.                     // year
  1139.                     // monthDay
  1140.                     // day
  1141.                     // month
  1142.                 "---ddzzzzzz", "--MM--", "--MM--Z", "--MM--zzzzzz"};
  1143.             }
  1144.         }
  1145.        
  1146.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToDateTime"]/*' />
  1147.         /// <devdoc>
  1148.         /// <para>[To be supplied.]</para>
  1149.         /// </devdoc>
  1150.         [Obsolete("Use XmlConvert.ToDateTime() that takes in XmlDateTimeSerializationMode")]
  1151.         public static DateTime ToDateTime(string s)
  1152.         {
  1153.             return ToDateTime(s, AllDateTimeFormats);
  1154.         }
  1155.        
  1156.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToDateTime1"]/*' />
  1157.         /// <devdoc>
  1158.         /// <para>[To be supplied.]</para>
  1159.         /// </devdoc>
  1160.         public static DateTime ToDateTime(string s, string format)
  1161.         {
  1162.             return DateTime.ParseExact(s, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite);
  1163.         }
  1164.        
  1165.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToDateTime2"]/*' />
  1166.         /// <devdoc>
  1167.         /// <para>[To be supplied.]</para>
  1168.         /// </devdoc>
  1169.         public static DateTime ToDateTime(string s, string[] formats)
  1170.         {
  1171.             return DateTime.ParseExact(s, formats, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite);
  1172.         }
  1173.        
  1174.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToDateTime3"]/*' />
  1175.         /// <devdoc>
  1176.         /// <para>[To be supplied.]</para>
  1177.         /// </devdoc>
  1178.         public static DateTime ToDateTime(string s, XmlDateTimeSerializationMode dateTimeOption)
  1179.         {
  1180.             XsdDateTime xsdDateTime = new XsdDateTime(s, XsdDateTimeFlags.AllXsd);
  1181.             DateTime dt = (DateTime)xsdDateTime;
  1182.            
  1183.             switch (dateTimeOption) {
  1184.                 case XmlDateTimeSerializationMode.Local:
  1185.                     dt = SwitchToLocalTime(dt);
  1186.                     break;
  1187.                 case XmlDateTimeSerializationMode.Utc:
  1188.                    
  1189.                     dt = SwitchToUtcTime(dt);
  1190.                     break;
  1191.                 case XmlDateTimeSerializationMode.Unspecified:
  1192.                    
  1193.                     dt = new DateTime(dt.Ticks, DateTimeKind.Unspecified);
  1194.                     break;
  1195.                 case XmlDateTimeSerializationMode.RoundtripKind:
  1196.                    
  1197.                     break;
  1198.                 default:
  1199.                    
  1200.                     throw new ArgumentException(Res.GetString(Res.Sch_InvalidDateTimeOption, dateTimeOption));
  1201.                     break;
  1202.             }
  1203.             return dt;
  1204.         }
  1205.        
  1206.         ///<include file='doc\XmlConvert.uex' path='docs/doc[@for="XmlConvert.ToGuid"]/*' />
  1207.         /// <devdoc>
  1208.         /// <para>[To be supplied.]</para>
  1209.         /// </devdoc>
  1210.         public static Guid ToGuid(string s)
  1211.         {
  1212.             return new Guid(s);
  1213.         }
  1214.        
  1215.         static internal Exception TryToGuid(string s, out Guid result)
  1216.         {
  1217.             Exception exception = null;
  1218.            
  1219.             result = Guid.Empty;
  1220.            
  1221.             try {
  1222.                 result = new Guid(s);
  1223.             }
  1224.             catch (ArgumentException) {
  1225.                 exception = new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Guid"));
  1226.             }
  1227.             catch (FormatException) {
  1228.                 exception = new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Guid"));
  1229.             }
  1230.             return exception;
  1231.         }
  1232.        
  1233.         private static DateTime SwitchToLocalTime(DateTime value)
  1234.         {
  1235.             switch (value.Kind) {
  1236.                 case DateTimeKind.Local:
  1237.                     return value;
  1238.                 case DateTimeKind.Unspecified:
  1239.                    
  1240.                     return new DateTime(value.Ticks, DateTimeKind.Local);
  1241.                 case DateTimeKind.Utc:
  1242.                    
  1243.                     return value.ToLocalTime();
  1244.             }
  1245.             return value;
  1246.         }
  1247.        
  1248.         private static DateTime SwitchToUtcTime(DateTime value)
  1249.         {
  1250.             switch (value.Kind) {
  1251.                 case DateTimeKind.Utc:
  1252.                     return value;
  1253.                 case DateTimeKind.Unspecified:
  1254.                    
  1255.                     return new DateTime(value.Ticks, DateTimeKind.Utc);
  1256.                 case DateTimeKind.Local:
  1257.                    
  1258.                     return value.ToUniversalTime();
  1259.             }
  1260.             return value;
  1261.         }
  1262.        
  1263.         static internal Uri ToUri(string s)
  1264.         {
  1265.             if (s != null && s.Length > 0) {
  1266.                 //string.Empty is a valid uri but not " "
  1267.                 s = TrimString(s);
  1268.                 if (s.Length == 0 || s.IndexOf("##", StringComparison.Ordinal) != -1) {
  1269.                     throw new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Uri"));
  1270.                 }
  1271.             }
  1272.             Uri uri;
  1273.             if (!Uri.TryCreate(s, UriKind.RelativeOrAbsolute, out uri)) {
  1274.                 throw new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Uri"));
  1275.             }
  1276.             return uri;
  1277.         }
  1278.        
  1279.         static internal Exception TryToUri(string s, out Uri result)
  1280.         {
  1281.             result = null;
  1282.            
  1283.             if (s != null && s.Length > 0) {
  1284.                 //string.Empty is a valid uri but not " "
  1285.                 s = TrimString(s);
  1286.                 if (s.Length == 0 || s.IndexOf("##", StringComparison.Ordinal) != -1) {
  1287.                     return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Uri"));
  1288.                 }
  1289.             }
  1290.             if (!Uri.TryCreate(s, UriKind.RelativeOrAbsolute, out result)) {
  1291.                 return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Uri"));
  1292.             }
  1293.             return null;
  1294.         }
  1295.        
  1296.         // Compares the given character interval and string and returns true if the characters are identical
  1297.         static internal bool StrEqual(char[] chars, int strPos1, int strLen1, string str2)
  1298.         {
  1299.             if (strLen1 != str2.Length) {
  1300.                 return false;
  1301.             }
  1302.            
  1303.             int i = 0;
  1304.             while (i < strLen1 && chars[strPos1 + i] == str2[i]) {
  1305.                 i++;
  1306.             }
  1307.             return i == strLen1;
  1308.         }
  1309.        
  1310.         // XML whitespace characters, <spec>http://www.w3.org/TR/REC-xml#NT-S</spec>
  1311.         static internal readonly char[] WhitespaceChars = new char[] {' ', '\t', '\n', '\r'};
  1312.        
  1313.         // Trim a string using XML whitespace characters
  1314.         static internal string TrimString(string value)
  1315.         {
  1316.             return value.Trim(WhitespaceChars);
  1317.         }
  1318.        
  1319.         // Split a string into a whitespace-separated list of tokens
  1320.         static internal string[] SplitString(string value)
  1321.         {
  1322.             return value.Split(WhitespaceChars, StringSplitOptions.RemoveEmptyEntries);
  1323.         }
  1324.        
  1325.         static internal bool IsNegativeZero(double value)
  1326.         {
  1327.             // Simple equals function will report that -0 is equal to +0, so compare bits instead
  1328.             if (value == 0 && BitConverter.DoubleToInt64Bits(value) == BitConverter.DoubleToInt64Bits(-0.0)) {
  1329.                 return true;
  1330.             }
  1331.             return false;
  1332.         }
  1333.        
  1334.         unsafe static internal void VerifyCharData(string data, ExceptionType exceptionType)
  1335.         {
  1336.             if (data == null || data.Length == 0) {
  1337.                 return;
  1338.             }
  1339.            
  1340.             XmlCharType xmlCharType = XmlCharType.Instance;
  1341.             int i = 0;
  1342.             int len = data.Length;
  1343.             for (;;) {
  1344.                 while (i < len && (xmlCharType.charProperties[data[i]] & XmlCharType.fCharData) != 0) {
  1345.                     i++;
  1346.                 }
  1347.                 if (i == len) {
  1348.                     return;
  1349.                 }
  1350.                
  1351.                 char ch = data[i];
  1352.                 if (ch >= SurHighStart && ch <= SurHighEnd) {
  1353.                     if (i + 1 == len) {
  1354.                         throw CreateException(Res.Xml_InvalidSurrogateMissingLowChar, exceptionType);
  1355.                     }
  1356.                     ch = data[i + 1];
  1357.                     if (ch >= SurLowStart && ch <= SurLowEnd) {
  1358.                         i += 2;
  1359.                         continue;
  1360.                     }
  1361.                     else {
  1362.                         throw CreateInvalidSurrogatePairException(data[i + 1], data[i], exceptionType);
  1363.                     }
  1364.                 }
  1365.                 throw CreateInvalidCharException(data[i]);
  1366.             }
  1367.         }
  1368.        
  1369.         unsafe static internal void VerifyCharData(char[] data, int offset, int len, ExceptionType exceptionType)
  1370.         {
  1371.             if (data == null || len == 0) {
  1372.                 return;
  1373.             }
  1374.            
  1375.             XmlCharType xmlCharType = XmlCharType.Instance;
  1376.             int i = offset;
  1377.             int endPos = offset + len;
  1378.             for (;;) {
  1379.                 while (i < endPos && (xmlCharType.charProperties[data[i]] & XmlCharType.fCharData) != 0) {
  1380.                     i++;
  1381.                 }
  1382.                 if (i == endPos) {
  1383.                     return;
  1384.                 }
  1385.                
  1386.                 char ch = data[i];
  1387.                 if (ch >= SurHighStart && ch <= SurHighEnd) {
  1388.                     if (i + 1 == endPos) {
  1389.                         throw CreateException(Res.Xml_InvalidSurrogateMissingLowChar, exceptionType);
  1390.                     }
  1391.                     ch = data[i + 1];
  1392.                     if (ch >= SurLowStart && ch <= SurLowEnd) {
  1393.                         i += 2;
  1394.                         continue;
  1395.                     }
  1396.                     else {
  1397.                         throw CreateInvalidSurrogatePairException(data[i + 1], data[i], exceptionType);
  1398.                     }
  1399.                 }
  1400.                 throw CreateInvalidCharException(data[i]);
  1401.             }
  1402.         }
  1403.        
  1404.         static internal string EscapeValueForDebuggerDisplay(string value)
  1405.         {
  1406.             StringBuilder sb = null;
  1407.             int i = 0;
  1408.             int start = 0;
  1409.             while (i < value.Length) {
  1410.                 char ch = value[i];
  1411.                 if ((int)ch < 32 || ch == '"') {
  1412.                     if (sb == null) {
  1413.                         sb = new StringBuilder(value.Length + 4);
  1414.                     }
  1415.                     if (i - start > 0) {
  1416.                         sb.Append(value, start, i - start);
  1417.                     }
  1418.                     start = i + 1;
  1419.                     switch (ch) {
  1420.                         case '"':
  1421.                             sb.Append("\\\"");
  1422.                             break;
  1423.                         case '\r':
  1424.                             sb.Append("\\r");
  1425.                             break;
  1426.                         case '\n':
  1427.                             sb.Append("\\n");
  1428.                             break;
  1429.                         case '\t':
  1430.                             sb.Append("\\t");
  1431.                             break;
  1432.                         default:
  1433.                             sb.Append(ch);
  1434.                             break;
  1435.                     }
  1436.                 }
  1437.                 i++;
  1438.             }
  1439.             if (sb == null) {
  1440.                 return value;
  1441.             }
  1442.             if (i - start > 0) {
  1443.                 sb.Append(value, start, i - start);
  1444.             }
  1445.             return sb.ToString();
  1446.         }
  1447.        
  1448.         static internal Exception CreateException(string res, ExceptionType exceptionType)
  1449.         {
  1450.             switch (exceptionType) {
  1451.                 case ExceptionType.ArgumentException:
  1452.                     return new ArgumentException(Res.GetString(res));
  1453.                 case ExceptionType.XmlException:
  1454.                 default:
  1455.                     return new XmlException(res, string.Empty);
  1456.             }
  1457.         }
  1458.        
  1459.         static internal Exception CreateException(string res, string arg, ExceptionType exceptionType)
  1460.         {
  1461.             switch (exceptionType) {
  1462.                 case ExceptionType.ArgumentException:
  1463.                     return new ArgumentException(Res.GetString(res, arg));
  1464.                 case ExceptionType.XmlException:
  1465.                 default:
  1466.                     return new XmlException(res, arg);
  1467.             }
  1468.         }
  1469.        
  1470.         static internal Exception CreateException(string res, string[] args, ExceptionType exceptionType)
  1471.         {
  1472.             switch (exceptionType) {
  1473.                 case ExceptionType.ArgumentException:
  1474.                     return new ArgumentException(Res.GetString(res, args));
  1475.                 case ExceptionType.XmlException:
  1476.                 default:
  1477.                     return new XmlException(res, args);
  1478.             }
  1479.         }
  1480.        
  1481.         static internal Exception CreateInvalidSurrogatePairException(char low, char hi)
  1482.         {
  1483.             return CreateInvalidSurrogatePairException(low, hi, ExceptionType.ArgumentException);
  1484.         }
  1485.        
  1486.         static internal Exception CreateInvalidSurrogatePairException(char low, char hi, ExceptionType exceptionType)
  1487.         {
  1488.             string[] args = new string[] {((uint)hi).ToString("X", CultureInfo.InvariantCulture), ((uint)low).ToString("X", CultureInfo.InvariantCulture)};
  1489.             return CreateException(Res.Xml_InvalidSurrogatePairWithArgs, args, exceptionType);
  1490.         }
  1491.        
  1492.         static internal Exception CreateInvalidHighSurrogateCharException(char hi)
  1493.         {
  1494.             return CreateInvalidHighSurrogateCharException(hi, ExceptionType.ArgumentException);
  1495.         }
  1496.        
  1497.         static internal Exception CreateInvalidHighSurrogateCharException(char hi, ExceptionType exceptionType)
  1498.         {
  1499.             return CreateException(Res.Xml_InvalidSurrogateHighChar, ((uint)hi).ToString("X", CultureInfo.InvariantCulture), exceptionType);
  1500.         }
  1501.        
  1502.         static internal Exception CreateInvalidCharException(char invChar)
  1503.         {
  1504.             return CreateInvalidCharException(invChar, ExceptionType.ArgumentException);
  1505.         }
  1506.        
  1507.         static internal Exception CreateInvalidCharException(char invChar, ExceptionType exceptionType)
  1508.         {
  1509.             return CreateException(Res.Xml_InvalidCharacter, XmlException.BuildCharExceptionStr(invChar), exceptionType);
  1510.         }
  1511.        
  1512.         static internal ArgumentException CreateInvalidNameArgumentException(string name, string argumentName)
  1513.         {
  1514.             return (name == null) ? new ArgumentNullException(argumentName) : new ArgumentException(Res.GetString(Res.Xml_EmptyName), argumentName);
  1515.         }
  1516.     }
  1517. }

Developer Fusion