万本电子书0元读

万本电子书0元读

顶部广告

Hands-On Domain-Driven Design with .NET Core电子书

售       价:¥

4人正在读 | 0人评论 6.2

作       者:Alexey Zimarev

出  版  社:Packt Publishing

出版时间:2019-04-30

字       数:58.8万

所属分类: 进口书 > 外文原版书 > 电脑/网络

温馨提示:数字商品不支持退换货,不提供源文件,不支持导出打印

为你推荐

  • 读书简介
  • 目录
  • 累计评论(0条)
  • 读书简介
  • 目录
  • 累计评论(0条)
Solve complex business problems by understanding users better, finding the right problem to solve, and building lean event-driven systems to give your customers what they really want Key Features * Apply DDD principles using modern tools such as EventStorming, Event Sourcing, and CQRS * Learn how DDD applies directly to various architectural styles such as REST, reactive systems, and microservices * Empower teams to work flexibly with improved services and decoupled interactions Book Description Developers across the world are rapidly adopting DDD principles to deliver powerful results when writing software that deals with complex business requirements. This book will guide you in involving business stakeholders when choosing the software you are planning to build for them. By figuring out the temporal nature of behavior-driven domain models, you will be able to build leaner, more agile, and modular systems. You’ll begin by uncovering domain complexity and learn how to capture the behavioral aspects of the domain language. You will then learn about EventStorming and advance to creating a new project in .NET Core 2.1; you’ll also and write some code to transfer your events from sticky notes to C#. The book will show you how to use aggregates to handle commands and produce events. As you progress, you’ll get to grips with Bounded Contexts, Context Map, Event Sourcing, and CQRS. After translating domain models into executable C# code, you will create a frontend for your application using Vue.js. In addition to this, you’ll learn how to refactor your code and cover event versioning and migration essentials. By the end of this DDD book, you will have gained the confidence to implement the DDD approach in your organization and be able to explore new techniques that complement what you’ve learned from the book. What you will learn * Discover and resolve domain complexity together with business stakeholders * Avoid common pitfalls when creating the domain model * Study the concept of Bounded Context and aggregate * Design and build temporal models based on behavior and not only data * Explore benefits and drawbacks of Event Sourcing * Get acquainted with CQRS and to-the-point read models with projections * Practice building one-way flow UI with Vue.js * Understand how a task-based UI conforms to DDD principles Who this book is for This book is for .NET developers who have an intermediate level understanding of C#, and for those who seek to deliver value, not just write code. Intermediate level of competence in JavaScript will be helpful to follow the UI chapters.
目录展开

Dedication

About Packt

Why subscribe?

Packt.com

Contributors

About the author

About the reviewers

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

Why Domain-Driven Design?

Understanding the problem

Problem space and solution space

What went wrong with requirements

Dealing with complexity

Types of complexity

Categorizing complexity

Decision making and biases

Knowledge

Domain knowledge

Avoiding ignorance

Summary

Further reading

Language and Context

Ubiquitous Language

Domain language

Sample application domain

Making implicit explicit

Domain language for classified ads

Language and context

Summary

EventStorming

EventStorming

Modeling language

Visualization

Facilitating an EventStorming workshop

Who to invite

Preparing the space

Materials

The room

The workshop

Timing and scheduling

The beginning

During the workshop

After the workshop

Our first model

Summary

Further reading

Designing the Model

Domain model

What does the model represent?

Anemic domain model

Functional languages and anemic models

What to include in the domain model

Design considerations

CQRS

Design-level EventStorming

Getting deeper knowledge

Preparation for the workshop

Extended notation

Commands

Read models

Users

Policies

All together now

Modeling the reference domain

Summary

Further reading

Implementing the Model

Technical requirements

Starting up the implementation

Creating projects

The framework

Transferring the model to code

Entities

Identities

Classified ad entity

Adding behavior

Ensuring correctness

Constraints for input values

Value objects

Factories

Domain services

Entity invariants

Domain events in code

Domain events as objects

Raising events

Events change state

Summary

Acting with Commands

Technical requirements

Outside the domain model

Exposing the web API

Public API contracts

HTTP endpoints

Application layer

Handling commands

The command handler pattern

Application service

Summary

Consistency Boundary

Technical requirements

Domain model consistency

Transaction boundaries

Aggregate pattern

Protecting invariants

Analyzing constraints for a command

Enforcing the rules

Entities inside an aggregate

Summary

Aggregate Persistence

Technical requirements

Aggregate persistence

Repository and units of work

Implementation for RavenDB

Implementation of Entity Framework Core

Summary

CQRS - The Read Side

Technical requirements

Adding user profiles

User profile domain concerns

Domain project organization

Adding new value objects

User profile aggregate root

Application side for the user profile

The query side

CQRS and read-to-write mismatch

Queries and read models

Implementing queries

Query API

Queries with RavenDB

Queries with Entity Framework

Summary

Event Sourcing

Technical requirements

Why Event Sourcing

Issues with state persistence

What is Event Sourcing?

Event Sourcing around us

Event Sourced aggregates

Event streams

Event stores

Event-oriented persistence

Writing to Event Store

Reading from Event Store

The wiring infrastructure

The aggregate store in application services

Running the event-sourced app

Summary

Further reading

Projections and Queries

Events and queries

Building read models from events

Projections

Subscriptions

Implementing projections

Catch-up subscriptions

Cross-aggregate projections

Projecting events from two aggregates

Multiple projections per subscription

Event links and special streams

Enriching read models

Querying from a projection

Upcasting events

Persistent storage

Checkpoints

Persisting read models

Wrapping up

Summary

Bounded Context

The single model trap

Starting small

Complexity, again

Big ball of mud

Structuring systems

Linguistic boundaries

Team autonomy

Limiting work in progress

Improving throughput

Conway's law

Loose coupling, high alignment

Geography

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

累计评论(0条) 0个书友正在讨论这本书 发表评论

发表评论

发表评论,分享你的想法吧!

买过这本书的人还买过

读了这本书的人还在读

回顶部