book

Microsoft® .NET: Architecting Applications for the Enterprise

by Dino Esposito and Andrea Saltarello

October 2008

Intermediate to advanced

464 pages

14h 20m

English

Microsoft Press

Read now

Unlock full access

Dino’s CreditsAndrea’s Credits
What Is Architecture?Who This Book Is ForCompanion ContentHardware and Software RequirementsFind Additional Content OnlineSupport for This BookQuestions and Comments
What’s a Software Architecture, Anyway?Applying Architectural Principles to SoftwareDefining the Architecture from a Standard ViewpointExamining Key Architecture-Related Points in ANSI/IEEE 1471Defining the System from a Standard ViewpointDescribing the ArchitectureValidating the ArchitectureWhat’s Architecture and What’s NotNo System Is a MonolithDefining the Borderline Between Architecture and ImplementationDealing with Hard-to-Change DecisionsArchitecture Is About DecisionsChanging the Organization of the Business LogicSwitching to a Different LibraryChanging the Constructor’s SignatureChanging a Member’s ModifiersRequirements and Quality of SoftwareExamining the ISO/IEC 9126 StandardFunctional RequirementsNonfunctional RequirementsGathering RequirementsSpecificationsMethodology and the Use of RequirementsWho’s the Architect, Anyway?An Architect’s ResponsibilitiesAcknowledging the RequirementsBreaking Down the SystemIdentifying and Evaluating TechnologiesFormulating SpecificationsHow Many Types of Architects Do You Know?Common Misconceptions About ArchitectsThe Architect Is an AnalystThe Architect Is a Project ManagerThe Architect Never Writes Any CodeOverview of the Software Development ProcessThe Software Life CycleProcessesActivitiesModels for Software DevelopmentTraditional MethodologiesAgile MethodologiesMicrosoft Solutions FrameworkSummaryMurphy’s Laws of the Chapter
UML at a GlanceMotivation for and History of Modeling LanguagesUML PredecessorsVersions and Standards of UMLThe Strengths and Weaknesses of UMLUML in PracticeUML Modes and UsageUML as a SketchUML as a BlueprintUML as a Programming LanguageHow We Use UML in Our Own Real WorldUML DiagramsUse-Case DiagramsA Look at the NotationGeneric RelationshipsInclusionExtensionGeneralizationClass DiagramsA Look at the NotationAttributesOperationsAssociationsGeneralizationDependencySequence DiagramsA Look at the NotationLife and Death of an ObjectAsynchronous MessagesStanding in the Way of ControlSummaryMurphy’s Laws of the Chapter
Basic Design PrinciplesFor What the Alarm Bell Should RingRigid, Therefore FragileEasier to Use Than to ReuseEasier to Work Around Than to FixStructured DesignFrom Spaghetti Code to Lasagna CodeCohesionCouplingSeparation of ConcernsIdentifying the ConcernsModularityInformation HidingSoC and Programming ParadigmsObject-Oriented DesignBasic OOD PrinciplesFind Pertinent Objects FirstFavor Low CouplingFavor Code ReuseAdvanced PrinciplesThe Open/Closed PrincipleLiskov’s Substitution PrincipleThe Dependency Inversion PrincipleFrom Principles to PatternsWhat’s a Pattern, Anyway?Design PatternsHow to Work with Design PatternsWhere’s the Value in Patterns, Exactly?Applied Design PatternsArchitectural PatternsPatterns vs. IdiomsWhat’s an Idiom, Anyway?Sample IdiomsIdiomatic DesignIdiomatic Design: Structures or Classes?Idiomatic Design: Do Not Use List<T> in Public SignaturesDependency InjectionFrom DIP to Inversion of ControlIoC FrameworksIoC Containers in ActionApplying Requirements by DesignTestabilitySoftware TestingSoftware ContractsUnit TestingUnit Testing in ActionDealing with DependenciesFrom Fakes to MocksSecuritySecurity as a (Strict) RequirementSecurity Development LifecycleFoundations of SDL: LayeringFoundations of SDL: ComponentizationFoundation of SDL: RolesThreat ModelSecurity and the ArchitectFinal Security PushFrom Objects to AspectsAspect-Oriented ProgrammingCross-Cutting ConcernsProcessing AspectsInside AOP AspectsAOP in .NETAOP in ActionEnabling PoliciesDefining PoliciesDefining HandlersSummaryMurphy’s Laws of the Chapter
What’s the Business Logic Layer, Anyway?Dissecting the Business LayerThe Domain’s Object ModelThe Domain EntitiesBusiness RulesValidationBusiness Processes and WorkflowsWhere Would You Fit the BLL?Layer vs. TierWhy Should You Care About Layers?Why Should You Care About Tiers?Exposing BLL to the WorldHosting BLLBusiness and Other LayersBLL Distribution and MeasurementsGray Area #1: Data FormattingGray Area #2: CRUD OperationsGray Area #3: Stored ProceduresPatterns for Creating the Business LayerWhy Patterns for the BLL?Procedural PatternsObject-Based PatternsDifferences at a GlanceObject-Based vs. Procedural PatternsA Quick Measure of ComplexityThe Transaction Script PatternGeneralities of the TS PatternWhen to Use TSWhat’s Good About TSWhat’s Bad About TSThe Pattern in ActionDesigning Business ComponentsImplementing Business ComponentsBusiness Components as Command ObjectsConsiderations About the Command PatternStatic and Instance MethodsPassing Data to Transaction ScriptsThe Table Module PatternGeneralities of the TM PatternWhen to Use TMWhat’s Good About TMWhat’s Bad About TMGimme a Quick Answer: TS or TM?The TM Pattern in ActionInternals of a Business ComponentTypical Structure of a Business ComponentTyped DataSetsTable AdaptersThe Table Data Gateway PatternThe Active Record PatternGeneralities of the AR PatternWhen to Use ARWhat’s Good About ARWhat’s Bad About ARThe AR Pattern in ActionA Typical Active Record ClassThe Foreign-Key Mapping PatternData ConversionThe Row Data Gateway PatternLINQ-to-SQLIs LINQ-to-SQL an Active Record?Castle ActiveRecordThe Domain Model PatternGeneralities of the DM PatternWhen to Use DMWhat’s Good About DMWhat’s Bad About DMThe DM Pattern in ActionDesigning the Domain ModelThe Logic in the Domain ObjectsPersistence IgnoranceEntities and Value ObjectsThe Repository PatternMapping Objects to TablesThe Special Case PatternSummaryMurphy’s Laws of the Chapter
What’s the Service Layer, Anyway?Responsibilities of the Service LayerWhat the Service Layer Is Intended ForOrchestrating the System’s BehaviorWhat’s a Service, Anyway?What’s Service Orientation?Our Definition of a ServiceService vs. ClassIs Every Class a Service?Services in the Service LayerFrom Code-Behind to ServicesBenefits of a Service LayerMacro and Micro ServicesThe Service Layer Pattern in ActionGeneralities of the Service Layer PatternReal-World Examples of a Service LayerWhen to Use a Service LayerWhat’s Good About a Service LayerWhat’s Bad About a Service LayerWhere Does a Service Layer Fit?The Service Layer Pattern in ActionDesigning a Service Layer ClassImplementing a Service Layer ClassDealing with Roles and SecurityService Layer and Transaction ScriptDomain Logic and Application LogicRelated PatternsThe Remote Façade PatternMotivation for Using the Remote Façade PatternThe Remote Façade Pattern and the Service LayerThe Data Transfer Object PatternMotivation for Using the PatternData Transfer Object and Service LayerThe Adapter PatternMotivation for Using the Adapter PatternThe Adapter Pattern and the Service LayerDTO vs. AssemblyExamining Some DTO FactsDTO in Action: Load an OrderDTO in Action: Update an OrderWhen You Can Do Without DTOsWhat You Gain and What You LoseService-Oriented ArchitectureTenets of SOABoundaries Are ExplicitServices Are AutonomousUse Contracts, Not ClassesCompatibility Is Based on PolicyA Summary of the TenetsWhat SOA Is NotSOA Is Not a RevolutionSOA Is Not a TechnologySOA Is Not a Web ServiceSOA Is Not a GoalSOA and the Service LayerSOA in PracticeWhat’s Good About Using SOA in the Service LayerSOA AntipatternsCRUDy InterfacesChatty InterfacesThe Very Special Case of Rich Web Front EndsRefactoring the Service LayerWhy Rich Web-Based Clients Are a ProblemRefactoring for FunctionalityRefactoring for SecurityDesigning an AJAX Service LayerScript-Enabling ASP.NET XML Web ServicesScript-Enabling WCF ServicesGenerating JavaScript ProxiesJSON vs. XMLSecuring the AJAX Service LayerDetecting OutsidersLogin Pages Never Go Out of StyleChecking Identity and Authorization in the ServiceSummaryMurphy’s Laws of the Chapter
What’s the Data Access Layer, Anyway?Functional Requirements of the Data Access LayerDatabase IndependenceConfigurable as a Plug-inPersisting the Application’s Object ModelResponsibilities of the Data Access LayerCRUD ServicesQuery ServicesTransactions ManagementHandling ConcurrencyPutting It All Together: The Data ContextThe Data Access Layer and Other LayersThe DAL and the Business LayerThe DAL and the Service LayerThe DAL and the Presentation LayerDesigning Your Own Data Access LayerThe Contract of the DALThe Separated Interface PatternProgram to a (DAL) InterfaceAbstracting the Capabilities of a DALThe Plugin PatternGeneralities of the Plugin PatternThe DAL Factory in ActionBuilding a DAL PluginService Locator vs. PluginThe Inversion of Control PatternInjecting a Reference to the DALInversion of Control in Action Through UnityDependency Injection MechanismsInversion of Control vs. PluginLaying the Groundwork for a Data ContextThe IDataContext InterfaceA Common Class for the Data ContextCrafting Your Own Data Access LayerImplementing the Persistence LayerThe Gateway to StorageA Factory for Data MappersInside Data MappersBridging Types and TablesCross-Table OperationsImplementing Query ServicesA Repository of ObjectsImplementing a RepositoryBasic Query CapabilitiesQuery by CriteriaImplementing Transactional SemanticsDefining a Unit of WorkScheduled ActionsManaging DAL TransactionsImplementing Uniquing and Identity MapsGetting Unique ObjectsImplementing an Identity MapUniquing Is Not Like CachingAn Identity Map Looks, Walks, and Quacks Like a CacheCaching and Queries: A Not So Powerful DuoImplementing ConcurrencyDon’t Worry, Be OptimisticSpecializing the Data MapperCreating a Proxy for the EntityUsing a Timestamp ColumnImplementing Lazy LoadingOn-Demand Data LoadingHard-Coded Fetch PlansSpecifying a Dynamic Fetch PlanPower to the DAL with an O/RM ToolObject/Relational MappersDo I Really Need an O/RM Tool?If Only We Could Have an Object-Oriented DBMSCreating an O/R Mapping LayerSample O/RM ToolsUsing an O/RM Tool to Build a DALThe O/RM Is Your Data ContextObject Services with an O/RMTransactions with an O/RMQuerying with an O/RMThe Domain Model and Persistence IgnoranceWhy Is Persistence Ignorance So Desirable?To SP or Not to SPAbout Myths and Stored ProceduresMyth: Stored Procedures Are Faster Than SQL CodeMyth: Stored Procedures Are More Secure Than SQL CodeMyth: Stored Procedures Can Be Used to Fend Off SQL InjectionMyth: Stored Procedures Can Be Used to Reduce Brittleness of SQL CodeWhat Stored Procedures Are ForShould You Use Stored Procedures?What About Dynamic SQL?Embedding SQL StaticallyThe Turning Point Created by O/R MappersDo You Still Need a DBA?SummaryMurphy’s Laws of the Chapter

