Living in the Tech Avalanche Generation

/// <summary>
/// Tests the entity equality matching
/// via a specification.
/// </summary>
[Test()]
public void TestExpressions()
{
    Order o1 = new Order();
    o1.OrderID = 1;
    o1.Customer = new Customer();
    o1.Customer.Country = “Australia”;

    Specification<Order> firstSpec =
        new Specification<Order>(o => o.OrderID == 1);

    Specification<Order> secondSpec =
        new Specification<Order>(o => o.Customer.Country == “Australia”);

    var orSpec = firstSpec | secondSpec;

    Console.WriteLine(“The Order o1 matches? {0}”, orSpec.Matches(o1));

    Assert.IsTrue(orSpec.Matches(o1));
}

public interface ISpecification<T>
{
    Expression<Func<T, bool>> EvalPredicate { get; }
    Func<T, bool> EvalFunc { get; }
    bool Matches(T entity);
}

[Test()]
public void SimpleSpecificationExample()
{
    Specification<Order> order_spec =
        new Specification<Order>(o => o.Order_Details.All
            (od => od.Product is DiscontinuedProduct));

    using (var ctx = new NorthwindEntities())
    {
        ObjectQuery<Order> orders =
            (ObjectQuery<Order>)
            from o in ctx.Orders
                .Include(“Order_Details”)
                .Include(“Customer”)
            .Where(order_spec.EvalPredicate)
            select o;

        Console.WriteLine(orders.ToTraceString());

        foreach (var order in orders)
        {
            var sumup =
                order.Order_Details.Sum
                (od => od.Quantity * od.UnitPrice);
            Console.WriteLine(“The sum of orders for order ID: “ +
                “{0} is {1} and Country is {2}”,
                order.OrderID.ToString(), sumup.ToString(),
                order.Customer.Country);
        }

        //test if all the products retrieved are indeed discontinued
        var discontinued = orders.Count(o => o.Order_Details.Count
            (od => od.Product as DiscontinuedProduct == null) > 1);

        Assert.AreEqual(discontinued, 0);
    }
}

