Is this a known pattern?
-
I'm thinking condition-based programming. I'm not sure if I just made that up right now though. Also, isn't that exactly the type of thing you can already do with a Linq query? It is elegant, just like Linq, and it's a good thing to do as long as you can implement it in such a way that the condition is only executed as little as possible, and you don't have to load the whole potential result set into memory and then filter it. It's more functional programming than declarative, I think. In languages where functions are first class objects (e.g. Javascript) it is more common to pass filter functions or other types of function (for example a sort order comparator) around and potentially declare them locally as you have done here. What you're passing in the 'where' parameter is a pure function.
BobJanova wrote:
Also, isn't that exactly the type of thing you can already do with a Linq query?
Yes, it's certainly like Linq :-D The difference is that it may or may not cause a Linq-to-Entities query to run and hit the database server.
BobJanova wrote:
It's more functional programming than declarative, I think.
Yes, I suppose it is. I was focused on making it easy to use rather than the programming paradigm. Thanks, Nick
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
I don't know if it's known or not. You could call it "Query Mapper"
If your actions inspire others to dream more, learn more, do more and become more, you are a leader." - John Quincy Adams
You must accept one of two basic premises: Either we are alone in the universe, or we are not alone in the universe. And either way, the implications are staggering” - Wernher von Braun -
Nicholas Butler wrote:
I just called it caching
Most people do. First law of patterns. They are a fancy name for stuff you already do.
*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington
"Mind bleach! Send me mind bleach!" - Nagy Vilmos
My blog | My articles | MoXAML PowerToys | Mole 2010 - debugging made easier - my favourite utility
Pete O'Hanlon wrote:
First law of patterns. They are a fancy name for stuff you already do.
Along with the first law of programming ( "it's already been done" ), I was hoping someone had already come up with the fancy name. Nick
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
YAPNBUDP - Yet another pretentiously named but unnecessary design pattern :)
"If you think it's expensive to hire a professional to do the job, wait until you hire an amateur." Red Adair. nils illegitimus carborundum me, me, me
-
As an alternative, it also looks a bit like a Query Object - mapping onto a Repository pattern.
*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington
"Mind bleach! Send me mind bleach!" - Nagy Vilmos
My blog | My articles | MoXAML PowerToys | Mole 2010 - debugging made easier - my favourite utility
There you have it: QORP!
-
peterchen wrote:
It's known as PNAMUT - Pretentious Name for Muddling Through.
Correct, but not very catchy :)
peterchen wrote:
The purpose of the data layer method (as you call it) is to protect the application against changes; e.g. a new privacy regulation mandates you may not track age, only states such as "above minimum drinking age".
That was a contrived example but I agree: it's certainly not High Church. Nick
When you pronounce it quickly, you can make it sound almost like "PEANUT".
FILETIME to time_t
| FoldWithUs! | sighist | WhoIncludes - Analyzing C++ include file hierarchy -
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
I use this stuff all the time, and love it !! Linq, Lamdas, Linq with Lamdas.. It saves a lot of time with EF.
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
'Specification Pattern' with only one logical chain.
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
Isn't it just a simple Facade pattern?
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
I have been working with a pattern called "composite specification" that uses lambda expressions in this way. We are looking at combining it's use with NHibernate, which can turn the composed lambdas into SQL. Seems like a pretty powerful, flexible approach to me.
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
How about LOOP? LINQ-Object Oriented Programming
"To alcohol! The cause of, and solution to, all of life's problems" - Homer Simpson
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
when you use lambda expression and delegates, these are a variant of the observer pattern.
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
-
I use this stuff all the time, and love it !! Linq, Lamdas, Linq with Lamdas.. It saves a lot of time with EF.
Baxter R Pearson wrote:
It saves a lot of time with EF.
Exactly :) I've sent you a PM - could you let me know if it doesn't come through ( sometimes they go missing. ) Nick
-
Isn't it just a simple Facade pattern?
Nathan Gloyn wrote:
Isn't it just a simple Facade pattern?
It does hide a lot of complexity, but I think the difference is that the parameters passed are functions not values. I don't know if that makes it a different pattern, though :) Nick
-
Nathan Gloyn wrote:
Isn't it just a simple Facade pattern?
It does hide a lot of complexity, but I think the difference is that the parameters passed are functions not values. I don't know if that makes it a different pattern, though :) Nick
From the all knowing Wikipedia: A facade is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can: - make a software library easier to use, understand and test, since the facade has convenient methods for common tasks; - make the library more readable, for the same reason; Certainly sounds like its a facade based on that definition :)
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick
Technically it's a DSL (Domain Specific Language) implemented on top of a formal language. You can tell if it's a DSL if simply reading the words makes approximate sense in English: User fetch all where the user age is greater than 21. You could obviously improve it: Fetch all users where the user age is greater than 21.
var users = Fetch.All.Users( where: user => user.Age > 21 );
The paradigm you are using is very close to a fluent interface - technically fluent interfaces need to happen with method calls (
DAL.Users().Where().Age().GreaterThan(21)) but there isn't any reason you can't violate that - especially if it increases clarity (which yours does).He who asks a question is a fool for five minutes. He who does not ask a question remains a fool forever. [Chineese Proverb] Jonathan C Dickinson (C# Software Engineer)
-
I have been working with a pattern called "composite specification" that uses lambda expressions in this way. We are looking at combining it's use with NHibernate, which can turn the composed lambdas into SQL. Seems like a pretty powerful, flexible approach to me.
I've sent you a PM - could let me know if it goes missing? ( they sometimes do ) Nick
-
I'm having difficulty finding a name for a style of programming. You can make one up if you like, but I'd prefer something that is already documented :) I've written a layer over the Entity Framework that allows the application code to pass parameters into the data layer that shape the returned result sets. So you can write something like this:
List users = DAL.User.FetchAll( where: user => user.Age > 21 );
It's declarative programming, but I was looking for a more specific name. Something like "locality of intent". Basically, you say what you need in the place where you need it. It's the opposite of having a data layer method like this:
List FetchAllUsersWhereAgeGreaterThan( int minimumAge )
Is this a known pattern? I've run out of obvious words to Google. Ta, Nick