devforce.smilingassociates.com

DevForce Silverlight: Client and Server projects in VS2010

If you use the DevForce Template to generate a Silverlight App , you will create a Web Project (Server)
and a Silverlight Application (Client). The ADO.NET Entity Data Model must be
contained or referenced in a Web Project (the Server).  

 

DevForce will generate from an ADO.NET Entity Data Model a file with the extension of IB.Designer.cs

(usingthe IdeaBlade OM Designer Extension). The DevForce generated IB.Designer.cs
must be available on both client side projects and on the Server Web Project. Your
Client side project must contain a link to the IB.Designer.cs file (or reference
a Silverlight class project that contains a link).

You may choose to create a Class Library to house your ADO.Net Entity Data Model. If you do so
make sure to create a Silverlight Class Library and give it the same assembly
name as the project containing the Entity Data Model. DevForce will find the Silverlight
project with the same assembly name and will create a linked IB.Designer.cs
file when the EDM Designer is saved.  
 
Make sure that your Web project(Server) references the Project that contains your ADO.NET Entity
DataModel. If you don’t and attempt to run your app , you will get an EntityServerException.
 
 
 
 
 
 
 
 
 
 

Creating Entities in an EntityManager

 
Newing an entity leaves its
entitystate(Entity.EntityAspect.EntityState) detached . And it is not attached
to an EntityManager.
 
Using createEntity auto associates
the new entity to an EntityManager (EntityState is still detached).
 
Adding an Entity to the
EntityManager via EntityManager.AddEntity or Entity.EntityAspect.AddToManager()
changes the EntityState to Added.
 
Assigning a detached entity to
one that is attached will attach the original entity . If the detached entity
has many entities in its graph the entire graph will be attached.
 
             var dm = new NorthwindIBEntities();
 
            //Attaches to customer to EntityManager 
            var newcust = dm.CreateEntity<Customer>();
            newcust.EntityAspect.AddToManager();
 
            var newcuststate = newcust.EntityAspect.EntityState; //Added
 
            //Order is NOT attached to an EntityManager
            var order = new Order();
 
            var nullem = order.EntityAspect.EntityManager;//null value
 
            var neworderstate = order.EntityAspect.EntityState; //Detached
 
            //Order is now Attached to the same EntityManager as Customer
            order.Customer = newcust;
 
         
            var afterorderstate = order.EntityAspect.EntityState; //Added
 
            var orderem = order.EntityAspect.EntityManager; //entitymanager is attached

 
 
CreateEntity<T> is similar
to New but because it is generic we can pass in types so we can write logic
that does not need to know the type.
 
 

 

Getting Started with DevForce

Start with this link:
 
C:\Users\Public\Documents\DevForce
2010\Learning Resources\_LRUI\BusinessObjectMapping.htm
 
You may want to start with building an Entity Framework Model,
most likely by Using
the EDM Designer with DevForce to create your model.
 
DevForce delegates to the
Entity Framework the mapping between object and relational database schemas.
 

http://msdn.microsoft.com/en-us/library/aa697427(VS.80).aspx

However, DevForce will manage
the Entities created in your model with its own class called the EntityManager (similar
to the EntityFramework’s Context).
 

The key components of DevForce
include:

the EntityManager, which includes a queryable client-side cache;

the Business Object Server (BOS) for services in a middle tier;

object mapping enhancements which extend the Entity Framework designer and generate DevForce entity code;

business object enhancements such as dynamic validation/verification, localization, object lifecycle events, binding support, and other extensions that simplify your code.

a provider for the LINQ language that permits LINQ queries to be used with both the client-side cache and remote data sources

To get a feel for DevForce
create your own Model and Application by following a Hello DevForce Walkthrough…
 

C:\Users\Public\Documents\DevForce
2010\Learning Resources\010_IntroToDevForce\Hello DevForce.pdf
 
Alternatively you can watch
the videos on the following page:
 

http://www.ideablade.com/Videos/DevForce2010DevelopersTour/index.html

