用于客户端和服务器端验证的 ASP.NET Core 重用代码

Question

I have a project on ASP.NET Core using Razor pages. I am using Entity Framework but with my own custom entity configuration like below:

namespace Customer.Data.Relational.Configuration {
   public sealed class CustomerConfiguration {
      public static void Configure(EntityTypeBuilder<CustomerEntity> entity) {
         entity.ToTable("customers")
            .HasKey(k => k.Id)
            .HasName("pk_customers");

         entity.Property(p => p.Id)
            .HasColumnName("customer_id")
            .HasColumnType("bigint")
            .ValueGeneratedOnAdd()
            .IsRequired();

         entity.Property(p => p.Code)
            .HasColumnName("customer_code")
            .HasColumnType("nvarchar(15)")
            .IsRequired();

         entity.Property(p => p.FirstName)
            .HasColumnName("first_name")
            .HasColumnType("nvarchar(100)")
            .IsRequired();

         entity.Property(p => p.LastName)
            .HasColumnName("last_name")
            .HasColumnType("nvarchar(100)")
            .IsRequired();

         entity.Property(p => p.EmailAddress)
            .HasColumnName("email_address")
            .HasColumnType("nvarchar(100)")
            .IsRequired();

         entity.Property(p => p.IsPremierCustomer)
            .HasColumnName("premier_customer")
            .HasColumnType("bit")
            .IsRequired();

         entity.HasIndex(k => k.Code)
            .HasName("uq_customers")
            .IsUnique();

         entity.HasOne(o => o.CustomerType)
            .WithMany()
            .HasForeignKey(f => f.CustomerTypeId)
            .OnDelete(DeleteBehavior.Restrict)
            .HasConstraintName("fk_customers_customer_types");
      }
   }
}

This allows my entity classes to be free of any form of annotations (leaving them to be just POCOs).

namespace Customer.Entities {
   public class CustomerEntity : IAuditableEntity {
      public long Id { get; set; } = default;

      public string Code {
         get; set;
      }

      public string FirstName {
         get; set;
      }

      public string LastName {
         get; set;
      }

      public string EmailAddress {
         get; set;
      }

      public bool IsPremierCustomer {
         get; set;
      }
   }
}

I am using FluentValidations for validating user input. I created custom validator classes. On the client-side, I have enabled integration of FluentValidation with ASP.NET Core. On the server-side, I validate manually by invoking the FluentValidation APIs.

Question - Is this approach right? Is there any other approach where-in I can re-use the validations on both client and server? Any pointers or references appreciated.

Thanks.

Answer 1

At a high level this sounds pretty similar to how I use it at the moment. There is nothing wrong with doing both client and server side validation, sometimes it's necessary depending on the complexity/dependencies of the rule.

Some of the tricks that can lead to validator/rule reuse:

• Rules that are common can be extracted to property validators or separated into functional concerns , can help with reuse/maintainability

• Include(validator) can allow you to sort of mirror your POCO inheritance graph, meaning you can reuse rules from parent class validators

• Consider implementing client side/server side rule sets to allow you to avoid double handling/invoking the same rules client-side and server-side, or to allow for your services to handle different validation scenarios (eg, the validation strategy may be different for a web app and a separate headless service that both use the same service layer)

• Set up a custom language manager to override default messages to avoid overuse of the WithMessage extension

In terms of user experience I try to funnel as much through to the client side as possible. Sometimes this means writing your own client side adapters. This is a good start if you need to go down that route.