C#

double Calculate(Shape shape)
{
  Circle circle = shape as Circle;
  if (circle == null)
  {
    throw new InvalidOperationException("You didn't pass in a circle");
  }
  return Math.Pow(circle.Radius, 2)* 3.14;
}

public class Shape
{
    public string Name { get; set; }
}

public class Circle : Shape
{
    public double Radius { get; set; }
    public Circle(string name, double radius)
    { Name = name; Radius = radius; }
}

public class Square : Shape
{
    public double Side { get; set; }
    public Square(string name, double side)
    { Name = name; Side = side; }
}

public interface ICalculateAreaStrategy
{
    double Calculate(Shape shape);
}

public class CalculateCircleAreaStrategy : ICalculateAreaStrategy
{
    public double Calculate(Shape shape)
    {
        // "up cast" the Shape to a Circle, if shape is not a Circle then "as" will return null
        Circle c = shape as Circle;

        if (c == null)
        {
            return 0;
        }

        return 3.14 * c.Radius * c.Radius;
    }
}

public class CalculateSquareAreaStrategy : ICalculateAreaStrategy
{
    public double Calculate(Shape shape)
    {
        // "up cast" the Shape to a Square, if shape is not a Square then "as" will return null
        Square s = shape as Square;

        if (s == null)
        {
            return 0;
        }

        return s.Side * s.Side;
    }
}

public class CalculateAreaService
{
    readonly ICalculateAreaStrategy calculateAreaStrategy;

    public CalculateAreaService(ICalculateAreaStrategy strategy)
    {
        calculateAreaStrategy = strategy;
    }

    public double CalculateArea(Shape shape)
    {
        return calculateAreaStrategy.Calculate(shape);
    }
}

CalculateAreaService cas = new CalculateAreaService(new CalculateSquareAreaStrategy());

Console.WriteLine(cas.CalculateArea(new Square("Square", 3)));

cas = new CalculateAreaService(new CalculateCircleAreaStrategy());

Console.WriteLine(cas.CalculateArea(new Circle("Circle", 3)));

Console.ReadLine();

public interface ICalculateArea
{
    double Calculate();
}

public class CalculateCircleArea : ICalculateArea
{
    private Circle circle;

    public CalculateCircleArea(Circle circle)
    {
        this.circle = circle;
    }

    public double Calculate()
    {
        return 3.14 * circle.Radius * circle.Radius;
    }
}

public class CalculateSquareArea : ICalculateArea
{
    private Square square;

    public CalculateSquareArea(Square square)
    {
        this.square = square;
    }

    public double Calculate()
    {
        return square.Side * square.Side;
    }
}

List<ICalculateArea> calcs = new List<ICalculateArea>();
calcs.Add(new CalculateSquareArea(new Square("Square", 3)));
calcs.Add(new CalculateCircleArea(new Circle("Circle", 3)));

foreach (var calc in calcs)
{
    Console.WriteLine(calc.Calculate());
}

* "Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it." (Gang of Four)

* "Specifies a set of classes, each representing a potential behaviour. Switching between those classes changes the application behaviour. (The Strategy)

Liagapi wrote:

vary independently from clients

Pete O'Hanlon wrote:

What you need to do is materialize the data into something like a list first

where t.Started >= startDT

// Extract the date parts, so that EF doesn't try to convert the properties to SQL:
int startYear = startDT.Year;
int startMonth = startDT.Month;
int startDay = startDT.Day;
int startHour = startDT.Hour;
int startMinute = startDT.Minute;
int startSecond = startDT.Second;

...
where t.Started >= EntityFunctions.CreateDateTimeOffset(
    startYear, startMonth, startDay, startHour, startMinute, startSecond, 
    SqlFunctions.DatePart("tz", t.Started))
...