Archive

Archive for the ‘News’ Category

What’s new with CodeFluent Entities 769?

April 7, 2014 Leave a comment

As with any previous release, CodeFluent Entities 769 includes numerous new features and bug fixes.

Keeping ahead with the latest technologies is our priority and we are extremely thrilled to announce that CodeFluent Entities now supports Microsoft SQL Server 2014.

Since the beginning of the year, CodeFluent Entities offers a new licensing model. You can try CodeFluent Entities by downloading the 30-day trial version which is unlimited in features and model size. The tool is also available in four registred editions: Personal (free for non-commercial use and limited to 50 entities), Professional, Enterprise and Ultimate.

But what else?

JsonUtilities

We made some greats improvements to the JsonUtilities:

Pretty-print Json

string json = @"{""name"": ""John Doe"",""age"": 35}";
var obj = JsonUtilities.Deserialize(json);
JsonUtilities.WriteFormatted(Console.Out, obj);

Will output:

{
  "name": "John Doe",
  "age": 35
}

Deserialization

JsonUtilities now supports XmlAttribute:

string json = @"{""name"": ""John Doe"",""age"": 35}";
var person = JsonUtilities.Deserialize<Person>(json, 
                 JsonSerializationOptions.UseXmlAttribute);

public class Person
{
    [XmlAttribute("name")]
    public string Name { get; set; }
 
    [XmlAttribute("age")]
    public int Age { get; set; }
}

We also added some automatic conversions between types. For example you can deserialize json to a Dictionary<string, decimal>. Values will be converted to decimal if possible. Internally this will use the ConvertUtilities class which I hope you are already using.

Relation UX improvements

We introduce a new ribbon item named Add relation. Of course the concept of relation already exists in the product, but we constantly strive to improve our product. Now there is an item in the ribbon to add a relation. The new form allows to select entities and properties and even create a new property if needed:

Add relations

When you don’t know which option to select (one-to-one, one-to-many, many-to-one or many-to-many) to define the type of relation, just read the description:

Relation Type

In this example, only the second sentence (one Customer has many Orders) is logical. If none of them seem valid, it may indicate that properties are badly named.

Microsoft SQL Server 2014 support

The SQL Server Producer now supports Microsoft SQL Server 2014. Christmas comes early for CodeFluent Entities users :).

SQL Server 2014

A new way to Activate

Last but not least, we provide a new screen to activate the product. With this new form, you can get your license key by connecting to your account directly in Microsoft Visual Studio:

Registered edition

If you are not a current customer, you can always download our free evaluation and see it in action.

Remember that you can follow the latest new features and bug fixes of CodeFluent Entities subscribing to this RSS Feed.

If you have any questions or comments, feel free to share them below.

Happy downloading!

The R&D Team

And the winner is…

February 27, 2014 Leave a comment

In a previous post, we talked about the The CodeFluent Entities Quiz and we asked three questions about basic features.

More than 60% of particpants answered 3 questions correctly. It wasn’t that difficult. :)

Quiz CodeFluent Entities

Here are the answers:

Question 1 : What are the databases supported by CodeFluent Entities?

  • Microsoft SQL Server
  • Microsoft SQL Azure
  • Oracle
  • MySQL
  • PostgreSQL
  • All those mentionned

Question 2 : How can we create Web service with CodeFluent Entities?

  • Creating a T4 template
  • Adding a producer
  • Handwriting

Question 3 : What is the continuous generation?

  • Apply model changes consistently to all layers without losing changes nor data
  • Generate the model in background each time the model is edited
  • The generation process never stop and use 100% of the CPU

Additional Information and References :

PostgreSQL Producer
MySQL Producer
Oracle Database Producer
Microsoft SQL Azure Producer
Microsoft SQL Server Producer
Documentation – Generating
Service Object Model Producer
Generating JSON Web Services from an Existing Database with CodeFluent Entities (Code Project)
Continuous generation (video)

The final draw took place on Febrary 26th, 2014 and the prize was awarded to Guillaume Spera.

Congratulations!

CodeFluent Entities and Visual Studio 2013

November 12, 2013 Leave a comment

Good news: Visual Studio 2013 is now available for download and CodeFluent Entities latest build (61214.761) runs great on it!

CFE-VS2013

You can learn the new features of Visual Studio 2013 here:

The Visual Studio 2013 download includes the .NET framework 4.5.1. If you have not seen it yet, you can read about the framework here:

On November 13th, do not miss the Visual Studio 2013 Virtual Launch.  You will discover the breadth and depth of new features and capabilities in the Visual Studio 2013 release.

Note that you can download the latest version of CodeFluent Entities here, or update your version using the Licensing tool.

Remember that you can follow the latest new features and bug fixes of CodeFluent Entities subscribing to this RSS.

Enjoy! :-)
Sabrina Pereira

Categories: News Tags: ,

CodeFluent Entities and Visual Studio 2013 preview


As announced on the //Build/ 2013 event, the Visual Studio 2013 preview is available for download.

Visual Studio 2013 preview sign in

Visual Studio 2013 preview sign in

 

Visual Studio 2013 home page

Visual Studio 2013 home page

You can discover the new features of Visual Studio 2013 here:

The Visual Studio 2013 download includes the .NET framework 4.5.1 preview, so this is the opportunity to discover it:

Finally, the CodeFluent Entities latest build (61214.714) is compatible with the Visual Studio 2013 preview version.

