Cacher is the code snippet organizer for pro developers

    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

User usr = new User();
usr.Id = 1;
usr.Name = "Diego Dias";

 var result = Given<User>
                .Then
                .Verify(u => u.Id > 1, "id is required.")
                .Verify(u => u.Name.Length > 10, "Name should not be greater than 10 chracteres.")
                .IsValid(usr);

            Console.WriteLine(string.Format("HasError => {0} : Errors => {1}", 
                                            result.HasError, 
                                            string.Join(", ", result.ErrorMessages)));
            Console.ReadLine();

 public class Given<TModel>
        where TModel : class
    {
        private readonly IList<AssertProperty<TModel>> properties;

        public static Given<TModel> Then
        {
            get { return new Given<TModel>(); }
        }

        public Given()
        {
            properties = new List<AssertProperty<TModel>>();
        }

        public Given<TModel> Verify(Predicate<TModel> validate, string errorMessage)
        {
            properties.Add(new AssertProperty<TModel>(validate, errorMessage));
            return this;
        }

        public AssertationResult IsValid(TModel model)
        {
            var errorMessages = properties
                .Select(property => property.IsValid(model))
                .Where(errorMessage => !string.IsNullOrWhiteSpace(errorMessage));

            return new AssertationResult(errorMessages.ToArray());
        }
    }

    public class AssertationResult
    {
        public bool HasError {
            get { return ErrorMessages.Any(); }
        }
        public string[] ErrorMessages { get; private set; }

        public AssertationResult(string[] errorMessages)
        {
            ErrorMessages = errorMessages;
        }
    }

    public class AssertProperty<TModel>
        where TModel : class
    {
        private readonly Predicate<TModel> validate;
        private readonly string errorMessage;

        public AssertProperty(Predicate<TModel> validate, string errorMessage)
        {
            this.validate = validate;
            this.errorMessage = errorMessage;
        }

        public string IsValid(TModel model)
        {
            var success = validate(model);
            return success
                       ? string.Empty
                       : errorMessage;
        }
    }