User Interface and Presentation LogicResponsibilities of the Presentation LayerIndependence from GraphicsIndependence from UI TechnologySupport for TestingIndependence from a Model of the DataResponsibilities of the User InterfaceUseful Data DisplayComfortable Data EntryGeneral AppearanceCommon Pitfalls of a Presentation LayerRADness in the PresentationBoundaries of the Presentation LayerWhat Users Get Is What You WantEvolution of the Presentation PatternsThe Model-View-Controller PatternMoving Away from Autonomous ViewsMVC: Pattern or Paradigm?Generalities of the MVC PatternThe Model in MVCThe View in MVCThe Controller in MVCModel2: A Web Variation of MVCThe Model-View-Presenter PatternGeneralities of the MVP PatternThe Model in MVPThe View in MVPThe Presenter in MVPMVP and Enterprise-Class ApplicationsThe Presentation Model PatternThe Model in PMThe View in PMThe Presenter in PMChoosing a Pattern for the User InterfaceMy Focus Is the WebMy Focus Is WindowsI Need to Support Multiple GUIsDesign of the PresentationWhat Data Is Displayed in the View?Creating a Contract for the ViewHow Much Logic Do You Want in the View?Do You Want a Passive View?Implementing the Contract in the ViewProcessing User ActionsConnecting View and PresenterBuilding the PresenterExecuting User ActionsThe Presenter and the Service LayerSelecting the Next ViewCardinality of Views, Presenters, and Application ControllersIdiomatic Presentation DesignMVP in Web PresentationsThe Web Client Software FactoryThe ASP .NET MVC FrameworkMVP in Windows PresentationsThe Smart Client Software FactoryThe MVC# FrameworkWindows Presentation FoundationSummaryMurphy’s Laws of the Chapter
Mantra #1—It DependsMantra #2—Requirements Are Lord Over AllMantra #3—Program to an InterfaceMantra #4—Keep It Simple but Not SimplisticMantra #5—Inheritance Is About Polymorphism, Not ReuseMantra #6—Not the DAL? Don’t Touch SQL ThenMantra #7—Maintainability FirstMantra #8—All User Input Is EvilMantra #9—Post-Mortem OptimizationMantra #10—Security and Testability Are by Design
Motivation for Creating NSKDownloading NSKNSK RequirementsThe Northwind DatabaseWhat’s in NSK?The Data FolderThe Business FolderThe Presentation FolderFuture Evolution of NSK
Dino EspositoAndrea Saltarello

Overview

Make the right architectural decisions up front—and improve the quality and reliability of your results. Led by two enterprise programming experts, you’ll learn how to apply the patterns and techniques that help control project complexity—and make systems easier to build, support, and upgrade—right from the start.

Get pragmatic architectural guidance on how to:

Build testability, maintainability, and security into your system early in the design

Expose business logic through a service-oriented interface

Choose the best pattern for organizing business logic and behavior

Review and apply the patterns for separating the UI and presentation logic

Delve deep into the patterns and practices for the data access layer

Tackle the impedance mismatch between objects and data

Minimize development effort and avoid over-engineering—and deliver more robust results

Get code samples on the Web.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Start your free trial

Professional Enterprise .NET

Jon Arking, Scott Millett

Microsoft® .NET Remoting

Scott McLean, James Naftel, Kim Williams

Microsoft® .NET Distributed Applications: Integrating XML Web Services and .NET Remoting

Matthew MacDonald

RESTful .NET

Jon Flanders

Publisher Resources

ISBN: 9780735626096Purchase book