This tutorial guides you through the process of creating a simple application powered by ADO.NET Entity Framework. In less than 5 minutes you will have a ready-to-use data access layer for your business objects.
Please note that this tutorial is not applicable for Entity Framework Core. It is intended for previous Entity Framework versions.
In this walkthrough:
ADO.NET Entity Framework is an object-relational mapping (ORM) framework for the .NET Framework. It is designed to enable developers to create data access applications by programming against a conceptual application model instead of programming directly against a relational storage schema. The goal is to decrease the amount of code and maintenance required for data-oriented applications.
In order to connect to Salesforce server you need dotConnect for Salesforce installed and IDE running. ADO.NET Entity Framework requires .NET Framework 3.5 Service Pack 1 or higher and Visual Studio 2008 Service Pack 1 or higher. Note that Entity Framework support is not available in Standard Edition of dotConnect for Salesforce.
In this tutorial we will use Account and Contact Salesforce objects.
For Entity Framework 6, you will also need a NuGet Visual Studio extension installed since it is used for adding EntityFramework NuGet package. Alternatively you may create model for Entity Framework v1 or v4, which don't require NuGet, in this tutorial.
In this sample we will create a simple console application. It could be any other project type as well, but for simplicity's sake we'll use console project throughout the tutorial. Start Visual Studio and create a new console application.
The following actions are required if you want to create an Entity Framework v6 model.
Open the Package Manager Console window and execute the following command in it.
install-package EntityFramework
After this add the following line:
<provider invariantName="Devart.Data.Salesforce" type="Devart.Data.Salesforce.Entity.SalesforceEntityProviderServices, Devart.Data.Salesforce.Entity, Version=3.2.520.0, Culture=neutral, PublicKeyToken=09af7300eec23701" />
to the entityFramework -> providers section.
<entityFramework> <providers> <provider invariantName="Devart.Data.Salesforce" type="Devart.Data.Salesforce.Entity.SalesforceEntityProviderServices, Devart.Data.Salesforce.Entity, Version=3.2.520.0, Culture=neutral, PublicKeyToken=09af7300eec23701" /> </providers> </entityFramework>
Note: replace 3.2.520.0 with the actual assembly version.
You also need to add the following assemblies to the project references:
After this you need to rebuild the project before running the EDM wizard.
After this, in each added entity click the OwnerID property and set their StoreGeneratedPattern property to Identity in the Properties window. Then open this model in the XML editor (right-click the model in Solution Explorer and select Open With... from the shortcut menu, and then select XML (Text) Editor in the list and click OK. In the XML editor add the 'StoreGeneratedPattern="Identity"' parameter for the Property tag of OwnerID property for all entities in the Storage part.
The model you've just generated is ready to use. Its name is Model1.edmx, unless you changed it in the step 2. You can inspect it visually in the designer or take a look behind the scenes with XML Editor.
The wizard creates classes for all selected tables that represent entities. It also creates a descendant of System.Data.Entity.DbContext class (used by default since Visual Studio 2012) or System.Data.Objects.ObjectContext class (used by default in older Visual Studio versions), which controls the connection to the database, and the whole data flow. This class includes properties and methods named after your database objects. You will use these members to retrieve and modify data in the context. The code is contained in an autogenerated file Model1.Designer.cs (Model1.Designer.vb).
Note that if you have an association between two properties of non-coinciding numeric types, you can manually change both conceptual and storage types to the type that will be wide enough to include data for each property.
All Entity Framework operations are executed are executed through a DbContext descendant (default since Visual Studio 2012) or through a ObjectContext descendant, which is named SalesforceEntities in this tutorial. To retrieve data you have to first create an instance of the context, then prepare a query with LINQ to Entities or EntitySQL or their mix, and then access the object returned by the query, which may be a collection of objects or a single object.
Let's read all the data from the Account object, sort it by it Name, and output some columns. Add the following block of code to the method Main:
As simple as that. You prepare a query and then iterate through it as you would do with a usual collection of objects. The database interaction is performed by Entity Framework in the background. Now let's see who is who in this code sample.
Here is the project's output in the console:
Note that the LINQ to Entities query code just describes the query. It does not execute it. This approach is known as deferred execution.
Now let's query data from two Salesforce tables (objects) united with a master-detail relationship. Replace the old code with this:
This sample is much like the previous one, with exception that it adds the Include method that instructs the query to retrieve data from one more table.
What earlier was adding rows to tables, now is just adding new objects to context collections. When you are ready to send the changes to the database, call the SaveChanges() method of the context. Before doing this, you must first set all properties that do not support null (Nothing) values. The SaveChanges() method generates and executes commands that perform the equivalent INSERT, UPDATE, or DELETE statements against the data source.
Let's add a new contact and a new account to Salesforce. Replace the old code with this:
The methods AddToAccount, AddToContact, and others are automatically generated in the context. Such methods exist for every class in your model.
Note that after you have added the new contact and account by submitting the changes, you cannot execute this solution again as is. To execute the solution again, change the names and IDs of the objects to be added.
Entity instances are modified as usual. The only thing to remember is that you have to invoke the SaveChanges() method to send the data to the database.
Append the following block to the existing code and launch the project:
To extract an instance from a context use the DeleteObject method of the context. The object is removed from the collection of its type, but not destroyed. To delete the object's data from the database invoke the SaveChanges() method.
You can do this with a block of code like the following:
Now that you can perform the basic data manipulation with Entity Framework, you can move on to some advanced topics.
We recommend you to use Entity Developer (Devart Entity Model, *.edml) instead of EDM Designer (ADO.NET Entity Data Model, *.edmx) because it is adjusted for working with Salesforce and has an advanced functionality. Additionally, Entity Developer adds registration of EF6 provider in app.config automatically and offers designer (Database First / Model First) for EF Core.
Here are some useful links to MSDN:
For hands-on experience download the separate Entity Framework Query Samples (EF1/EF4/EF5/EF6) package or use samples shipped with dotConnect for Salesforce. You can access the samples from the Start menu.
To understand deeper the works of Entity Framework engine you can watch the generated SQL statements in dbMonitor.
Entity Framework section | Entity Framework Support Overview