This chapter is from the book
This chapter is from the book
This chapter is from the book
Discussion
In many systems, some use cases partly overlap; that is, a sub-sequence of actions is the same in several use cases. If this is a coincidence, and the sub-sequences are unrelated to each other and will be modified independently, no additional measures are needed. However, if it is required that these sub-sequences of actions must be the same, this requirement should be expressed in the model. This is done by modeling the common sub-sequence of actions, including its alternative flows, in a separate use case. When the performance of the sub-sequence is to be modified, only this use case will be updated.
It is important that the commonality encompasses a sequence of actions and not just a single action. Furthermore, if there is no explicit requirement stating that the sub-sequence must be the same in the overlapping use cases, there must be another significant reason for introducing the additional use case into the model (for example, to enable future reuse). If not, the complexity of the model will be increased without any defendable cause.
Obviously, the use-case model must comprise relationships of some kind between the use case modeling the common sub-sequence of actions and the use cases in which the sub-sequence is to appear. Which kind of relationship to use depends on the situation (see also Chapter 7, "Include: Reusing Existing Use Cases," Chapter 8, "Extend: Expanding Existing Use Cases," and Chapter 11, "Use-Case Generalization: Classification and Inheritance").
Sub-Sequence Independent of Context
If the sub-sequence must be independent of in which context it is used, an include relationship should be used, as in the Commonality: Reuse pattern. In this case, the base use cases will have include relationships to the use case modeling the common sub-sequence of actions. The description of the flow of the base use case will incorporate a reference to the included use case where the common sub-sequence is to be performed, but there will be no references in the other direction because the common sub-sequence is independent of its context (see Chapter 7). Reuse of the same sequence of actions in multiple use cases is a typical example of when to use the include relationship (see Figure 17.1).
){kind=small}
Figure 17.1 The PIN code is checked in multiple use cases.
In a library system, the borrower must always present the library card and a corresponding PIN code when registering a new loan, checking the existing loans, or extending an existing loan.
The sub-sequence checking whether the card is valid and whether the PIN code matches the card will be modeled in a separate use case to be reused in all the different loan-handling use cases (see Figure 17.1). When adding a new type of loan transaction to the library system, the new use case will have an include relationship to the existing Check Card and PIN Code use case. Hence, that sequence of actions will be reused when defining the new use case.
Note that the whole sub-sequence is to be performed at a single location in the base use case. It is not possible to split the sub-sequence in parts where one is to be performed at one location and the other at another location. If this is required, one include relationship must be defined for each sub-sequence part.
Additions to Existing Use Cases
When a new sub-sequence of actions is to be added to multiple already existing use cases, or when the same sub-sequence can be extracted from already existing use cases without breaking them or making them incomplete, an extend relationship is to be used. This is the Commonality: Addition pattern. In this case, the existing use cases will be independent of the common sub-sequence of actions, so their descriptions will not contain any references to the use case modeling the commonality. Hence, this use case can be added or removed without affecting the definition of the existing use cases (see Chapter 8).
)
Figure 17.2 The check if someone has pre-registered to be the next borrower
of a book is inserted into multiple use cases.
Each time a book is returned to the library, the library system checks whether someone has pre-registered to be the next borrower of that book. If so, a notification is sent to that person and the book becomes unavailable for any other borrower within the next seven days.
The same check is also performed when the librarian registers that the library has bought a new copy of a book.
Because the Return Book use case and the Register New Copy use case are both complete in themselves, we can model this check in a separate use case, called Check Reservation Queue, that will have extend relationships to the other two use cases (see Figure 17.2).
Although all the behavior modeled by the extension use case will be added to the base use case, it is not required that all is added at the same location in the base use case. Instead, one part of the extension use case may be added to one location and another part be added to another location. However, if the parts have an internal order in the extension use case, they must be inserted in that order into the base use case (see Chapter 10, "More on Extend and Extension Points").
Similar Use Cases
Some systems include several use cases that perform similar tasks. One example is a warehouse management system where each type of order is carried out in a similar way. An automated production system is another example, where the different kinds of production directives are executed similarly but not identically. Because all the use cases modeling the performance of tasks are of the same kind, this commonality should be captured in the model. It is done by introducing a new use case that will model how a task is to be performed in general, including all the actions common to all kinds of tasks. The specific performances of the tasks are captured in separate use cases with generalization relationships to the new use case, as in the Commonality: Similarities pattern. The child use cases may specialize actions defined in the parent use case as well as add new ones (see Chapter 11).
Commonality Within a Single Use Case
In one use case, the same sub-sequence of actions may appear several times, typically in different alternative flows, but sometimes even in the same flow. In such cases, the common sub-sequence should not be extracted into a separate use case, because it only adds to the complexity of the model. Instead, the sub-sequence is described in a separate section in the description of the use case according to the Commonality: Internal Reuse pattern. When describing the flow of the use case, this section will be referenced from all the locations where the common sub-sequence is to be performed.