验证.net中的数据

我正在寻找任何推荐的验证框架，或N层客户端应用程序的模式，我想编写一次验证方法并将其绑定到WPF GUI，如果可能的话，还要针对服务器端和客户端相关的业务逻辑。

非常简单，您的业务实体应该包括一个存储业务验证的部分（这就是业务逻辑）。无论您是在设计基于web的应用程序、基于客户端的应用程序、移动应用程序等，这都会起作用。非常灵活

假设您有一个业务对象（实体），如客户：

public class Customer
 {
         public Customer(int customerId, string company, string city, string country)
        {
            CustomerId = customerId;
            Company = company;
            City = city;
            Country = country;
        }
  }

然后，您意识到您希望您的业务逻辑表明您验证了customerID（此外，它大于0），您需要一个公司名称（如果没有公司名称，则客户无效）等等。这些验证是您的业务逻辑层。因此，您可以将customer类更改为从BusinessObject层继承，这样您的类就变成：

    public class Customer : BusinessObject
    {
        /// <summary>
        /// Default constructor for customer class.
        /// Initializes automatic properties.
        /// </summary>
        public Customer()
        {
            // Default property values
            Orders = new List<Order>();

            // Business rules
            AddRule(new ValidateId("CustomerId"));

            AddRule(new ValidateRequired("Company"));
            AddRule(new ValidateLength("Company", 1, 40));

        }

        /// <summary>
        /// Overloaded constructor for the Customer class.
        /// </summary>
        /// <param name="customerId">Unique Identifier for the Customer.</param>
        /// <param name="company">Name of the Customer.</param>
        /// <param name="city">City where Customer is located.</param>
        /// <param name="country">Country where Customer is located.</param>
        public Customer(int customerId, string company, string city, string country)
            : this()
        {
            CustomerId = customerId;
            Company = company;
            City = city;
            Country = country;
        }
//much more code like methods...
}

公共类客户：BusinessObject
{
/// 
///customer类的默认构造函数。
///初始化自动属性。
/// 
公众客户（）
{
//默认属性值
订单=新列表（）；
//商业规则
AddRule（新的ValidateId（“CustomerId”））；
AddRule（需要新的验证人（“公司”））；
AddRule（新的ValidateLength（“公司”，1，40））；
}
/// 
///Customer类的重载构造函数。
/// 
///客户的唯一标识符。
///客户的姓名。
///客户所在城市。
///客户所在国家/地区。
公共客户（国际客户ID、字符串公司、字符串城市、字符串国家）
：此（）
{
CustomerId=CustomerId；
公司=公司；
城市=城市；
国家=国家；
}
//更多类似代码的方法。。。
}

您不需要BusinessObject类型的对象，但BusinessObject充当的是存储验证错误和业务规则的抽象类。业务规则最终是您在调用AddRule时声明的规则：

public abstract class BusinessObject
{
    /// <summary>
    /// Default value for version number (used in LINQ's optimistic concurrency)
    /// </summary>
    protected static readonly string _versionDefault = "NotSet";

    // List of business rules
    private IList<BusinessRule> _businessRules = new List<BusinessRule>();

    // List of validation errors (following validation failure)
    private IList<string> _validationErrors = new List<string>();

    /// <summary>
    /// Gets list of validations errors.
    /// </summary>
    public IList<string> ValidationErrors
    {
        get { return _validationErrors; }
    }

    /// <summary>
    /// Adds a business rule to the business object.
    /// </summary>
    /// <param name="rule"></param>
    protected void AddRule(BusinessRule rule)
    {
        _businessRules.Add(rule);
    }

    /// <summary>
    /// Determines whether business rules are valid or not.
    /// Creates a list of validation errors when appropriate.
    /// </summary>
    /// <returns></returns>
    public bool Validate()
    {
        bool isValid = true;

        _validationErrors.Clear();

        foreach (BusinessRule rule in _businessRules)
        {
            if (!rule.Validate(this))
            {
                isValid = false;
                _validationErrors.Add(rule.ErrorMessage);
            }
        }
        return isValid;
    }
}

公共抽象类BusinessObject
{
/// 
///版本号的默认值（用于LINQ的乐观并发）
/// 
受保护的静态只读字符串_versionDefault=“NotSet”；
//业务规则列表
私有IList_businessRules=新列表（）；
//验证错误列表（验证失败后）
私有IList_validationErrors=新列表（）；
/// 
///获取验证错误的列表。
/// 
公共IList验证错误
{
获取{return\u validationErrors；}
}
/// 
///将业务规则添加到业务对象。
/// 
/// 
受保护的void AddRule（BusinessRule）
{
_businessRules.Add（rule）；
}
/// 
///确定业务规则是否有效。
///在适当时创建验证错误列表。
/// 
/// 
公共bool验证（）
{
bool isValid=true；
_validationErrors.Clear（）；
foreach（businessRules中的BusinessRule）
{
如果（！rule.Validate（此））
{
isValid=false；
_validationErrors.Add（rule.ErrorMessage）；
}
}
返回有效；
}
}

