branching: monads

CreateJobV6.cs

// Create Job
return ValidateComputer(order).Resolve(
    fail: () => {
        new Job()
        {
            ActivationTime = order.ClientLocalStartTime,
            ComputerName = order.ComputerName,
            orderId = order.Id,
            Status = invalidComputerErrorMessage,
        }
    },
    success: () =>
    {
        var computer = GetComputer(order.ComputerName, order.CustomerId);
        computer.CustomerId = GetCustomerId(order.CustomerId, computer.CustomerId);
        var siteServerAddress = GetServerAddress(order.ComputerName, computer.CustomerId);
        var deploymentType = GetDeploymentType(order.MaterialNumber, computer.CustomerId);

        return new Job()
        {
            ActivationTime = order.ClientLocalStartTime,
            ComputerName = order.ComputerName,
            orderId = order.Id,
            JobActions = CreateJobActions(deploymentType, order, siteServerAddress, computer),
            Status = "created",
        }
    });

private Either ValidateComputer(Order order)
{
    bool valid = !String.IsNullOrEmpty(order.ComputerName);
    if (valid)
    {
        return new Success();
    }
    return new Fail();
}

#
# Either
#

public abstract class Either<TFail, TSuccess>
{
    public abstract TResult Resolve<TResult>(Func<TFail, TResult> fail, Func<TSuccess, TResult> success);
    public abstract TResult Resolve<TResult>(Func<TFail, TResult> fail, Action<TSuccess> success);
}

public class Fail<TFail, TSuccess> : Either<TFail, TSuccess>
{
    private readonly TFail value;

    public Fail(TFail value)
    {
        this.value = value;
    }

    public override TResult Resolve<TResult>(Func<TFail, TResult> fail, Action<TSuccess> success)
    {
        return fail(value);
    }
}

public class Success<TFail, TSuccess> : Either<TFail, TSuccess>
{
    private readonly TSuccess value;

    public Success(TSuccess value)
    {
        this.value = value;
    }

    public override TResult Resolve<TResult>(Func<TFail, TResult> fail, Func<TSuccess, TResult> success)
    {
        return success(value);
    }
}