How to implement composable queries: the 10k feet view It’s not difficult to realize that in order to achieve this the methods being chained must incrementally set up some data structure which is finally being interpreted by some method that executes the final query. But there are some degrees of freedom regarding exactly how this … Read more
Give a look to the following article published just a couple of days ago by Dustin Diaz, Twitter Engineer on @anywhere: Asynchronous method queue chaining in JavaScript He talks about a really nice technique that allows you to implement a fluent interface on asynchronous methods, basically methods chained together independent of a callback, using a … Read more
Overwriting __new__() works if you want to modify the string on construction: class caps(str): def __new__(cls, content): return str.__new__(cls, content.upper()) But if you just want to add new methods, you don’t even have to touch the constructor: class text(str): def duplicate(self): return text(self + self) Note that the inherited methods, like for example upper() will … Read more
Try to use some Extension methods. static class FluentManager { public static T WithFirstName<T>(this T person, string firstName) where T : FluentPerson { person.FirstName = firstName; return person; } public static T WithId<T>(this T customer, long id) where T : FluentCustomer { customer.ID = id; return customer; } } class FluentPerson { public string FirstName … Read more
Char is not valid primitive type for entity framework = entity framework doesn’t map it. If you check CSDL reference you will see list of valid types (char is not among them). Database char(1) is translated as string (SQL to CSDL translation). Char is described as non-unicode string with fixed length 1. The only ugly … Read more
The core idea behind building a fluent interface is one of readability – someone reading the code should be able to understand what is being achieved without having to dig into the implementation to clarify details. In modern OO languages such as C#, VB.NET and Java, method chaining is one way that this is achieved, … Read more
UPDATE from November 2020: The original answer below was written in 2011; the rules for generic method type inference, overload resolution, and how “final validation” of methods is done have had small but significant changes in recent versions of C#; this answer, and the link to an archived article on my original MSDN blog about … Read more
I wanted to create an extension method that could enumerate over a list of things, and return a list of those things that were of a certain type. It would look like this: listOfFruits.ThatAre<Banana>().Where(banana => banana.Peel != Color.Black) … Sadly, this is not possible. The proposed signature for this extension method would have looked like: … Read more
I agree that this is subjective. For the most part I avoid method chaining, but recently I also found a case where it was just the right thing – I had a method which accepted something like 10 parameters, and needed more, but for the most time you only had to specify a few. With … Read more
No, you cannot. In Python, all data (classes, methods, functions, etc) defined in C extension modules (including builtins) are immutable. This is because C modules are shared between multiple interpreters in the same process, so monkeypatching them would also affect unrelated interpreters in the same process. (Multiple interpreters in the same process are possible through … Read more