Code:
/ FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / Xml / System / Xml / XmlConvert.cs / 4 / XmlConvert.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml {
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Xml.Schema;
using System.Diagnostics;
using System.Collections;
// ExceptionType enum is used inside XmlConvert to specify which type of exception should be thrown at some of the verification and exception creating methods
internal enum ExceptionType {
ArgumentException,
XmlException,
}
public enum XmlDateTimeSerializationMode {
Local,
Utc,
Unspecified,
RoundtripKind,
}
///
/// Encodes and decodes XML names according to
/// the "Encoding of arbitrary Unicode Characters in XML Names" specification.
///
public class XmlConvert {
internal const int SurHighStart = 0xd800; // 1101 10xx
internal const int SurHighEnd = 0xdbff;
internal const int SurLowStart = 0xdc00; // 1101 11xx
internal const int SurLowEnd = 0xdfff;
internal const int SurMask = 0xfc00; // 1111 11xx
internal static char[] crt = new char[] {'\n', '\r', '\t'};
///
///
/// Converts names, such
/// as DataTable or
/// DataColumn names, that contain characters that are not permitted in
/// XML names to valid names.
///
public static string EncodeName(string name) {
return EncodeName(name, true/*Name_not_NmToken*/, false/*Local?*/);
}
///
/// Verifies the name is valid
/// according to production [7] in the XML spec.
///
public static string EncodeNmToken(string name) {
return EncodeName(name, false/*Name_not_NmToken*/, false/*Local?*/);
}
///
/// Converts names, such as DataTable or DataColumn names, that contain
/// characters that are not permitted in XML names to valid names.
///
public static string EncodeLocalName(string name) {
return EncodeName(name, true/*Name_not_NmToken*/, true/*Local?*/);
}
///
///
/// Transforms an XML name into an object name (such as DataTable or DataColumn).
///
public static string DecodeName(string name) {
if (name == null || name.Length == 0)
return name;
StringBuilder bufBld = null;
int length = name.Length;
int copyPosition = 0;
int underscorePos = name.IndexOf('_');
MatchCollection mc = null;
IEnumerator en = null;
if (underscorePos >= 0)
{
if ( c_DecodeCharPattern == null ) {
c_DecodeCharPattern = new Regex("_[Xx]([0-9a-fA-F]{4}|[0-9a-fA-F]{8})_");
}
mc = c_DecodeCharPattern.Matches(name, underscorePos);
en = mc.GetEnumerator();
} else {
return name;
}
int matchPos = -1;
if (en != null && en.MoveNext())
{
Match m = (Match)en.Current;
matchPos = m.Index;
}
for (int position = 0; position < length - c_EncodedCharLength + 1; position ++) {
if (position == matchPos) {
if (en.MoveNext())
{
Match m = (Match)en.Current;
matchPos = m.Index;
}
if (bufBld == null) {
bufBld = new StringBuilder(length + 20);
}
bufBld.Append(name, copyPosition, position - copyPosition);
if (name[position + 6]!='_') { //_x1234_
Int32 u =
FromHex(name[position + 2]) * 0x10000000 +
FromHex(name[position + 3]) * 0x1000000 +
FromHex(name[position + 4]) * 0x100000 +
FromHex(name[position + 5]) * 0x10000 +
FromHex(name[position + 6]) * 0x1000 +
FromHex(name[position + 7]) * 0x100 +
FromHex(name[position + 8]) * 0x10 +
FromHex(name[position + 9]);
if (u >= 0x00010000) {
if (u <= 0x0010ffff) { //convert to two chars
copyPosition = position + c_EncodedCharLength + 4;
char x = (char) (((u - 0x10000) / 0x400) + 0xd800);
char y = (char) ((u - (( x - 0xd800) * 0x400) ) - 0x10000 + 0xdc00);
bufBld.Append(x);
bufBld.Append(y);
}
//else bad ucs-4 char dont convert
}
else { //convert to single char
copyPosition = position + c_EncodedCharLength + 4;
bufBld.Append((char)u);
}
position += c_EncodedCharLength - 1 + 4; //just skip
}
else {
copyPosition = position + c_EncodedCharLength;
bufBld.Append((char)(
FromHex(name[position + 2]) * 0x1000 +
FromHex(name[position + 3]) * 0x100 +
FromHex(name[position + 4]) * 0x10 +
FromHex(name[position + 5])));
position += c_EncodedCharLength - 1;
}
}
}
if (copyPosition == 0) {
return name;
}
else {
if (copyPosition < length) {
bufBld.Append(name, copyPosition, length - copyPosition);
}
return bufBld.ToString();
}
}
private static string EncodeName(string name, bool first, bool local) {
if (name == null)
return name;
if (name.Length == 0) {
if(!first)
throw new XmlException(Res.Xml_InvalidNmToken,name);
return name;
}
StringBuilder bufBld = null;
int length = name.Length;
int copyPosition = 0;
int position = 0;
XmlCharType xmlCharType = XmlCharType.Instance;
int underscorePos = name.IndexOf('_');
MatchCollection mc = null;
IEnumerator en = null;
if (underscorePos >= 0)
{
if ( c_EncodeCharPattern == null ) {
c_EncodeCharPattern = new Regex("(?<=_)[Xx]([0-9a-fA-F]{4}|[0-9a-fA-F]{8})_");
}
mc = c_EncodeCharPattern.Matches(name, underscorePos);
en = mc.GetEnumerator();
}
int matchPos = -1;
if (en != null && en.MoveNext())
{
Match m = (Match)en.Current;
matchPos = m.Index - 1;
}
if (first) {
if ( ( !xmlCharType.IsStartNCNameChar( name[0] ) && (local || (!local && name[0] != ':'))) ||
matchPos == 0) {
if (bufBld == null) {
bufBld = new StringBuilder(length + 20);
}
bufBld.Append("_x");
if (length > 1 && name[0] >= 0xd800 && name[0] <= 0xdbff && name[1] >= 0xdc00 && name[1] <= 0xdfff) {
int x = name[0];
int y = name[1];
Int32 u = (x - 0xD800) * 0x400 + (y - 0xDC00) + 0x10000;
bufBld.Append(u.ToString("X8", CultureInfo.InvariantCulture));
position ++;
copyPosition = 2;
}
else {
bufBld.Append(((Int32)name[0]).ToString("X4", CultureInfo.InvariantCulture));
copyPosition = 1;
}
bufBld.Append("_");
position ++;
if (matchPos == 0)
if (en.MoveNext())
{
Match m = (Match)en.Current;
matchPos = m.Index - 1;
}
}
}
for (; position < length; position ++) {
if ((local && !xmlCharType.IsNCNameChar(name[position])) ||
(!local && !xmlCharType.IsNameChar(name[position])) ||
(matchPos == position))
{
if (bufBld == null) {
bufBld = new StringBuilder(length + 20);
}
if (matchPos == position)
if (en.MoveNext())
{
Match m = (Match)en.Current;
matchPos = m.Index - 1;
}
bufBld.Append(name, copyPosition, position - copyPosition);
bufBld.Append("_x");
if ((length > position + 1) && name[position] >= 0xd800 && name[position] <= 0xdbff && name[position + 1] >= 0xdc00 && name[position + 1] <= 0xdfff) {
int x = name[position];
int y = name[position + 1];
Int32 u = (x - 0xD800) * 0x400 + (y - 0xDC00) + 0x10000;
bufBld.Append(u.ToString("X8", CultureInfo.InvariantCulture));
copyPosition = position + 2;
position ++;
}
else {
bufBld.Append(((Int32)name[position]).ToString("X4", CultureInfo.InvariantCulture));
copyPosition = position + 1;
}
bufBld.Append("_");
}
}
if (copyPosition == 0) {
return name;
}
else {
if (copyPosition < length) {
bufBld.Append(name, copyPosition, length - copyPosition);
}
return bufBld.ToString();
}
}
private static readonly int c_EncodedCharLength = 7; // ("_xFFFF_".Length);
private static Regex c_EncodeCharPattern;
private static Regex c_DecodeCharPattern;
private static int FromHex(char digit) {
return(digit <= '9')
? ((int)digit - (int)'0')
: (((digit <= 'F')
? ((int)digit - (int)'A')
: ((int)digit - (int)'a'))
+ 10);
}
internal static byte[] FromBinHexString(string s) {
return FromBinHexString(s, true);
}
internal static byte[] FromBinHexString(string s, bool allowOddCount ) {
return BinHexDecoder.Decode(s.ToCharArray(), allowOddCount);
}
internal static string ToBinHexString(byte[] inArray) {
return BinHexEncoder.Encode(inArray, 0, inArray.Length);
}
///
///
///
///
public static unsafe string VerifyName(string name) {
if (name == null || name.Length == 0) {
throw new ArgumentNullException("name");
}
XmlCharType xmlCharType = XmlCharType.Instance;
char ch = name[0];
if ((xmlCharType.charProperties[ch] & XmlCharType.fNCStartName) == 0 && ch != ':') { // if (!xmlCharType.IsStartNameChar(name[0])) {
throw new XmlException(Res.Xml_BadStartNameChar,XmlException.BuildCharExceptionStr(ch));
}
for (int i = 1; i < name.Length; i++) {
if ((xmlCharType.charProperties[name[i]] & XmlCharType.fNCName) == 0 && name[i] != ':') { // if (!xmlCharType.IsNameChar(name[i])) {
throw new XmlException(Res.Xml_BadNameChar,XmlException.BuildCharExceptionStr(name[i]));
}
}
return name;
}
internal static Exception TryVerifyName(string name) {
if (name == null || name.Length == 0) {
return new XmlException(Res.Xml_EmptyName, string.Empty);
}
XmlCharType xmlCharType = XmlCharType.Instance;
char ch = name[0];
if (!xmlCharType.IsStartNameChar(ch) && ch != ':') {
return new XmlException(Res.Xml_BadStartNameChar, XmlException.BuildCharExceptionStr(ch));
}
for (int i = 1; i < name.Length; i++) {
ch = name[i];
if (!xmlCharType.IsNameChar(ch) && ch != ':') {
return new XmlException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(ch));
}
}
return null;
}
internal static string VerifyQName(string name) {
return VerifyQName(name, ExceptionType.XmlException);
}
internal static unsafe string VerifyQName(string name, ExceptionType exceptionType) {
if (name == null || name.Length == 0) {
throw new ArgumentException("name");
}
XmlCharType xmlCharType = XmlCharType.Instance;
int nameLength = name.Length;
int position = 0;
int colonPosition = -1;
Continue:
if ((xmlCharType.charProperties[name[position]] & XmlCharType.fNCStartName) != 0) { // if (xmlCharType.IsStartNCNameChar(name[position])) {
position ++;
while (position < nameLength && (xmlCharType.charProperties[name[position]] & XmlCharType.fNCName) != 0) { // xmlCharType.IsNCNameChar(name[position])) {
position ++;
}
if (position == nameLength) {
return name;
}
if (name[position] == ':') {
if (colonPosition == -1) {
if (position + 1 < nameLength) {
colonPosition = position;
position++;
goto Continue;
}
}
}
}
throw CreateException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(name[position]), exceptionType);
}
///
///
///
///
public static string VerifyNCName(string name) {
if (name == null || name.Length == 0) {
throw new ArgumentNullException("name");
}
return ValidateNames.ParseNCNameThrow(name);
}
internal static Exception TryVerifyNCName(string name) {
int len = ValidateNames.ParseNCName(name, 0);
if (len == 0 || len != name.Length) {
return ValidateNames.GetInvalidNameException(name, 0, len);
}
return null;
}
///
///
///
///
public static string VerifyTOKEN(string token) {
if (token == null || token.Length == 0) {
return token;
}
if (token[0] == ' ' || token[token.Length - 1] == ' ' || token.IndexOfAny(crt) != -1 || token.IndexOf(" ", StringComparison.Ordinal) != -1) {
throw new XmlException(Res.Sch_NotTokenString, token);
}
return token;
}
internal static Exception TryVerifyTOKEN(string token) {
if (token == null || token.Length == 0) {
return null;
}
if (token[0] == ' ' || token[token.Length - 1] == ' ' || token.IndexOfAny(crt) != -1 || token.IndexOf(" ", StringComparison.Ordinal) != -1) {
return new XmlException(Res.Sch_NotTokenString, token);
}
return null;
}
///
///
///
///
public static string VerifyNMTOKEN(string name) {
return VerifyNMTOKEN(name, ExceptionType.XmlException);
}
internal static string VerifyNMTOKEN(string name, ExceptionType exceptionType) {
if (name == null) {
throw new ArgumentNullException("name");
}
if (name.Length == 0) {
throw CreateException(Res.Xml_InvalidNmToken, name, exceptionType);
}
XmlCharType xmlCharType = XmlCharType.Instance;
for (int i = 0; i < name.Length; i++) {
if (!xmlCharType.IsNameChar(name[i])) {
throw CreateException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(name[i]), exceptionType);
}
}
return name;
}
internal static Exception TryVerifyNMTOKEN(string name) {
if (name == null || name.Length == 0) {
return new XmlException(Res.Xml_EmptyName, string.Empty);
}
XmlCharType xmlCharType = XmlCharType.Instance;
for (int i = 0; i < name.Length; i++) {
if (!xmlCharType.IsNameChar(name[i])) {
return new XmlException(Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr(name[i]));
}
}
return null;
}
internal static string VerifyNormalizedString(string str) {
if (str.IndexOfAny(crt) != -1) {
throw new XmlSchemaException(Res.Sch_NotNormalizedString, str);
}
return str;
}
internal static Exception TryVerifyNormalizedString(string str) {
if (str.IndexOfAny(crt) != -1) {
return new XmlSchemaException(Res.Sch_NotNormalizedString, str);
}
return null;
}
// Value convertors:
//
// String representation of Base types in XML (xsd) sometimes differ from
// one common language runtime offer and for all types it has to be locale independent.
// o -- means that XmlConvert pass through to common language runtime converter with InvariantInfo FormatInfo
// x -- means we doing something special to make a convertion.
//
// From: To: Bol Chr SBy Byt I16 U16 I32 U32 I64 U64 Sgl Dbl Dec Dat Tim Str uid
// -----------------------------------------------------------------------------
// Boolean x
// Char o
// SByte o
// Byte o
// Int16 o
// UInt16 o
// Int32 o
// UInt32 o
// Int64 o
// UInt64 o
// Single x
// Double x
// Decimal o
// DateTime x
// String x o o o o o o o o o o x x o o x
// Guid x
// -----------------------------------------------------------------------------
///
/// [To be supplied.]
///
public static string ToString(Boolean value) {
return value ? "true" : "false";
}
///
/// [To be supplied.]
///
public static string ToString(Char value) {
return value.ToString(null);
}
///
/// [To be supplied.]
///
public static string ToString(Decimal value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
[CLSCompliant(false)]
public static string ToString(SByte value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
public static string ToString(Int16 value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
public static string ToString(Int32 value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
public static string ToString(Int64 value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
public static string ToString(Byte value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
[CLSCompliant(false)]
public static string ToString(UInt16 value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
[CLSCompliant(false)]
public static string ToString(UInt32 value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
[CLSCompliant(false)]
public static string ToString(UInt64 value) {
return value.ToString(null, NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
public static string ToString(Single value) {
if (Single.IsNegativeInfinity(value)) return "-INF";
if (Single.IsPositiveInfinity(value)) return "INF";
if (IsNegativeZero((double)value)) {
return("-0");
}
return value.ToString("R", NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
public static string ToString(Double value) {
if (Double.IsNegativeInfinity(value)) return "-INF";
if (Double.IsPositiveInfinity(value)) return "INF";
if (IsNegativeZero(value)) {
return("-0");
}
return value.ToString("R", NumberFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
public static string ToString(TimeSpan value) {
return new XsdDuration(value).ToString();
}
///
/// [To be supplied.]
///
[Obsolete("Use XmlConvert.ToString() that takes in XmlDateTimeSerializationMode")]
public static string ToString(DateTime value) {
return ToString(value, "yyyy-MM-ddTHH:mm:ss.fffffffzzzzzz");
}
///
/// [To be supplied.]
///
public static string ToString(DateTime value, string format) {
return value.ToString(format, DateTimeFormatInfo.InvariantInfo);
}
///
/// [To be supplied.]
///
public static string ToString(DateTime value, XmlDateTimeSerializationMode dateTimeOption) {
switch(dateTimeOption) {
case XmlDateTimeSerializationMode.Local:
value = SwitchToLocalTime(value);
break;
case XmlDateTimeSerializationMode.Utc:
value = SwitchToUtcTime(value);
break;
case XmlDateTimeSerializationMode.Unspecified:
value = new DateTime(value.Ticks, DateTimeKind.Unspecified);
break;
case XmlDateTimeSerializationMode.RoundtripKind:
break;
default:
throw new ArgumentException(Res.GetString(Res.Sch_InvalidDateTimeOption, dateTimeOption));
}
XsdDateTime xsdDateTime = new XsdDateTime(value, XsdDateTimeFlags.DateTime);
return xsdDateTime.ToString();
}
public static string ToString(DateTimeOffset value) {
XsdDateTime xsdDateTime = new XsdDateTime(value);
return xsdDateTime.ToString();
}
public static string ToString(DateTimeOffset value, string format) {
return value.ToString( format, DateTimeFormatInfo.InvariantInfo );
}
///
/// [To be supplied.]
///
public static string ToString(Guid value) {
return value.ToString();
}
///
/// [To be supplied.]
///
public static Boolean ToBoolean (string s) {
s = TrimString(s);
if (s == "1" || s == "true" ) return true;
if (s == "0" || s == "false") return false;
throw new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Boolean"));
}
internal static Exception TryToBoolean(string s, out Boolean result) {
s = TrimString(s);
if (s == "0" || s == "false") {
result = false;
return null;
}
else if (s == "1" || s == "true") {
result = true;
return null;
}
result = false;
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Boolean"));
}
///
/// [To be supplied.]
///
public static Char ToChar (string s) {
return Char.Parse(s);
}
internal static Exception TryToChar(string s, out Char result) {
if (!Char.TryParse(s, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Char"));
}
return null;
}
///
/// [To be supplied.]
///
public static Decimal ToDecimal (string s) {
return Decimal.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToDecimal(string s, out Decimal result) {
if (!Decimal.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Decimal"));
}
return null;
}
internal static Decimal ToInteger (string s) {
return Decimal.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToInteger(string s, out Decimal result) {
if (!Decimal.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Integer"));
}
return null;
}
///
/// [To be supplied.]
///
[CLSCompliant(false)]
public static SByte ToSByte (string s) {
return SByte.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToSByte(string s, out SByte result) {
if (!SByte.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "SByte"));
}
return null;
}
///
/// [To be supplied.]
///
public static Int16 ToInt16 (string s) {
return Int16.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToInt16(string s, out Int16 result) {
if (!Int16.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Int16"));
}
return null;
}
///
/// [To be supplied.]
///
public static Int32 ToInt32 (string s) {
return Int32.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToInt32(string s, out Int32 result) {
if (!Int32.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Int32"));
}
return null;
}
///
/// [To be supplied.]
///
public static Int64 ToInt64 (string s) {
return Int64.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToInt64(string s, out Int64 result) {
if (!Int64.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Int64"));
}
return null;
}
///
/// [To be supplied.]
///
public static Byte ToByte (string s) {
return Byte.Parse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToByte(string s, out Byte result) {
if (!Byte.TryParse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Byte"));
}
return null;
}
///
/// [To be supplied.]
///
[CLSCompliant(false)]
public static UInt16 ToUInt16 (string s) {
return UInt16.Parse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToUInt16(string s, out UInt16 result) {
if (!UInt16.TryParse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "UInt16"));
}
return null;
}
///
/// [To be supplied.]
///
[CLSCompliant(false)]
public static UInt32 ToUInt32 (string s) {
return UInt32.Parse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToUInt32(string s, out UInt32 result) {
if (!UInt32.TryParse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "UInt32"));
}
return null;
}
///
/// [To be supplied.]
///
[CLSCompliant(false)]
public static UInt64 ToUInt64 (string s) {
return UInt64.Parse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
}
internal static Exception TryToUInt64(string s, out UInt64 result) {
if (!UInt64.TryParse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "UInt64"));
}
return null;
}
///
/// [To be supplied.]
///
public static Single ToSingle (string s) {
s = TrimString(s);
if(s == "-INF") return Single.NegativeInfinity;
if(s == "INF") return Single.PositiveInfinity;
float f = Single.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo);
if (f == 0 && s[0] == '-') {
return -0f;
}
return f;
}
internal static Exception TryToSingle(string s, out Single result) {
s = TrimString(s);
if (s == "-INF") {
result = Single.NegativeInfinity;
return null;
}
else if (s == "INF") {
result = Single.PositiveInfinity;
return null;
}
else if (!Single.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Single"));
}
if (result == 0 && s[0] == '-') {
result = -0f;
}
return null;
}
///
/// [To be supplied.]
///
public static Double ToDouble(string s) {
s = TrimString(s);
if(s == "-INF") return Double.NegativeInfinity;
if(s == "INF") return Double.PositiveInfinity;
double dVal = Double.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowExponent|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo);
if (dVal == 0 && s[0] == '-') {
return -0d;
}
return dVal;
}
internal static Exception TryToDouble (string s, out double result) {
s = TrimString(s);
if (s == "-INF") {
result = Double.NegativeInfinity;
return null;
}
else if (s == "INF") {
result = Double.PositiveInfinity;
return null;
}
else if (!Double.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowExponent, NumberFormatInfo.InvariantInfo, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Double"));
}
if (result == 0 && s[0] == '-') {
result = -0d;
}
return null;
}
internal static Double ToXPathDouble (Object o) {
string str = o as string;
if (str != null) {
str = TrimString(str);
if (str.Length != 0 && str[0] != '+') {
double d;
if (Double.TryParse(str, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out d)) {
return d;
}
}
return Double.NaN;
}
if (o is double) {
return (double) o;
}
if (o is bool) {
return ((bool) o) ? 1.0 : 0.0;
}
try {
return Convert.ToDouble(o, NumberFormatInfo.InvariantInfo);
} catch ( FormatException ) {
} catch ( OverflowException ) {
} catch ( ArgumentNullException ) {}
return Double.NaN;
}
internal static String ToXPathString(Object value){
string s = value as string;
if ( s != null ) {
return s;
}
else if ( value is double ) {
return ((double)value).ToString("R", NumberFormatInfo.InvariantInfo);
}
else if ( value is bool ) {
return (bool)value ? "true" : "false";
}
else {
return Convert.ToString(value, NumberFormatInfo.InvariantInfo);
}
}
internal static Double XPathRound(Double value) {
double temp = Math.Round(value);
return (value - temp == 0.5) ? temp + 1 : temp;
}
///
/// [To be supplied.]
///
public static TimeSpan ToTimeSpan(string s) {
XsdDuration duration;
TimeSpan timeSpan;
try {
duration = new XsdDuration(s);
}
catch (Exception) {
// Remap exception for v1 compatibility
throw new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "TimeSpan"));
}
timeSpan = duration.ToTimeSpan();
return timeSpan;
}
internal static Exception TryToTimeSpan(string s, out TimeSpan result) {
XsdDuration duration;
Exception exception;
exception = XsdDuration.TryParse(s, out duration);
if (exception != null) {
result = TimeSpan.MinValue;
return exception;
}
else {
return duration.TryToTimeSpan(out result);
}
}
// use AllDateTimeFormats property to access the formats
static string[] s_allDateTimeFormats;
//
static string[] AllDateTimeFormats {
get {
if ( s_allDateTimeFormats == null ) {
CreateAllDateTimeFormats();
}
return s_allDateTimeFormats;
}
}
static void CreateAllDateTimeFormats() {
if ( s_allDateTimeFormats == null ) {
// no locking; the array is immutable so it's not a problem that it may get initialized more than once
s_allDateTimeFormats = new string[] {
"yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz", //dateTime
"yyyy-MM-ddTHH:mm:ss.FFFFFFF",
"yyyy-MM-ddTHH:mm:ss.FFFFFFFZ",
"HH:mm:ss.FFFFFFF", //time
"HH:mm:ss.FFFFFFFZ",
"HH:mm:ss.FFFFFFFzzzzzz",
"yyyy-MM-dd", // date
"yyyy-MM-ddZ",
"yyyy-MM-ddzzzzzz",
"yyyy-MM", // yearMonth
"yyyy-MMZ",
"yyyy-MMzzzzzz",
"yyyy", // year
"yyyyZ",
"yyyyzzzzzz",
"--MM-dd", // monthDay
"--MM-ddZ",
"--MM-ddzzzzzz",
"---dd", // day
"---ddZ",
"---ddzzzzzz",
"--MM--", // month
"--MM--Z",
"--MM--zzzzzz",
};
}
}
///
/// [To be supplied.]
///
[Obsolete("Use XmlConvert.ToDateTime() that takes in XmlDateTimeSerializationMode")]
public static DateTime ToDateTime(string s) {
return ToDateTime(s, AllDateTimeFormats);
}
///
/// [To be supplied.]
///
public static DateTime ToDateTime(string s, string format) {
return DateTime.ParseExact(s, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowLeadingWhite|DateTimeStyles.AllowTrailingWhite);
}
///
/// [To be supplied.]
///
public static DateTime ToDateTime(string s, string[] formats) {
return DateTime.ParseExact(s, formats, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowLeadingWhite|DateTimeStyles.AllowTrailingWhite);
}
///
/// [To be supplied.]
///
public static DateTime ToDateTime(string s, XmlDateTimeSerializationMode dateTimeOption) {
XsdDateTime xsdDateTime = new XsdDateTime(s, XsdDateTimeFlags.AllXsd);
DateTime dt = (DateTime)xsdDateTime;
switch (dateTimeOption) {
case XmlDateTimeSerializationMode.Local:
dt = SwitchToLocalTime(dt);
break;
case XmlDateTimeSerializationMode.Utc:
dt = SwitchToUtcTime(dt);
break;
case XmlDateTimeSerializationMode.Unspecified:
dt = new DateTime(dt.Ticks, DateTimeKind.Unspecified);
break;
case XmlDateTimeSerializationMode.RoundtripKind:
break;
default:
throw new ArgumentException(Res.GetString(Res.Sch_InvalidDateTimeOption, dateTimeOption));
}
return dt;
}
public static DateTimeOffset ToDateTimeOffset(string s) {
if (s == null) {
throw new ArgumentNullException("s");
}
XsdDateTime xsdDateTime = new XsdDateTime(s, XsdDateTimeFlags.AllXsd);
DateTimeOffset dateTimeOffset = (DateTimeOffset)xsdDateTime;
return dateTimeOffset;
}
public static DateTimeOffset ToDateTimeOffset(string s, string format) {
if ( s == null ) {
throw new ArgumentNullException( "s" );
}
return DateTimeOffset.ParseExact( s, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite );
}
public static DateTimeOffset ToDateTimeOffset(string s, string[] formats) {
if ( s == null ) {
throw new ArgumentNullException( "s" );
}
return DateTimeOffset.ParseExact( s, formats, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite );
}
///
/// [To be supplied.]
///
public static Guid ToGuid (string s) {
return new Guid(s);
}
internal static Exception TryToGuid(string s, out Guid result) {
Exception exception = null;
result = Guid.Empty;
try {
result = new Guid(s);
}
catch (ArgumentException) {
exception = new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Guid"));
}
catch (FormatException) {
exception = new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Guid"));
}
return exception;
}
private static DateTime SwitchToLocalTime(DateTime value) {
switch (value.Kind) {
case DateTimeKind.Local:
return value;
case DateTimeKind.Unspecified:
return new DateTime(value.Ticks, DateTimeKind.Local);
case DateTimeKind.Utc:
return value.ToLocalTime();
}
return value;
}
private static DateTime SwitchToUtcTime(DateTime value) {
switch (value.Kind) {
case DateTimeKind.Utc:
return value;
case DateTimeKind.Unspecified:
return new DateTime(value.Ticks, DateTimeKind.Utc);
case DateTimeKind.Local:
return value.ToUniversalTime();
}
return value;
}
internal static Uri ToUri(string s) {
if (s != null && s.Length > 0) { //string.Empty is a valid uri but not " "
s = TrimString(s);
if (s.Length == 0 || s.IndexOf("##", StringComparison.Ordinal) != -1) {
throw new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Uri"));
}
}
Uri uri;
if (!Uri.TryCreate(s, UriKind.RelativeOrAbsolute, out uri)) {
throw new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Uri"));
}
return uri;
}
internal static Exception TryToUri(string s, out Uri result) {
result = null;
if (s != null && s.Length > 0) { //string.Empty is a valid uri but not " "
s = TrimString(s);
if (s.Length == 0 || s.IndexOf("##", StringComparison.Ordinal) != -1) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Uri"));
}
}
if (!Uri.TryCreate(s, UriKind.RelativeOrAbsolute, out result)) {
return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Uri"));
}
return null;
}
// Compares the given character interval and string and returns true if the characters are identical
internal static bool StrEqual( char[] chars, int strPos1, int strLen1, string str2 ) {
if ( strLen1 != str2.Length ) {
return false;
}
int i = 0;
while ( i < strLen1 && chars[strPos1+i] == str2[i] ) {
i++;
}
return i == strLen1;
}
// XML whitespace characters, http://www.w3.org/TR/REC-xml#NT-S
internal static readonly char[] WhitespaceChars = new char[] { ' ', '\t', '\n', '\r' };
// Trim a string using XML whitespace characters
internal static string TrimString(string value) {
return value.Trim(WhitespaceChars);
}
// Split a string into a whitespace-separated list of tokens
internal static string[] SplitString(string value) {
return value.Split(WhitespaceChars, StringSplitOptions.RemoveEmptyEntries);
}
internal static bool IsNegativeZero(double value) {
// Simple equals function will report that -0 is equal to +0, so compare bits instead
if (value == 0 && BitConverter.DoubleToInt64Bits(value) == BitConverter.DoubleToInt64Bits(-0e0)) {
return true;
}
return false;
}
internal static unsafe void VerifyCharData( string data, ExceptionType exceptionType ) {
if ( data == null || data.Length == 0 ) {
return;
}
XmlCharType xmlCharType = XmlCharType.Instance;
int i = 0;
int len = data.Length;
for (;;) {
while ( i < len && ( xmlCharType.charProperties[data[i]] & XmlCharType.fCharData ) != 0 ) {
i++;
}
if ( i == len ) {
return;
}
char ch = data[i];
if ( ch >= SurHighStart && ch <= SurHighEnd ) {
if ( i + 1 == len ) {
throw CreateException( Res.Xml_InvalidSurrogateMissingLowChar, exceptionType );
}
ch = data[i+1];
if ( ch >= SurLowStart && ch <= SurLowEnd ) {
i += 2;
continue;
}
else {
throw CreateInvalidSurrogatePairException( data[i+1], data[i], exceptionType );
}
}
throw CreateInvalidCharException( data[i] );
}
}
internal static unsafe void VerifyCharData( char[] data, int offset, int len, ExceptionType exceptionType ) {
if ( data == null || len == 0 ) {
return;
}
XmlCharType xmlCharType = XmlCharType.Instance;
int i = offset;
int endPos = offset + len;
for (;;) {
while ( i < endPos && ( xmlCharType.charProperties[data[i]] & XmlCharType.fCharData ) != 0 ) {
i++;
}
if ( i == endPos ) {
return;
}
char ch = data[i];
if ( ch >= SurHighStart && ch <= SurHighEnd ) {
if ( i + 1 == endPos ) {
throw CreateException( Res.Xml_InvalidSurrogateMissingLowChar, exceptionType );
}
ch = data[i+1];
if ( ch >= SurLowStart && ch <= SurLowEnd ) {
i += 2;
continue;
}
else {
throw CreateInvalidSurrogatePairException( data[i+1], data[i], exceptionType );
}
}
throw CreateInvalidCharException( data[i] );
}
}
internal static string EscapeValueForDebuggerDisplay( string value ) {
StringBuilder sb = null;
int i = 0;
int start = 0;
while ( i < value.Length ) {
char ch = value[i];
if ( (int)ch < 0x20 || ch == '"' ) {
if ( sb == null ) {
sb = new StringBuilder( value.Length + 4 );
}
if ( i - start > 0 ) {
sb.Append( value, start, i - start );
}
start = i + 1;
switch ( ch ) {
case '"':
sb.Append( "\\\"" );
break;
case '\r':
sb.Append( "\\r" );
break;
case '\n':
sb.Append( "\\n" );
break;
case '\t':
sb.Append( "\\t" );
break;
default:
sb.Append( ch );
break;
}
}
i++;
}
if ( sb == null ) {
return value;
}
if ( i - start > 0 ) {
sb.Append( value, start, i - start );
}
return sb.ToString();
}
internal static Exception CreateException( string res, ExceptionType exceptionType ) {
switch ( exceptionType ) {
case ExceptionType.ArgumentException:
return new ArgumentException( Res.GetString( res ) );
case ExceptionType.XmlException:
default:
return new XmlException( res, string.Empty );
}
}
internal static Exception CreateException( string res, string arg, ExceptionType exceptionType ) {
switch ( exceptionType ) {
case ExceptionType.ArgumentException:
return new ArgumentException( Res.GetString( res, arg ) );
case ExceptionType.XmlException:
default:
return new XmlException( res, arg );
}
}
internal static Exception CreateException( string res, string[] args, ExceptionType exceptionType ) {
switch ( exceptionType ) {
case ExceptionType.ArgumentException:
return new ArgumentException( Res.GetString( res, args ) );
case ExceptionType.XmlException:
default:
return new XmlException( res, args );
}
}
internal static Exception CreateInvalidSurrogatePairException( char low, char hi ) {
return CreateInvalidSurrogatePairException( low, hi, ExceptionType.ArgumentException );
}
internal static Exception CreateInvalidSurrogatePairException( char low, char hi, ExceptionType exceptionType ) {
string[] args = new string[] {
((uint)hi).ToString( "X", CultureInfo.InvariantCulture ),
((uint)low).ToString( "X", CultureInfo.InvariantCulture )
} ;
return CreateException( Res.Xml_InvalidSurrogatePairWithArgs, args, exceptionType );
}
internal static Exception CreateInvalidHighSurrogateCharException( char hi ) {
return CreateInvalidHighSurrogateCharException( hi, ExceptionType.ArgumentException );
}
internal static Exception CreateInvalidHighSurrogateCharException( char hi, ExceptionType exceptionType ) {
return CreateException( Res.Xml_InvalidSurrogateHighChar, ((uint)hi).ToString( "X", CultureInfo.InvariantCulture ), exceptionType );
}
internal static Exception CreateInvalidCharException( char invChar ) {
return CreateInvalidCharException( invChar, ExceptionType.ArgumentException );
}
internal static Exception CreateInvalidCharException( char invChar, ExceptionType exceptionType ) {
return CreateException( Res.Xml_InvalidCharacter, XmlException.BuildCharExceptionStr( invChar ), exceptionType );
}
internal static ArgumentException CreateInvalidNameArgumentException( string name, string argumentName ) {
return ( name == null ) ? new ArgumentNullException( argumentName ) : new ArgumentException( Res.GetString( Res.Xml_EmptyName ), argumentName );
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- GenericTransactionFlowAttribute.cs
- Rotation3DAnimation.cs
- UserNamePasswordValidator.cs
- NullableFloatSumAggregationOperator.cs
- TemplateParser.cs
- UnsafeNativeMethodsCLR.cs
- HttpCookieCollection.cs
- CqlLexer.cs
- ZoomingMessageFilter.cs
- httpstaticobjectscollection.cs
- Point3DValueSerializer.cs
- Geometry.cs
- StringFunctions.cs
- DesignerLabelAdapter.cs
- ParamArrayAttribute.cs
- GC.cs
- ServiceParser.cs
- Emitter.cs
- PasswordValidationException.cs
- ToolboxItem.cs
- XPathBinder.cs
- ChtmlPageAdapter.cs
- DataView.cs
- ToolboxDataAttribute.cs
- HttpPostProtocolReflector.cs
- PackageDigitalSignatureManager.cs
- SafeSystemMetrics.cs
- SemaphoreSlim.cs
- DynamicFilter.cs
- WindowsUpDown.cs
- FixedHyperLink.cs
- EventRecord.cs
- odbcmetadatafactory.cs
- SoapSchemaMember.cs
- DiscriminatorMap.cs
- SiteMembershipCondition.cs
- DrawTreeNodeEventArgs.cs
- WindowsAltTab.cs
- TimerEventSubscription.cs
- TransactionBridge.cs
- HtmlInputFile.cs
- DataGridViewBand.cs
- Knowncolors.cs
- SafeRightsManagementHandle.cs
- EffectiveValueEntry.cs
- Int32.cs
- ThreadLocal.cs
- ProjectionAnalyzer.cs
- RequestCacheValidator.cs
- LinkedResourceCollection.cs
- TokenCreationException.cs
- DetectRunnableInstancesTask.cs
- GraphicsPathIterator.cs
- ProfileManager.cs
- DataGridViewCellFormattingEventArgs.cs
- WebConfigManager.cs
- ToolStripItemEventArgs.cs
- MessageQueueKey.cs
- TemplatedEditableDesignerRegion.cs
- LogAppendAsyncResult.cs
- UTF7Encoding.cs
- ThreadStateException.cs
- DocumentReferenceCollection.cs
- InstanceDescriptor.cs
- listitem.cs
- OleDbException.cs
- BitmapMetadataEnumerator.cs
- OleDbPropertySetGuid.cs
- SolidColorBrush.cs
- ObjectHandle.cs
- WebFormsRootDesigner.cs
- EventLogHandle.cs
- TogglePatternIdentifiers.cs
- RichTextBox.cs
- MULTI_QI.cs
- LongValidator.cs
- EncoderReplacementFallback.cs
- ToolStripArrowRenderEventArgs.cs
- DependencyPropertyValueSerializer.cs
- newinstructionaction.cs
- StorageAssociationSetMapping.cs
- WebPartManagerInternals.cs
- ScalarRestriction.cs
- Floater.cs
- GridViewRowEventArgs.cs
- SiteOfOriginPart.cs
- PackagingUtilities.cs
- CheckBoxField.cs
- AsymmetricKeyExchangeDeformatter.cs
- ReflectionHelper.cs
- FormatterConverter.cs
- TextElementEnumerator.cs
- HttpCachePolicy.cs
- RootProfilePropertySettingsCollection.cs
- CqlQuery.cs
- XmlSchemaElement.cs
- QueryAccessibilityHelpEvent.cs
- Encoding.cs
- Speller.cs
- ClientSponsor.cs