CodeFluent Entities and Visual Studio 2013 preview

CodeFluent Entities and Visual Studio 2013 preview

You can download the latest version of CodeFluent Entities here, or update your version using the Licensing tool.

Remember that you can follow the latest new features and bug fixes of CodeFluent Entities subscribing to this RSS.

So you can start playing around :)

And if you missed the //Build/ 2013:

Regards,

Pablo Fernandez Duran

Navigate To… is now supported by CodeFluent Entities

February 13, 2013 Leave a comment

 
I don’t know you, but one of my favorite (and useful) commands in Visual Studio is the “Navigate to…” command (VS 2010 or higher), Menu->Edit->Navigate to… Or Ctrl+, (coma). This is one of my top most used commands in Visual Studio.
 

The Navigate To Command

The Navigate To Command


 
I find very useful to find all kind of custom symbols (classes, enums, attributes, properties, methods, events…) within my Visual Studio solution.
 
Once you have made a search, a list of results is displayed. At the left of each result you can see an icon that represents the type of the matched item (class, property, method…), you can find the entire list of icons here.
 
I have seen other kind of techniques to perform a symbol search. For example, some people do a simple search (string search) at the solution (or project) level Edit->Find and Replace->Find in Files or (Ctrl+Shift+F).
 
Find And Replace Command

Find And Replace Command


 
This works fine but it would not be as accurate as the “Navigate to…” search. Indeed, a global search will also search in string definitions, encapsulated variables and within all kind of files (if the file type has not been specified).
 
Find And Replace Results

Find And Replace Results


 
Well, good news every one! Now the CodeFluent Entities model (Designer Surface and XML representation) is integrated in to the “Navigate to…” search results.
 
Navigate To Results with CodeFluent Entities integration

Navigate To Results with CodeFluent Entities integration


 
Is not that great? On the search results we can distinguish the CodeFluent Entities concepts like Entities, Properties, Relations and even Instances. You can easily identify the CodeFluent Entities related concepts by the suffix [of Entity ‘EntityName’].
 
You may only want to search within the CodeFluent Entities concepts, well this is possible by typing “_cfe ” before the search term. For example, if I type “_cfe Artist” I will only get CodeFluent Entities results.
 
Searching only within CodeFluent Entities concepts

Searching only within CodeFluent Entities concepts


 
You can even search for entities instances. Imagine I have in my model an instance of type “Artist” called “The Police” (value of the Name property), if I type “The Police” in the “Navigate to…” window I will also get results related to the instances in my model matching this term.
 
Searching for instances

Searching for instances


 
Finally, when you choose to navigate to a search result, a nice zoom effect will take you directly to the related entity on the CodeFluent Entities Modeler Designer.
 
Navigating to the Result

Navigating to the Result


 

Hint: if you press “Shift” when navigating to a search result (OK button or Enter key) you go directly to the XML definition (CodeFluent Entities parts).

 

Navigation to the XML definition

Navigation to the XML definition


 

This feature is available since build number (1.0.61214.701), you can download the latest version here or find some information on how to update your CodeFluent Entities version in this post.

 
If you want to know more about the navigation in the modeler you may appreciate this post.
 
I know you will find this feature useful.
 
Regards.
 
Pablo Fernandez Duran

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

    Count and Delete methods now supported by Event Rules

    November 20, 2012 Leave a comment

    Event rules are triggered upon a lifecycle event of a CodeFluent Entities concept allowing the developer to plug himself in the lifecycle (e.g. before saving an entity, or before the validation step) of an entity to extend its behavior. Event rules can be applied on the following three concepts:

    1. On entities,
    2. On properties,
    3. On methods.
      The third one (On Methods) contains three event rule types:
    • OnAddParameters
    • OnAfter
    • OnBefore
      Until today the Count and Delete methods were not supported by Method event rules. This post is meant to let you know that as of today Delete and Count methods can be used with event rules.

    More information on Event rules in the documentation.

    Cheers,

    Thibault NESTOR

    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

    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

    The Method Editor got better

    October 12, 2012 Leave a comment

    Since the build 682 the Method Editor has been improved. Indeed, instead of having a single window where all method types were mixed up we now have a new window that breaks them down by types:

    image

    If your are not familiar with the Method concept of CodeFluent Entities yet, then I invite you to read about it in the documentation.

    As you can see, you can choose the method type you want:

    • CFQL
    • Snippet with method signature
    • Snippet without method signature.

    Selecting the CFQL method type will bring up the CFQL Method Editor:

    This editor provides intellisense as well as error recognition.

    ScreenShot015

    ScreenShot016

    It will also automatically switch to the RAW edit mode when necessary, letting you select the raw body language of your choice.

    ScreenShot008

    ScreenShot018

    ScreenShot019

    Selecting the Snippet with method signature’s method type, will ask you to choose the class that will use the snippet: the entity or the collection.

    ScreenShot022

    Clicking OK will bring up the Snippet Method Editor:

    It enables you to choose the language of your choice to write your snippet.

    ScreenShot020

    As for the Snippet with signature method type, selecting the Snippet without method signature’s method type, will also ask you to choose the class that will use the snippet: the entity or the collection.

    ScreenShot023

    Clicking OK will bring up the same Snippet Method Editor you’ve just seen.

    This Method Editor is clearer and we hope it helps to make your developer life easier.

    Cheers

    Thibault Nestor

    Follow

    Get every new post delivered to your Inbox.

    Join 41 other followers