Comparison with a range
Here you go. I made Range inclusive only, but it's easy to modify. I also extracted a few interfaces for easy unit testing and use IEnumerable&lt;T&gt; instead of IList&lt;T&gt;.

public interface IPriceComparison
{
    bool Evaluate(decimal price, params decimal[] valuesToCompare);
}

public abstract class PriceComparison : IPriceComparison
{
    private static readonly IPriceComparison under = UnderPriceComparison.Create();

    private static readonly IPriceComparison above = AbovePriceComparison.Create();

    private static readonly IPriceComparison range = RangePriceComparison.Create();

    public static IPriceComparison Under
    {
        get
        {
            return under;
        }
    }

    public static IPriceComparison Above
    {
        get
        {
            return above;
        }
    }

    public static IPriceComparison Range
    {
        get
        {
            return range;
        }
    }

    public abstract bool Evaluate(decimal price, params decimal[] valuesToCompare);
}

public sealed class AbovePriceComparison : PriceComparison
{
    private AbovePriceComparison()
    {
    }

    public static IPriceComparison Create()
    {
        return new AbovePriceComparison();
    }

    public override bool Evaluate(decimal price, params decimal[] valuesToCompare)
    {
        return (valuesToCompare == null) || (valuesToCompare.Length != 1) || (price &gt; valuesToCompare[0]);
    }
}

public sealed class UnderPriceComparison : PriceComparison
{
    private UnderPriceComparison()
    {
    }

    public static IPriceComparison Create()
    {
        return new UnderPriceComparison();
    }

    public override bool Evaluate(decimal price, params decimal[] valuesToCompare)
    {
        return (valuesToCompare == null) || (valuesToCompare.Length != 1) || (price &lt; valuesToCompare[0]);
    }
}

public sealed class RangePriceComparison : PriceComparison
{
    private RangePriceComparison()
    {
    }

    public static IPriceComparison Create()
    {
        return new RangePriceComparison();
    }

    public override bool Evaluate(decimal price, params decimal[] valuesToCompare)
    {
        return (valuesToCompare == null)
            || (valuesToCompare.Length != 2)
            || ((price &gt; valuesToCompare[0]) &amp;&amp; (price &lt; valuesToCompare[1]));
    }
}

public interface IBuyOrder
{
    int Price
    {
        get;
    }
}

public sealed class BuyOrder : IBuyOrder
{
    private readonly int price;

    private BuyOrder(int price)
    {
        this.price = price;
    }

    public static IBuyOrder Create(int price)
    {
        return new BuyOrder(price);
    }

    public int Price
    {
        get
        {
            return this.price;
        }
    }
}

public interface IBuyIndicator
{
    IEnumerable&lt;IBuyOrder&gt; Apply(IEnumerable&lt;int&gt; productPrices);
}

public sealed class PriceIndicator : IBuyIndicator
{
    private readonly IPriceComparison comparison;

    private readonly decimal[] values;

    private PriceIndicator(IPriceComparison comparison, params decimal[] values)
    {
        if (comparison == null)
        {
            throw new ArgumentNullException("comparison");
        }

        this.comparison = comparison;
        this.values = values;
    }

    public static IBuyIndicator Create(IPriceComparison comparison, params decimal[] values)
    {
        return new PriceIndicator(comparison, values);
    }

    public IEnumerable&lt;IBuyOrder&gt; Apply(IEnumerable&lt;int&gt; productPrices)
    {
        return productPrices.Where(price =&gt; this.comparison.Evaluate(price, this.values))
            .Select(BuyOrder.Create)
            .ToList();
    }
}