Transcript OpenAccess ORM

OpenAccess ORM
Modeling, API, tools and best practices
Viktor Zhivkov
Senior Software Developer, OpenAccess ORM
Telerik Software Academy
http://academy.telerik.com
Table of Contents
 Hello to OpenAccess
 Features
 Components
 OpenAccess API
 Working with LINQ
 Bulk Operations
 Code generation wizards
2
Supported database servers
SQL Compact
Edition
MS SQL 2000+
Oracle 9+
SQLite
VistaDB
LocalDb
SQL Anywhere
My SQL 5.0+
MariaDb
PostgreSQL
SQL Azure
Firebird
ADS
3
OpenAccess features over EF 5.0
 Batch Operations over metadata
 Code generation for Services
 Runtime model modifications
 Build-in validation
framework
 .Net 3.5 Framework support
 Pessimistic
concurrency control
 Level 2 caching
 Advanced connection pooling
4
First encounter with OpenAccess
5
Components
 Visual
Designer – design surface where you can
compose your data model
 Toolbox – contains model building block
–
classes, associations and etc.
 Model Explorer – view over the conceptual
data model
 Model Schema Explorer – view over the
relational data model
 Mapping details editor – tool used to map
domain classes to relational tables
6
First OpenAccess model
DEMO!
7
Model Settings
 Model settings dialog
allows you to set up:
 Your model, model names, database names,
 Code generation options
 Runtime configuration, logging, caching,
connection pooling
 Schema updates
8
Update from Database
 Pull changes made in the database into the
existing conceptual model
DEMO
9
Update Database from Model
Push changes made to the conceptual model to the database in
form of SQL DDL script
DEMO
10
Fluent mapping
 Define your model using code-only mapping
 Possible
scenarios:
 Code-first with lots of manual coding
 Database-first with one-time code generation
DEMO
11
What is a model?
Metadata Container
Contains all
required
metadata
that describes
the model,
like:
- Domain
Classes
- Domain
Methods
Class1
Class1
Class2
ClassN
Runtime Configuration
.CS
.CS
.CS
.CS
.CS
.CS
12
What is a model?
Metadata Container
Meta
Persistent
Type:
Describes a
domain class
with all its
properties,
settings and
mappings
Class1
Class1
Class2
ClassN
Runtime Configuration
.CS
.CS
.CS
.CS
.CS
.CS
13
What is a model?
Metadata Container
Class1
Class1
Configuration
of the
runtime, all
switches
available in
Model
Settings
dialog
Class2
ClassN
Runtime Configuration
.CS
.CS
.CS
.CS
.CS
.CS
14
What is a model?
Metadata Container
Class1
Class1
Code file that
defines the
.Net class
representing
the model
(derived from
OpenAccessC
ontext)
Class2
ClassN
Runtime Configuration
.CS
.CS
.CS
.CS
.CS
.CS
15
What is a model?
Metadata Container
Class1
Class1
Plain .Net
class (POCO)
that defines
an entity
(Domain
Class)
Class2
ClassN
Runtime Configuration
.CS
.CS
.CS
.CS
.CS
.CS
16
Model internals - Enhancer
 Entities bound to a data context need change
tracking in order to be used in Create, Update,
Delete operations (CUD operations)
 Enhancer is the behind the scenes tool that
does that for you with minimum interruption
 Uses MSIL code weaving to inject the necessary
code in your types
 Required some changes in the default build
process!
17
Enhancer – reflection time
 Demo – see the original
code and the
enhanced one side by side
DEMO
18
CRUD Operations

Create
 1: new Entity();
 2: context.Add();
 3: context.SaveChanges();

Read – context.Entities.First(o => o.Id == id);

Update
 1: entity.Name = entity.Name + “1”;
 2: context.SaveChanges();

Delete
 1: context.Remove(entity);
 2: context.SaveChanges();
DEMO
19
Entity States
Add()
New
NotManaged
Hollow
SaveChanges()
SaveChanges()
Dirty
Remove()
Load data
Remove()
change
Deleted
Remove()
Attach()
Clean
Detach()
Detached
20
Lazy Loading
 Entity properties
are loaded lazily by default!
 Simple properties will have their data inmemory
 Navigation properties will have the target
entity in Hollow state
DEMO
21
Fetch API
 Load related objects eagerly
 Different approaches
DEMO
 Fetch Strategy – applied to the
OpenAccessContext and used for every delete
that is included in the strategy
 Include<T>() – applied to a LINQ query
 Optimizes the way data is
loaded – can solve
N+1 loading problems
22
Caching
 Two levels of object caching:
 Per context (Level 1 Cache) – in memory set of
all loaded entities.
 Per database (Level 2 Cache) – in memory set of
all loaded entities across all context instances in
the Application Domain
 Also works in web farm scenarios using MSMQ
synchronization
 Prepared statement cache for SQL statements
 Query cache for LINQ queries
23
Attach/Detach
 API for linking an entity to context or breaking
the same link
 One entity can be managed by only
one
context at a time
 In order to persist an entity it should be
detached
 Attached entities are not suited to travel
across application levels or service boundaries
 Detached entities can track changes in their
state
24
Best Practices
 Use short living
context instances
 L1 Cache can grow indefinitely
 Entities can be included in wrong transaction
 Best – use “using” block
 Avoid FlushChanges
 Opens transaction and keeps it active until
SaveChanges() or ClearChanges() are called
25
LINQ and OpenAccess

OpenAccess supports almost all of the features of LINQ to SQL and LINQ
to EF

Some differences:
 Queries that will be ineffective due client side execution of filters will
throw exception rather than running as it does in EF
 Generic property accessors using FieldValue<T>() method
 Support for 3 special names to access internal OA properties
 Somewhat better DateTime and bitwise operations support
