Dep.Injection in NET. (Anglais) Broché – 6 octobre 2011
Rentrée scolaire 2017 : découvrez notre boutique de livres, fournitures, cartables, ordinateurs, vêtements ... Voir plus.
|Neuf à partir de||Occasion à partir de|
- Choisissez parmi 17 000 points de collecte en France
- Les membres du programme Amazon Prime bénéficient de livraison gratuites illimitées
- Trouvez votre point de collecte et ajoutez-le à votre carnet d’adresses
- Sélectionnez cette adresse lors de votre commande
Produits fréquemment achetés ensemble
Les clients ayant acheté cet article ont également acheté
Description du produit
Présentation de l'éditeur
Dependency Injection (DI) is a software design technique behind the
wildly popular Spring tool in Java. .NET developers are only now
discovering how DI can improve the quality and maintainability of
their C# code.
Dependency Injection in .NET is a comprehensive guide that
introduces DI to .NET developers. It covers core concepts and patterns,
and introduces important DI frameworks, such as StructureMap,
Windsor and Spring.NET. For each framework, it presents examples of
its particular usage, as well as examines how the framework relates to
the common patterns.
First and only book on DI in .NETF
Provides both patterns and practical examplesF
Presents major DI frameworks for .NETF
Very strong response in Manning Early Access Program
Biographie de l'auteur
is a professional software developer and architect living in
Copenhagen, Denmark. He has been working with software since 1995 and
TDD since 2003, including six years with Microsoft as a consultant,
developer and architect. Since 2009, Mark has been an architect with
Aucun appareil Kindle n'est requis. Téléchargez l'une des applis Kindle gratuites et commencez à lire les livres Kindle sur votre smartphone, tablette ou ordinateur.
Pour obtenir l'appli gratuite, saisissez votre numéro de téléphone mobile.
Détails sur le produit
Si vous vendez ce produit, souhaitez-vous suggérer des mises à jour par l'intermédiaire du support vendeur ?
Commentaires client les plus utiles sur Amazon.com
The Long Story: I bought this book last year. I can't remember exactly why I bought it, but I suspect that it had something to do with intellectual intimidation and the frightening title. I come from a non-OO background, but I am too young to get through the next 20 years without dealing with the reality of OO prevalence in small (i.e. numerous) projects. I had 2 choices ... start at the bottom or start at the top. Believe me, I chose the latter with this book.
I'm not going to explain the content in every chapter, simply because other reviewers have already done the job as I would have. Read Mr. T. Anderson's fine review if you need that kind of detail. Instead, I will talk about the effect that this book had had on how I think.
Chapter 2 is the velvet sledgehammer in the face. I read along with the case study, nodding my head and exercising my (in retrospect, tiny) brain as Seeman describes how "Mary" and "Jens" go about building a layered application. I'm thinking, yes Mary and Jens, this is what the magazines, blog articles, and dime-a-dozen gurus are saying regarding the construction of layered application. Seeman then dissects the "layered" application. Actually, he doesn't dissect it; he tears it to shreds and stamps all over it. Brilliantly. It's truly scary to read this chapter. You will feel like a complete novice at the end of it. You then have two choices ... (1) reject this stuff as abstract, ivory tower nonsense, or (2) put on your big-boy-pants.
Having lived with this book for almost a year, this is how I suggest you use it:
1. Read from Part 1 through Part 3.
2. Stop. Think. Cry at how embarrassed you feel at the end of Part 1 Chapter 2.
3. Read Part 2 again.
4. Stop. Think. Cry at how happy you feel now that you've lifted yourself beyond 99% of .NET developers. Beyond 99% of software professionals, period.
5. Do some "poor-man's DI" exercises.
6. Read only the introductory sections of each chapter within Part 4.
7. Pick a DI container in Part 4 that appeals to you based on the previous bullet, read its Part 4 chapter, and spend 1-2 months playing with it.
8. Revisit Parts 2 and 3 on a regular basis as references.
9. Don't think about sauces or Fowlerisms.
Criticisms: Very, very, few. I do not think it's too "wordy" at all. Any repetition is done with the realization that this stuff is really, really, hard for most of us. But yes, any mention of nonsense about "Anemic Domain Models" normally sets my blood boiling and warrants an immediate docking of at least 1 star. I can't dock a star from this book. It's that good. It's written by a mildly (but not offensively) dogmatic Danish guy who talks about sauces in every chapter. I like my Filets Mignons dry, thank you very much. And still, at the end of the day ... this is best software development book I have ever read. By far. By miles. By kilometers ...
That may seem like hyperbole, but it's really not - I would not have been able to meet tight deadlines for many of the projects without
- being able to easily test code to find bugs early (the later in the process that a bug is found the more expensive it is to fix) (TDD and Liskov Substitution Principle)
- being able to build up an toolbox of small chunks of code that do a single thing well and can be composed into different things quickly depending on what I need at the time
- being able to quickly react to changing requirements by swapping out different dependencies (paying attention to where the composition root should be)
- being able to add cross-cutting functionality without modifying existing code modules (decorator pattern)
- being able to "make things fit" (adapter pattern)
- being able to manage project risk by hiding dependencies on other people's code (whether open-source, another team in the company, etc) behind seams/interfaces in the right place
I would agree with a review I've read (somewhere...can't remember if it was on Amazon or not...) that there are some prerequisites to reading this book, such as a good grasp of MVC.Net. I definitely got a lot out of the examples, but couldn't help but feel sorry for readers who don't have that background. I'm still giving it 5 stars though. My word of caution to readers before purchasing this book would be to go through some MVC.Net tutorials and at least get familiar with the paradigm itself, the Global.asax file, Entity Framework basics, Controller Factories, and interfaces/abstract classes. You'll get more out of it if you have a basic understanding of these concepts. If you don't, some of the content won't seem relevant.
Lastly, I'd recommend reading the author's blog and Stack Overflow articles. He is one sharp dude. LEARN FROM HIM!