EntityManager Constructor(Boolean,String,EntityServiceOption,String)

Initialize a new instance of the EntityManager class for the specified data source key extension and optionally connect to the EntityServer, with the option to use local or distributed data sources.

Syntax

Visual Basic
C#

'Declaration
 
Public Function New( _
   Optional ByVal shouldConnect As Boolean, _
   Optional ByVal dataSourceExtension As String, _
   Optional ByVal entityServiceOption As EntityServiceOption, _
   Optional ByVal compositionContextName As String _
)

'Usage
 
Dim shouldConnect As Boolean
Dim dataSourceExtension As String
Dim entityServiceOption As EntityServiceOption
Dim compositionContextName As String
 
Dim instance As New EntityManager(shouldConnect, dataSourceExtension, entityServiceOption, compositionContextName)

public EntityManager( 
   bool shouldConnect,
   string dataSourceExtension,
   EntityServiceOption entityServiceOption,
   string compositionContextName
)

Parameters

shouldConnect: True if a connection to the EntityServer should be made.
dataSourceExtension: The DataSourceKey extension to search for in IdeaBlade configuration file.
entityServiceOption: Determines whether to use local or distributed data sources.
compositionContextName: Optional name of the CompositionContext to use for MEF composition.

Exceptions

Exception	Description
IdeaBlade.Core.IdeaBladeException	Thrown for miscellaneous initialization failures
EntityServerException	Thrown for connection failures
System.ArgumentException	Thrown in a Silverlight application when BOS is not specified

Remarks

You can use the dataSourceExtension to determine the run-time data source key(s) to be used. Every EntityManager (and EntityServer) is associated with a data source extension. By default, if an extension is not specified, then an "empty" extension is used. See the "Data Source Keys, DataSourceKeyResolvers, and Data Source Extensions" topic in the DevForce Resource Center for more information on data source extensions. The use of different data source extensions can be especially beneficial as you move your application between development, test and production environments, and for other situations in which the data source to be accessed will be determined at run time. The resolved DataSourceKey(s) must either be specified in the IdeaBlade configuration file or through a custom implementation of IDataSourceKeyResolver.

You can also choose whether a connection to the IdeaBlade.EntityModel.Server.EntityServer should be made now. If shouldConnect is true you will not be able to catch any EntityServerException thrown due to connection problems in an EntityServerError handler since the handler will not yet be set; you should instead wrap the call in a try/catch. If shouldConnect is false then you will need to call the Connect method when you are ready to begin communicating with the EntityServer.

Use the entityServiceOption to explicitly specify whether you will be using local or distributed data sources. By default the ObjectServer element in the IdeaBlade configuration file determines this, but if you need to use both local and distributed data sources within the same application you'll use the EntityServiceOption to indicate what the EntityManager will use. See the "Access Both Local and Remote Data Sources In the Same N-tier Application" topic in the DevForce Resource Center for more information.

You can also provide the name of the CompositionContext to be used to compose parts for runtime extensibility. By default if you don't provide a name the "default" context is used. See the CompositionContext for more information and sample usage.

No connection to data sources is made during EntityManager initialization.

An EntityManagerCreated event is fired upon creation.

Example

private bool Initialize() {
      string runTimeEnv;
#if TEST
      runTimeEnv = "Test";
#else
      runTimeEnv = "Prod";
#endif

      // Initialize an EntityManager for the given data source extension, and set up an error handler.
      IdeaBladeTest1Manager mgr = new IdeaBladeTest1Manager(false, runTimeEnv);
      mgr.EntityServerError += EntityServerErrorHandler;

      // Explicitly connect to the BOS now.
      // Note that no data source connection is made until entities are accessed.
      try {
        mgr.Connect();
      } catch (EntityServerException ese) {
        MessageBox.Show(ese.Message, "EntityServerException");
      } catch (Exception e) {
        MessageBox.Show(e.Message, "Exception");
      }
      return mgr.IsConnected;
    }
    private void EntityServerErrorHandler(object pSender, EntityServerErrorEventArgs e) {
      // Always a good idea to log all exception info.
      Exception ex = e.Exception;
      while (ex != null) {
        TraceFns.WriteLine(ex.ToString());
        ex = ex.InnerException;
      }
      MessageBox.Show("Trying to handle error");
      // Leave e.Handled = false if the Error should be thrown back to the calling code
      e.Handled = true;         // exception will not be thrown
    }

Requirements

Target Platforms: Windows 7, Windows Vista SP1 or later, Windows XP SP3, Windows Server 2008 (Server Core not supported), Windows Server 2008 R2 (Server Core supported with SP1 or later), Windows Server 2003 SP2

Reference

EntityManager Class
EntityManager Members
Overload List