Is FluentValidation checking if a type is GUID?

Yes, FluentValidation can check if a type is a GUID (Globally Unique Identifier). FluentValidation does not inherently have a dedicated method like 'IsGuid()' to check if a type is a GUID but it provides several ways to validate GUID values efficiently.

Here's how you can validate GUID values using FluentValidation:

1. Using NotEmpty() and Must(): You can use NotEmpty() to ensure the GUID isn't empty, and then a custom Must() method to validate the GUID format. Here's an example of this validation:

using FluentValidation;

public class MyModel {
  public Guid MyGuid { get; set; }
}

public class MyModelValidator : AbstractValidator<MyModel> {
  public MyModelValidator() {
    RuleFor(x => x.MyGuid)
      .NotEmpty()
      .Must(BeAValidGuid)
      .WithMessage("'{PropertyName}' must be a valid GUID.");
  }

  private bool BeAValidGuid(Guid guid) {
     return Guid.TryParse(guid.ToString(), out _);
  }
}

In this example, NotEmpty() ensures the GUID is not its default zero value. The Must(BeAValidGuid) part checks if the GUID can be parsed to the correct format. BeAValidGuid function leverages Guid.TryParse which is the most reliable way to validate GUID formats. If it is an invalid GUID format, it will return false.

2. Alternative approach with Custom(): You can achieve similar behavior with the Custom() method, giving you access to the validation context to add custom logic:

using FluentValidation;

public class MyModel {
  public Guid MyGuid { get; set; }
}

public class MyModelValidator : AbstractValidator<MyModel> {
   public MyModelValidator() {
    RuleFor(x => x.MyGuid)
      .NotEmpty()
      .Custom((guid, context) => {
        if (!Guid.TryParse(guid.ToString(), out _)) {
          context.AddFailure("'{PropertyName}' must be a valid GUID.");
        }
      });
  }
}

Using Custom you can inject logic directly into the validation rule. The NotEmpty() remains to avoid zero-valued GUIDs being passed on.

3. Handling Nullable GUIDs: If your GUID property is nullable (e.g., Guid?), you need to adjust the validation accordingly.

using FluentValidation;

public class MyModel {
   public Guid? MyGuid { get; set; }
}

public class MyModelValidator : AbstractValidator<MyModel> {
  public MyModelValidator() {
    RuleFor(x => x.MyGuid)
      .Must(BeAValidNullableGuid)
      .WithMessage("'{PropertyName}' must be a valid GUID.");
  }

  private bool BeAValidNullableGuid(Guid? guid) {
    if (!guid.HasValue) return true; // Null is allowed
    return Guid.TryParse(guid.Value.ToString(), out _);
  }
}

In this case, BeAValidNullableGuid function checkes first if the GUID is null. If it is, validation passes (as the property is nullable). If it's not null, then it proceeds with the parsing logic.

In summary, while FluentValidation does not have a built-in IsGuid() validator, you can easily validate GUIDs using a combination of NotEmpty(), Must() and Custom(), ensuring that GUID values are properly formatted.

Learn more about this