Eduardo Dias

Small Dependency Injection Framework with Lambda Expressions

Mon, 10 Dec 2012 19:22:18 GMT

Hi everyone, I was evaluating some frameworks for Dependency Injection for a given project here in the company. Frameworks such as Ninject and Unity are very good, but four needs, to 'big'. So we came up with a more 'minimalist' solution.

Based on the Service Locator pattern, we have create the following and quite small service registry:

public sealed class ServiceRegistry
{
    private static readonly Dictionary<Type, Func<Object>> Services = new Dictionary<Type, Func<object>>();

    public static T Resolve<T>() where T : class
    {
        var type = typeof (T);
        if (Services.ContainsKey(type))
            return Services[type]() as T;
        return default(T);
    }

    public static void Bind<T>(Func<T> expression) where T : class
    {
        var type = typeof (T);
        if (Services.ContainsKey(type))
            Services.Remove(type);
        Services.Add(type, expression);
    }
}

Using lambda expressions we can bind dynamic type resolvers for our interfaces with no problems and, if necessary, using runtime elements such as configuration parameters and session values.

So, how we use it? It is very simple and straight forward, we just need to bind the types in our application initialization and when required ask for the registry to resolve it (please see the following example):

protected void Application_Start()
{
    //Simple type binding
    ServiceRegistry.Bind<IEmailService>(() = new SmtpEmailService());

    //'Complex' binding using environment variables
    ServiceRegistry.Bind<IIdentityVerifier>(() => {
        var session = HttpContext.Current.Session;
        return new MockIdentityVerifier(session["current-user"]);
    });
}

The use would be as simple as:

//...
var identityVerifier = ServiceRegistry.Resolve<IIdentityVerifier>();
identityVerifier.Verify(user);
//...

I hope you all enjoy!

Thank you,

Eduardo

Introducing Native Query Filters for Running Objects

Fri, 07 Dec 2012 17:18:47 GMT

In my previous post we have discussed how to create queries and associate them to domain models. To create these queries, the developer can use Dynamic LINQ API using string values parameters (as shown below)

It is powerful and complete, but we still miss the power of the IntelliSense and the ability to compose an native query and after an good conversation with Noah Coad (@noahcoad), he asked me: Eduardo, why you don't implement native LINQ instead of Dynamic LINQ?

Well, we all know that, unfortunately, it's not possible to include lambda expressions to an Attribute. Considering this, I have implemented the native LINQ by using what I call "type delegation", where we just need to inform the type of the filter that it will be properly activated during the query execution.

Now we can create even more powerful queries using native LINQ and with no restrictions:

I hope you enjoy it and feel free to give your feedback! :)

See you!

Creating Multiple Queries for Running Objects

Mon, 24 Sep 2012 13:57:00 GMT

Running Objects combines the power of LINQ with Metadata definition to let you leverage multiples perspectives of your queries of objects. By default, RO brings all the objects in natural order of insertion and including all the visible properties of your class. In this post, we will understand how the QueryAttribute class is structured and how to make use of it.

The QueryAttribute class

This class is the responsible to specify all the possible perspectives of a list of objects. In other words, is using this attribute that you will be able to create different lists of the same class.

Property	Description
Id	A unique identifier associated to each Query, it is automatically generated in case of not being supplied.
Name	The label to be used in the UI and that will be used to describe the query in the class metadata model. If not specified, its value will be “All Items”.
Select	The list of properties being selected. The query will display properties in order of selection. Each property must be separated by a comma and with no spaces in between.
Where	Use common LINQ expressions to specify the criteria for your query. Running Objects makes use of Dynamic LINQ API, so you can use keywords such as it and also make use of regular parameters using the regular notation (@0, @1, @n).
OrderBy	The purpose of OrderBy is quite simple and straight forward, the only difference is that it contains a special notation (quite easy as well). You can specify multiple criteria of sorting separated by comma with no spaces. The order of sorting can be specified by the keywords Asc and Desc where you should have colon separating the property and direction (e.g.: PropertyName:Asc ).
Skip	The number of items to skip.
Take	The number of items to take.
Includes	An array with the name of properties that should being loaded.
Parameters	The values of parameters specified in the Where property.
IsDefault	Mark as true to define as the default query of the class. If multiple queries are marked as default, Running Objects will bring the first of them.
CacheDuration	Set the number of seconds you want to have this query being cached. Once its value is specified, the cache will automatically be activated.
Paging	Mark as true to enable paging for the given query.
PageSize	If you want to customize the number of items to be loaded, specify the value of PageSize property.

Using QueryAttribute

Using the class Director from our Movie Database example (accessible here), we can see how beneficial it can be.

This will result in two different filters in UI and also to be used by the RESTful service layer (we will discuss it later). The following images show the two queries being applied and rendered to the user.

All Items

All With Movies

Conclusion

I hope now you can improve even more your Running Objects application. If you have questions and/or suggestions leave a comment.

Take care!

Eduardo

Running Objects – Associations and Relationships

Wed, 05 Sep 2012 19:24:00 GMT

After the introduction to the Running Objects with the tutorial Movie Database in 2 Minutes (available here), I would like to demonstrate how Running Objects interprets the Associations where we will cover:

Direct Association – A reference to another complex object.
Aggregation – A collection of another complex object.

