using System.Threading.Tasks;

using System.Collections.Generic;

using System.Linq;

using System.Diagnostics;

using System.Threading;

using System;

​

public class Program

{

    public async static void Main()

    {

        Console.WriteLine("test");

        var test1 = new TestDomainObject();

        var result = await test1.Validate();

        Console.WriteLine(result);

    }

​

    public class TestDomainObject : ValidatableBase

    {

        protected override IEnumerable<ValidationRule> ValidationRules

        {

            get

            {

                yield return new ValidationRule();

                yield return new ValidationRule();

                yield return new ValidationRule();

            }

        }

    }

​

    public class ValidatableBase

    {

        protected virtual IEnumerable<ValidationRule> ValidationRules => Enumerable.Empty<ValidationRule>();

        protected virtual IEnumerable<ValidatableBase> ValidatableChildren

        {

            get

            {

                yield return this;

            }

        }

​

        public async Task<ValidationResult> Validate()

        {

            return await Task.Run<ValidationResult>(() =>

            {

                var validationState = (ValidationState)GetValidationResults().Select(i => (int)i.State).OrderByDescending(i => i).First();

                return new ValidationResult(validationState);

            });

        }

​

        private IEnumerable<ValidationResult> GetValidationResults()

        {

            foreach (var children in ValidatableChildren)

            {

                foreach (var rule in ValidationRules)

                {

                    yield return rule.Validate();

                }

            }

        }

    }

​

    public class ValidationResult

    {

        public ValidationResult(ValidationState state)

        {

            State = state;

        }

​

        public ValidationState State

        {

            get;

            set;

        }

​

        public static ValidationResult CreateValid()

        {

            return new ValidationResult(ValidationState.Valid);

        }

    }

​

    public class ValidationRule

    {

        public ValidationResult Validate()

        {

            var sw = Stopwatch.StartNew();

            while (sw.ElapsedMilliseconds < 10000)

            {

                Console.WriteLine(sw.ElapsedMilliseconds);

                Thread.SpinWait(1000);

            }

​

            return ValidationResult.CreateValid();

        }

    }

​

    public enum ValidationState

    {

        Valid,

        Invalid

    }

}