These videos deal with
creating a Silverlight Project.
 
 
I would follow these simple projects by reading   Business Object Persistence concepts at  C:\Users\Public\Documents\DevForce 2010\Learning Resources\040_BusObjPersistence\Business Object Persistence.pdf 

and the Advanced Persistence at

C:\Users\Public\Documents\DevForce 2010\Learning Resources\040_BusObjPersistence\Business Object Persistence_Advanced.pdf 
 

DevForce Edmx and Connection Strings

An Ideablade config section must be found in an app.config.
(A default config is used if none is found and the default will not be
connected to your model). In WPF, the app.config can be in the same project as
the model and that project will be searched BEFORE the folder containing
the executing project. The connection string information includes the names of
the csdl, ssdl, msl and all of these names must match the name of the .edmx
file.
 
 

Caliburn: Creating your own IResult subclass

Tip1.

When creating a CompletedEventArgs if you set the Error property, Caliburn will expect to handle the Error with a Rescue Attributed Method.  If you don't implement such a method in the class that uses your IResult Caliburn will throw the error. This can cause a problem if you are wrapping a class that returns its own return object including the error and you expect to handle the error yourself. 

Eg..
 
 public
IEnumerable<IResult> Login()    
{
var loginresult = _reportingRepository.Login(new LoginCredential(Username,
Password, null));
yield return loginresult;

 //This
code will never be called because the login error is thrown by Caliburn
if (loginresult.LoginOperation.HasError)   
{   
ErrorMessage = loginresult.LoginOperation.Error.Message;    
}   
yield break;    
}

Using

[Rescue("LoginFailure")]
and 
public void LoginFailure(Exception e)
 
will handle the error.
 

Only set CompletedEventArgs.Error if you plan to implement a Rescue Method.

Tip2.

If an action is called (eg when bound to a Button Click
Command by Convention) and the Action returns a subclassed IEnumerable<IResult>)
the action will fail to execute and it will fail silently).

So always use an IResult not a subclass as the return value of your Action Method. 
 
 

Dependency Injection Component Registration

http://caliburn.codeplex.com/wikipage?title=Auto-Registering%20Components

Covers use of Singleton and PerRequest. Also explains
configuring framework with list of assemblies to look for components.
 
 

Caliburn Modules

To build a module inherit from ModuleBase, which is the default implementation of IModule.  When Caliburn initializes itself, it will search all assemblies registered through CaliburnApplication.SelectAssemblies or CaliburnFramework.Assemblies looking for implementors of IModule.

[This method will look for and register components with the UnityContainer where registration characteristics are noted via attributes. i.e. if you use Attributes on Classes for example identifying Singletons you will need to ensure that you override SelectAssemblies.]  Best Practice: retrieve classes from the service locator using Interfaces and not Class Types. The framework will fail if the implementation cannot be found. Contrast that to using a class which will resolve even if it has not been registered with the IOC. This can present problems if you use attributes on Classes that you expect the IOC to resolve.

The CaliburnFramework will call the IModule GetComponents method. This gives the module an opportunity to tell the framework what components should be registered with the IoC container.

Then, after Caliburn has finished initializing itself, it will cal the Initialize method on each module. This allows the module to do any custom startup logic. It is in this method that you might open screens, add to menus and do any procedural UI construction related to the module itself. 

 For dynamic modules, after loading/downloading the assembly, you need to resolve an instance of IAssemblySource from the IoC container. Add the dynamic assembly to the IAssemblySource. This will cause Caliburn to go through the same process as above for your dynamic module (asking it for components and then initializing). Caliburn does not currently prescribe how or from where these dynamic assemblies should be obtained.

Define an EntryPoint for your Module

-----

Building a Caliburn App: Useful links and tidbits

As I work with Caliburn I will make notes and refer to links that I find useful. The Caliburn V1.1 Documentation

is here http://caliburn.codeplex.com/documentation.  

As I build with V2.0 I will reference links I find useful which may or may not be in the V1.1 Documentation.

To create an application from the CaliburnApplication class (subclasses Application)

http://caliburn.codeplex.com/wikipage?title=Application&referringTitle=Documentation

....

Need to override SelectAssemblies to tell Caliburn where to search when looking to resolve conventions and ???