This topic has not yet been rated - Rate this topic

How to: Manage the Connection in a Long-Running Object Context

This topic provides an example of how to manually open a connection for a long-running object context. The example also shows how to ensure that the connection is released by calling Dispose on the context.

The example in this topic is based on the AdventureWorks Sales Model. To run the code in this example, you must have already added the AdventureWorks Sales Model to your project and configured your project to use the Entity Framework. To do this, complete the procedure in How to: Use the Entity Data Model Wizard.

Example

This example manually opens the connection used by a long-running ObjectContext, then executes a query and saves the changes. The connection is closed when the ObjectContext is disposed.

// Define the order ID for the order we want.
int orderId = 43680;

// Create a long-running context.
AdventureWorksEntities context =
    new AdventureWorksEntities();

try
{
    if (context.Connection.State != ConnectionState.Open)
    {
        // Explicitly open the connection.
        context.Connection.Open();
    }

    // Execute a query to return an order.
    SalesOrderHeader order =
        context.SalesOrderHeaders.Where(
        "it.SalesOrderID = @orderId", new ObjectParameter("orderId", orderId))
        .Execute(MergeOption.AppendOnly).First();

    // Change the status of an existing order.
    order.Status = 1;

    // You do not have to call the Load method to load the details for the order,
    // because  lazy loading is set to true 
    // by the constructor of the AdventureWorksEntities object. 
    // With  lazy loading set to true the related objects are loaded when
    // you access the navigation property. In this case SalesOrderDetails.

    // Delete the first item in the order.
    context.DeleteObject(order.SalesOrderDetails.First());

    // Save changes.
    if (0 < context.SaveChanges())
    {
        Console.WriteLine("Changes saved.");
    }

    // Create a new SalesOrderDetail object.
    // You can use the static CreateObjectName method (the Entity Framework
    // adds this method to the generated entity types) instead of the new operator:
    // SalesOrderDetail.CreateSalesOrderDetail(1, 0, 2, 750, 1, (decimal)2171.2942, 0, 0,
    //                                         Guid.NewGuid(), DateTime.Today));
    SalesOrderDetail detail = new SalesOrderDetail
    {
        SalesOrderID = 0,
        SalesOrderDetailID = 0,
        OrderQty = 2,
        ProductID = 750,
        SpecialOfferID = 1,
        UnitPrice = (decimal)2171.2942,
        UnitPriceDiscount = 0,
        LineTotal = 0,
        rowguid = Guid.NewGuid(),
        ModifiedDate = DateTime.Now
    };

    order.SalesOrderDetails.Add(detail);


    // Save changes again.
    if (0 < context.SaveChanges())
    {
        Console.WriteLine("Changes saved.");
    }
}
catch (InvalidOperationException ex)
{
    Console.WriteLine(ex.ToString());
}
finally
{
    // Explicitly dispose of the context, 
    // which closes the connection. 
    context.Dispose();
}

See Also

Did you find this helpful?
(1500 characters remaining)
Community Content Add
Annotations FAQ
Performance
I think the purpose of this article is to point out an alternate way of managing the connection when performance is an issue. You can open it manually and keep it open for a longer period of time while calling context.SaveChanges() many times. Allowing for more efficient bulk operations.

The using statement is a good practice though!
Poor article
What is the point of this article ? The object context does not seem to be alive for very long.
Also, why not use the "using" statement instead of manually calling dispose in a try .. finally .. block ?