How to validate GUID is a GUID
C#asp.netStringGuidC# Problem Overview
How to determine if a string contains a GUID vs just a string of numbers.
will a GUID always contain at least 1 alpha character?
C# Solutions
Solution 1 - C#
See if these helps :-
Guid.Parse
- Docs
Guid guidResult = Guid.Parse(inputString)
Guid.TryParse
- Docs
bool isValid = Guid.TryParse(inputString, out guidOutput)
Solution 2 - C#
When I'm just testing a string to see if it is a GUID, I don't really want to create a Guid object that I don't need. So...
public static class GuidEx
{
public static bool IsGuid(string value)
{
Guid x;
return Guid.TryParse(value, out x);
}
}
And here's how you use it:
string testMe = "not a guid";
if (GuidEx.IsGuid(testMe))
{
...
}
Solution 3 - C#
A GUID is a 16-byte (128-bit) number, typically represented by a 32-character hexadecimal string. A GUID (in hex form) need not contain any alpha characters, though by chance it probably would. If you are targeting a GUID in hex form, you can check that the string is 32-characters long (after stripping dashes and curly brackets) and has only letters A-F and numbers.
There is certain style of presenting GUIDs (dash-placement) and regular expressions can be used to check for this, e.g.,
@"^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$"
from http://www.geekzilla.co.uk/view8AD536EF-BC0D-427F-9F15-3A1BC663848E.htm. That said, it should be emphasized that the GUID really is a 128-bit number and could be represented in a number of different ways.
Solution 4 - C#
There is no guarantee that a GUID contains alpha characters. FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF
is a valid GUID so is 00000000-0000-0000-0000-000000000000
and anything in between.
If you are using .NET 4.0, you can use the answer above for the Guid.Parse and Guid.TryParse. Otherwise, you can do something like this:
public static bool TryParseGuid(string guidString, out Guid guid)
{
if (guidString == null) throw new ArgumentNullException("guidString");
try
{
guid = new Guid(guidString);
return true;
}
catch (FormatException)
{
guid = default(Guid);
return false;
}
}
Solution 5 - C#
This is a fairly clean, modern C# approach that suppresses the out variable:
var isValid = Guid.TryParse(inputString, out _);
Solution 6 - C#
Based on the accepted answer I created an Extension method as follows:
public static Guid ToGuid(this string aString)
{
Guid newGuid;
if (string.IsNullOrWhiteSpace(aString))
{
return MagicNumbers.defaultGuid;
}
if (Guid.TryParse(aString, out newGuid))
{
return newGuid;
}
return MagicNumbers.defaultGuid;
}
Where "MagicNumbers.defaultGuid" is just "an empty" all zero Guid "00000000-0000-0000-0000-000000000000".
In my case returning that value as the result of an invalid ToGuid conversion was not a problem.
Solution 7 - C#
if(MyGuid != Guid.Empty)
{
// Valid Guid
}
else
{
// Invalid Guid
}
Solution 8 - C#
see http://en.wikipedia.org/wiki/Globally_unique_identifier
There is no guarantee that an alpha will actually be there.
Solution 9 - C#
Will return the Guid if it is valid Guid, else it will return Guid.Empty
if (!Guid.TryParse(yourGuidString, out yourGuid)){
yourGuid= Guid.Empty;
}
Solution 10 - C#
Use GUID constructor standard functionality
Public Function IsValid(pString As String) As Boolean
Try
Dim mGuid As New Guid(pString)
Catch ex As Exception
Return False
End Try
Return True
End Function