需要实现每个业务规则，如validateid、validaterequired和validatelength：

public class ValidateId : BusinessRule
{
    public ValidateId(string propertyName)
        : base(propertyName)
    {
        ErrorMessage = propertyName + " is an invalid identifier";
    }

    public ValidateId(string propertyName, string errorMessage)
        : base(propertyName)
    {
        ErrorMessage = errorMessage;
    }

    public override bool Validate(BusinessObject businessObject)
    {
        try
        {
            int id = int.Parse(GetPropertyValue(businessObject).ToString());
            return id >= 0;
        }
        catch
        {
            return false;
        }
    }

     public class ValidateLength : BusinessRule
        {
            private int _min;
            private int _max;

            public ValidateLength(string propertyName, int min, int max)
                : base(propertyName)
            {
                _min = min;
                _max = max;

                ErrorMessage = propertyName + " must be between " + _min + " and " + _max + " characters long.";
            }

            public ValidateLength(string propertyName, string errorMessage, int min, int max)
                : this(propertyName, min, max)
            {
                ErrorMessage = errorMessage;
            }

            public override bool Validate(BusinessObject businessObject)
            {
                int length = GetPropertyValue(businessObject).ToString().Length;
                return length >= _min && length <= _max;
            }
        }

public类ValidateId:BusinessRule
{
公共验证ID（字符串属性名称）
：base（propertyName）
{
ErrorMessage=propertyName+“是无效标识符”；
}
公共ValidateId（字符串属性名称、字符串错误消息）
：base（propertyName）
{
ErrorMessage=ErrorMessage；
}
公共覆盖bool验证（BusinessObject BusinessObject）
{
尝试
{
int id=int.Parse（GetPropertyValue（businessObject.ToString（））；
返回id>=0；
}
抓住
{
返回false；
}
}
公共类ValidateLength:BusinessRule
{
私人互联网;；
私人国际最大值；
公共ValidateLength（字符串属性名称、最小整数、最大整数）
：base（propertyName）
{
_min=min；
_max=max；
ErrorMessage=propertyName+“长度必须介于“+\u最小值+”和“+\u最大值+”字符之间。”；
}
公共ValidateLength（字符串属性名称、字符串错误消息、最小整数、最大整数）
：此（属性名称、最小值、最大值）
{
ErrorMessage=ErrorMessage；
}
公共覆盖bool验证（BusinessObject BusinessObject）
{
int length=GetPropertyValue（businessObject）.ToString（）.length；
return length>=\u min&&length一个简单的搜索返回许多验证框架。许多都使用John提到的非常类似的技术。类似的。似乎符合您的标准。
如果我想避免反射以获得最佳性能，您会得到更好的结果吗？@Chen Kinnrot-唯一使用的反射是GetPropertyV内部值。你可以做的另一件事是去掉所有这些验证类，只对每个属性进行硬编码。但是，如果你的应用程序足够简单，那么就这样做。@Chen Kinnrot-你需要更详细的信息吗？或者我们提供了足够的信息来标记答案是否被接受。
public abstract class BusinessRule
    {
        public string PropertyName { get; set; }
        public string ErrorMessage { get; set; }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="propertyName">The property name to which rule applies.</param>
        public BusinessRule(string propertyName)
        {
            PropertyName = propertyName;
            ErrorMessage = propertyName + " is not valid";
        }

        /// <summary>
        /// Overloaded constructor
        /// </summary>
        /// <param name="propertyName">The property name to which rule applies.</param>
        /// <param name="errorMessage">The error message.</param>
        public BusinessRule(string propertyName, string errorMessage)
            : this(propertyName)
        {
            ErrorMessage = errorMessage;
        }

        /// <summary>
        /// Validation method. To be implemented in derived classes.
        /// </summary>
        /// <param name="businessObject"></param>
        /// <returns></returns>
        public abstract bool Validate(BusinessObject businessObject);

        /// <summary>
        /// Gets value for given business object's property using reflection.
        /// </summary>
        /// <param name="businessObject"></param>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        protected object GetPropertyValue(BusinessObject businessObject)
        {
            return businessObject.GetType().GetProperty(PropertyName).GetValue(businessObject, null);
        }
    }