SELECT
[Project2].[EmployeeID] AS [EmployeeID],
[Project2].[Freight] AS [Freight],
[Project2].[OrderDate] AS [OrderDate],
[Project2].[OrderID] AS [OrderID],
[Project2].[RequiredDate] AS [RequiredDate],
[Project2].[ShipAddress] AS [ShipAddress],
[Project2].[ShipCity] AS [ShipCity],
[Project2].[ShipCountry] AS [ShipCountry],
[Project2].[ShipName] AS [ShipName],
[Project2].[ShippedDate] AS [ShippedDate],
[Project2].[ShipPostalCode] AS [ShipPostalCode],
[Project2].[ShipRegion] AS [ShipRegion],
[Project2].[ShipVia] AS [ShipVia],
[Project2].[C1] AS [C1],
[Project2].[CustomerID] AS [CustomerID],
[Project2].[CompanyName] AS [CompanyName],
[Project2].[ContactName] AS [ContactName],
[Project2].[ContactTitle] AS [ContactTitle],
[Project2].[Address] AS [Address],
[Project2].[City] AS [City],
[Project2].[Region] AS [Region],
[Project2].[PostalCode] AS [PostalCode],
[Project2].[Country] AS [Country],
[Project2].[Phone] AS [Phone],
[Project2].[Fax] AS [Fax],
[Project2].[CustType] AS [CustType],
[Project2].[C3] AS [C2],
[Project2].[C2] AS [C3],
[Project2].[OrderID1] AS [OrderID1],
[Project2].[ProductID] AS [ProductID],
[Project2].[UnitPrice] AS [UnitPrice],
[Project2].[Quantity] AS [Quantity],
[Project2].[Discount] AS [Discount]
FROM ( SELECT
    [Extent1].[EmployeeID] AS [EmployeeID],
    [Extent1].[Freight] AS [Freight],
    [Extent1].[OrderDate] AS [OrderDate],
    [Extent1].[OrderID] AS [OrderID],
    [Extent1].[RequiredDate] AS [RequiredDate],
    [Extent1].[ShipAddress] AS [ShipAddress],
    [Extent1].[ShipCity] AS [ShipCity],
    [Extent1].[ShipCountry] AS [ShipCountry],
    [Extent1].[ShipName] AS [ShipName],
    [Extent1].[ShippedDate] AS [ShippedDate],
    [Extent1].[ShipPostalCode] AS [ShipPostalCode],
    [Extent1].[ShipRegion] AS [ShipRegion],
    [Extent1].[ShipVia] AS [ShipVia],
    [Extent2].[Address] AS [Address],
    [Extent2].[City] AS [City],
    [Extent2].[CompanyName] AS [CompanyName],
    [Extent2].[ContactName] AS [ContactName],
    [Extent2].[ContactTitle] AS [ContactTitle],
    [Extent2].[Country] AS [Country],
    [Extent2].[CustomerID] AS [CustomerID],
    [Extent2].[CustType] AS [CustType],
    [Extent2].[Fax] AS [Fax],
    [Extent2].[Phone] AS [Phone],
    [Extent2].[PostalCode] AS [PostalCode],
    [Extent2].[Region] AS [Region],
    1 AS [C1],
    [Extent3].[Discount] AS [Discount],
    [Extent3].[OrderID] AS [OrderID1],
    [Extent3].[ProductID] AS [ProductID],
    [Extent3].[Quantity] AS [Quantity],
    [Extent3].[UnitPrice] AS [UnitPrice],
    CASE WHEN ([Extent3].[Discount] IS NULL)
        THEN CAST(NULL AS int) ELSE 1 END AS [C2],
    CASE WHEN ([Extent3].[Discount] IS NULL)
        THEN CAST(NULL AS int) ELSE 1 END AS [C3]
    FROM   [dbo].[Orders] AS [Extent1]
        LEFT OUTER JOIN
            [dbo].[Customers] AS [Extent2]
        ON
            [Extent1].[CustomerID] = [Extent2].[CustomerID]
        LEFT OUTER JOIN
            [dbo].[Order Details] AS [Extent3]
        ON
            [Extent1].[OrderID] = [Extent3].[OrderID]
    WHERE  NOT EXISTS
        (SELECT
            cast(1 as bit) AS [C1]
        FROM
            [dbo].[Order Details] AS [Extent4]
        LEFT OUTER JOIN
            [dbo].[Products] AS [Extent5]
        ON
            [Extent4].[ProductID] = [Extent5].[ProductID]
        WHERE
            ([Extent1].[OrderID] = [Extent4].[OrderID])
        AND
            (( NOT    (CASE WHEN ([Extent5].[Discontinued] IS NULL)
                    THEN CAST(NULL AS varchar(1))
                    ELSE CASE WHEN ([Extent5].[Discontinued] = 0)
                    THEN ‘4X’ ELSE ‘4X0X’ END END LIKE ‘4X0X%’))
               OR    (CASE WHEN (CASE WHEN ([Extent5].[Discontinued] IS NULL)
                    THEN CAST(NULL AS varchar(1))
                    ELSE CASE WHEN ([Extent5].[Discontinued] = 0)
                    THEN ‘4X’ ELSE ‘4X0X’ END END LIKE ‘4X0X%’)
                    THEN cast(1 as bit) WHEN ( NOT
                    (CASE WHEN ([Extent5].[Discontinued] IS NULL)
                    THEN CAST(NULL AS varchar(1))
                    ELSE CASE WHEN ([Extent5].[Discontinued] = 0)
                    THEN ‘4X’ ELSE ‘4X0X’ END END LIKE ‘4X0X%’))
                    THEN cast(0 as bit) END IS NULL))
    )
)  AS [Project2]
ORDER BY
    [Project2].[OrderID] ASC,
    [Project2].[CustomerID] ASC,
    [Project2].[C3] ASC

