Telerik OpenAccess Classic

Telerik OpenAccess ORM Send comments on this topic.
How to: Add, Modify, and Delete Objects
Programmer's Guide > OpenAccess ORM Classic (Old API) > OpenAccess Tasks > How to: Add, Modify, and Delete Objects

Glossary Item Box

This documentation article is a legacy resource describing the functionality of the deprecated OpenAccess Classic only. The contemporary documentation of Telerik OpenAccess ORM is available here.

Creating Objects

 Creating objects and persisting them with Telerik OpenAccess ORM is as easy as working with non-persisting ones.The scope object is an object that should be disposed after accomplishing the required operations. This can be done by calling the scope.Dispose() method or implementing the using clause.

VB .NET Copy Code
    Dim scope As IObjectScope = ObjectScopeProvider1.GetNewObjectScope()
   'you could see in some expamples that this can also be done with
   'Database.Get("DatabaseConnection1").GetObjectScope();
   'there is absolutely no diference
   Using scope
    scope.Transaction.Begin()
    Dim o As New Order("John Smith", New DateTime(2008, 12, 12), "Telerik's Address")
    o.Details.Add(New OrderDetail("RadControls for WinForms", 799.9f, 3))
    o.Details.Add(New OrderDetail("OpenAccess ORM", 399.9f, 3))
    o.Details.Add(New OrderDetail("RadControls for ASP .NET", 799.9f, 5))
    scope.Add(o)
    scope.Transaction.Commit()
   End Using
C# Copy Code
      IObjectScope scope = ObjectScopeProvider1.GetNewObjectScope();
           //you could see in some expamples that this can also be done with  
           
//Database.Get("DatabaseConnection1").GetObjectScope();
           
//there is absolutely no diference
           
using (scope)
           {
               scope.Transaction.Begin();
               Order o =
new Order("John Smith", new DateTime(2008, 12, 12), "Telerik's Address");
               o.Details.Add(
new OrderDetail("RadControls for WinForms", 799.9f, 3));
               o.Details.Add(
new OrderDetail("OpenAccess ORM", 399.9f, 3));
               o.Details.Add(
new OrderDetail("RadControls for ASP .NET", 799.9f, 5));
               scope.Add(o);
               scope.Transaction.Commit();
           }  

So making an object and its children to persist is very easy. It is required to add only the root object of the object graph to have all persistent entities handled automatically. Telerik OpenAccess ORM will care about the rest like adding the records in the ObjectDetail table and in the join table. That is called persistence by reachability. You should notice that your classes must be marked as [Telerik.OpenAccess.Persistent] so the ORM can traverse through the three of objects and persist all of them. If it finds any non-persistent class it will throw an exception.

In case you want to exclude a field from being persisted, e.g. a callback delegate, mark it with the Telerik.OpenAccess.Transient attribute:

VB .NET Copy Code
Public Delegate Sub OnProgressDelegate(pct As Double)
<OpenAccess.Persistent> _
Class Order
 <Telerik.OpenAccess.Transient> _
 Public onProgress As OnProgressDelegate = Nothing
End Class
C# Copy Code
public delegate void OnProgressDelegate(double pct);
    
   
[OpenAccess.Persistent]
   
class Order
    {
        ...
       [Telerik.OpenAccess.Transient]
       
public OnProgressDelegate onProgress=null;

    }  

Updating Objects

Updating an object state is the easiest of them all. You only need to extract the specified object, modify it and commit the transaction. You must not forget that inserting, updating and deleting objects MUST be done within a scope of a transaction. If there is no transaction open and a field changes an exception will be thrown. Here’s a simple example:

C# Copy Code
var result = from o in scope.Extent<Order>()
            where o.Customer.Contains(
"John")
            select o;

scope.Transaction.Begin();
Order firstJohnOrder = (Order)result.First();
firstJohnOrder.Customer =
"Sir John The First";
scope.Transaction.Commit();  
VB .NET Copy Code
Dim result = From o In scope.Extent(Of Order)() _
             Where o.Customer.Contains("John") _
             Select o
scope.Transaction.Begin()
Dim firstJohnOrder As Order = CType(result.First(), Order)
firstJohnOrder.Customer = "Sir John The First"
scope.Transaction.Commit()

You noticed we extracted more than one object with the query. Here the feature called change tracking comes in. Each object has it’s own change tracker and after the transaction commit was called the ORM checks which objects are marked as dirty and stores only those that are changed. That is a great performance booster when working with large databases.

Deleting Objects

 The O/R Mapping differs from the ADO .NET because you need to load your data first and then delete it. You CAN NOT write any “DELETE” statements for deleting thousands of rows in one move here. That is because O/R Mapping is all about working with single objects. SQL on the other hand is for batch operations. But what OpenAccess ORM offers is a Remove() method which could take as an argument an enumerable collection as it takes a single object so you don’t need to remove objects one by one.

Here is an example of the scope.Remove() method:

C# Copy Code
var result = from o in scope.Extent<Order>()
            where o.Customer.Contains(
"John")
            select o;
scope.Transaction.Begin();
scope.Remove(result.ToList());
scope.Transaction.Commit();
scope.Dispose();   
VB .NET Copy Code
Dim result = From o In scope.Extent(Of Order)() _
             Where o.Customer.Contains("John") _
             Select o
scope.Transaction.Begin()
scope.Remove(result.ToList())
scope.Transaction.Commit()
scope.Dispose()

If the object we are removing contains other objects or collections related to him(this is where the depend attribute makes advantage), they are all removed.However these objects also need to be loaded before being removed and that the OpenAccess ORM engine does for you.

 

 If you want to delete some extremely large amount of data be carefull and considering the performance-instead you may execute directly few DELETE statements inside a transaction for the purpose.