summaryrefslogtreecommitdiff
path: root/src/mscorlib/src/System/Guid.cs
diff options
context:
space:
mode:
Diffstat (limited to 'src/mscorlib/src/System/Guid.cs')
-rw-r--r--src/mscorlib/src/System/Guid.cs873
1 files changed, 521 insertions, 352 deletions
diff --git a/src/mscorlib/src/System/Guid.cs b/src/mscorlib/src/System/Guid.cs
index 1116faf027..f64211d5d0 100644
--- a/src/mscorlib/src/System/Guid.cs
+++ b/src/mscorlib/src/System/Guid.cs
@@ -2,17 +2,18 @@
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-namespace System {
-
- using System;
- using System.Globalization;
- using System.Text;
- using Microsoft.Win32;
- using System.Runtime.InteropServices;
- using System.Runtime.CompilerServices;
- using System.Diagnostics;
- using System.Diagnostics.Contracts;
+using System;
+using System.Globalization;
+using System.Text;
+using Microsoft.Win32;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
+using System.Diagnostics.Contracts;
+
+namespace System
+{
// Represents a Globally Unique Identifier.
[StructLayout(LayoutKind.Sequential)]
[Serializable]
@@ -24,17 +25,17 @@ namespace System {
////////////////////////////////////////////////////////////////////////////////
// Member variables
////////////////////////////////////////////////////////////////////////////////
- private int _a;
- private short _b;
- private short _c;
- private byte _d;
- private byte _e;
- private byte _f;
- private byte _g;
- private byte _h;
- private byte _i;
- private byte _j;
- private byte _k;
+ private int _a;
+ private short _b;
+ private short _c;
+ private byte _d;
+ private byte _e;
+ private byte _f;
+ private byte _g;
+ private byte _h;
+ private byte _i;
+ private byte _j;
+ private byte _k;
@@ -46,10 +47,10 @@ namespace System {
//
public Guid(byte[] b)
{
- if (b==null)
+ if (b == null)
throw new ArgumentNullException(nameof(b));
if (b.Length != 16)
- throw new ArgumentException(Environment.GetResourceString("Arg_GuidArrayCtor", "16"), nameof(b));
+ throw new ArgumentException(SR.Format(SR.Arg_GuidArrayCtor, "16"), nameof(b));
Contract.EndContractBlock();
_a = ((int)b[3] << 24) | ((int)b[2] << 16) | ((int)b[1] << 8) | b[0];
@@ -66,7 +67,7 @@ namespace System {
}
[CLSCompliant(false)]
- public Guid (uint a, ushort b, ushort c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k)
+ public Guid(uint a, ushort b, ushort c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k)
{
_a = (int)a;
_b = (short)b;
@@ -86,16 +87,16 @@ namespace System {
//
public Guid(int a, short b, short c, byte[] d)
{
- if (d==null)
+ if (d == null)
throw new ArgumentNullException(nameof(d));
// Check that array is not too big
- if(d.Length != 8)
- throw new ArgumentException(Environment.GetResourceString("Arg_GuidArrayCtor", "8"), nameof(d));
+ if (d.Length != 8)
+ throw new ArgumentException(SR.Format(SR.Arg_GuidArrayCtor, "8"), nameof(d));
Contract.EndContractBlock();
- _a = a;
- _b = b;
- _c = c;
+ _a = a;
+ _b = b;
+ _c = c;
_d = d[0];
_e = d[1];
_f = d[2];
@@ -125,41 +126,45 @@ namespace System {
}
[Flags]
- private enum GuidStyles {
- None = 0x00000000,
- AllowParenthesis = 0x00000001, //Allow the guid to be enclosed in parens
- AllowBraces = 0x00000002, //Allow the guid to be enclosed in braces
- AllowDashes = 0x00000004, //Allow the guid to contain dash group separators
- AllowHexPrefix = 0x00000008, //Allow the guid to contain {0xdd,0xdd}
- RequireParenthesis = 0x00000010, //Require the guid to be enclosed in parens
- RequireBraces = 0x00000020, //Require the guid to be enclosed in braces
- RequireDashes = 0x00000040, //Require the guid to contain dash group separators
- RequireHexPrefix = 0x00000080, //Require the guid to contain {0xdd,0xdd}
-
- HexFormat = RequireBraces | RequireHexPrefix, /* X */
- NumberFormat = None, /* N */
- DigitFormat = RequireDashes, /* D */
- BraceFormat = RequireBraces | RequireDashes, /* B */
- ParenthesisFormat = RequireParenthesis | RequireDashes, /* P */
-
- Any = AllowParenthesis | AllowBraces | AllowDashes | AllowHexPrefix,
+ private enum GuidStyles
+ {
+ None = 0x00000000,
+ AllowParenthesis = 0x00000001, //Allow the guid to be enclosed in parens
+ AllowBraces = 0x00000002, //Allow the guid to be enclosed in braces
+ AllowDashes = 0x00000004, //Allow the guid to contain dash group separators
+ AllowHexPrefix = 0x00000008, //Allow the guid to contain {0xdd,0xdd}
+ RequireParenthesis = 0x00000010, //Require the guid to be enclosed in parens
+ RequireBraces = 0x00000020, //Require the guid to be enclosed in braces
+ RequireDashes = 0x00000040, //Require the guid to contain dash group separators
+ RequireHexPrefix = 0x00000080, //Require the guid to contain {0xdd,0xdd}
+
+ HexFormat = RequireBraces | RequireHexPrefix, /* X */
+ NumberFormat = None, /* N */
+ DigitFormat = RequireDashes, /* D */
+ BraceFormat = RequireBraces | RequireDashes, /* B */
+ ParenthesisFormat = RequireParenthesis | RequireDashes, /* P */
+
+ Any = AllowParenthesis | AllowBraces | AllowDashes | AllowHexPrefix,
}
- private enum GuidParseThrowStyle {
- None = 0,
- All = 1,
- AllButOverflow = 2
+ private enum GuidParseThrowStyle
+ {
+ None = 0,
+ All = 1,
+ AllButOverflow = 2
}
- private enum ParseFailureKind {
- None = 0,
- ArgumentNull = 1,
- Format = 2,
- FormatWithParameter = 3,
- NativeException = 4,
+ private enum ParseFailureKind
+ {
+ None = 0,
+ ArgumentNull = 1,
+ Format = 2,
+ FormatWithParameter = 3,
+ NativeException = 4,
FormatWithInnerException = 5
}
// This will store the result of the parsing. And it will eventually be used to construct a Guid instance.
- private struct GuidResult {
+ private struct GuidResult
+ {
internal Guid parsedGuid;
internal GuidParseThrowStyle throwStyle;
@@ -169,53 +174,61 @@ namespace System {
internal string m_failureArgumentName;
internal Exception m_innerException;
- internal void Init(GuidParseThrowStyle canThrow) {
+ internal void Init(GuidParseThrowStyle canThrow)
+ {
parsedGuid = Guid.Empty;
- throwStyle = canThrow;
+ throwStyle = canThrow;
}
- internal void SetFailure(Exception nativeException) {
+ internal void SetFailure(Exception nativeException)
+ {
m_failure = ParseFailureKind.NativeException;
m_innerException = nativeException;
}
- internal void SetFailure(ParseFailureKind failure, string failureMessageID) {
+ internal void SetFailure(ParseFailureKind failure, string failureMessageID)
+ {
SetFailure(failure, failureMessageID, null, null, null);
}
- internal void SetFailure(ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument) {
+ internal void SetFailure(ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument)
+ {
SetFailure(failure, failureMessageID, failureMessageFormatArgument, null, null);
}
internal void SetFailure(ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument,
- string failureArgumentName, Exception innerException) {
+ string failureArgumentName, Exception innerException)
+ {
Debug.Assert(failure != ParseFailureKind.NativeException, "ParseFailureKind.NativeException should not be used with this overload");
m_failure = failure;
m_failureMessageID = failureMessageID;
m_failureMessageFormatArgument = failureMessageFormatArgument;
m_failureArgumentName = failureArgumentName;
m_innerException = innerException;
- if (throwStyle != GuidParseThrowStyle.None) {
+ if (throwStyle != GuidParseThrowStyle.None)
+ {
throw GetGuidParseException();
}
}
- internal Exception GetGuidParseException() {
- switch (m_failure) {
- case ParseFailureKind.ArgumentNull:
- return new ArgumentNullException(m_failureArgumentName, Environment.GetResourceString(m_failureMessageID));
+ internal Exception GetGuidParseException()
+ {
+ switch (m_failure)
+ {
+ case ParseFailureKind.ArgumentNull:
+ return new ArgumentNullException(m_failureArgumentName, SR.GetResourceString(m_failureMessageID));
- case ParseFailureKind.FormatWithInnerException:
- return new FormatException(Environment.GetResourceString(m_failureMessageID), m_innerException);
+ case ParseFailureKind.FormatWithInnerException:
+ return new FormatException(SR.GetResourceString(m_failureMessageID), m_innerException);
- case ParseFailureKind.FormatWithParameter:
- return new FormatException(Environment.GetResourceString(m_failureMessageID, m_failureMessageFormatArgument));
+ case ParseFailureKind.FormatWithParameter:
+ return new FormatException(SR.Format(SR.GetResourceString(m_failureMessageID), m_failureMessageFormatArgument));
- case ParseFailureKind.Format:
- return new FormatException(Environment.GetResourceString(m_failureMessageID));
+ case ParseFailureKind.Format:
+ return new FormatException(SR.GetResourceString(m_failureMessageID));
- case ParseFailureKind.NativeException:
- return m_innerException;
+ case ParseFailureKind.NativeException:
+ return m_innerException;
- default:
- Debug.Assert(false, "Unknown GuidParseFailure: " + m_failure);
- return new FormatException(Environment.GetResourceString("Format_GuidUnrecognized"));
+ default:
+ Debug.Assert(false, "Unknown GuidParseFailure: " + m_failure);
+ return new FormatException(SR.Format_GuidUnrecognized);
}
}
}
@@ -230,7 +243,8 @@ namespace System {
//
public Guid(String g)
{
- if (g==null) {
+ if (g == null)
+ {
throw new ArgumentNullException(nameof(g));
}
Contract.EndContractBlock();
@@ -238,10 +252,12 @@ namespace System {
GuidResult result = new GuidResult();
result.Init(GuidParseThrowStyle.All);
- if (TryParseGuid(g, GuidStyles.Any, ref result)) {
+ if (TryParseGuid(g, GuidStyles.Any, ref result))
+ {
this = result.parsedGuid;
}
- else {
+ else
+ {
throw result.GetGuidParseException();
}
}
@@ -249,17 +265,20 @@ namespace System {
public static Guid Parse(String input)
{
- if (input == null) {
+ if (input == null)
+ {
throw new ArgumentNullException(nameof(input));
}
Contract.EndContractBlock();
GuidResult result = new GuidResult();
result.Init(GuidParseThrowStyle.AllButOverflow);
- if (TryParseGuid(input, GuidStyles.Any, ref result)) {
+ if (TryParseGuid(input, GuidStyles.Any, ref result))
+ {
return result.parsedGuid;
}
- else {
+ else
+ {
throw result.GetGuidParseException();
}
}
@@ -268,11 +287,13 @@ namespace System {
{
GuidResult parseResult = new GuidResult();
parseResult.Init(GuidParseThrowStyle.None);
- if (TryParseGuid(input, GuidStyles.Any, ref parseResult)) {
+ if (TryParseGuid(input, GuidStyles.Any, ref parseResult))
+ {
result = parseResult.parsedGuid;
return true;
}
- else {
+ else
+ {
result = Guid.Empty;
return false;
}
@@ -286,45 +307,55 @@ namespace System {
if (format == null)
throw new ArgumentNullException(nameof(format));
- if( format.Length != 1) {
+ if (format.Length != 1)
+ {
// all acceptable format strings are of length 1
- throw new FormatException(Environment.GetResourceString("Format_InvalidGuidFormatSpecification"));
+ throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
}
GuidStyles style;
char formatCh = format[0];
- if (formatCh == 'D' || formatCh == 'd') {
+ if (formatCh == 'D' || formatCh == 'd')
+ {
style = GuidStyles.DigitFormat;
- }
- else if (formatCh == 'N' || formatCh == 'n') {
+ }
+ else if (formatCh == 'N' || formatCh == 'n')
+ {
style = GuidStyles.NumberFormat;
}
- else if (formatCh == 'B' || formatCh == 'b') {
+ else if (formatCh == 'B' || formatCh == 'b')
+ {
style = GuidStyles.BraceFormat;
}
- else if (formatCh == 'P' || formatCh == 'p') {
+ else if (formatCh == 'P' || formatCh == 'p')
+ {
style = GuidStyles.ParenthesisFormat;
}
- else if (formatCh == 'X' || formatCh == 'x') {
+ else if (formatCh == 'X' || formatCh == 'x')
+ {
style = GuidStyles.HexFormat;
}
- else {
- throw new FormatException(Environment.GetResourceString("Format_InvalidGuidFormatSpecification"));
+ else
+ {
+ throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
}
GuidResult result = new GuidResult();
result.Init(GuidParseThrowStyle.AllButOverflow);
- if (TryParseGuid(input, style, ref result)) {
+ if (TryParseGuid(input, style, ref result))
+ {
return result.parsedGuid;
}
- else {
+ else
+ {
throw result.GetGuidParseException();
}
}
public static bool TryParseExact(String input, String format, out Guid result)
{
- if (format == null || format.Length != 1) {
+ if (format == null || format.Length != 1)
+ {
result = Guid.Empty;
return false;
}
@@ -332,22 +363,28 @@ namespace System {
GuidStyles style;
char formatCh = format[0];
- if (formatCh == 'D' || formatCh == 'd') {
+ if (formatCh == 'D' || formatCh == 'd')
+ {
style = GuidStyles.DigitFormat;
- }
- else if (formatCh == 'N' || formatCh == 'n') {
+ }
+ else if (formatCh == 'N' || formatCh == 'n')
+ {
style = GuidStyles.NumberFormat;
}
- else if (formatCh == 'B' || formatCh == 'b') {
+ else if (formatCh == 'B' || formatCh == 'b')
+ {
style = GuidStyles.BraceFormat;
}
- else if (formatCh == 'P' || formatCh == 'p') {
+ else if (formatCh == 'P' || formatCh == 'p')
+ {
style = GuidStyles.ParenthesisFormat;
}
- else if (formatCh == 'X' || formatCh == 'x') {
+ else if (formatCh == 'X' || formatCh == 'x')
+ {
style = GuidStyles.HexFormat;
}
- else {
+ else
+ {
// invalid guid format specification
result = Guid.Empty;
return false;
@@ -355,11 +392,13 @@ namespace System {
GuidResult parseResult = new GuidResult();
parseResult.Init(GuidParseThrowStyle.None);
- if (TryParseGuid(input, style, ref parseResult)) {
+ if (TryParseGuid(input, style, ref parseResult))
+ {
result = parseResult.parsedGuid;
return true;
}
- else {
+ else
+ {
result = Guid.Empty;
return false;
}
@@ -368,13 +407,15 @@ namespace System {
private static bool TryParseGuid(String g, GuidStyles flags, ref GuidResult result)
{
- if (g == null) {
+ if (g == null)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidUnrecognized");
return false;
}
String guidString = g.Trim(); //Remove Whitespace
- if (guidString.Length == 0) {
+ if (guidString.Length == 0)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidUnrecognized");
return false;
}
@@ -382,15 +423,19 @@ namespace System {
// Check for dashes
bool dashesExistInString = (guidString.IndexOf('-', 0) >= 0);
- if (dashesExistInString) {
- if ((flags & (GuidStyles.AllowDashes | GuidStyles.RequireDashes)) == 0) {
+ if (dashesExistInString)
+ {
+ if ((flags & (GuidStyles.AllowDashes | GuidStyles.RequireDashes)) == 0)
+ {
// dashes are not allowed
result.SetFailure(ParseFailureKind.Format, "Format_GuidUnrecognized");
return false;
}
}
- else {
- if ((flags & GuidStyles.RequireDashes) != 0) {
+ else
+ {
+ if ((flags & GuidStyles.RequireDashes) != 0)
+ {
// dashes are required
result.SetFailure(ParseFailureKind.Format, "Format_GuidUnrecognized");
return false;
@@ -400,15 +445,19 @@ namespace System {
// Check for braces
bool bracesExistInString = (guidString.IndexOf('{', 0) >= 0);
- if (bracesExistInString) {
- if ((flags & (GuidStyles.AllowBraces | GuidStyles.RequireBraces)) == 0) {
+ if (bracesExistInString)
+ {
+ if ((flags & (GuidStyles.AllowBraces | GuidStyles.RequireBraces)) == 0)
+ {
// braces are not allowed
result.SetFailure(ParseFailureKind.Format, "Format_GuidUnrecognized");
return false;
}
}
- else {
- if ((flags & GuidStyles.RequireBraces) != 0) {
+ else
+ {
+ if ((flags & GuidStyles.RequireBraces) != 0)
+ {
// braces are required
result.SetFailure(ParseFailureKind.Format, "Format_GuidUnrecognized");
return false;
@@ -417,50 +466,61 @@ namespace System {
// Check for parenthesis
bool parenthesisExistInString = (guidString.IndexOf('(', 0) >= 0);
-
- if (parenthesisExistInString) {
- if ((flags & (GuidStyles.AllowParenthesis | GuidStyles.RequireParenthesis)) == 0) {
+
+ if (parenthesisExistInString)
+ {
+ if ((flags & (GuidStyles.AllowParenthesis | GuidStyles.RequireParenthesis)) == 0)
+ {
// parenthesis are not allowed
result.SetFailure(ParseFailureKind.Format, "Format_GuidUnrecognized");
return false;
}
}
- else {
- if ((flags & GuidStyles.RequireParenthesis) != 0) {
+ else
+ {
+ if ((flags & GuidStyles.RequireParenthesis) != 0)
+ {
// parenthesis are required
result.SetFailure(ParseFailureKind.Format, "Format_GuidUnrecognized");
return false;
}
}
- try {
+ try
+ {
// let's get on with the parsing
- if (dashesExistInString) {
+ if (dashesExistInString)
+ {
// Check if it's of the form [{|(]dddddddd-dddd-dddd-dddd-dddddddddddd[}|)]
return TryParseGuidWithDashes(guidString, ref result);
}
- else if (bracesExistInString) {
+ else if (bracesExistInString)
+ {
// Check if it's of the form {0xdddddddd,0xdddd,0xdddd,{0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd}}
return TryParseGuidWithHexPrefix(guidString, ref result);
}
- else {
+ else
+ {
// Check if it's of the form dddddddddddddddddddddddddddddddd
return TryParseGuidWithNoStyle(guidString, ref result);
}
}
- catch(IndexOutOfRangeException ex) {
+ catch (IndexOutOfRangeException ex)
+ {
result.SetFailure(ParseFailureKind.FormatWithInnerException, "Format_GuidUnrecognized", null, null, ex);
return false;
}
- catch (ArgumentException ex) {
+ catch (ArgumentException ex)
+ {
result.SetFailure(ParseFailureKind.FormatWithInnerException, "Format_GuidUnrecognized", null, null, ex);
return false;
- }
+ }
}
-
+
// Check if it's of the form {0xdddddddd,0xdddd,0xdddd,{0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd}}
- private static bool TryParseGuidWithHexPrefix(String guidString, ref GuidResult result) {
+ private static bool TryParseGuidWithHexPrefix(String guidString, ref GuidResult result)
+ {
int numStart = 0;
int numLen = 0;
@@ -468,13 +528,15 @@ namespace System {
guidString = EatAllWhitespace(guidString);
// Check for leading '{'
- if(String.IsNullOrEmpty(guidString) || guidString[0] != '{') {
+ if (String.IsNullOrEmpty(guidString) || guidString[0] != '{')
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidBrace");
return false;
}
// Check for '0x'
- if(!IsHexPrefix(guidString, 1)) {
+ if (!IsHexPrefix(guidString, 1))
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidHexPrefix", "{0xdddddddd, etc}");
return false;
}
@@ -482,7 +544,8 @@ namespace System {
// Find the end of this hex number (since it is not fixed length)
numStart = 3;
numLen = guidString.IndexOf(',', numStart) - numStart;
- if(numLen <= 0) {
+ if (numLen <= 0)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidComma");
return false;
}
@@ -492,14 +555,16 @@ namespace System {
return false;
// Check for '0x'
- if(!IsHexPrefix(guidString, numStart+numLen+1)) {
+ if (!IsHexPrefix(guidString, numStart + numLen + 1))
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidHexPrefix", "{0xdddddddd, 0xdddd, etc}");
return false;
}
// +3 to get by ',0x'
numStart = numStart + numLen + 3;
numLen = guidString.IndexOf(',', numStart) - numStart;
- if(numLen <= 0) {
+ if (numLen <= 0)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidComma");
return false;
}
@@ -508,14 +573,16 @@ namespace System {
if (!StringToShort(guidString.Substring(numStart, numLen) /*first DWORD*/, -1, ParseNumbers.IsTight, out result.parsedGuid._b, ref result))
return false;
// Check for '0x'
- if(!IsHexPrefix(guidString, numStart+numLen+1)) {
+ if (!IsHexPrefix(guidString, numStart + numLen + 1))
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidHexPrefix", "{0xdddddddd, 0xdddd, 0xdddd, etc}");
return false;
}
// +3 to get by ',0x'
numStart = numStart + numLen + 3;
numLen = guidString.IndexOf(',', numStart) - numStart;
- if(numLen <= 0) {
+ if (numLen <= 0)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidComma");
return false;
}
@@ -523,9 +590,10 @@ namespace System {
// Read in the number
if (!StringToShort(guidString.Substring(numStart, numLen) /*first DWORD*/, -1, ParseNumbers.IsTight, out result.parsedGuid._c, ref result))
return false;
-
+
// Check for '{'
- if(guidString.Length <= numStart+numLen+1 || guidString[numStart+numLen+1] != '{') {
+ if (guidString.Length <= numStart + numLen + 1 || guidString[numStart + numLen + 1] != '{')
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidBrace");
return false;
}
@@ -534,10 +602,11 @@ namespace System {
numLen++;
byte[] bytes = new byte[8];
- for(int i = 0; i < 8; i++)
+ for (int i = 0; i < 8; i++)
{
// Check for '0x'
- if(!IsHexPrefix(guidString, numStart+numLen+1)) {
+ if (!IsHexPrefix(guidString, numStart + numLen + 1))
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidHexPrefix", "{... { ... 0xdd, ...}}");
return false;
}
@@ -546,33 +615,37 @@ namespace System {
numStart = numStart + numLen + 3;
// Calculate number length
- if(i < 7) // first 7 cases
+ if (i < 7) // first 7 cases
{
numLen = guidString.IndexOf(',', numStart) - numStart;
- if(numLen <= 0) {
+ if (numLen <= 0)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidComma");
return false;
- }
+ }
}
else // last case ends with '}', not ','
{
numLen = guidString.IndexOf('}', numStart) - numStart;
- if(numLen <= 0) {
+ if (numLen <= 0)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidBraceAfterLastNumber");
return false;
- }
+ }
}
// Read in the number
int signedNumber;
- if (!StringToInt(guidString.Substring(numStart, numLen), -1, ParseNumbers.IsTight, out signedNumber, ref result)) {
+ if (!StringToInt(guidString.Substring(numStart, numLen), -1, ParseNumbers.IsTight, out signedNumber, ref result))
+ {
return false;
}
uint number = (uint)signedNumber;
// check for overflow
- if(number > 255) {
- result.SetFailure(ParseFailureKind.Format, "Overflow_Byte");
+ if (number > 255)
+ {
+ result.SetFailure(ParseFailureKind.Format, "Overflow_Byte");
return false;
}
bytes[i] = (byte)number;
@@ -588,40 +661,48 @@ namespace System {
result.parsedGuid._k = bytes[7];
// Check for last '}'
- if(numStart+numLen+1 >= guidString.Length || guidString[numStart+numLen+1] != '}') {
+ if (numStart + numLen + 1 >= guidString.Length || guidString[numStart + numLen + 1] != '}')
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidEndBrace");
return false;
}
// Check if we have extra characters at the end
- if( numStart+numLen+1 != guidString.Length -1) {
+ if (numStart + numLen + 1 != guidString.Length - 1)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_ExtraJunkAtEnd");
return false;
}
-
+
return true;
}
-
+
// Check if it's of the form dddddddddddddddddddddddddddddddd
- private static bool TryParseGuidWithNoStyle(String guidString, ref GuidResult result) {
- int startPos=0;
+ private static bool TryParseGuidWithNoStyle(String guidString, ref GuidResult result)
+ {
+ int startPos = 0;
int temp;
long templ;
int currentPos = 0;
- if(guidString.Length != 32) {
+ if (guidString.Length != 32)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidInvLen");
return false;
}
- for(int i= 0; i< guidString.Length; i++) {
+ for (int i = 0; i < guidString.Length; i++)
+ {
char ch = guidString[i];
- if(ch >= '0' && ch <= '9') {
+ if (ch >= '0' && ch <= '9')
+ {
continue;
}
- else {
+ else
+ {
char upperCaseCh = Char.ToUpper(ch, CultureInfo.InvariantCulture);
- if(upperCaseCh >= 'A' && upperCaseCh <= 'F') {
+ if (upperCaseCh >= 'A' && upperCaseCh <= 'F')
+ {
continue;
}
}
@@ -651,20 +732,21 @@ namespace System {
if (!StringToLong(guidString, ref currentPos, ParseNumbers.NoSpace, out templ, ref result))
return false;
- if (currentPos - startPos!=12) {
+ if (currentPos - startPos != 12)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidInvLen");
return false;
}
- result.parsedGuid._d = (byte)(temp>>8);
+ result.parsedGuid._d = (byte)(temp >> 8);
result.parsedGuid._e = (byte)(temp);
temp = (int)(templ >> 32);
- result.parsedGuid._f = (byte)(temp>>8);
+ result.parsedGuid._f = (byte)(temp >> 8);
result.parsedGuid._g = (byte)(temp);
temp = (int)(templ);
- result.parsedGuid._h = (byte)(temp>>24);
- result.parsedGuid._i = (byte)(temp>>16);
- result.parsedGuid._j = (byte)(temp>>8);
+ result.parsedGuid._h = (byte)(temp >> 24);
+ result.parsedGuid._i = (byte)(temp >> 16);
+ result.parsedGuid._j = (byte)(temp >> 8);
result.parsedGuid._k = (byte)(temp);
return true;
@@ -672,36 +754,43 @@ namespace System {
// Check if it's of the form [{|(]dddddddd-dddd-dddd-dddd-dddddddddddd[}|)]
- private static bool TryParseGuidWithDashes(String guidString, ref GuidResult result) {
- int startPos=0;
+ private static bool TryParseGuidWithDashes(String guidString, ref GuidResult result)
+ {
+ int startPos = 0;
int temp;
long templ;
int currentPos = 0;
// check to see that it's the proper length
- if (guidString[0]=='{') {
- if (guidString.Length!=38 || guidString[37]!='}') {
+ if (guidString[0] == '{')
+ {
+ if (guidString.Length != 38 || guidString[37] != '}')
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidInvLen");
return false;
}
- startPos=1;
+ startPos = 1;
}
- else if (guidString[0]=='(') {
- if (guidString.Length!=38 || guidString[37]!=')') {
+ else if (guidString[0] == '(')
+ {
+ if (guidString.Length != 38 || guidString[37] != ')')
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidInvLen");
return false;
}
- startPos=1;
+ startPos = 1;
}
- else if(guidString.Length != 36) {
+ else if (guidString.Length != 36)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidInvLen");
return false;
}
- if (guidString[8+startPos] != '-' ||
- guidString[13+startPos] != '-' ||
- guidString[18+startPos] != '-' ||
- guidString[23+startPos] != '-') {
+ if (guidString[8 + startPos] != '-' ||
+ guidString[13 + startPos] != '-' ||
+ guidString[18 + startPos] != '-' ||
+ guidString[23 + startPos] != '-')
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidDashes");
return false;
}
@@ -725,24 +814,25 @@ namespace System {
if (!StringToInt(guidString, ref currentPos, 4, ParseNumbers.NoSpace, out temp, ref result))
return false;
++currentPos; //Increment past the '-';
- startPos=currentPos;
+ startPos = currentPos;
if (!StringToLong(guidString, ref currentPos, ParseNumbers.NoSpace, out templ, ref result))
return false;
- if (currentPos - startPos != 12) {
+ if (currentPos - startPos != 12)
+ {
result.SetFailure(ParseFailureKind.Format, "Format_GuidInvLen");
return false;
}
- result.parsedGuid._d = (byte)(temp>>8);
+ result.parsedGuid._d = (byte)(temp >> 8);
result.parsedGuid._e = (byte)(temp);
temp = (int)(templ >> 32);
- result.parsedGuid._f = (byte)(temp>>8);
+ result.parsedGuid._f = (byte)(temp >> 8);
result.parsedGuid._g = (byte)(temp);
temp = (int)(templ);
- result.parsedGuid._h = (byte)(temp>>24);
- result.parsedGuid._i = (byte)(temp>>16);
- result.parsedGuid._j = (byte)(temp>>8);
+ result.parsedGuid._h = (byte)(temp >> 24);
+ result.parsedGuid._i = (byte)(temp >> 16);
+ result.parsedGuid._j = (byte)(temp >> 8);
result.parsedGuid._k = (byte)(temp);
return true;
@@ -752,10 +842,12 @@ namespace System {
//
// StringToShort, StringToInt, and StringToLong are wrappers around COMUtilNative integer parsing routines;
- private static unsafe bool StringToShort(String str, int requiredLength, int flags, out short result, ref GuidResult parseResult) {
+ private static unsafe bool StringToShort(String str, int requiredLength, int flags, out short result, ref GuidResult parseResult)
+ {
return StringToShort(str, null, requiredLength, flags, out result, ref parseResult);
}
- private static unsafe bool StringToShort(String str, int* parsePos, int requiredLength, int flags, out short result, ref GuidResult parseResult) {
+ private static unsafe bool StringToShort(String str, int* parsePos, int requiredLength, int flags, out short result, ref GuidResult parseResult)
+ {
result = 0;
int x;
bool retValue = StringToInt(str, parsePos, requiredLength, flags, out x, ref parseResult);
@@ -763,79 +855,103 @@ namespace System {
return retValue;
}
- private static unsafe bool StringToInt(String str, int requiredLength, int flags, out int result, ref GuidResult parseResult) {
+ private static unsafe bool StringToInt(String str, int requiredLength, int flags, out int result, ref GuidResult parseResult)
+ {
return StringToInt(str, null, requiredLength, flags, out result, ref parseResult);
}
- private static unsafe bool StringToInt(String str, ref int parsePos, int requiredLength, int flags, out int result, ref GuidResult parseResult) {
- fixed(int * ppos = &parsePos) {
+ private static unsafe bool StringToInt(String str, ref int parsePos, int requiredLength, int flags, out int result, ref GuidResult parseResult)
+ {
+ fixed (int* ppos = &parsePos)
+ {
return StringToInt(str, ppos, requiredLength, flags, out result, ref parseResult);
}
}
- private static unsafe bool StringToInt(String str, int* parsePos, int requiredLength, int flags, out int result, ref GuidResult parseResult) {
+ private static unsafe bool StringToInt(String str, int* parsePos, int requiredLength, int flags, out int result, ref GuidResult parseResult)
+ {
result = 0;
int currStart = (parsePos == null) ? 0 : (*parsePos);
- try {
+ try
+ {
result = ParseNumbers.StringToInt(str, 16, flags, parsePos);
}
- catch (OverflowException ex) {
- if (parseResult.throwStyle == GuidParseThrowStyle.All) {
+ catch (OverflowException ex)
+ {
+ if (parseResult.throwStyle == GuidParseThrowStyle.All)
+ {
throw;
}
- else if (parseResult.throwStyle == GuidParseThrowStyle.AllButOverflow) {
- throw new FormatException(Environment.GetResourceString("Format_GuidUnrecognized"), ex);
+ else if (parseResult.throwStyle == GuidParseThrowStyle.AllButOverflow)
+ {
+ throw new FormatException(SR.Format_GuidUnrecognized, ex);
}
- else {
+ else
+ {
parseResult.SetFailure(ex);
return false;
}
}
- catch (Exception ex) {
- if (parseResult.throwStyle == GuidParseThrowStyle.None) {
+ catch (Exception ex)
+ {
+ if (parseResult.throwStyle == GuidParseThrowStyle.None)
+ {
parseResult.SetFailure(ex);
return false;
}
- else {
+ else
+ {
throw;
}
}
//If we didn't parse enough characters, there's clearly an error.
- if (requiredLength != -1 && parsePos != null && (*parsePos) - currStart != requiredLength) {
+ if (requiredLength != -1 && parsePos != null && (*parsePos) - currStart != requiredLength)
+ {
parseResult.SetFailure(ParseFailureKind.Format, "Format_GuidInvalidChar");
return false;
}
return true;
}
- private static unsafe bool StringToLong(String str, ref int parsePos, int flags, out long result, ref GuidResult parseResult) {
- fixed(int * ppos = &parsePos) {
+ private static unsafe bool StringToLong(String str, ref int parsePos, int flags, out long result, ref GuidResult parseResult)
+ {
+ fixed (int* ppos = &parsePos)
+ {
return StringToLong(str, ppos, flags, out result, ref parseResult);
}
}
- private static unsafe bool StringToLong(String str, int* parsePos, int flags, out long result, ref GuidResult parseResult) {
+ private static unsafe bool StringToLong(String str, int* parsePos, int flags, out long result, ref GuidResult parseResult)
+ {
result = 0;
- try {
+ try
+ {
result = ParseNumbers.StringToLong(str, 16, flags, parsePos);
}
- catch (OverflowException ex) {
- if (parseResult.throwStyle == GuidParseThrowStyle.All) {
+ catch (OverflowException ex)
+ {
+ if (parseResult.throwStyle == GuidParseThrowStyle.All)
+ {
throw;
}
- else if (parseResult.throwStyle == GuidParseThrowStyle.AllButOverflow) {
- throw new FormatException(Environment.GetResourceString("Format_GuidUnrecognized"), ex);
+ else if (parseResult.throwStyle == GuidParseThrowStyle.AllButOverflow)
+ {
+ throw new FormatException(SR.Format_GuidUnrecognized, ex);
}
- else {
+ else
+ {
parseResult.SetFailure(ex);
return false;
}
}
- catch (Exception ex) {
- if (parseResult.throwStyle == GuidParseThrowStyle.None) {
+ catch (Exception ex)
+ {
+ if (parseResult.throwStyle == GuidParseThrowStyle.None)
+ {
parseResult.SetFailure(ex);
return false;
}
- else {
+ else
+ {
throw;
}
}
@@ -850,10 +966,10 @@ namespace System {
char curChar;
// Now get each char from str and if it is not whitespace add it to chArr
- for(int i = 0; i < str.Length; i++)
+ for (int i = 0; i < str.Length; i++)
{
curChar = str[i];
- if(!Char.IsWhiteSpace(curChar))
+ if (!Char.IsWhiteSpace(curChar))
{
chArr[newLength++] = curChar;
}
@@ -865,7 +981,7 @@ namespace System {
private static bool IsHexPrefix(String str, int i)
{
- if(str.Length > i+1 && str[i] == '0' && (Char.ToLower(str[i+1], CultureInfo.InvariantCulture) == 'x'))
+ if (str.Length > i + 1 && str[i] == '0' && (Char.ToLower(str[i + 1], CultureInfo.InvariantCulture) == 'x'))
return true;
else
return false;
@@ -879,7 +995,7 @@ namespace System {
g[0] = (byte)(_a);
g[1] = (byte)(_a >> 8);
- g[2] = (byte)(_a >> 16);
+ g[2] = (byte)(_a >> 16);
g[3] = (byte)(_a >> 24);
g[4] = (byte)(_b);
g[5] = (byte)(_b >> 8);
@@ -901,14 +1017,14 @@ namespace System {
// Returns the guid in "registry" format.
public override String ToString()
{
- return ToString("D",null);
+ return ToString("D", null);
}
public unsafe override int GetHashCode()
{
// Simply XOR all the bits of the GUID 32 bits at a time.
- fixed (int* ptr = &this._a)
- return ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
+ fixed (int* ptr = &_a)
+ return ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
}
// Returns true if and only if the guid represented
@@ -917,16 +1033,16 @@ namespace System {
{
Guid g;
// Check that o is a Guid first
- if(o == null || !(o is Guid))
+ if (o == null || !(o is Guid))
return false;
- else g = (Guid) o;
+ else g = (Guid)o;
// Now compare each of the elements
- if(g._a != _a)
+ if (g._a != _a)
return false;
- if(g._b != _b)
+ if (g._b != _b)
return false;
- if(g._c != _c)
+ if (g._c != _c)
return false;
if (g._d != _d)
return false;
@@ -951,11 +1067,11 @@ namespace System {
public bool Equals(Guid g)
{
// Now compare each of the elements
- if(g._a != _a)
+ if (g._a != _a)
return false;
- if(g._b != _b)
+ if (g._b != _b)
return false;
- if(g._c != _c)
+ if (g._c != _c)
return false;
if (g._d != _d)
return false;
@@ -977,64 +1093,80 @@ namespace System {
return true;
}
- private int GetResult(uint me, uint them) {
- if (me<them) {
+ private int GetResult(uint me, uint them)
+ {
+ if (me < them)
+ {
return -1;
}
return 1;
}
- public int CompareTo(Object value) {
- if (value == null) {
+ public int CompareTo(Object value)
+ {
+ if (value == null)
+ {
return 1;
}
- if (!(value is Guid)) {
- throw new ArgumentException(Environment.GetResourceString("Arg_MustBeGuid"), nameof(value));
+ if (!(value is Guid))
+ {
+ throw new ArgumentException(SR.Arg_MustBeGuid, nameof(value));
}
Guid g = (Guid)value;
- if (g._a!=this._a) {
- return GetResult((uint)this._a, (uint)g._a);
+ if (g._a != _a)
+ {
+ return GetResult((uint)_a, (uint)g._a);
}
- if (g._b!=this._b) {
- return GetResult((uint)this._b, (uint)g._b);
+ if (g._b != _b)
+ {
+ return GetResult((uint)_b, (uint)g._b);
}
- if (g._c!=this._c) {
- return GetResult((uint)this._c, (uint)g._c);
+ if (g._c != _c)
+ {
+ return GetResult((uint)_c, (uint)g._c);
}
- if (g._d!=this._d) {
- return GetResult((uint)this._d, (uint)g._d);
+ if (g._d != _d)
+ {
+ return GetResult((uint)_d, (uint)g._d);
}
- if (g._e!=this._e) {
- return GetResult((uint)this._e, (uint)g._e);
+ if (g._e != _e)
+ {
+ return GetResult((uint)_e, (uint)g._e);
}
- if (g._f!=this._f) {
- return GetResult((uint)this._f, (uint)g._f);
+ if (g._f != _f)
+ {
+ return GetResult((uint)_f, (uint)g._f);
}
- if (g._g!=this._g) {
- return GetResult((uint)this._g, (uint)g._g);
+ if (g._g != _g)
+ {
+ return GetResult((uint)_g, (uint)g._g);
}
- if (g._h!=this._h) {
- return GetResult((uint)this._h, (uint)g._h);
+ if (g._h != _h)
+ {
+ return GetResult((uint)_h, (uint)g._h);
}
- if (g._i!=this._i) {
- return GetResult((uint)this._i, (uint)g._i);
+ if (g._i != _i)
+ {
+ return GetResult((uint)_i, (uint)g._i);
}
- if (g._j!=this._j) {
- return GetResult((uint)this._j, (uint)g._j);
+ if (g._j != _j)
+ {
+ return GetResult((uint)_j, (uint)g._j);
}
- if (g._k!=this._k) {
- return GetResult((uint)this._k, (uint)g._k);
+ if (g._k != _k)
+ {
+ return GetResult((uint)_k, (uint)g._k);
}
return 0;
@@ -1042,48 +1174,59 @@ namespace System {
public int CompareTo(Guid value)
{
- if (value._a!=this._a) {
- return GetResult((uint)this._a, (uint)value._a);
+ if (value._a != _a)
+ {
+ return GetResult((uint)_a, (uint)value._a);
}
- if (value._b!=this._b) {
- return GetResult((uint)this._b, (uint)value._b);
+ if (value._b != _b)
+ {
+ return GetResult((uint)_b, (uint)value._b);
}
- if (value._c!=this._c) {
- return GetResult((uint)this._c, (uint)value._c);
+ if (value._c != _c)
+ {
+ return GetResult((uint)_c, (uint)value._c);
}
- if (value._d!=this._d) {
- return GetResult((uint)this._d, (uint)value._d);
+ if (value._d != _d)
+ {
+ return GetResult((uint)_d, (uint)value._d);
}
- if (value._e!=this._e) {
- return GetResult((uint)this._e, (uint)value._e);
+ if (value._e != _e)
+ {
+ return GetResult((uint)_e, (uint)value._e);
}
- if (value._f!=this._f) {
- return GetResult((uint)this._f, (uint)value._f);
+ if (value._f != _f)
+ {
+ return GetResult((uint)_f, (uint)value._f);
}
- if (value._g!=this._g) {
- return GetResult((uint)this._g, (uint)value._g);
+ if (value._g != _g)
+ {
+ return GetResult((uint)_g, (uint)value._g);
}
- if (value._h!=this._h) {
- return GetResult((uint)this._h, (uint)value._h);
+ if (value._h != _h)
+ {
+ return GetResult((uint)_h, (uint)value._h);
}
- if (value._i!=this._i) {
- return GetResult((uint)this._i, (uint)value._i);
+ if (value._i != _i)
+ {
+ return GetResult((uint)_i, (uint)value._i);
}
- if (value._j!=this._j) {
- return GetResult((uint)this._j, (uint)value._j);
+ if (value._j != _j)
+ {
+ return GetResult((uint)_j, (uint)value._j);
}
- if (value._k!=this._k) {
- return GetResult((uint)this._k, (uint)value._k);
+ if (value._k != _k)
+ {
+ return GetResult((uint)_k, (uint)value._k);
}
return 0;
@@ -1092,27 +1235,27 @@ namespace System {
public static bool operator ==(Guid a, Guid b)
{
// Now compare each of the elements
- if(a._a != b._a)
+ if (a._a != b._a)
return false;
- if(a._b != b._b)
+ if (a._b != b._b)
return false;
- if(a._c != b._c)
+ if (a._c != b._c)
return false;
- if(a._d != b._d)
+ if (a._d != b._d)
return false;
- if(a._e != b._e)
+ if (a._e != b._e)
return false;
- if(a._f != b._f)
+ if (a._f != b._f)
return false;
- if(a._g != b._g)
+ if (a._g != b._g)
return false;
- if(a._h != b._h)
+ if (a._h != b._h)
return false;
- if(a._i != b._i)
+ if (a._i != b._i)
return false;
- if(a._j != b._j)
+ if (a._j != b._j)
return false;
- if(a._k != b._k)
+ if (a._k != b._k)
return false;
return true;
@@ -1125,7 +1268,8 @@ namespace System {
// This will create a new guid. Since we've now decided that constructors should 0-init,
// we need a method that allows users to create a guid.
- public static Guid NewGuid() {
+ public static Guid NewGuid()
+ {
// CoCreateGuid should never return Guid.Empty, since it attempts to maintain some
// uniqueness guarantees. It should also never return a known GUID, but it's unclear
// how extensively it checks for known values.
@@ -1136,37 +1280,45 @@ namespace System {
return guid;
}
- public String ToString(String format) {
+ public String ToString(String format)
+ {
return ToString(format, null);
}
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
private static char HexToChar(int a)
{
a = a & 0xf;
- return (char) ((a > 9) ? a - 10 + 0x61 : a + 0x30);
+ return (char)((a > 9) ? a - 10 + 0x61 : a + 0x30);
}
- unsafe private static int HexsToChars(char* guidChars, int offset, int a, int b)
+ unsafe private static int HexsToChars(char* guidChars, int a, int b)
{
- return HexsToChars(guidChars, offset, a, b, false);
+ guidChars[0] = HexToChar(a >> 4);
+ guidChars[1] = HexToChar(a);
+
+ guidChars[2] = HexToChar(b >> 4);
+ guidChars[3] = HexToChar(b);
+
+ return 4;
}
- unsafe private static int HexsToChars(char* guidChars, int offset, int a, int b, bool hex)
+ unsafe private static int HexsToCharsHexOutput(char* guidChars, int a, int b)
{
- if (hex) {
- guidChars[offset++] = '0';
- guidChars[offset++] = 'x';
- }
- guidChars[offset++] = HexToChar(a>>4);
- guidChars[offset++] = HexToChar(a);
- if (hex) {
- guidChars[offset++] = ',';
- guidChars[offset++] = '0';
- guidChars[offset++] = 'x';
- }
- guidChars[offset++] = HexToChar(b>>4);
- guidChars[offset++] = HexToChar(b);
- return offset;
+ guidChars[0] = '0';
+ guidChars[1] = 'x';
+
+ guidChars[2] = HexToChar(a >> 4);
+ guidChars[3] = HexToChar(a);
+
+ guidChars[4] = ',';
+ guidChars[5] = '0';
+ guidChars[6] = 'x';
+
+ guidChars[7] = HexToChar(b >> 4);
+ guidChars[8] = HexToChar(b);
+
+ return 9;
}
// IFormattable interface
@@ -1181,41 +1333,53 @@ namespace System {
bool dash = true;
bool hex = false;
- if( format.Length != 1) {
+ if (format.Length != 1)
+ {
// all acceptable format strings are of length 1
- throw new FormatException(Environment.GetResourceString("Format_InvalidGuidFormatSpecification"));
+ throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
}
-
+
char formatCh = format[0];
- if (formatCh == 'D' || formatCh == 'd') {
+ if (formatCh == 'D' || formatCh == 'd')
+ {
guidString = string.FastAllocateString(36);
- }
- else if (formatCh == 'N' || formatCh == 'n') {
+ }
+ else if (formatCh == 'N' || formatCh == 'n')
+ {
guidString = string.FastAllocateString(32);
dash = false;
}
- else if (formatCh == 'B' || formatCh == 'b') {
+ else if (formatCh == 'B' || formatCh == 'b')
+ {
guidString = string.FastAllocateString(38);
- unsafe {
- fixed (char* guidChars = guidString) {
+ unsafe
+ {
+ fixed (char* guidChars = guidString)
+ {
guidChars[offset++] = '{';
guidChars[37] = '}';
}
}
}
- else if (formatCh == 'P' || formatCh == 'p') {
+ else if (formatCh == 'P' || formatCh == 'p')
+ {
guidString = string.FastAllocateString(38);
- unsafe {
- fixed (char* guidChars = guidString) {
+ unsafe
+ {
+ fixed (char* guidChars = guidString)
+ {
guidChars[offset++] = '(';
guidChars[37] = ')';
}
}
}
- else if (formatCh == 'X' || formatCh == 'x') {
+ else if (formatCh == 'X' || formatCh == 'x')
+ {
guidString = string.FastAllocateString(68);
- unsafe {
- fixed (char* guidChars = guidString) {
+ unsafe
+ {
+ fixed (char* guidChars = guidString)
+ {
guidChars[offset++] = '{';
guidChars[67] = '}';
}
@@ -1223,51 +1387,56 @@ namespace System {
dash = false;
hex = true;
}
- else {
- throw new FormatException(Environment.GetResourceString("Format_InvalidGuidFormatSpecification"));
+ else
+ {
+ throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
}
- unsafe {
- fixed (char* guidChars = guidString) {
- if (hex) {
+ unsafe
+ {
+ fixed (char* guidChars = guidString)
+ {
+ if (hex)
+ {
// {0xdddddddd,0xdddd,0xdddd,{0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd}}
guidChars[offset++] = '0';
guidChars[offset++] = 'x';
- offset = HexsToChars(guidChars, offset, _a >> 24, _a >> 16);
- offset = HexsToChars(guidChars, offset, _a >> 8, _a);
+ offset += HexsToChars(guidChars + offset, _a >> 24, _a >> 16);
+ offset += HexsToChars(guidChars + offset, _a >> 8, _a);
guidChars[offset++] = ',';
guidChars[offset++] = '0';
guidChars[offset++] = 'x';
- offset = HexsToChars(guidChars, offset, _b >> 8, _b);
+ offset += HexsToChars(guidChars + offset, _b >> 8, _b);
guidChars[offset++] = ',';
guidChars[offset++] = '0';
guidChars[offset++] = 'x';
- offset = HexsToChars(guidChars, offset, _c >> 8, _c);
+ offset += HexsToChars(guidChars + offset, _c >> 8, _c);
guidChars[offset++] = ',';
guidChars[offset++] = '{';
- offset = HexsToChars(guidChars, offset, _d, _e, true);
+ offset += HexsToCharsHexOutput(guidChars + offset, _d, _e);
guidChars[offset++] = ',';
- offset = HexsToChars(guidChars, offset, _f, _g, true);
+ offset += HexsToCharsHexOutput(guidChars + offset, _f, _g);
guidChars[offset++] = ',';
- offset = HexsToChars(guidChars, offset, _h, _i, true);
+ offset += HexsToCharsHexOutput(guidChars + offset, _h, _i);
guidChars[offset++] = ',';
- offset = HexsToChars(guidChars, offset, _j, _k, true);
+ offset += HexsToCharsHexOutput(guidChars + offset, _j, _k);
guidChars[offset++] = '}';
}
- else {
+ else
+ {
// [{|(]dddddddd[-]dddd[-]dddd[-]dddd[-]dddddddddddd[}|)]
- offset = HexsToChars(guidChars, offset, _a >> 24, _a >> 16);
- offset = HexsToChars(guidChars, offset, _a >> 8, _a);
+ offset += HexsToChars(guidChars + offset, _a >> 24, _a >> 16);
+ offset += HexsToChars(guidChars + offset, _a >> 8, _a);
if (dash) guidChars[offset++] = '-';
- offset = HexsToChars(guidChars, offset, _b >> 8, _b);
+ offset += HexsToChars(guidChars + offset, _b >> 8, _b);
if (dash) guidChars[offset++] = '-';
- offset = HexsToChars(guidChars, offset, _c >> 8, _c);
+ offset += HexsToChars(guidChars + offset, _c >> 8, _c);
if (dash) guidChars[offset++] = '-';
- offset = HexsToChars(guidChars, offset, _d, _e);
+ offset += HexsToChars(guidChars + offset, _d, _e);
if (dash) guidChars[offset++] = '-';
- offset = HexsToChars(guidChars, offset, _f, _g);
- offset = HexsToChars(guidChars, offset, _h, _i);
- offset = HexsToChars(guidChars, offset, _j, _k);
+ offset += HexsToChars(guidChars + offset, _f, _g);
+ offset += HexsToChars(guidChars + offset, _h, _i);
+ offset += HexsToChars(guidChars + offset, _j, _k);
}
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-24 09:27:09 +0000