For those coming with a database perspective, by demonstrating these associations we will also exemplify the underline relationships such as 1 to Many and Many to Many relationships.

We will perform the following steps to accomplish our goal:

Creating the Application Project
Modeling our Domain Models
Implementing our Classes
Running the Objects ;)

Creating the Application Project

As in the Movie Database tutorial, the first step is to create a ASP.NET MVC 3 project and then select the Running Objects template as shown in the images below:

Create a new ASP.NET MVC 3 Web Application	Select the Running Objects project template

Modeling our Domain Models

Now that we have created the project we can start working in our model. To demonstrate how to use associations between classes with Running Objects we will create the class model as the following figure:

Movie Database Class Model

We can see that we have an aggregation of Movies in Category and an aggregation of Categories in Movie, it represents our Many-to-Many relationship. In the other side, we have a 1 to Many relationship through a direct association from Movie to Director and we also have an aggregation of Movies in Director.

Implementing our Classes

Now that we have designed our model, we need to implement the classes. Lets take a look at the source code and see how it is implemented.

Category	Director	Movie

Basically this is what you need to develop to get the application running. But as we are using Entity Framework as our repository, we need to create the Data Context class for it. It is very simple and straight forward, we just need to tell Entity Framework about our model.

Entity Framework Data Context

Now that we have developed everything we need, what is next? How to configure Running Objects to understand this model?

Well, we don’t need to do anything. The previous configuration from the tutorial Movie Database in 2 Minutes is enough to make RO to understand our model. But for highlighting purposes, let see how is the configuration for our project.

Running Objects Configuration

Running the Objects

Now, we just need to run the application. In the first run it will create the database (Entity Framework does it automatically) and consequently take more time to run, after that everything will be fast and fine.

The following screen demonstrate constructor of movie receiving a collection of Categories and one Director.

New Movie using Associations

Download the Source

The source code of our application is available here.

Conclusion

Running Objects handles associations naturally, it uses the principles of Object Orientation and the power of .NET reflection to instruct and understand our model. We will cover more topics in how to use RO in the next posts.

See you!

Eduardo

Movie Database in 2 Minutes with Running Objects

Fri, 31 Aug 2012 23:32:00 GMT

Demonstrating how to use Running Objects, we have published a tutorial in how to create a Movie Database, like the one from Stephen Walther, in just 2 minutes. The tutorial demonstrate how to create the application end-to-end.

You can access the tutorial in the following URL:

http://runningobjects.azurewebsites.net/p/movie-database-in-2-minutes

I hope you enjoy it!

Regards,

Eduardo

Introduction to Running Objects

Tue, 31 Jul 2012 19:50:00 GMT

In the last years, the fast and constant evolution of business requirements together with the high priority and short development schedule became the main problems for thousands of developers trying to tackle the challenge of deliver high quality applications in the shortest time possible. In the same time, we have several initiatives that try to support the development community and solve these problems.

Methodologies such as Scrum for project management with its iterative delivery; development approaches such as Domain-Driven Design that suggests to focus on the domain and its logic; patterns such as Model-View-Controller that supports the development isolating areas such as presentation and domain logic, coordinating them through a control layer and Service Oriented Architecture that aids the integration design of applications through the exposure of services are essential elements to achieve the existing software development requirements.

To fulfill these requirements and provide developers with a tool that supports the latest methodologies, patterns and architectures, enabling them to deliver the highest business value in the shortest time possible was born Running Objects.

What is Running Objects?

Running Objects is a framework that allows you to use simple OO concepts, focus on your business domain and do not waste time with areas that are not relevant to your application. You will build better software, with less time and with no pain.

It’s built on top of ASP.NET MVC using a refined mix of concepts such as Domain-Driven Design, Naked Objects, Object-Oriented UI and Design Patterns. Basically, everything that is necessary to let you aggregate the highest business value in the shortest time to your application.

What can it do for you?

Domain-Driven Development with Object-Oriented Modeling

Use the power of DDD and OO to develop your applications. Your OO design and model will be your application. You don't need to worry with developing Data Access Components and/or User Interface code. Keep the focus in your business requirements.

Test-Driven Development with ease

Making use of OO concepts, Running Objects let you create a clean code, ready for unit testing. You can ask "But do I need to do something else to create the unit tests”, we will answer "Yes, the unit tests”.

Automatic RESTful service generation

Expose your objects as REST services automatically. Running Objects follows the HATEOAS (Hypermedia as the Engine of Application State) REST constraint to generate the RESTful service layer of your objects.

Fluent Security Configuration

No more hassles configuring security of your application. Use the code based configuration to create high-coherent security settings. You will never have an out of date security configuration again!

Extensible User Interface

Running Objects provides a default set of views that automatically generates the user interface based on your objects. But if you want to customize them, feel free to take the control and create your own views, templates and mix them all!

Transparent Persistence

Using the Repository Pattern, Running Objects let you use the persistence you want! It has an Entity Framework Repository ready to use, so if you are using Entity Framework, it will be just 1 line of configuration to use it!

What are the next steps?

For more information about the Running Objects, please check it out the official website at http://runningobjects.com, take a look at the get started tutorial and download it! We are currently working in more blog posts, webcasts and tutorials, so stay tuned!