[Test()]
public void CombinedOrSpecExample()
{
    Specification<Order> country_customer_spec =
        new Specification<Order>
            (o => o.Customer.Country == “Germany” ||
                o.Customer.Country == “Usa”);

    Specification<Order> german_customer_spec =
        new Specification<Order>
            (o => o.Customer.Country == “Germany”);

    Specification<Order> us_customer_spec =
        new Specification<Order>
            (o => o.Customer.Country == “Usa”);

    Specification<Order> orderid_spec =
        new Specification<Order>(o => o.OrderID != 10279);

    Specification<Order> ords_with_discontinued_prods =
        new Specification<Order>(o => o.Order_Details.All
            (od => od.Product is DiscontinuedProduct));

    var orSpec = ords_with_discontinued_prods &
        orderid_spec & (german_customer_spec | us_customer_spec);

    using (var ctx = new NorthwindEntities())
    {
        //note the eager loading here
        //and still further down we have
        //to lazy load the same data
        //as eager loading has not worked
        //as expected.
        var discontinued_products_on_order =
            (ObjectQuery<Order_Detail>)
            from o in ctx.Orders
                .Include(“Order_Details”)
                .Include(“Customer”)
            .Where(orSpec.EvalPredicate)
            from od in ctx.OrderDetails
                .Include(“Product”)
            where od.OrderID == o.OrderID
            select od;

        Console.WriteLine(discontinued_products_on_order.ToTraceString());

        //demonstrates the current short comings IMO of the
        //entity framework with respect to the eager loading
        //and lazy loading. As you can see the includes are
        //NOT doing what you might expect as we still have
        //to load them lazy below.
        foreach (var ord_detail in discontinued_products_on_order)
        {
            if (!ord_detail.ProductReference.IsLoaded)
            {
                ord_detail.ProductReference.Load();
            }
            if (!ord_detail.OrderReference.IsLoaded)
            {
                ord_detail.OrderReference.Load();
            }
            if (!ord_detail.Order.CustomerReference.IsLoaded)
            {
                ord_detail.Order.CustomerReference.Load();
            }
            Console.WriteLine(“The OrderID: {0} the product name: {1} “ +
                “the customers location {2}”,
                ord_detail.OrderID, ord_detail.Product.ProductName,
                ord_detail.Order.Customer.Country);
        }

        Assert.IsTrue(discontinued_products_on_order
                      .Count(p => p.Order.Customer.Country != “Germany” &&
                                  p.Order.Customer.Country != “USA”) == 0);
    }
}

SELECT
    1 AS [C1],
    [Extent3].[OrderID] AS [OrderID],
    [Extent3].[ProductID] AS [ProductID],
    [Extent3].[UnitPrice] AS [UnitPrice],
    [Extent3].[Quantity] AS [Quantity],
    [Extent3].[Discount] AS [Discount]
FROM
    [dbo].[Orders] AS [Extent1]
LEFT OUTER JOIN
    [dbo].[Customers] AS [Extent2]
ON
    [Extent1].[CustomerID] = [Extent2].[CustomerID]
INNER JOIN
    [dbo].[Order Details] AS [Extent3]
ON
    [Extent1].[OrderID] = [Extent3].[OrderID]
WHERE
    (
    NOT EXISTS(
        SELECT
            cast(1 as bit) AS [C1]
        FROM
            [dbo].[Order Details] AS [Extent4]
        LEFT OUTER JOIN
            [dbo].[Products] AS [Extent5]
        ON
            [Extent4].[ProductID] = [Extent5].[ProductID]
        WHERE
            ([Extent1].[OrderID] = [Extent4].[OrderID])
        AND
            ((    NOT (CASE WHEN ([Extent5].[Discontinued] IS NULL)
                    THEN CAST(NULL AS varchar(1))
                    ELSE CASE WHEN ([Extent5].[Discontinued] = 0)
                    THEN ‘4X’ ELSE ‘4X0X’ END END LIKE ‘4X0X%’))
                OR (CASE WHEN (CASE WHEN ([Extent5].[Discontinued] IS NULL)
                    THEN CAST(NULL AS varchar(1))
                    ELSE CASE WHEN ([Extent5].[Discontinued] = 0)
                    THEN ‘4X’ ELSE ‘4X0X’ END END LIKE ‘4X0X%’)
                    THEN cast(1 as bit) WHEN ( NOT
                    (CASE WHEN ([Extent5].[Discontinued] IS NULL)
                    THEN CAST(NULL AS varchar(1)) ELSE
                    CASE WHEN ([Extent5].[Discontinued] = 0)
                    THEN ‘4X’ ELSE ‘4X0X’ END END LIKE ‘4X0X%’))
                    THEN cast(0 as bit) END IS NULL))
))
AND
    (10279 <> [Extent1].[OrderID])