DEMO
26
Dynamic LINQ
 String-based
LINQ API that mirrors parts of
the original LINQ API
 Useful with UI components that allow
userdefined filtering, sorting and grouping
 Used in OpenAccess to query artificial
types
 More on ScottGu’s blog
DEMO
27
Common LINQ Mistakes
 Calling
.ToList() too early or to hammer out
errors
 Using .Net specific or user-defined methods,
types and properties
 Missing
FetchStrategy or Include()
 Too broad
FetchStrategy
 Dispose the context before data
is
materialized
DEMO
28
Important Considerations

Use variables for filter criteria rather than in-place calculated
values or literals and constants
 Variables enable OpenAccess to cache
 the compiled query and reuse it with different value
 the query result

Avoid non-trivial projections. Any return type outside of the
known entity types will cause the result not to be cached.
When tempted to reduce the network traffic by reducing the
number of returned columns consider how this can affect L1
and L2 caches and ideally test the performance with and
without the projection for your whole scenario
29
How to check your queries
 Use OpenAccessProfiler
 Use openAccessContext.Log
 Use IQueryable<T>.ToString()
 Use your favorite profiler provided by the
database server vendor
30
Bulk Operations

Update and Delete operations that operate on matching rows
on the server side without loading data in the application’s
memory

Matching rows are defined as the result of a LINQ query

Delete or update operations are performed efficiently on the
database server

Normally a temporary table is used to how some intermediate
data that is required for the operation. The tables is deleted
when the transaction is complete

Behavior is similar to the normal delete and update of entities
using OpenAccess context API
31
Bulk Update
 Discount rental cars that are manufactured
before 1990 by 20%:
Context.Cars.Where(c => c.Year < 1990)
.UpdateAll(u => u.Set(c => c.Prize, c => c.Prize * 0,8));
Roughly equivalent in SQL to:
update Cars c set(c.Prize = c.Prize * 0,8) where c.Year < 1990
DEMO
32
Bulk Delete
 Remove discontinued products from the
database:
Context.Products.Where(p => p.Discontinued)
.DeleteAll();
DEMO
 Roughly equivalent in SQL to:
delete from Products p where p.Discontinued = 1
33
Bulk Operations details
 Each operation has its own transaction
separate from the one in the
OpenAccessContext
 Bulk operations will invalidate
any cached
instances in the Level 2 Cache. Eviction is done
by type and will affect usually a lot of objects.
 A temporary table will be used. Appropriate
permissions are required. If creation of temp
table fails the required temporary data will be
put in memory.
34
Bulk Operation details (2)
 Source queries and update descriptors
should
be 100% pushable to the database server
 Setting reference navigation
properties is
possible but dangerous
 Setting collection navigation
properties is
forbidden
 Using symbolic names is
allowed
35
Add OpenAccess Service wizard
 Can generated for you an entire service
layer
that exposes your data model in a few clicks
 Supports generation of:
 Plain WCF services with DTOs
 Data Services
 Web API
 RESTful Collection Services
 AtomPub
DEMO
36
Dynamic Data wizard
 Can generate for you a Dynamic Data Web
Application that gives you generic interface for
CRUD operations over your data model
DEMO
37

OpenAccess product
Resources
 http://www.telerik.com/products/orm.aspx

OpenAccess online documentation
 http://www.telerik.com/products/orm/gettingstarted.aspx

OpenAccess Samples Kit
 http://www.telerik.com/products/orm/features/sa
mples-kit.aspx

OpenAccess Forum
 http://www.telerik.com/community/forums/orm.as
px
38
OpenAccess ORM
Questions?
Exercises
1. Customize code generation
Customize the OpenAccess Code Generation T4
templates so that all the generated classes inherit from a
single non-persistent class. Then generate a model out of
a Northwind database and demonstrate that with the
generated OpenAccessContext and persistent classes you
are able to retrieve and update data in a small console
application (under the same solution but in a separate
project).
40
Exercises
2. Implement entity cloning using binary
serialization
Define a function that can clone single entity
loaded from the database (for more fame – a
graph of entities, starting with from one of the
nodes). Test that all properties of the original
instance have the same values as the ones on the
cloned.
41
Exercises
3. Compare Bulk Delete with normal delete
operation
Insert 100 000 entities in single table. Delete each row that has ID
where ID mod 7 == 1
Once delete the entities using OpenAccessContext.Remove()
method.
Then delete the entities using DeleteAll() bulk operation.
Both times track the SQL statements that are sent to the server.
Both times measure the time required to complete the
operation(s). For bonus points measure the memory consumption
in addition to the time. Output the measurements in text file
including timestamp and machine name
42
Exercises
4. Do code review of the code generated by Add
OpenAccess Service wizard for Web API services
Make critical code review (peer review) of the code generated by
Add OpenAccess Service wizard for Web API services: Base
controller, Concrete controllers, Base repository, Concrete repositories,
Global asax routes definition
Watch for bad practices in handling data-related task, bad design
decisions, incorrect implementation of design patterns, code
smells, bad code formatting, inefficient code and etc. List at least 3
issues with the generated code.
43
Exercises
5. List 5 suggestions for improvements all over
OpenAccess (issues described in Exercise 4 do
not count!).
Issues can be anything that made working with
OpenAccess unpleasant – bugs, missing
documentation, missing features, bad menu
positioning, unexpected outcome, visual glitches…
As with any bug/issue can you define the steps to
reproduce it?
44
Free Trainings @ Telerik Academy
 "Web Design with HTML 5, CSS 3 and
JavaScript" course @ Telerik Academy


Telerik Software Academy


academy.telerik.com
Telerik Academy @ Facebook


html5course.telerik.com
facebook.com/TelerikAcademy
Telerik Software Academy Forums

forums.academy.telerik.com