I am not a programmer in real life, I just learn it for fun and to pass my free time. So I am kinda away from programmers` environment and always have problems with terminology, so please forgive my ignorance if my question was too easy.
Can someone tell me if I am right or wrong here:
Context
???
Entity
Am I right? and what's number 2 called?
Context
Entity Collection
Query result / collection
Related
First of all, in this question I'd like to stay away from the polemic on whether source code commenting is good or bad. I'm just trying to understand more clearly what people mean when they talk about comments that tell you WHY, WHAT or HOW.
We often see guidelines like "Comments should tell you WHY; code itself should tell you HOW". It is easy to agree with the statement on an abstract level. However, people usually drop this like a dogma, and leave the room without further explanation. I've seen this used in so many different places and contexts, that it looks like people can agree on the catchphrase, but they seem to be talking about different things entirely.
So, back to the question: if comments should tell you WHY, what is this WHY we are talking about? Is this the reason why that piece of code exists in the first place? Is this what that piece code should be doing? I would really appreciate if someone could give a clear explanation, and then add some good examples (bad examples are not really needed, but fell free to add them for contrast).
Please do not immediately close this question as duplicate or polemic. I have tried hard to make it very objective. There are many questions on whether comments are good or bad, but no one that addresses the specific question of what are good examples of comments that tell you WHY.
Thanks,
Comments serve two main purposes:
to summarise. Many would say "why document this method when we can just read the code?", but one line of text that describes what a method is for/what it does, can often be much faster to read and easier to understand than 30 lines of code, especially if that code calls other methods that you may need to read as well...
to explain the things that are not obvious from the code - the WHY, or more detail on the how. Simple examples include "we must add the new XmlElement and then remove the old one, as the ReplaceChild method in .net does not work!", or "Uses an iterative Newton-Raphson approach to solve for X ", or "we must not close the port here because the reading thread may still be running", or "use this method where performance is critical, but beware that this method may provide a result that is in error by up to 5%"
While designing & developing a data-centered project using Entity Framework, I have spent too much time to find a way to accomplish one of the following but have come across nothing practical.
To find an alternative to implement "Polymorphic Association" which cannot be implemented along with "TPC Inheritance Mapping" in EF - since this kind of inheritance mapping fits well with the logical design of my model, or
To find a way to improve the poor performance of "TPT Inheritance mapping" which seems to me is the only practical alternative to TPC.
"TPH Inheritance Mapping", in my opinion, does not make sense from the "database design" and "data validation" point of view.
Besides, since other parts of the project rely almost totally on Microsoft products, I do not tend to switch to other ORM frameworks such as NHibernate.
Now I would like to ask those of you who are professional software developers and have possibly faced this problem, to please advise me about any other available options/solutions. How is this issue usually solved in professional design/development tasks?
Appreciate any guidance in advance
Just playing around I seem to be able to achieve all manner of polymorphic associations. One thing I found helped is to make sure all your foreign keys and relationships are explicitly defined, this will avoid any ambiguity that Code First may encounter. Julie Lerman in her book Code First does mention that foreign keys should be defined otherwise unexpected things with the association mappings may occur.
Hope that helps, if not let us have some code and say what you can't get to work.
Cheers
I got this question during an interview in the past and never really dug into in, but I've put some thought into it lately and I can't come up with a good answer. When I think of attached properties my mind goes straight to UI related concepts - what benefits could be had in using attached properties with LINQ? I'm starting to think the answer is "they're not" unless I find out otherwise!
Linq and attached properties are not related. I think this question is asked to confuse you.
I'm looking to learn LINQ, but I'm finding that there is a lot more to it then what I initally expected. In fact, there's so much that I'm not sure where is the best place to start. I know that there's LINQ to SQL, and LINQ to Entities, and a number of other LINQ whatevers out there.
Which is the best to start with? It seems that I see more information readily available about LINQ to SQL, but I have seen quite a bit of information about LINQ to Entities also. Is LINQ to Entities more difficult than LINQ to SQL?
Also, I'm looking for some good resources on learning LINQ. I've seen that Scott Gu has a few blogs on LINQ to SQL, but I'm looking for a little more. Does anyone have a LINQ book that they're impressed with?
LINQ Pad is a good way to start learning, its also free...
http://www.linqpad.net/
I have been looking quite alot for the same, but i have found that there isnt really a place where everything is together..
But there is a few good resources.
LinQ 101 - http://msdn.microsoft.com/en-us/vcsharp/aa336746.aspx
And this one got quite a few small example snippets on how to do things in alot of different languages.
And it got a section for linq too
http://www.java2s.com/Code/CSharp/LINQ/CatalogLINQ.htm
Id say start with linq to sql, they stopped developing that a while back, but the syntax is exactly like linq to entities, linq to entities and linq to sql is almost the same, there is a few things different, but id say start from the "bottom" :)
This is a really good tutorial about how to jump from "linq to sql" to "linq to entities"
http://naspinski.net/post/Getting-started-with-Linq-To-Entities.aspx
In the beginning, I found Standard Query Operators (MS Word .doc) an invaluable reference.
Pro LINQ by Joseph Rattz is a great book on the subject, although it doesn't cover LINQ to Entities.
As well as in depth examples for each of the standard query operators, it covers:
LINQ to Objects
LINQ to XML
LINQ to DataSet
LINQ to SQL
Although this isn't free, and might seem "daunting" to a beginner. But the Professional LINQ book published by Wrox I found was good as a "get your feet wet" book. It's not what I would consider part of their professional series despite the title and doesn't go into nearly as much depth as it should, but it's a good start nevertheless.
This book/ebook is very good also. Very good for starters.
http://www.manning.com/marguerie/
Here's a great site for practicing it (and also c#).
It still doesn't have LOTS of questions, but there are just enough to get you going (and you can also add questions yourself).
The next best thing to a personal beginner LINQ tutor:
http://www.asp.net/LEARN/linq-videos/
Another good way to learn LINQ is by browsing through code examples, and try them out on your own, if time permits.
Here are two of my personal favorite LINQ resources, which both have easy to understand code examples, and in my view are great for the beginner:
http://linqsamples.com
and
http://www.dotnetperls.com/linq
What are the drawbacks of linq in general.
Can be hard to understand when you first start out with it
Deferred execution can separate errors from their causes (in terms of time)
Out-of-process LINQ (e.g. LINQ to SQL) will always be a somewhat leaky abstraction - you need to know what works and what doesn't, essentially
I still love LINQ massively though :)
EDIT: Having written this short list, I remembered that I've got an answer to a very similar question...
The biggest pain with LINQ is that (with database backends) you can't use it over a repository interface without it being a leaky abstraction.
LINQ is fantastic within a layer (especially the DAL etc), but since different providers support different things, you can't rely on Expression<Func<...>> or IQueryable<T> features working the same for different implementations.
As examples, between LINQ-to-SQL and Entity Framework:
EF doesn't support Single()
EF will error if you Skip/Take/First without an explicit OrderBy
EF doesn't support UDFs
etc. The LINQ provider for ADO.NET Data Services supports different combinations. This makes mocking and other abstractions unsafe.
But: for in-memory (LINQ-to-Objects), or in a single layer/implementation... fantastic.
Some more thoughts here: Pragmatic LINQ.
Like any abstraction in programming, it is vulnerable to a misunderstanding: "If I just understand this abstraction, I don't need to understand what's happening under the covers."
The truth is, if you do understand what's happening under the covers, you'll get much better value out of the abstraction, because you'll understand where it ceases to be applicable, so you'll be able to apply it with greater confidence of success where it is appropriate.
This is true of all abstractions, and applies to Linq in bucketfuls. To understand Linq to Objects, the best thing to do is to learn how to write Select, Where, Aggregate, etc. in C# with yield return. And then figure out how yield return replaces a lot of hand-written code by writing it all with classes. Then you'll be able to use it with an appreciation of the effort it is saving you, and it will no longer seem like magic, so you'll understand the limitations.
Same for the variants of Linq where the predicates are captured as expressions and transported off to another environment to be executed. You have to understand how it works in order to safely use it.
So the number 1 drawback of Linq is: the simple examples look deceptively short and simple. The problem is, how did the author of the sample know what to write? Because they knew how to write it all out in long form, and they knew how pieces of Linq could be used as abreviations, and so they arrived at the nice short version.
As I say, not really specific to Linq, but highly relevant to it anyway.
Anonymous types. Proper ORM should always return objects of 'your' type (partial class, with possiblity of adding my methods, overriding etc.). There are doezne of tutorials and examples of different complex queries using linq but non of them care to explain the advantage of returning a 'bag of properties' (return new { .........} ). How am I supposed to work with anonymous type, wrap it in another class again?
Actually I can´t think of any drawbacks. It makes programming life a lot simpler because a lot of things can be written in a more compact but still better readable way.
But having said this, I must also agree with Jon that you should have some idea what you´re doing (but that holds for all technological advances).
the only drawback which it has is its performance see this article