Archive

Posts Tagged ‘Smart-Client’

Generating a WPF Smart Client using the Smart Client Producer

October 22, 2012 Leave a comment

Hello!

In a previous posts, we showed you the output of the WPF Smart Client Producer. In this post we’ll show you how to generate a WPF smart client. It will be a WPF application consuming WCF services thanks to a proxy and the data will be stored in a database Smile.

Creating the solution

Start by creating a new CodeFluent Project. We’ll use the “ContactManager Sample Model” for the purpose of this article.ContactManagerModel

Add a new Class Library project named “ContactManager” to your solution. It will be used to host the generated files corresponding to your Business Object model and WCF service’s contracts. Add it a folder called “ServicesConfig” that will be used to store your WCF service’s configuration files.

Add a new Class Library project named “ContactManager.Proxy” to your solution. It will be used to host the generated files corresponding to the proxy.

Add a new SQL Server Database project named “ContactManager.Persistence” to your solution. It will be used to host your generated SQL scripts.

Add a new WPF application project named “ContactManager.SmartClient” to your solution. It will be used to host the generated files of your WPF application. Remove the MainWindow.xaml file since we are going to generate our own. Also, by default, Microsoft Visual Studio 2010 sets the target framework to .NET Framework 4 Client Profile. Go to the property of your project and change the target to .NET Framework 4 in order to use the standard libraries.

image

Adding the producers

The Business Object Model Producer

To generate your Business Objects model, add the Business Object Model Producer to your CodeFluent Entities project by clicking “Add new producer” on the “Producers” folder in Visual Studio’s Solution Explorer, expand the Business Layer Producers node and select it:

image

In the Target Directory field, select your Class Library project called ContactManager.

image

Click OK.

The SQL Server Producer

To generate your persistence scripts, add the SQL Server Producer (or the one that suits your configuration) to your CodeFluent Entities project by clicking “Add new producer” on the “Producers” folder in Visual Studio’s Solution Explorer, expand the Persistence Layer Producers node and select it:

image

In the Connection String field enter your connection string used to connect to your SQL Server. Also in the Target Directory field, select your SQL Server Database project called ContactManager.Persistence. Finally in the Target Version field, select your SQL Server version.

The Service Object Model Producer

To generate your WCF service and your proxy, add the Service Object Model Producer to your CodeFluent Entities project by clicking “Add new SubProducer” on your  “Business Object Model” producer in Visual Studio’s Solution Explorer, expand the Business Layer Producers node and select it:

image

In the Target Directory field, select your Class Library project called ContactManager.Proxy and click OK.

The Template Producer

Note: The Template producer is not mandatory. However, it is really handy if you want to be able to quickly run and test your WCF service using the CodeFluent Entities Hoster.

Lets now generate the configuration files of your WCF service. Add the Template Producer to your CodeFluent Entities project by clicking “Add new producer” on the “Producers” folder in Visual Studio’s Solution Explorer, expand the Utility Producers node and select it:

ScreenShot032

In the Source Directory field select the “Server” folder located at “CodeFluent Entities installation folder > Modeler >Templates > ServiceModel”. And in the Target Directory field, select the folder called ServicesConfig located in your Class Library project called ContactManager, then click OK.

The WPF Smart Client Producer

Then, to generate your WPF smart client, add the WPF Smart Client Producer to your CodeFluent Entities project by clicking “Add new producer” on the “Producers” folder in Visual Studio’s Solution Explorer, expand the Application Producers node and select it:

image

In the Target Directory field, select your WPF application project called ContactManager.SmartClient and click OK.

Generating code

Now to start generating code, build your CodeFluent Entities project called ContactManager.Model.

Here is the visual studio solution you should have by now, each project containing the generated code (your database should have been created too):

image

Building and running the application

At this stage, your application has been generated and is almost ready to be built and run. Since your WPF application uses the Proxy you need to add your Class Library project called ContactManager.Proxy as a reference to your WPF application project called ContactManager.SmartClient project.

Now you can build your solution, then run your WCF service as you usually do or thanks to the CodeFluent Entities Hoster using your generated service configuration files. Finally start your WPF application.

Tip: If you use the CodeFluent Entities Hoster, a quick and easy way to ensure the executable is automatically copied to the output directory is to add a reference to it. This is absolutely not required to compile your Business Object model (your Class Library called ContactManager), it’s just a shortcut to have the executable in the output directory without having to create post-build events.

And tadaaa! You’ve created your 100% functional WPF smart client without a single line of code!

SmartClient (1)

SmartClient (2)

Enjoy!

Thibault Nestor

CodeFluent Entities is not an ORM

March 20, 2012 1 comment

