Applying Domain-Driven Design and Patterns: With Examples in C# and .NET

Index

[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y]

RAD (Rapid Application Development)

RAM, storing data (persistence infrastructure)

Rapid Application Development (RAD)

reachability

reactive validation

recognizing if an application will be long lasting

reconstituting entities from persistence

     reflection against private fields

     specific constructors

     specific methods

recordset

Recordset pattern

Refactor!

refactoring 2nd 3rd 4th

     code smells

         cleaning tools

         preventing growing problems 2nd

         preventing growing problems: Form Template Method

         preventing growing problems: Inline-Singleton

         routine cleanings

         routine cleanings: Encapsulate Collection

         routine cleanings: Encapsulate Field

         routine cleanings: Extract Method

     DDD

     mock objects

     TDD

ReferencePerson 2nd

refining Domain Model

     historic customer information

     Order

     OrderDate

     OrderFactory

     OrderRepository

     OrderType

     ReferencePerson

     through TDD experimentation

     total amount of each order

reflection 2nd 3rd

     private fields

     reconstituting entities from persistence

Register()

registries

Registry, handling example

registry

Registry pattern, Inversion of Control

relational data structures

relational databases

     impedance mismatch:with Domain model

     NHibernate

     storing data (persistence infrastructure)

relational model

     granularity

     navigation

relationships

     impedance mismatch between domain model and relational database

     managing

remote facade

Remote Facade pattern

Rename

replacing

     collaborators with mock objects

     collaborators with testing stubs

repositories

     deciding on structure of

     list customers applying filters

     locations of queries

     NHibernate

     PI

         cost for single-set Repositories

         Fake

         problems doing small scale integration testing

         problems testing

     structure of Repository-related tests

requirements for Domain Models

resetting databases before tests

ReSharper

resource managers, storing data (persistence infrastructure)

results, Functional Research

retreiving data, example

reusability

     patterns

     TDD

reusing

     mapping metadata

     rules

reusing ideas, up-front architecture design

Rich Client applications, SOA

Rollback()

     NHibernate

Rosen-Lidholm, Martin

routing cleanings, code smells

     cleaning tools

     Encapsulate Collection

     Encapsulate Field

     Extract Method

rule classes, creating

rules

     business rules, moving into aspects

     categorizing

     complex rules

     domain-related rules

         Aggregates

         avoiding problems

         cooperation

         IDs

         locating set-based processing methods

         service validation

         transitions

     injecting

     list of rules

         setting up

     Notification pattern

     order placement business rules

     pluggable rules

     principles for

         configurability

         location within state

         prevent going into bad states

         productivity

         states

         testability

         two-way rules checking

     reusing

     setting up a list of rules

Rumbaugh, Jim

runtime versus compile time PI

Категории