Then, we create a single master class that implements all interfaces, so its methods can simply return the this instance. That way, we not only concentrate the API logic in a single class, but we also avoid multiple object instantiations in a single chain. This alternative design still gives the benefits of a fluent API, assuming the master class is not visible to the user. A relationship, in the context of databases, is a situation that exists between two relational database tables, when one table has a foreign key that references the primary key of the other table. When working with Code First, you define your model by defining your domain CLR classes. By default, the Entity Framework uses the Code First conventions to map your classes to the database schema.

fluent api

Here I am using StringBuilder to store the actual string content of the dockerfile and the setters are essentially just adding content to this string builder. As you can see, my constructor is private which initializes a new object and I have a factory method that returns a new object. Besides the brute enforcement of a protocol, a fluent API also integrates neatly with certain IDE services. Auto-completion is a common IDE feature that suggests possible code continuations.

This post will introduce these Fluent APIs, share some common benefits and pitfalls of using such an API and a short tutorial on how to design such a class yourself. Here you can see that every function returns the existing class in order to create a Fluent API chain. However, the final function “GetData” returns the main expected value. In this article we will look at creating a Fluent API class in C#.NET. In a Fluent API, we can link together different functionalities to get a particular result. We see this used many times in Entity Framework Core and when manipulating List type of items using lambda expressions.

Fluent API: Practice and Theory

It also contradicts the “fail-fast” approach for error protection. In the Java Swing API, the LayoutManager interface defines how Container objects can have controlled Component placement. Learn from the Best One of the more powerful LayoutManager implementations is the GridBagLayout class which requires the use of the GridBagConstraints class to specify how layout control occurs.

fluent api

The Fluent Interface pattern is useful when you want to provide an easy readable, flowing API. Those interfaces tend to mimic domain specific languages, so they can nearly be read as human languages. When columns must have values you can mark those columns as NOT NULL. Entity Framework code first should configure such properties with the IsRequired()method. If application Net Developer ASP Net MVC Developer Azure, Entity Framework FJS-C-CB-NI tries to insert/update record with NULL values Entity Framework throws DbEntityValidationException. Probably the most important thing to notice about this style is that the intent is to do something along the lines of an internalDomainSpecificLanguage. Indeed this is why we chose the term ‘fluent’ to describe it, in many ways the two terms are synonyms.


We also show the applicability of fluent APIs to domain-specific languages. You can see when the database is generated, the table and columns name are created as specified in the above code. Below are the Student and Enrollment which has one-to-many relationship, but the foreign key in Enrollment table is not following the default Code First conventions. So rather than going into the domain classes to add these configurations, we can do this inside of the context. Override the OnModelCreating method and use a parameter modelBuilder of type ModelBuilder to configure domain classes, as shown below.

fluent api

These classes are then added to the DbModelBuilder’s configuration in the OnModelCreating method. Prior to version 2.0 of Entity Framework Core, there was no equivalent to this approach and one had to roll one’s own solution. In the above example, the HasRequired method specifies that the Student navigation property must be Null. So you must assign Student with Enrollment entity every time you add or update Enrollment. To handle this we need to use HasOptional method instead of HasRequired method.

You can refer to this link to the repo containing the full code for this class. This would let the object either call the same methods again or use the WithCommand method to short circuit and get out of the loop. Here each method would be returning the same object and at last the GenerateDockerFile() would return the text content of the docker file. If you want to see the final result, you can check this repo containing all the code that we are going to write. The intention of designing a ‘fluent’ API is to produce an API that is readable and flows.

The price of this fluency is more effort, both in thinking and in the API construction itself. The simple API of constructor, setter, and addition methods is much easier to write. After representing the protocol with an FSM, we can directly implement it in a fluent API. We turn every state into a class, and each edge into a method; given an edge labeled f from state X to state Y, we add method f() to class X and give the method the return type Y. To every accepting state, we also add terminating methods (build()).

Fluent API Configurations in EF 6

Unfortunately, the fluent API implementation may end up messy and unmaintainable, because it is composed of multiple classes. If two FSM edges have the same label, then we have to encode them as identical methods in two different API classes. Also, as fluent methods may not return the class they are contained in, they have to instantiate a new object, and pass it any intermediate data collected in the chain. Both of these problems can be solved by encoding fluent API states as interfaces, rather than classes.

In Python, returning self in the instance method is one way to implement the fluent pattern. In Raku, there are many approaches, but one of the simplest is to declare attributes as read/write and use the given keyword. The type annotations are optional, but the native gradual typing makes it much safer to write directly to public attributes. A common use of the fluent interface in C++ is the standard iostream, which chains overloaded operators. C# uses fluent programming extensively in LINQ to build queries using “standard query operators”. The following table lists important methods for each type of configuration.

So far we’ve mostly seen Top 10 Programming Languages for Engineers IEs to create configurations of objects, often involving value objects. I’m not sure if this is a defining characteristic, although I suspect there is something about them appearing in a declarative context. The key test of fluency, for us, is the Domain Specific Language quality. The more the use of the API has that language like flow, the more fluent it is. We can now model these stages as interfaces now, and use the transition between these stages to determine the return type of each methods. You can also see the setter method FromImage that adds content to the object and returns it back, which will enable us to use “method-chaining” on our objects.

Code Against Interfaces, Not Implementations

It allows you to configure default database schema to be used for tables. This schema name used for all database objects which do not have explicit schema name. Since I wrote this post this term’s been used rather widely, which gives me a nice feeling of tingly gratification. I’ve refined my ideas about fluent interfaces and internal DSLs in the book I’ve been working on. I’ve also noticed a common misconception – many people seem to equate fluent interfaces with Method Chaining.

So any exhortations to use them can only be preliminary – however I do think they are ripe for more experimentation. Now if we use the same fluent class, we get in a way guided tour of the natural order of methods and the methods we have at our disposal. Here are a few examples of the awesome code completion we get with this fluent class. One is the entry method like CreateBuilder() above or Initialize(). Although not really required , these are important in setting up the skeleton of the underlying object. The second one is the exit method like ToList() in LINQ or GenerateDockerFile() here which gives the actual result.

Learn about facades design pattern and how to use them in Sitefinity CMS Fluent API. It is another layer, which can be described as a wrapper of the all manager classes that a developer would usually use in order to create content, pages, classification units or users. The example uses a nested include to include all posts and post categories. In 3.0.1 and later, you can include or select a count of relations alongside fields – for example, a user’s post count. In essence we create the various objects and wire them up together.

A introductory post talking about fluent apis, its pros and cons and how to design one for yourself from scratch. Besides, of course, proper documentation, the usability of an API is greatly influenced by its design. In this post we discuss fluent APIs, which are produced by a funky and popular design technique. We learn what fluent API is, how it benefits the programmer, and how to compose expressive fluent APIs.

If you want to specify the join table name and the names of the columns in the table you need to do additional configuration by using the Map method. In the following example, the Course Title property is required so IsRequired method is used to create NotNull column. Similarly, Student EnrollmentDate is optional so we will be using IsOptional method to allow a null value in this column as shown in the following code. When the database is generated, you will see the tables name as specified in the OnModelCreating method.

I’ll continue with the common example of making out an order for a customer. A line item can be skippable, meaning I’d prefer to deliver without this line item rather than delay the whole order. These benefits may seem superflous or not worth the effort required to build such an interface API and I totally get that.