CodeFluent Entities is a unique product integrated into Visual Studio 2008/2010/vNext which allows you to generate components such as scripts (e.g. T-SQL, PL/SQL), code (e.g. C#, VB), web services (e.g. WCF, ASMX) and UIs (e.g. ASP.NET, SharePoint, WPF).

The code generation process is model-first and continuous: from your declarative model, a meta-model will be inferred which code generators will then translate into code. Over 20 code generators (a.k.a. “producers”) are provided “out of the box” and can be combined to create your own application following your desired architecture, using your desired technologies.

For instance, adding an instance of the SQL Server Producer to your project will translate your model into a database (schemas, tables, stored procedures, views, constraints, etc.):

Adding an instance of the Business Object Model Producer will translate your model into .NET classes (C# or VB.NET) consuming the persistence layer:

Adding a WCF Producer will generate WCF services, contracts and proxies exposing your .NET classes:

Adding a WPF Smart Client Producer will generate a WPF application consuming the WCF services thanks to the generated proxy:

And that’s just an example of what you can do: you can also build ASP.NET web sites, SharePoint apps, Windows Forms apps, Silverlight apps, etc.

Your application is layered following best practices, all its business logic is in the middle-tier (the Business Object Model generated by the Business Object Model producer), and supporting a new technology gets down to adding a new producer or creating screens on the generated code.

Last but not least, you can create your own producer which translates this inferred meta-model into what you need.

 

Cheers,

Carl Anderson

The Smart Client Object Model: Silverlight Support


We introduced the Smart Client Object Model in a previous post and we mentioned the fact that it could be used in both standard .NET apps as well as Silverlight apps. This is true thanks to Silverlight’s CoreCLR.

Starting from Silverlight 2, Silverlight ships a scaled version of the original .NET CLR named the CoreCLR. It basically is a stripped down version of the standard CLR, only containing what is needed to develop rich .NET internet applications. In a nutshell, the CoreCLR contains:

  • Most of the same Base Class Libraries as the ones provided in the standard CLR,
  • JIT,
  • Garbage Collector,
  • Security Model,
  • Exception Handling,
  • Loader & Binder,
  • Debugging APIs

Nevertheless, as you understood, not all .NET classes are available so to ensure that the generated Smart Client Object Model can be used by any Smart-Client including Silverlight ones you’ll need to reference the CodeFluent Silverlight Runtime (corresponding to your Silverlight version)which adds support for missing features required by the object model.

Furthermore, the runtime also adds a key feature which is the Silverlight Automatic Asynchronous Proxy (aka SLAAP). As you may know, the Silverlight programming model requires that all server calls cannot be issued from the UI thread and need to be asynchronous. As a consequence developers need to implement the IAsyncResult interface for all their server calls. Therefore, without using CodeFluent Entities, making a server call in Silverlight looks like something like this:

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
    MySampleService.CustomerCollectionClient client = new MySampleService.CustomerCollectionClient();
    client.LoadAllCompleted += new EventHandler(client_LoadAllCompleted);
    client.LoadAllAsync();
}

void client_LoadAllCompleted(object sender, MySampleService.LoadAllCompletedEventArgs e)
{
    listBox1.ItemsSource = e.Result;
}

Well using CodeFluent Entities and its generated Smart Client Object Model you don’t have to bother using the IAsyncResult interface anymore with those LoadAllAsync and LoadAllCompleted members, but simply call the LoadAll method as you would have done in a standard .NET application. However, since Silverlight requires that server calls should not be issued on the UI thread you need to run it on a background thread such as this:

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
    ThreadPool.QueueUserWorkItem(GetCustomers);
}

private void GetCustomers(object state)
{
    CustomerCollection customers = CustomerCollection.LoadAll();
    Dispatcher.BeginInvoke(() => listBox1.ItemsSource = customers);
}

Better, but still this implies that developers have to do the QueueUserWorkItem and BeginInvoke themselves. To remedy this, the runtimes actually include two handy extensions RunAsync and UpdateUI which actually take care of all this. This way loading business data using the Smart Client Object Model in Silverlight gets down to do the following:

private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
    this.RunAsync(() =>
    {
        // 1. business code
        CustomerCollection customers = CustomerCollection.LoadAll();

        this.UpdateUI(() =>
        {
            // 2. UI update code
            listBox1.ItemsSource = customers;
        });
    });
}

To sum-up, key points using the Smart Client Object Model in Silverlight are:

  • It’s the same object model for all smart clients,
  • this is possible mostly thanks to the runtimes which provide the missing features in the targeted CoreCLR (2, 3, 4),
  • furthermore the runtimes provide the Silverlight Automatic Asynchronous Proxy feature so you don’t have to bother with IAsyncResult anymore.

The Smart Client Object Model

May 27, 2011 2 comments

The Service Object Model Producer generates the communication layer between the server and a client side. It’s based on Windows Communication Foundation (WCF) and generates the needed services and contracts to expose your object model, as well as an enhanced proxy which allows us developers to create Smart-Clients without having to take care of all communication aspects.

This communication layer is absolutely standard WCF, so you can configure it as you wish using your desired addresses, bindings and configurations. Likewise, since the generated services and contracts are standard WCF services you don’t have to use the generated proxy, you could perfectly consume those web services using the Microsoft Visual Studio generated proxy.

However, the generated proxy is in fact a little more than a just a proxy. It’s in fact a remote version of the generated Business Object Model (BOM), and since it takes care of all communication aspects, it actually provides Smart-Client developers the same development experience as when developing a rich client: you’re manipulating Customers, Orders, Products, and not Channels, Endpoints and Factories, and that’s why we named it the Smart-Client Object Model (SCOM).

Using CodeFluent Entities, the Service Object Model Producer – with its generated services, contracts and Smart-Client Object Model – is the way to create Smart-Clients. Furthermore, the generated SCOM can also be used in Silverlight 2 and upper, so the same Smart-Client Object Model can be used for all your Smart-Clients whether they are standard .NET apps (Windows Forms, WPF, etc.) or Silverlight Apps.

scom_architecture_thumb

Want to know more? Here’s a set of links that might be of interest to you:

Modeler Overview

February 4, 2011 Leave a comment

Wondering how it goes to develop an application using CodeFluent Entities?

Check-out this video! Using the Modeler in Visual Studio 2010, you’ll see how to:

· Define entities,

· Define properties,

· Define enumerations,

· Collaborate,

· View the inferred Meta-Model (CodeFluent Entities is not template based generation!),

· Generate,

· Define instances,

· Generate continuously,

· Define methods,

· Add validation rules,

· Extend the generated code,

· Use the XML view,

· WPF Smart Client Producer,

· SharePoint Web Parts Producer,

· A custom ASP.NET MVC web site,

· Create a model from an existing application (Northwind).

 

Follow

Get every new post delivered to your Inbox.

Join 46 other followers