Customer Reviews

Pro LINQ Object Relational Mapping with C# 2008 (Expert's Voice in .NET)

5 star:		(6)
4 star:		(2)
3 star:		(1)
2 star:		(1)
1 star:		(1)

 

 

I originally gave this book two stars, because of the lack of source code and support. To the author's credit, he jumped right on those criticisms and has resolved those problems. In light of that, I rate this book four stars.

This book gives a pretty good overview of LINQ to SQL--it's not a bad starting point for those (like myself) who prefer the conventions of Domain-Driven Design. The book isn't really a good primer on DDD, but it isn't meant to be. For that, I'd recommend Applying Domain-Driven Design and Patterns: With Examples in C# and .NET.

The book includes a case study, 'The Bank of Pluto'. Source code should be available on the Apress website. You will want to have it to go through the last half of the book, which shows excerpts from the code but doesn't always give enough context to be able to figure it out. While it isn't a complete reference application, the Bank of Pluto example has enough detail to get most programmers up and running.

The book covers both LINQ to SQL, the basic ORM provided by Mictosoft, and the ADO.NET Entity Framework, a more robust framework that can be used as an ORM. It separates it's discussion of the two technologies, which is a good thing. The initial release of the EF is proving quite controversial, with many DDD enthusiasts complaining that it is too database-oriented and "not ready for prime time". Given the controversey, I am passing on EF until Rev. 2.0, at least, so I skipped the EF chapters in the book. That still left me with a good discussion of LINQ to SQL that stands well on its own.

As the text points out LINQ to SQL works pretty well in small-to-mid-size applications, and it can be used successfully in domain-driven designs. It does have problems with complex, enterprise-level domain models. Nonetheless, if you are a domain-driven designer, this book provides a nice introduction to LINQ to SQL and how to integrate it into your application architecture.

The first two chapters of this book start out with a discussion of Domain-Driven Design (DDD) Principles, what Object-Relational Mapping (ORM) Tools are, the role of ORMs in DDD-informed application development, and criteria for evaluating ORM tools. Chapters Three through Seven then provide a quick tour of LINQ to SQL and ADO.Net Entity Framework (Beta 3 Version) basics. It's not until Chapter Eight that things become interesting (at least to me). After describing the functionalities that he wants to implement in the running banking application sample, the author provides plenty of code demonstrating the comparative strengths and weaknesses of the two ORM tools, potential gotchas and workarounds, lessons learned, and recommended best practices in architecting N-Tier Applications. The author's writing style is conversational, which is good most of the time, except for those few occasions when he seemed to have switched from one topic to another rather abruptly. Overall, a great book!

I read a majority of this book, and it is a very good overview for using Linq to Sql and Entity Framework as a Data Access Layer. It does a good job of going through several scenarios. The only lacking thing in this book is something that you will learn in practice using this stuff in a real world application, and finally learn some of the limitations of EF and Linq To Sql. But what it does cover is very solid, but expect to learn some nuances with EF on your own.

Overall, I think this is a really good book. I am fairly new to programming and this is a great introduction to domain driven design and object relational mapping using Microsoft tools. The author really captured an interesting case study which helped make digesting a complex topic simpler. The framework, which is largely based on Billy McCafferty's Nhibernate framework is usable and something that I can see implementing on any number of projects. Overall it's a good book and an easy read for .NET data access developers. [...].

I am not sure what the 2 and 3 star reviews are about, because I thought this book was excellent, and considering the book says "intermediate"
I'm not sure why people were expecting a "deep technical ORM, LINQ to SQL, or EF" book.

The book is broken into 5 different parts:
Part 1 - ORM Concepts - This is really good background for people who don't understand ORM patterns, and DDD, but it is a bit dry. If you are familiar with pattern based development and ORM you can probably skip over this section. I give this section 4 stars

Part 2 - LINQ to SQL Examined - This is a solid overview of LINQ to SQL. The author goes through all of the basics of LINQ to SQL and gives you just enough to move into more complex LINQ to SQL development. My biggest complaint is that there are a few left-over Beta2 errors but I contacted the author and he told me that an errata had been submitted. Overall I give this section 5 stars.

Part 3 - Entity Framework Examined - Again, this section is a good overview of EF. I like this section because the author really explores all of the meta-data behind the Entity Framework. I would have to say my biggest complaint is that there isn't enough content here on EF, but what is available in the book is a good starting point for EF developers. I think this section deserves 4 stars because I longed for more

Part 4/Part 5 - The Bank of Pluto Case Study/Building on the Bank of Pluto Foundation - I combined these sections because in my opinion they should be a single section. This is the heart of the book where the other goes through in detail a real world case study using POCO and DAO with LINQ to SQL and EF. I think this section really make the book a winner and a must read for all. 5 stars on these sections.

Overall Pro's - Great, easy to read book that covers ORM patterns, the basics of LINQ to SQL and EF, and the inner-workings of building a real world ORM data access framework.

Overall Con's - Needed a little more information in sections, and is heavily DDD focused.