AND
    ((N‘Germany’ = [Extent2].[Country])
OR
    (N‘Usa’ = [Extent2].[Country]))

public class EntitiesRepository<E, C> where E : EntityObject
                                      where C : ObjectContext
{
    private readonly C _ctx;

    public C Session
    {
        get { return _ctx; }
    }

    public EntitiesRepository(C session)
    {
        _ctx = session;
    }

    public void Save()
    {
        _ctx.SaveChanges();
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO have their pluralized names
    /// changed by the developer. For example if Customers
    /// table from Northwind produces an Entity that by
    /// default is named Customers but has it’s name changed
    /// to Customer this method call would fail. In Version
    /// 2.0 this pluralizing behaviour will change and this
    /// method overload should be used only if Developers
    /// change EntitySet names from the default name generated.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> All(string entitySetName)
    {
        return (ObjectQuery<E>)_ctx.CreateQuery<E>(“[" + entitySetName + "]“);
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer. For example if Customers
    /// table from Northwind produces an Entity that by
    /// default is EntitySet name is NOT changed.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> All()
    {
        return (ObjectQuery<E>)_ctx.CreateQuery<E>(“[" + typeof(E).Name + "]“);
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO have their pluralized names
    /// changed by the developer. For example if Customers
    /// table from Northwind produces an Entity that by
    /// default is named Customers but has it’s name changed
    /// to Customer this method call would fail. In Version
    /// 2.0 this pluralizing behaviour will change and this
    /// method overload should be used only if Developers
    /// change EntitySet names from the default name generated.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> All(string entitySetName, ISpecification<E> where)
    {
        return (ObjectQuery<E>)
            _ctx.CreateQuery<E>(“[" + entitySetName + "]“)
            .Where(where.EvalPredicate);
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer. For example if Customers
    /// table from Northwind produces an Entity that by
    /// default is EntitySet name is NOT changed.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> All(ISpecification<E> where)
    {
        return (ObjectQuery<E>)
            _ctx.CreateQuery<E>(“[" + typeof(E).Name + "]“)
            .Where(where.EvalPredicate);
    }
}

public E Unique(string entitySetName, ISpecification<E> where)
{
    if (_ctx.CreateQuery<E>(“[" + entitySetName + "]“).
        Where<E>(where.EvalPredicate).Count() > 1)
    {
        throw new NotUniqueEntityException();
    }
    return (E)
        _ctx.CreateQuery<E>(“[" + entitySetName + "]“)
        .Where(where.EvalPredicate).First();
}

[Test()]
[ExpectedException(typeof(NotUniqueEntityException))]
public void FailTestForUnique()
{
    //new up the repository
    EntitiesRepository<Customer, NorthwindEntities> ctx =
        new EntitiesRepository<Customer,
        NorthwindEntities>(new NorthwindEntities());

    //new up a specification
    Specification<Customer> cust_spec =
        new Specification<Customer>(c => c.Country == “Germany”);

    var unique_german_cust = ctx.Unique(“Customers”, cust_spec);

    Assert.IsNotNull(unique_german_cust);

    Console.WriteLine(“The Unique customer ID is : {0}”,
                        unique_german_cust.CustomerID);
}

public class NotUniqueEntityException : Exception
{
    public NotUniqueEntityException() :
        base(“The entity query produced more than “ +
                “a single result and is not unique”) { }
}