Pro ASP.NET Core MVC

Overall the book is a great reference on MVC and ASP.NET Core, starting with some high-level explanations, walking through the process of building a demo application over several chapters, and then going into a deep dive of all the various pieces. I learned a lot about ASP and the book is easy to follow.However, the book has one gaping flaw around how it structures database access. Adam uses a strategy of defining an interface for data access and then implementing it with Entity Framework, which is all fine. However, he makes the terrible decision to expose the Entity Framework DbSets using IEnumerable<T> properties in his data access interface, and he does all filtering in the controller classes, which only access the database using this IEnumerable.While this will compile and function, there is a huge, huge difference between the following statements:DBSet<Product> products = ...;var p1 = (products as IQueryable<Product>).Where(p => p.Category == "Sporting Goods").OrderBy(p => p.Id).Skip(20).Take(10);var p2 = (products as IEnumerable<Product>).Where(p => p.Category == "Sporting Goods").OrderBy(p => p.Id).Skip(20).Take(10);Both return a product collection of 10 products in the sporting goods category. However, the first one (using IQueryable) is a LINQ to Entities query that will bake the filter, ordering, skip, and take criteria right into the T-SQL query that is sent down to the database. The query to the database will return 10 rows, which will be materialized into 10 Product objects.The second statement of these (using IEnumerable), while it eventually gives you the same 10 objects, is not using LINQ to Entities, it's a LINQ to Objects statement. It will select the entire Product table from the database, materialize every row to an object, and then sort, filter and discard all but 10 of those objects in memory. If you had 100,000 products in your SQL table, you would create and immediately discard 99,990 objects just to get the 10 you wanted, as well as reading every single row in your table for every operation.Adam is upfront that this isn't a book on Entity Framework - but I do have to dock him some points for repeatedly erring in how he implemented the database access.

I am still reading this book but am extremely impressed. The author writes with clarity and is methodically covering this huge topic in an easily digestible manner. Even the sequencing of topics is highly tailored towards incremental learning. For instance he often writes mini-tutorials in a chapter for a related topic (like the Razor engine) just to give you enough acquaintance with it to understand the topic currently in focus. And he will note to expect a much deeper dive later in the book.In this way, the reader is following a virtuous "spiral" of learning, circulating around the breadth of ASP.Net Core MVC but with each turn going to a deeper level of detail, bolstered with concise and relevant examples. This is exactly how I learn best.He also comments on best practices, like how to separate the tasks that your controller versus model versus view should contain; or where your unit tests should live. He's pragmatic though, and where appropriate notes there may be other/different ways that are valid too (like unit testing approaches).I am a long time ASP.NET Web Forms / C# developer and I am eager to start coding new projects with this approach and anticipate referring back to this book for months to come.

This book serves two audiences - developers new to C#/ASP.NET/MVC and developers new to CORE. I think it is very difficult to serve two audiences equally with one book - but this book is as close to perfection as it gets. Every chapter has a synopsis that highlights the differences with ASP.NET 4 / MVC 5. So, experienced reader will pay more attention to Dependency Injection and ViewComponents.There are some areas that I wish were covered deeper (for example, Identity and Memory-based database for unit testing). But it's a 1000-page book already, so I realize that some things will be limited.Given that API Controllers are now no different from regular controller, I think the chapter on API Controllers could be shorter. It goes into details of REST patterns that, while important, isn't specific to ASP.NET. Maybe a link to good resources would be sufficient. Or maybe I am just nitpicking. One nugget is the discussion how [FromBody] and similar attributes are required in API controllers and *why*!I am looking forward to Freeman's upcoming Angular2 book that I hope will go into more details of using ASP.NET in SPA context (less Razor, less JQuery, more API Controllers).

This is a very strong book on learning ASP.Net from a functional point of view. It walks through the tech by building applications step by step. Due to the ever-changing nature of the technology, you will need to download the updated chapters from the apress site to complete the exercises in the SportsStore app.One criticism would be that the author makes a lot of forward referencing statements to the effect of: "trust me, I'll explain more in Chapter 27". He delivers, but it is common to see these 15-20 chapter jumps between the practical application and the theory it relies on.

Adam Freeman is my all time favorite author in the asp.net arena. This is his latest book in the series and perhaps his best effort as well. In addition to updating all of the examples and framework coverage that has become a hallmark of this series, Adam also included some basic coverage of some of the c# features that can be confusing even for seasoned programmers that are either approaching c# for the first time or have not programmed in asp.net. I personally feel that Adam went out of his way to make his coverage easy to understand and follow. If someone is new to C# or AspNetCore and approaching this topic with a good background in programming but not necessarily in the subject matter, this is the best book that I could think to recommend.

Great book, really wish when a physical book was purchased the ebook was included for free - especially for books of this size.

Thanks.. I got it as I expected... On time...:)

A very thorough book on ASP.NET Core.

Good Book

This is an exceptional book. As a lapsed ASP classic programmer who, after 15+ years of not coding, is trying to pick up ASP.Net Core and C# I have found the current web programming environment confusing. I have purchased and followed a few books, which have not approached the subject with such rigour and clarity. The author takes you step by step through the topics that you need to build on to gain an understanding of how to build structured ASP.Net MVC applications. The author leads you away from drag and drop/scaffolding development, and the refactoring pain that ensues, instead demonstrating how to create concise strongly typed solutions based on standard design patterns resulting in re-useable code and ease of testing. I found the book challenging, encouraging further research into techniques and concepts to fully appreciate the constructs that the author present to the reader. I have been following the exercises in the book, initially using Visual Studio 2015. However, after having to install a later version of PowerScript to complete an exercise a known issue with VS2015 forced me to upgrade to Visual Studio 2017, in itself a painless process. The author has published updates to this edition, available from the website, to accommodate VS 2017 and I have experienced no real issues since the upgrade.