How to: Use ObjectContainer as an alternative of the ObjectScope in ASP .NET with web services

RELATED TO:

Article information

Article relates to

 OpenAccess Classic

Created by

 Zoran Kostov

Last modified

 April 29, 2009

Last modified by

 Zoran Kostov
The example that is demonstrated in this article  is using as a starting point the “Sofia Car Rental” application that is developed in our ‘Getting Started’ chapter of the OpenAccess documentation. It is recommended to read the “Getting Started” section of the Telerik OpenAccess ORM documentation[link] before proceeding with this article.

Scenario:

The administrator of “Sofia Car Rental” has a page where he/she is able to modify the available “Car” objects and also add or delete ones. The administrator role requires to do this in a disconnected manner so the changes are made internally and then brought to public in a batch when decided so. For that purpose the admin page loads the “Car” objects from a Web Service which transfers them in an ObjectContainer. The changes that the administrator makes are reflected only in ObjectContainer and that way the other pages that interact with the customers remain unchanged. All changes become visible when the administrator sends the set of changes from the ObejctContainer back to the server, using another method of the web service. This method reflects the changes in the “SofiaCarRental” database and also refreshes the ObjectContainer itself preventing it from containing inconsistent and obsolete data.

Implementation:

First thing to implement is the GetAllCars() method of the web service which returns a ChangeSet content and this is what gets loaded in the initialization of the container.

[WebMethod] 
public Telerik.OpenAccess.ObjectContainer.ChangeSet GetAllCars() 
{ 
 
    ObjectContainer.ChangeSet ccData = null; 
    IObjectScope os = ObjectScopeProvider1.GetNewObjectScope(); 
 
    os.Transaction.Begin(); 
    try 
    { 
        string resultName = "Cars"; 
        string query = "SELECT * FROM CarExtent AS x"; 
        IQuery qry = os.GetOqlQuery(query); 
        IQueryResult qres = qry.Execute(); 
 
        ObjectContainer oc = new ObjectContainer(); 
 
        Telerik.OpenAccess.IObjectCollector objCollector = 
        new FetchGroupCollector(FetchGroupCollector.DefaultFetchGroup); 
 
        if (qres != null) 
        { 
            oc.CopyFrom(os, resultName, qres, objCollector); 
        } 
        else 
        { 
            oc.CopyFrom(os, resultName, qres, null); 
 
        } 
            ccData = oc.GetContent(); 
    } 
    finally 
    { 
        os.Transaction.Rollback(); 
        os.Dispose(); 
    } 
    return ccData; 
} 
 
First an object scope is obtained from to the “SofiaCarRental” database and all the car persistent objects are fetched from the database. After that an ObjectContainer instance is created and then it gets filled with the result of the previous query from the object scope. The CopyFrom() method of the container is a way of filling the ObjectContainer with persistent objects.

The method returns a ChangeSet which represent the content of this container. That is the content that gets applied by the ObjectContainer in the Admin page.

Below is the code of the Page_Load method in the Admin page where the ObjectContainer gets initialized and filled with the necessary content.
protected void Page_Load(object sender, EventArgs e) 
{ 
    if (Session["container"] == null) 
    { 
        ObjectContainer container = new ObjectContainer(); 
        CarRentalAdministratorService service = new CarRentalAdministratorService(); 
        container.Apply(service.GetAllCars()); 
        Session["container"] = container; 
    } 
    else 
    { 
        ObjectContainer container = (ObjectContainer)Session["container"]; 
    } 
} 
 

NOTE: ObjectContainer should be used carefully in large web sites since it is stored in Session. If there are too many objects in the container it can become too “heavy” and it is not a good practice to store large amount of data in the Session state as it slows down the server.

The Admin web page contains a RadGrid for interactive execution of all the CRUD operations against the container and a Button which submits the changes made by the administrator to the database server. There are few event handlers that should be implemented to make all these operations possible.

First we should hook up for the NeedDatasource event of the RadGrid. Here is the code of the method that is invoked on this event:
protected void RadGrid1_NeedDataSource(object source, Telerik.Web.UI.GridNeedDataSourceEventArgs e) 
{ 
    ObjectContainer container = (ObjectContainer)Session["container"]; 
    RadGrid1.DataSource = LoadCars(container); 
} 
 
private IList LoadCars(Telerik.OpenAccess.ObjectContainer container) 
{ 
    return container.NamedList("Cars"); 
} 
 
