Archive

Archive for the ‘SoftFluent Products’ Category

Generating JSON web services from an existing database with CodeFluent Entities

February 6, 2013 Leave a comment

This article posted on CodeProject will show you how to generate a JSON base web service layer from an existing database using CodeFluent Entities. We will also generate a web client back office following an “Import wizard”.

A common scenario

 

Let us say that we are facing the following scenario:

  • We have a database that we want to expose via a JSON based web service layer, providing CRUD (Create, Read, Update and Delete) operations.
  • We also need to build a back office in order to manage and administrate the data coming from our database.
  • We may need, on a future, to access in a different way our database, for example from a Smart Client or expose a SOAP based web services layer (there are always new ideas).
  • We need to deploy this system as soon as possible.

Let us start, what we need to do is:

  • Build a data access layer capable to load data, create new data, update and delete existing data (and make sure it works).
  • Manage validation data (and make sure it works).
  • Build a JSON based web service layer:
    • Build every needed service contract and operations.
    • Configure our service contracts to support JSON.
    • Host our services.
    • Make sure it works
  • Build a web based client (and make sure it works).
  • Lay the foundations so any possible evolution and additional architecture can be supported including mobile access through different smartphone devices.
  • And everything I have missed.

    Or…. We can use CodeFluent Entities to do the plumbing and being sure that it works.

    In the starter wizard, we can see some of the possible built-in architectures that can be generated by CodeFluent Entities, and of course you can imagine your own architecture by creating a custom CodeFluent Entities project with your relevant set of producers.

    clip_image002

    The scenario we mention here is developed "step by step" in the full article on CodeProject

    SQL Azure producer now has its “Diff engine”!

    October 30, 2012 1 comment

    CodeFluent Entities provides an out-of-the-box SQL Azure producer. Using this producer you can generate SQL Azure scripts and automatically run them on your SQL Azure database.

    Although this producer enables you to work on a local SQL Server instance in order to benefit of the producer’s Diff Engine on the local instance, it was missing its own Diff Engine! Indeed, for each generation the producer was dropping tables before recreating them.

    This new build 686 brings to the SQL Azure Producer its own Diff Engine. It means that as of today, either using SQL Azure or SQL Server producer, you can continuously generate without loosing data.

    The SQL Azure producer’s property grid as been reorganized so the distinction between Local SQL server and Online SQL Azure properties is clearer. Besides, you’ll find a new property under the Online SQL Azure category called “Create Diffs” to enable or disable the SQL Azure Diff Engine. The Diff Engine is enable by default.

     

    azure

     

    Cheers,

    Thibault Nestor

    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

    User Interfaces generated by CodeFluent Entities using out-of-the-box producers

    October 16, 2012 2 comments

    Over the past articles we showed you how to use the following UI producers provided out of the box by CodeFluent Entities:

    · Windows Store producer

    · ASP.NET Web Forms Producer / AJAX/JSON

    · WPF Smart Client Producer

    · SharePoint Web Part Producer

    In this article I want to emphasize the fact that CodeFluent Entities is totally UI-agnostic. Indeed from the same and unique model you can generate screens that will be rendered in the targeted platforms of your choice. Here is for instance the list of all UI producers available:

    UI_Producer

    Let see all the user interfaces that CodeFluent Entities has been able to generate from the exact same model, using those different producers.

    Note that the generated applications are not just a set of user interfaces; they are actually complete interactive applications sharing the same business object model, database and are 100% functional.

    We used the “ContactManager Sample Model” supply by CodeFluent Entities:

    ContactManagerModel

    Here is the ContactManager model:

    ContactManagerSurface

    Since we’ve already seen how to use the producers provided by CodeFluent Entities in previous blog posts I’m going to skip their configurations and directly present you the generated UIs:

    UI generated using the Windows 8 Store Producer:

    The homepage generated by default lists all namespaces and their contained entities:

    Windows Store (1)

    Clicking on an entity gets you to the entity page.
    On this entity page you’ll find a screenshot of the entity from which this page was generated.

    Right Clicking on this page or typing Ctrl+Z will bring up a menu at the bottom where you’ll find the list of actions available on this entity. Those actions correspond in fact to business methods provided by the entity:

    Windows Store (2)

    Here is the screen displaying for the Contact entity when clicking on the “LoadAll” button and then selecting a contact:

    Windows Store (3)

    Bringing back the menu by hitting Ctrl+z or right clicking will enable you to create, edit or delete an entry:

    Windows Store (4)

    For instance, pushing the Edit button will give you the following screen:

    Windows Store (5)

    UI generated using the ASP .NET MVC Producer:

    The homepage generated by default lists all namespaces and their contained entities:

    ASP NET WebApp (1)

    Clicking on an entity gets you to the entity page.
    On this entity page you’ll find a screenshot of the entity from which this page was generated.

    On the left side of the page you’ll find a list of actions available on this entity. Those actions correspond to business methods provided by the entity:

    ASP NET WebApp (2)

    Here is the screen displaying for the Contact entity when clicking on the “LoadAll” button:
    It lists all the contacts through an HTML table and enables sorting.
    From it you can detail, edit or remove a contact.

    ASP NET WebApp (3)

    Clicking on the “Details” hyperlink will bring up the following screen:

    ASP NET WebApp (4)

    Clicking on the “Edit” hyperlink will enable you to edit the entry:

    ASP NET WebApp (5)

    UI generated using the ASP .NET AJAX Producer:

    The homepage generated by default lists all namespaces and their contained entities:

    ASP NET AJAX-JSON (1)

    Clicking on an entity gets you to the entity page.
    On this entity page you’ll find a screenshot of the entity from which this page was generated.

    On the left side of the page you’ll find a list of actions available on this entity. Those actions correspond to business methods provided by the entity:

    ASP NET AJAX-JSON (2)

    Here is the screen displaying for the Contact entity when clicking on the “LoadAll” button:
    It lists all the contacts through an Ajax grid supporting sorting and paging.
    From it you can detail, edit or remove a contact.

    ASP NET AJAX-JSON (3)

    And the one when clicking on the “Edit” button:

    ASP NET AJAX-JSON (4)

    UI generated using the ASP .NET WebForms Producer:

    The homepage generated by default lists all namespaces and their contained entities:

    ASP NET WebForms (1)

    Clicking on an entity gets you to the entity page.
    On this entity page you’ll find a screenshot of the entity from which this page was generated.

    On the left side of the page you’ll find a list of actions available on this entity. Those actions correspond to business methods provided by the entity:

    ASP NET WebForms (2)

    Here is the screen displaying for the Contact entity when clicking on the “LoadAll” button:
    It lists all the contacts through an HTML table and enables sorting.
    From it you can edit or remove a contact.

    ASP NET WebForms (3)

    And the one when clicking on the “Edit” button:

    ASP NET WebForms (4)

    UI generated using the Smart Client (WPF) Producer:

    The first screen generated by default lists all namespaces and their contained entities:

    SmartClient (1)

    Clicking on an entity will load all the data corresponding to it:
    From it you can create, edit or remove an entry.

    SmartClient (2)

    Clicking on an entry will open a window to edit it:

    SmartClient (3)

    UI generated using the SharePoint WebParts Producer:

    The homepage generated by default lists all namespaces:

    SharePoint (1)

    Clicking on a namespace lists all its entities:

    SharePoint (2)

    Clicking on an entity gets you to the entity page:
    It lists all the data of that entity through a Web Part.
    From it you can create a new entry, detail, edit or delete one.
    SharePoint (3)

    For instance, clicking on an entry brings up its details:

    SharePoint (4)

    and clicking on the “Edit” button brings up the editor:

    SharePoint (5)

    As you can see, from a same model we have generated several UIs all consistent with each other.

    Besides, thanks to the Platform Independent Form Editor you can also define forms directly on their entities which will then be translated into actual screens by user interface producers. We talked about it in details in this article.

    Finally, in the case you did not find the desired producer, I remind you that you can create your own template and use it with the Template Producer or you can even create your own custom producer. All you’ll need to do would be to implement the IProducer interface.

    To sum up, CodeFluent Entities is able to generate 100% functional applications with the UI of your choice just by using the right producer.

    Cheers,

    Thibault Nestor

    Using CodeFluent Entities with Microsoft Visual Studio Express

    October 15, 2012 Leave a comment

    Since 2005 Microsoft provides Visual Studio Express. This edition is a lightweight and free version of the Visual Studio product line. It is a great tool for users other than professional software developers. Unfortunately, it comes with some limitations that prevent CodeFluent Entities from being integrated to it. Indeed, Visual Studio Express does not support tool extensions. But don’t worry, CodeFluent Entities works perfectly as a standalone application too.

    When installing CodeFluent Entities you have the choice to install the Core Edition with or without the Modeler:

    1. The Core Edition refers to the CodeFluent Meta Compiler without Microsoft Visual Studio integration.
    2. The Modeler Edition refers to the edition shipping the CodeFluent Meta Compiler as well as the CodeFluent Entities Modeler which is a designer integrated into Microsoft Visual Studio.

    Working with Visual Studio Express you’d rather choose to install the Core Edition only. You’ll have access to the CodeFluent Meta Compiler which can be invoked by command line to generate ready to use components from a CodeFluent model. CodeFluent models are just plain-old XML files that you can create or edit with the editor of your choice such as your Visual Studio Express or with the Portable Modeler. The Portable Modeler is a standalone application which is the perfect tool for users working with Visual Studio Express (or without Visual Studio) who wish to get a graphical representation of a model.

    Here is an example that shows a CodeFluent model and how to use the meta compiler:

    A Model that defines a Customer entity, and the Microsoft SQL Server Producer as well as the Business Object Model Producer:

    <!-- Sample.xml -->
    <cf:project xmlns:cf="http://www.softfluent.com/codefluent/2005/1"
                defaultNamespace="Sample"
                defaultKeyPropertyTypeName="int"
                defaultConnectionString="server=(local)\SQLEXPRESS;
    database={1};Integrated Security=true">
        <!-- Microsoft SQL Server Producer -->
        <cf:producer typeName="CodeFluent.Producers.SqlServer.SqlServerProducer, 
    CodeFluent.Producers.SqlServer">
            <configuration targetDirectory="..\Generated\Sql" />
        </cf:producer>
        <!-- Business Object Model Producer -->
        <cf:producer typeName="CodeFluent.Producers.CodeDom.CodeDomProducer, 
    CodeFluent.Producers.CodeDom">
            <configuration targetDirectory="..\Generated\Model" 
    outputName="{0}.dll" />
        </cf:producer>
        <!-- Entities -->
        <Customer>
            <Id typeName="int" />
            <FirstName typeName="string" />
            <LastName typeName="string" />
        </Customer>
    </cf:project>

    The content of a Generate.bat batch file to launch CodeFluent.Build.exe:

    call "%ProgramFiles%\SoftFluent\CodeFluent\Current\CodeFluent.Build.exe" Sample.xml

    The command line including cfvars.bat set some environment variables needed by the meta compiler. I invite you to read the documentation here to learn more about the meta compiler.

    In addition, CodeFluent Entities is shipped with other sweet tools located in your installation directory:

      • The Importer (CodeFluent.Import.exe) that allows you to create a CodeFluent Entities model starting from an existing database or model.
      • The Meta Model Explorer (CodeFluent.View.exe) that provides a user interface to load a model and explore the inferred model.

    MetaModelExplorer

      • The Portable Modeler (CodeFluent.Portable.exe) which is a standalone version of the Visual Studio Integrated Modeler!

    PortableModeler

    To sum up, even though Visual Studio Express does not support extension tools such as CodeFluent Entities, you can still use CodeFluent Entities as a standalone application and still benefit of the power of command lines or user interfaces to create your CodeFluent model and generate your components.

    Note: if you can’t find the Core Edition of CodeFluent Entities, it’s because the download is not directly available since june 2012. So if you really need it, please contact our support at support@softfluent.com :-)

    Cheers,

    Thibault Nestor

    CodeFluent Service Host

    October 11, 2012 1 comment

    CodeFluent Entities is shipped with a very handy tool called the CodeFluent Service Host.

    CodeFluent Service Host is a command line tool that enables you to easily host Windows services as well as Windows Communication Foundation (WCF) services. It takes care of all the plumbing: service registration, start, stop, multi threading, log and so on… It supports CodeFluent Generated services as well as other manually coded services.

    Another sweet thing about it is that you can either use it in Console mode as well as in Windows Service mode. As a developer I found the Console mode very convenient since it allows me to quickly test my own services without having to install/uninstall them after each modification. Besides, you can print your traces and exceptions directly on the console! It also embeds a special out-of-the-box WCF exception handler that is capable of displaying WCF server errors without using any other external tool like the Service Trace Viewer.

    The CodeFluent.Runtime.ServiceHost.exe can be found in your CodeFluent Entities installation directory. In order to work it needs only the following:

    • The hosted assembly containing the service(s) and its referenced assemblies
    • A standard .NET configuration file indicating the host which service to host.
      Note that if you use the Service Object Model Producer (provided out-of-the-box by CodeFluent Entities) to generate your services, it will automatically create the configuration file needed by CodeFluent Service Host. Thus to start your service in Console mode you’ll just have to run CodeFluent.Runtime.ServiceHost.exe.
      Here is an example of how to use CodeFluent Service Host in Windows Service Mode:

    First we need to install the service. Here is the content of the InstallService.bat that will do it for us (This batch file can also be generated by the Service Object Model Producer):

    CodeFluent.Runtime.ServiceHost.exe /i /name:MyServiceName 
    /displayName:MyServiceDisplayName 
    /description:"This service is a WCF services host"

    Running the batch file will install your service. Then you’ll be able to manage your service as any other windows services thanks to the Windows Administration Services console:

    CodeFluent Service Hoster - Windows Service

    More info in the documentation can be found here.

    Note in the latest builds, CodeFluent Service Host is available in 4 editions:

    • CodeFluent.ServiceHost.exe 32-bit (CLR2)
    • CodeFluent.ServiceHost4.exe 32-bit (CLR4)
    • CodeFluent.ServiceHost.exe 64-bit (CLR2)
    • CodeFluent.ServiceHost4.exe 64-bit (CLR4)

    Of course, if you use a .config file, it will have to follow the .exe name, sor for the CLR4 versions, the config file will have to be named CodeFluent.ServiceHost4.exe.config.

    Cheers,

    Thibault Nestor

    Introducing the CodeFluent Entities Windows Store producer

    October 4, 2012 4 comments

    In this article, we’ll see how to use the brand new CodeFluent Entities “Windows Store” producer.

    We’re going to create a complete back-end application that will host web services exposing data which will be consumed by a Windows Store application.

    I will use an existing model provided out-of-the-box by CodeFluent Entities for this demo, namely the “ContactManager” model.

    Creating the solution

    Since my Windows Store application is going to consume web services, I’ll need to do some work before I can add the “Windows Store” producer.

    First, I’ll add two projects to my solution, a standard C# class library project and an empty Web Application project. My class library project will contain the CodeFluent Entities generated business entity classes, SQL scripts and WCF services. Here is what I will do for this:

    · Add the “Business Object Model” producer, make it point to my class library project;

    · Add a “Service Object Model” sub-producer to this producer. For this sub-producer I’ll specify “Enable JSON” as “JSON options” and I don’t want to produce a proxy so I’ll set the “Produce Proxy” property to “False”;

    · Create a new folder named “Scripts” to my class library project which will contain my generated SQL scripts to generate my database. Note we could also create a specific “SQL Server Database” project to hold these files;

    · Add a new persistence “SQL Server” producer, and set its target directory to the “Scripts” folder we’ve just created;

    · Now, my empty web application project will host my standard WCF .svc files. To quickly generate these, I will add an instance of the “Template” producer (Add new producer > “Utility Producers” > Template). Since I want to generate JSON, I’ll specify for the “Source Directory” the “Services” folder located at “CodeFluent Entities installation folder > Modeler >Templates > ServiceModel > JsonWebServices > Services” and for the “Target Directory” my empty web application folder.

    Adding the Windows Store project

    I’ll now add a new Windows Store Visual Studio project, a JavaScript Grid App project. Note: this is the only project type supported by the CodeFluent Entities Windows Store producer for the moment. This is pretty much what we have to do regarding the Windows Store project.

    Adding the Windows Store producer

    Now that our standard Windows Store project is added, I’ll need to add an instance of the brand new CodeFluent Entities Windows Store producer to my model:

    Screenshot (11)

    Screenshot (12)

    Since the Windows Store application will consume the web services that will be generated, I’ll need to reference the “Server Url“ in the Windows Store producer configuration. In this case, the “Server Url” is the URL of the web application I added earlier: http://localhost:49774/ (Please adapt to your settings). I’ll also set the “Base Services Url” to http://localhost:49774/Services.

    Then I’ll set the “Target Directory“ property to point to the Windows Store project folder I added and leave other properties to their default values according to the screenshot below.

    Screenshot (8)

    I’m now ready to build all that!

    Generating the code and launch the app

    To generate, as usual, I’ll right click on my CodeFluent Entities project and hit ‘Build’.

    Note: you may get back a CodeFluent Entities CF3708 error while trying to generate. It means the project attribute ‘createDefaultMethodForms’ is set to false. To set it to True, go to your CodeFluent Entities project properties, find the attribute in the ‘UI’ section, and set it to True. Starting with build 1.0.61003.684, the ‘createDefaultMethodForms’ attribute is set to True by default, on new projects.

    Now that all our layers are generated, I’ll need to specify on my solution properties that I want multiple startup projects.

    So I’ll set as first startup project my web application project which host my services and as second startup project my Windows Store application project like this:

    Screenshot (13)

    Now let’s hit ‘F5’ to run my projects and voilà! Here is my complete Windows Store connected application consuming my WCF/JSON web services, without a single line of code!

    Screenshot (5)Screenshot (6)Screenshot (7)

    Cheers,

    Aymeric ROLAND.

    The CodeFluent Entities Portable Modeler

    September 11, 2012 1 comment

    CodeFluent Entities has always included out-of-the-box a nifty little tool called the “Portable Modeler”. It’s a standalone CodeFluent Entities modeler application, not dependent on anything but the CodeFluent Entities product binaries. It means it’s not dependent on Visual Studio, but still allows to create, modify and save a CodeFluent Entities model:

    It exists as an .exe file located in the installation directory, appropriately named “CodeFluent.Modeler.Portable.exe”. Note the product setup does not install a shortcut on it so you’ll have to create one by yourself, and point to it:

    When you run it, it will just display a standard windowed application with Open, Save, etc. menu:

    You can start a New CodeFluent Entities project from scratch (“New”), you can import an existing database (“Import”), or open an existing model (“Open”). Note the “Open” command also supports Visual Studio .cfxproj  (the file type of a CodeFluent Entities Model when integrated Visual Studio). If you open an existing CodeFluent Entities model and just see a white panel like this…:

    … don’t panic :-) It just means there is no design surface defined for this model, and we don’t do this automatically for you (it requires a model change as a design surface is also a CodeFluent Entities model concept, just like the others), so you can add one like this:

    Give this new design surface a name (here I chose ‘def’), press ok on the New Surface dialog box, and then you should this something like this (depending on your surface rendering settings, here I’m using the ‘metro’ style):

    That’s it! Now you have access to the modeler ribbon we all love (it’s – almost – the same as the one in Visual Studio), there is also a right-click menu, and a property grid. Design surfaces are displayed as a list of Tabs (we can see the ‘Def’ tab above).

    Note this tool is not officially supported – beyond a best effort move as usual :-), but very practical for example if you want to give non-developer users the ability to open, view, and possibly change a model, as it does not requires Visual Studio to run. Of course, it lacks some features, notably source control, the cool solution wizards, and a solution explorer-like tree view.

    Introducing CodeFluent Entities PostgreSQL Producer

    August 20, 2012 Leave a comment

    CodeFluent Entities 2012 – Build 060809 introduced a new Persistence layer producer: the PostgreSQL Producer!

    The producer supports PostgreSQL 8.4 and above (8.3 is soon to be discontinued) and relies on the ADO.NET data provider Npgsql 2.0.11. The producer will try to load dynamically the Npgsql assembly. (You might need to copy the Npgsql.dll and Mono.Security.dll in your CodeFluent Entities installation directory if you don’t want to register Npgsql in the GAC).

    Please also note the PostgreSQL Producer also requires the liboss-uuid library to be installed on your server. On Windows, this library is shipped with the standard Windows packages of PostgreSQL 8.4+, and on Unix/Linux, you may need to install the postgresql-contrib package and its dependencies like libossp-uuid16, for the producer to be able to deploy the generated script on your server.

    Getting started

    The producer is available in the Persistence Layer Producers section of the Add New Producer window:

    as well as directly from the Starter Wizard:

    This is how you can set the connection string (in the Wizard pages):

    A first model

    I created a new project with the Start Wizard and design this very simple two-entity model:

    Basically all the employees have a first name, a last name, a birth date, and a job. Each job has salary – of type currency, a name and employees. I added two instances to the model: an employee named John Doe, born on June 12th, 1974 with a job named CEO and which salary is 30,000.

    I just set the Target Version of the PostgreSQL Producer to version 9.0 which the version I am currently running on my computer, and built the project.In the output window I can see the result of the generation process; the PostgreSQL producer generated 11 files and succeeded:

    All the automatically generated .SQL script files are available in the Persistence project of the solution:

    If I connect to my database with an administration tool I can see that a new database has been created with the named I specified in the Connection String, and populated with my model and instances:

    And I haven’t written a line of code yet!

    Consuming the generated persistence layer

    Consuming the PostgreSQL generated database is as easy as configuring the right connection string in the client project. In my case I created a Console Application Project named MyCompany.Management.Client.

    To prepare it, I had to reference my BOM Project – in my case MyCompany.Management – that was automatically created by the Starter Wizard, Npgsql.dll and CodeFluent Entities runtime, i.e. CodeFluent.Runtime.dll and CodeFluent.Runtime.PostgreSQL.dll. Note that you might need to set the Copy Local property to True for the Npgsql.dll reference if the dll is not registered in the GAC.

    I also had to change the target framework of the project from .NET Framework 4.0 Client Profile to the full .NET Framework 4.0.

    As I am using the PostgreSQL Producer I have to set the correct Connection String in App.config file:

    <?xml version="1.0"?>
    <configuration>
      <configSections>
        <section name="MyCompany.Management" type="CodeFluent.Runtime.CodeFluentConfigurationSectionHandler, CodeFluent.Runtime" />
      </configSections>
      <MyCompany.Management persistenceTypeName="PostgreSQL" connectionString="Server=localhost;Database=MyCompany_Management;User Id=postgres;Pwd=password" />
    </configuration>

    Note it is important to specify the persistenceTypeName=“PostgreSQL” attribute.

    Here is now the code of my console application :

    using System;
    namespace MyCompany.Management.Client
    {
      class Program
      {
        static void Main(string[] args)
        {
          // Create a new employee
          Employee newbie = new Employee();
          newbie.FirstName = "Jane";
          newbie.LastName = "Doe";
          newbie.BirthDate = new DateTime(1990, 01, 15);
    
          // Persist Jane Doe
          newbie.Save();
    
          // Load all the employees
          EmployeeCollection employees = EmployeeCollection.LoadAll();
          foreach (Employee employee in employees)
          {
            Console.Write("- {0} {1}, born on {2:MM-dd-yyyy}",
              employee.FirstName,
              employee.LastName,
              employee.BirthDate);
    
            if (employee.Job != null)
            {
              Console.Write(", is {0} with a salary of {1:C}",
                employee.Job.Name,
                employee.Job.Salary);
            }
    
            Console.WriteLine();
          }
        }
      }
    }

    It creates a new employee, saves it, and then loads a list of all the employees. As we can see, there is no specific code about PostgreSQL. Its use is completely transparent at this level.

    And here is the result:

    And the populated table:

    Happy PostgreSQL-ing!

    Baudouin Giard

    CodeFluent Entities Summer Contest

    August 7, 2012 Leave a comment

     

    You are a developer? A blogger? If so, you may have chance to win one of the packages given away by SoftFluent!

    So what’s the catch?

    The only thing you have to do is to share your opinion through an article on your blog or on a public platform.

    What an easy way to win some money!

    The deadline for the contest is the 31st of August. So why are you still reading rather than clicking the following link to get more information!

    http://www.softfluent.com/community-support/codefluent-entities/summer-2012-blogger-contest

    Follow

    Get every new post delivered to your Inbox.

    Join 49 other followers