Microsoft .NET: Architecting Applications for the Enterprise, Second Edition

Microsoft .NET: Architecting Applications for the Enterprise, Second Edition

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Book description

A software architect’s digest of core practices, pragmatically applied

Designing effective architecture is your best strategy for managing project complexity–and improving your results. But the principles and practices of software architecting–what the authors call the “science of hard decisions”–have been evolving for cloud, mobile, and other shifts. Now fully revised and updated, this book shares the knowledge and real-world perspectives that enable you to design for success–and deliver more successful solutions.

In this fully updated Second Edition, you will:

Show and hide more Table of contents Product information

Table of contents

  1. Title Page
  2. Copyright Page
  3. Dedication Page
  4. Contents at a glance
  5. Contents
  6. Introduction
    1. Organization of this book
    2. Who should read this book
    3. Assumptions
    4. This book might not be for you if.
    5. Downloads: Code samples
    6. Acknowledgments
    7. Errata, updates, & book support
    8. Free ebooks from Microsoft Press
    9. We want to hear from you
    10. Stay in touch
    1. Chapter 1. Architects and architecture today
      1. What’s software architecture, anyway?
        1. Applying architectural principles to software
        2. Acknowledging requirements
        3. What’s architecture and what’s not
        4. The architecture process
        1. An architect’s responsibilities
        2. The role of the architect
        3. Common misconceptions about architects
        1. The “Big Ball of Mud”
          1. Causes of the “Big Ball of Mud”
          2. Symptoms of the “Big Ball of Mud”
          3. Using metrics to detect a BBM
          1. Organizational culture
          2. Helping the team write better code
          1. That odd thing called “legacy code”
          2. Checkmate in three moves
          3. Deciding whether or not to add manpower
          1. Universal principles of software design
            1. From spaghetti code to lasagna code
            2. Separation of concerns
            3. Isolation
            1. Pertinent classes
            2. Program to an interface
            3. Composition vs. inheritance
            4. A second pass at object-orientation
            1. SOLID principles
            2. Patterns for handling dependencies
            3. Coding vectors
            4. Use of patterns
            5. Refactoring
            1. The If-Then-Throw pattern
            2. Software contracts
            1. The art of writing testable code
              1. What is testability, anyway?
              2. Testing your software
              3. Common practices of software testing
              1. Interface-based design
              2. Plugin architecture
              3. State machines
              1. Readability as a software attribute
              2. Some practical rules for improving readability
              1. Chapter 5. Discovering the domain architecture
                1. The real added value of domain-driven design
                  1. What’s in DDD for me?
                  2. Conducting analysis using DDD
                  3. Strategic model design
                  1. Purpose of the ubiquitous language
                  2. Structure of the ubiquitous language
                  3. How to define the ubiquitous language
                  4. Keeping language and model in sync
                  1. Discovering contexts
                  2. Context mapping
                  3. Giving each context its own architecture
                  1. Origins of the layered architecture
                  2. Presentation layer
                  3. Application layer
                  4. Domain layer
                  5. Infrastructure layer
                  1. User experience first
                    1. Focus on interactions
                    2. UX is not UI
                    3. How to create an effective experience
                    1. ASP.NET websites
                    2. Web Forms vs. ASP.NET MVC
                    3. Adding device support to websites
                    4. Single-page applications
                    5. Desktop rich client
                    1. Patterns for organizing the business logic
                      1. The fairytale of CRUD and an architecture Prince Charming
                      2. The Transaction Script pattern
                      3. The Domain Model pattern
                      4. The Anemic Domain Model (anti-)pattern
                      1. Task orchestration in ASP.NET MVC
                      2. Orchestrating tasks within the domain
                      1. Data flow in layered architecture
                      2. Sharing the Domain Model entities
                      3. Using data-transfer objects
                      1. Chapter 8. Introducing Domain Model
                        1. The data-to-behavior shift
                          1. Rationale behind models and domains
                          2. Database is infrastructure
                          1. Domain model
                          2. Aggregates
                          3. Domain services
                          4. Domain events
                          5. Cross-cutting concerns
                          1. The online store sample project
                            1. Selected use-cases
                            2. Selected approach
                            3. Structure of the I-Buy-Stuff project
                            4. Selected technologies
                            5. Bounded contexts for an online store
                            6. Context map of the I-Buy-Stuff application
                            1. Behavior is a game-changer
                            2. Entities scaffolding
                            3. Value objects scaffolding
                            4. Identifying aggregates
                            5. Persisting the model
                            1. Finding an order
                            2. Placing an order
                            3. Fidelity card (or customer loyalty program)
                            1. Separating commands from queries
                              1. Generalities of the CQRS pattern
                              2. Benefits of CQRS
                              3. Fitting CQRS in the business layer
                              4. CQRS always pays the architecture bill
                              1. The read domain model
                              2. Designing a read-model façade
                              3. Layered expression trees
                              1. Getting back to presentation
                              2. Formalizing commands and events
                              3. Handling commands and events
                              4. Readymade storage
                              1. CQRS implementations
                                1. Plain and simple CQRS
                                2. CQRS with command architecture
                                1. Creating a read façade
                                2. Packaging data for callers
                                1. Laying the groundwork
                                2. Orchestrating use-cases via commands
                                1. The breakthrough of events
                                  1. The next big thing (reloaded)
                                  2. The real world has events, not just models
                                  3. Moving away from “last-known good state”
                                  4. The deep impact of events in software architecture
                                  1. Persisting events
                                  2. Replaying events
                                  1. Event sourcing: Why and when
                                    1. Why event sourcing is a resource
                                    2. When event sourcing is appropriate
                                    1. A live-scoring system
                                    2. Implementation of the system
                                    1. A mini enterprise resource planning system
                                    2. Implementation of the system
                                    1. Chapter 14. The persistence layer
                                      1. Portrait of a persistence layer
                                        1. Responsibilities of the persistence layer
                                        2. Design of a Repository pattern
                                        1. The query side of repositories
                                        2. Persisting aggregates
                                        3. Storage technologies
                                        1. Familiarizing yourself with NoSQL
                                        2. What you gain and what you lose
                                        3. Planning a sound choice
                                        Show and hide more

                                        Product information

                                        • Title: Microsoft .NET: Architecting Applications for the Enterprise, Second Edition
                                        • Author(s): Dino Esposito, Andrea Saltarello
                                        • Release date: September 2014
                                        • Publisher(s): Microsoft Press
                                        • ISBN: 9780133986419

                                        You might also like

                                        Check it out now on O’Reilly

                                        Dive in for free with a 10-day trial of the O’Reilly learning platform—then explore all the other resources our members count on to build skills and solve problems every day.