I'm giving this book 5 stars because I think it brings something to MS development that other books haven't.

I must confess that when I read the title of the book "Pro LINQ Object Relational Mapping with C# 2008" I had big pretensions about the book. ORM, as the author mentions in the introduction, is not a subject commonly treated for the .NET world and I was expecting a deep technical book. This has definitively conditioned my final opinion about it.

The book is divided in several parts. You can see below the main ones.

· First one provides you with a fast overview about the ORM concepts. It explains the problematic between database and conceptual models, problems addressed with ORM, laziness, persistence ignorance, etc.

· Second one presents LINQ to SQL and EF explaining the features each one provides.

· Third part does a "complete" implementation of a sample application which provides you some insights about what it does mean working with LINQ to SQL and EF.

The biggest worth of the book is probably the third part, where the author instead of only write some excerpts of code, he has written some requirements and use cases to later on implement them as a developer would do in the "real world", including even some unitary tests.

What I didn't like is that, regardless it presents a wide range of concepts none of them is deeply treated, it always remains on the surface, which in my opinion has made of the book a "sugar free" version of what it could be.

I didn't like either to find certain technical errors like "...the CLR is doing the heavy lifting for you by translating your queries into method calls...". This is incorrect since the Common Language Runtime (CLR) does not translate the LINQ queries into methods; instead each language compiler is responsible of that conversion. With this sentence the reader can think it is better to use the method syntax instead of the LINQ syntax to avoid the translation performance cost during runtime, when it is not the case as it occurs during compilation time.

Therefore if you are looking for a deep technical ORM, LINQ to SQL or EF this is not your book. Instead if you have heard noise about these technologies and you are searching for a text to help you with an overview of what is what and the possibilities they offer, Pro LINQ Object Relational Mapping with C# 2008 can be what you need.

Es un libro completamente practico ya que contiene ejemplos muy completos para comprender la conexion a bases de datos por medio de LINQ.

By: Edwin Dario Cucul Cuc

If you have never written a database application this book will be way overkill for a beginner. I would say this book is targeted to the working professional who has written their own Data Access Layer in the past and are looking for best practices on how to do it in Visual Studio 2008.

The samples in the book are implemented in C# for Visual Studio 2008 SP1 (due to the Entity Framework). I found the intro chapters on top down vs bottom up design to be well laid out, but they had a lot of grammatical errors.

The later implementation chapters on actually building the system are very timely. If you are wondering how you would implement the same system in LINQ to SQL and Entity Framework this book is fantastic. The list of pro/con for each technology and then working examples of things that a real app had to implement by hand are great. In particular I found the authors reasons for using one technology over the other to be exactly right with my experiences as well.

This is a very "dense" book. Not a quick read as many of the implementation theory can leave you thinking for a while about the implications of such design choices in the real world.

I really enjoyed the book and have made it mandatory reading for everyone who works for me just for the discussion of LINQ strategies.

Object relational mapping (ORM) and LINQ are new, important topics that every enterprise .NET developer should take note of, and Mr. Mehta delivers with this very informative, thorough, and approachable book on the subject. Written for the intermediate-to-advanced C# developer, the author begins with a discussion on the general aspects of ORM and how it can simply the programmer's life by consolidating _all_ business logic into the tier it belongs, the business logic tier, making your overall codebase more organized and easy to maintain.

Two Microsoft ORM technologies are presented: the simple LINQ to SQL system, and the more advanced "enterprise" level Entity Framework. As an experienced C# developer, I found the introductory material on LINQ to SQL especially helpful and easy to follow, and the material timely and directly applicable to a CRUD application i'm currently working on (a school library system). Although Visual Studio wizards are simple enough to figure out, I appreciated Mr. Mehta's step-by-step walk-through of the VS wizard generated code, giving me a complete understanding of the underpinnings of the LINQ to SQL ORM technology. After reading chapters 3 and 4, i had all the information I needed for developing my school library application. I was pleasantly surprised how much development time i saved, now that i don't have to write my own data access layer and decipher the MSDN LINQ to SQL documentation on my own.

Mr. Mehta approaches the Entity Framework with a complete sample application, "The Bank of Pluto". This is a favorite approach of mine to learning, as i get a good idea of what to expect when developing an enterprise application and how it relates to the Entity Framework.

A couple of very minor improvements i would make to this already excellent text: a quick introduction to LINQ (which the author assumes the reader already knows) and an up-front comparison of LINQ to SQL and the Entity Framework (why choose one over the other, etc.) Although the comparison of the two technologies appears in the book, it isn't encountered until the end in chapter 12. If you read the book from beginning to end as i have, I would have gotten a better sense of what technology to use for my project at the start. This is just some minor nit-picking; these gaps can be filled with the existing MSDN documentation or other texts.

Overall, Vijay Mehta has delivered a very successful book and has become my first "go-to" source for information on this important subject. I will recommended it to any C# developer!

Very strong start giving a DDD recap but
LINQ to SQL and LINQ to entities chapters are boring and incomplete.
I have the impression that these chapters are not written by the same person ...