Fluent interface

Fluent interface

In software engineering, a fluent interface (as first coined by Eric Evans and Martin Fowler) is an object oriented construct that defines a behavior capable of relaying the instruction context of a subsequent call. Generally, the context is
* defined through the return value of a called method
* self referential, where the new context is equivalent to the last context
* terminated through the return of a void context.This style is beneficial due to its ability to provide a more fluid feel to the code, although some engineers find the the style difficult to read. A second criticism is that generally, programming needs are too dynamic to rely on the static contact definitionvague offered by a fluent interface.

Examples

The following example shows a class implementing a non-fluent interface, another class implementing a fluent counterpart of the aforementioned non-fluent interface, and differences in usage. The example is written in C#:

namespace Example.FluentInterfaces { using System; public interface IConfiguration { void SetColor(string color); void SetHeight(int height); void SetLength(int length); void SetDepth(int depth); }

public interface IConfigurationFluent { IConfigurationFluent SetColor(string color); IConfigurationFluent SetHeight(int height); IConfigurationFluent SetLength(int length); IConfigurationFluent SetDepth(int depth); }

public class Configuration : IConfiguration { string color; int height; int length; int width; void SetColor(string color) { this.color = color; } void SetHeight(int height) { this.height = height; } void SetLength(int length) { this.length = length; } void SetDepth(int depth) { this.depth = depth; } }

public class ConfigurationFluent : IConfigurationFluent { string color; int height; int length; int width; IConfigurationFluent SetColor(string color) { this.color = color; return this; } IConfigurationFluent SetHeight(int height) { this.height = height; return this; } IConfigurationFluent SetLength(int length) { this.length = length; return this; } IConfigurationFluent SetDepth(int depth) { this.depth = depth; return this; } }

public class ExampleProgram { [STAThread] public static void Main(string [] args) { //Standard Example IConfiguration config = new Configuration(); config.SetColor("blue"); config.SetHeight(1); config.SetLength(2); config.SetDepth(3); //FluentExample IConfigurationFluent config = new ConfigurationFluent().SetColor("blue") .SetHeight(1) .SetLength(2) .SetDepth(3); } } }

The following is an example of providing a fluent interface wrapper on top of a more traditional interface in C++:

// basic definition class GlutApp { private: int w_, h_, x_, y_, argc_, display_mode_; char **argv_; char *title_; public: GlutApp(int argc, char** argv) { argc_ = argc; argv_ = argv; } void setDisplayMode(int mode) { display_mode_ = mode; } void getDisplayMode() { return display_mode_; } void setWindowSize(int w, int h) { w_ = w; h_ = h; } void setWindowPosition(int x, int y) { x_ = x; y_ = y; } void setTitle(const char *title) { title_ = title; } void create(); }; // basic usage int main(int argc, char **argv) { GlutApp app(argc, argv); app.setDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_ALPHA|GLUT_DEPTH); // Set framebuffer params app.setWindowSize(500, 500); // Set window params app.setWindowPosition(200, 200); app.setTitle("My OpenGL/GLUT App"); app.create(); }

// Fluent wrapper class FluentGlutApp : private GlutApp { public: FluentGlutApp(int argc, char **argv) : GlutApp(argc, argv) {} // inherit parent constructor FluentGlutApp &withDoubleBuffer() { setDisplayMode(getDisplayMode() | GLUT_DOUBLE); return *this; } FluentGlutApp &withRGBA() { setDisplayMode(getDisplayMode() | GLUT_RGBA); return *this; } FluentGlutApp &withAlpha() { setDisplayMode(getDisplayMode() | GLUT_ALPHA); return *this; } FluentGlutApp &withDepth() { setDisplayMode(getDisplayMode() | GLUT_DEPTH); return *this; } FluentGlutApp &across(int w, int h) { setWindowSize(w, h); return *this; } FluentGlutApp &at(int x, int y) { setWindowPosition(x, y); return *this; } FluentGlutApp &named(const char *title) { setTitle(title); return *this; } // it doesn't make sense to chain after create(), so don't return *this void create() { GlutApp::create(); } }; // basic usage int main(int argc, char **argv) { FluentGlutApp app(argc, argv) .withDouble().withRGBA().withAlpha().withDepth() .at(200, 200).across(500, 500) .named("My OpenGL/GLUT App"); app.create(); }

External links

* [http://martinfowler.com/bliki/FluentInterface.html Martin Fowler's original bliki entry coining the term]


Wikimedia Foundation. 2010.

Игры ⚽ Нужен реферат?

Look at other dictionaries:

  • Fluent Interface — Fluent Interfaces[1] stellen in der Software Entwicklung eine Art Programmierschnittstelle dar, die es ermöglicht, beinahe in Satzform Funktionalitäten aufzurufen. Der daraus resultierende Programmcode ist leicht lesbar und macht somit das… …   Deutsch Wikipedia

  • Fluent interface — Текучий интерфейс (англ. fluent interface, название придумано Эриком Эвансом и Мартином Фаулером) способ реализации, в разработке программного обеспечения, объектно ориентированного API, нацеленный на повышение читабельности исходного кода… …   Википедия

  • Fluent — can refer to:* fluency, in linguistics, the ability to communicate quickly. * fluent (mathematics), in mathematics, a continuous function * fluent (artificial intelligence), in artificial intelligence, a condition that varies over time * Fluent,… …   Wikipedia

  • Fluent — Siège de la société …   Wikipédia en Français

  • Multiple frames interface — A Multiple Frames Interface (MFI) is a type of user interface which displays information in a set of frames or panels that can be scrolled vertically on the screen. It is an integrated interface designed to bring together virtually all the… …   Wikipedia

  • Désignation chaînée — Fluent Interface / Interface fluide En génie logiciel, une désignation chaînée ou chaînage de méthodes consiste à agir en une seule instruction sur plusieurs méthodes du même objet, dans un but de plus grande lisibilité. L idée principale est qu… …   Wikipédia en Français

  • Moose (analysis) — Moose Screenshot  …   Wikipedia

  • Ribbon — В этой статье не хватает ссылок на источники информации. Информация должна быть проверяема, иначе она может быть поставлена под сомнение и удалена. Вы можете отредактировать эту стать …   Википедия

  • Design Pattern — Entwurfsmuster (engl. design pattern) sind bewährte Lösungs Schablonen für wiederkehrende Entwurfsprobleme der Softwarearchitektur und Softwareentwicklung. Sie stellen damit eine wiederverwendbare Vorlage zur Problemlösung dar, die in einem… …   Deutsch Wikipedia

  • Design Patterns — Entwurfsmuster (engl. design pattern) sind bewährte Lösungs Schablonen für wiederkehrende Entwurfsprobleme der Softwarearchitektur und Softwareentwicklung. Sie stellen damit eine wiederverwendbare Vorlage zur Problemlösung dar, die in einem… …   Deutsch Wikipedia

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”