public class Employee
{
    public string Name { get; set; }
    public string Department { get; set; }
    public string Salary { get; set; }
}

public class MaxSalaryRule : StateRule<Employee>
{
    public override Expression<Func<Employee, bool>>
    {
        get { return candidate => candidate.Salary < 40000; }
    }
}

public class InHrDepartmentRule : StateRule<Employee>
{
    public override Expression<Func<Employee, bool>>
    {
        get { return candidate => candidate.Department == "Human Resources"; }
    }
}

// Compose a new rule from the others and describe it.
var salaryRaiseRule = new MaxSalaryRule()
    .And(new InHrDepartmentRule())
    .Describe("Employee must be in the HR deparment and have a salary less than $40,000.");

// Candidates can then be checked against a rule to see if they satisfy it.
var isEligible = salaryRaiseRule.IsSatified(someEmployee);

// A rule can also be used to filter an IQueryable via the Predicate property.
// Depending on the actual expression, this will also work with LINQ to Entities.
var eligibleEmployees = Employees.Where(salaryRaiseRule.Predicate);

// Example incorporating a repository pattern.
public class ApplySalaryRaise : Workflow<Employee>
{
    private readonly IRepository<Employee> _repository;

    public ApplySalaryRaise(IStateRule<Employee> rule, IRepository<Employee> repository) : base(rule)
    {
        _repository = repository;
    }

    protected override Employee ExecuteWorkflow(Employee candidate)
    {
        candidate.Salary += 5000;
        _repository.Update(candidate);
        return candidate;
    }
}

// Some example candidates for our workflow.
var eligibleEmployee = new Employee
    {
        Name = "John Smith",
        Department = "Human Resources",
        Salary = 10000;
    };

var ineligibleEmployee = new Employee
    {
        Name = "Tye Tarse",
        Department = "Board of Directors",
        Salary = 1000000
    };

// Give the candidate employee a $5000 raise if they're in HR and they earn less than $40k.
var salaryRaiseWorflow = new ApplySalaryRaise(salaryRaiseRule, new EmployeeRepository());

// Input candidate will be granted the salary raise.
salaryRaiseWorflow.Execute(eligibleEmployee); 

// This will throw a StateRuleException.
salaryRaiseWorflow.Execute(ineligibleEmployee);

// It is possible to chain workflows using flowable.
// This would apply two pay increases as long as the salary remained under $40k.
eligibleEmployee
    .AsFlowable()
    .Flow(salaryRaiseWorflow)
    .Flow(salaryRaiseWorflow);

// State rule checks can also be applied directly to flowables.
var canThisPersonGetMore = eligibleEmployee
    .AsFlowable()
    .Flow(salaryRaiseWorflow)
    .Satisfies(salaryRaiseRule);

public class Department
{
    public string Name { get; set; }
    public int EmployeeCount { get; set; }
    public string Building { get; set; }
}

// These examples have the repository/persistence code omitted for clarity.

public class MoveHrPersonToNewDepartment : Workflow<Employee, Department>
{
    public Department Destination { get; set; }

    protected override Department ExecuteWorkflow(Employee candidate)
    {
        candidate.Department = Destination.Name;
        Destination.EmployeeCount++;
        return Destination;
    }
}

public class MoveToTheNewOffice : Workflow<Department>
{
    protected override Department ExecuteWorkflow(Department candidate)
    {
        candidate.Building = "Uptown Office";
        return candidate;
    }
}

var moveToBoardWorkflow = new MoveHrPersonToNewDepartment(new InHrDepartmentRule())
    {
        // Something like this would come from the DB in a less contrived example, of course.
        Department = new Department 
            { 
                Name = "Board of Directors", 
                EmployeeCount = 5,
                Building = "Downtown Office"
            }
    };

var moveDeptOfficeWorkflow = new MoveToTheNewOffice();

var employeeLocation = eligibleEmployee
    .AsFlowable()
    .Flow(salaryRaiseWorflow)
    .Flow(moveToBoardWorkflow)
    .Flow(moveDeptOfficeWorkflow)
    .Value
    .Building; // "Uptown Office"