The objects in the object container are grouped in named lists. The only named list in this case is only the “Cars” named list. When calling the container.NamedList() method of the container with a name of a specific list as a parameter it returns an IList collection from all the objects that are part of it. That collection is used to bind the RadGrid to.
Next are the Insert, Delete and Update commands of the RadGrid:

protected void RadGrid1_DeleteCommand(object source, Telerik.Web.UI.GridCommandEventArgs e) 
{ 
     string carID = ((GridDataItem)e.Item).GetDataKeyValue("CarID").ToString(); 
     ObjectContainer container = (ObjectContainer)Session["container"]; 
     container.Transaction.Begin(); 
     Car car = (Car)container.GetObjectById(Database.OID.ParseObjectId(typeof(Car), carID)); 
     container.Remove(car); 
     container.NamedList("Cars").Remove(car); 
     container.Transaction.Commit(); 
} 
 
protected void RadGrid1_UpdateCommand(object source, GridCommandEventArgs e) 
{ 
     string carID = ((GridEditFormItem)e.Item).ParentItem.GetDataKeyValue("CarID").ToString(); 
     ObjectContainer container = (ObjectContainer)Session["container"]; 
     container.Transaction.Begin(); 
     Car car = (Car)container.GetObjectById(Database.OID.ParseObjectId(typeof(Car), carID)); 
     ((GridEditableItem)e.Item).UpdateValues(car); 
     container.Transaction.Commit(); 
 
} 
 
protected void RadGrid1_InsertCommand(object source, GridCommandEventArgs e) 
{ 
    ObjectContainer container = (ObjectContainer)Session["container"]; 
    container.Transaction.Begin(); 
    Car newCar = new Car(); 
    ((GridEditableItem)e.Item).UpdateValues(newCar); 
    container.Add(newCar); 
    container.NamedList("Cars").Add(newCar); 
    container.Transaction.Commit(); 
}  
 
The button that calls the Web Service method which updates the database and refreshes the ObjectContainer has the following code listening on its Click event:
protected void Button1_Click(object sender, EventArgs e) 
{ 
    ObjectContainer container = (Telerik.OpenAccess.ObjectContainer)Session["container"]; 
    ObjectContainer.ChangeSet changedData = container.GetChanges(Telerik.OpenAccess.ObjectContainer.Verify.Changed); 
    CarRentalAdministratorService service = new CarRentalAdministratorService(); 
    container.Apply(service.SyncCars(changedData)); 
} 
 
The important part of this code is the SyncCars method of the Web Service. This method takes a ChangeSet as a parameter, updates the database with the changes made in the container and than returns a fresh ChangeSet to the container which the container applies and that way its objects also remain in a consistent state.

The implementation of this web method is like:
[WebMethod] 
public ObjectContainer.ChangeSet SyncCars(ObjectContainer.ChangeSet changes) 
{ 
     try 
     { 
         ObjectContainer.ChangeSet ccData = null; 
         IObjectScope os = ObjectScopeProvider1.GetNewObjectScope(); 
         try 
         { 
             ccData = ObjectContainer.CommitChanges(changes, Telerik.OpenAccess.ObjectContainer.Verify.Changed, os, true, true); 
         } 
         finally 
         { 
             os.Dispose(); 
         } 
         return ccData; 
     } 
     catch (Exception exc) 
     { 
         string msg = exc.Message; 
         throw exc; 
     } 
} 
 
The final interactive web page has the following look:

There is little additional logic that prompts the administrator of how many records are Altered/Inserted/Deleted in this disconnected mode as that is the number of the outdated records on the database server as well as marking which those records are.

The full code for this sample application is available in Telerik OpenAccess ORM code library under the name “Using ObjectContainer with web services for administrating SofiaCarRental website”.

Related Products
Data Access

Resources Buy Try

More Resources

  • Forums

    Find answers to thousands of questions or reach out to our active community.

  • Videos

    Browse the Data Access videos to learn about handy features and tips and tricks.

  • Documentation

    Detailed help articles and API references for Telerik Data Access.

  • Knowledge Base

    Tutorials and working examples on how to achieve common scenarios.

  • Code Library

    Sample projects submitted by Telerik staff and community members.

  • Blog

    Stay up-to-date with the latest functionality, how-to articles, and industry trends.

  • Release History

    Up-to-date release notes for all new features and improvements.