What's is the difference between include and extend in use case diagram?

Question

What is the difference between include and extend in a use case diagram?

@Megamind 'extend = Optional' is not entirely true... Look at this example [link](http://agilemodeling.com/essays/useCaseReuse.htm) — Shanaka Jayalath, May 14 '16 at 13:47
I wouldn't do a better job than Scott Ambler at explaining how they can be used for reuse in use-case models and how they differ. So instead of paraphrasing him, I'd suggest to read [Reuse in Use-Case Models: <<extend>>, <<include>>, and Inheritance](http://www.agilemodeling.com/essays/useCaseReuse.htm). — Pascal Thivent, Nov 08 '09 at 16:06
You use include dependencies whenever one use case needs the behavior of another. Introducing a new use case that encapsulates similar logic that occurs in several use cases is quite common. - See more at: http://www.agilemodeling.com/essays/useCaseReuse.htm#Include — Noman Chali, May 24 '17 at 03:40

Doug Knesek · Answer 1 · 2018-07-22T19:25:50.303

324

Extend is used when a use case adds steps to another first-class use case.

For example, imagine "Withdraw Cash" is a use case of an Automated Teller Machine (ATM). "Assess Fee" would extend Withdraw Cash and describe the conditional "extension point" that is instantiated when the ATM user doesn't bank at the ATM's owning institution. Notice that the basic "Withdraw Cash" use case stands on its own, without the extension.

Include is used to extract use case fragments that are duplicated in multiple use cases. The included use case cannot stand alone and the original use case is not complete without the included one. This should be used sparingly and only in cases where the duplication is significant and exists by design (rather than by coincidence).

For example, the flow of events that occurs at the beginning of every ATM use case (when the user puts in their ATM card, enters their PIN, and is shown the main menu) would be a good candidate for an include.

edited Jul 22 '18 at 19:25

answered Nov 15 '09 at 18:48

Doug Knesek

6,527
3
21
26

3

`Include is used to extract use case fragments that are duplicated in multiple use cases`, what is extracted in those steps : `puts in their ATM card, enters their PIN, and is shown the main menu`? Thanks – Blaze Tama Nov 24 '14 at 14:28
5

I must disagree with including the "login" steps being a good candidate for a **include**. Those steps form a use case own their own, and should be linked to the others use cases by post-conditions -> pre-conditions. – Bruno Brant Jan 20 '15 at 17:10
41

@Bruno - No one would log in to an ATM machine and just walk away happy. Concrete use cases must provide stand-alone value to the actor, otherwise they are just functions in a functional decomposition. – Doug Knesek Jan 21 '15 at 19:06
@Blaze - All parts of the login flow, including those steps. – Doug Knesek Jan 21 '15 at 19:09
1

How could Assess Fee be a UC? This is a conditional flow in a scenario. It's not an added value at all. It's the complete opposite. – qwerty_so Oct 23 '15 at 19:49
1

@ThomasKilian - From the UML 2.5: "Extend is intended to be used when there is some additional behavior that should be added, possibly conditionally, to the behavior defined in one or more UseCases." And "the extending UseCase typically defines behavior that may not necessarily be meaningful by itself." It's the concrete Use Case that must provide value to the Actor; not the extending Use Case. – Doug Knesek Oct 24 '15 at 03:28
I know what the UML spec says. But honestly, even OMG can be wrong. And this is simply a bad concept. See my own answer above. – qwerty_so Oct 24 '15 at 07:46
@ThomasKilian - My objective was simply to answer given question. So I provided a simple UML 2.5 introductory example very similar to Jacobson's examples, since he invented the damned things. Personally, I use Use Cases to contextualize User Stories, and have found little use for "extends" relationships in the last decade. The OMG isn't wrong by definition, as they own the spec. They just don't have a monopoly on useful modeling heuristics. – Doug Knesek Oct 24 '15 at 14:38
Sure. It's never wrong as it's their standard. But you know that the fact not being useful is the same as being wrong (so to say). Additionally this concept leads to using it the wrong way and that's even worse. Though 2.5 is an improvement over previous versions it still has quite a number of bugs/issues/wrong concepts. I think we could have a lengthy discussion on this without being able to change matters. So let's agree to not start with that ;-) – qwerty_so Oct 24 '15 at 15:12
@ThomasKilian - I didn't say it wasn't useful in an absolute sense. It (and most of the UML) just hasn't been useful to me for a very long time. However, others may find the concept, as specified, useful in their contexts. – Doug Knesek Oct 24 '15 at 16:38
Let us [continue this discussion in chat](http://chat.stackoverflow.com/rooms/93257/discussion-between-doug-knesek-and-thomas-kilian). – Doug Knesek Oct 24 '15 at 19:09

score 138 · Answer 2 · edited Jun 10 '17 at 07:43

This may be contentious but the “includes are always and extends are sometimes” is a very common misconception which has almost taken over now as the de-facto meaning. Here’s a correct approach (in my view, and checked against Jacobson, Fowler, Larmen and 10 other references).

Relationships are dependencies

The key to Include and extend use case relationships is to realize that, common with the rest of UML, the dotted arrow between use cases is a dependency relationship. I’ll use the terms ‘base’, ‘included’ and ‘extending’ to refer to the use case roles.

include

A base use case is dependent on the included use case(s); without it/them the base use case is incomplete as the included use case(s) represent sub-sequences of the interaction that may happen always OR sometimes. (This is contrary to a popular misconception about this, what your use case suggests always happens in the main scenario and sometimes happens in alternate flows simply depends on what you choose as your main scenario; use cases can easily be restructured to represent a different flow as the main scenario and this should not matter).

In the best practice of one way dependency the base use case knows about (and refers to) the included use case, but the included use case shouldn’t ‘know’ about the base use case. This is why included use cases can be: a) base use cases in their own right and b) shared by a number of base use cases.

extend

The extending use case is dependent on the base use case; it literally extends the behavior described by the base use case. The base use case should be a fully functional use case in its own right (‘include’s included of course) without the extending use case’s additional functionality.

Extending use cases can be used in several situations:

The base use case represents the “must have” functionality of a project while the extending use case represents optional (should/could/want) behavior. This is where the term optional is relevant – optional whether to build/deliver rather than optional whether it sometimes runs as part of the base use case sequence.
In phase 1 you can deliver the base use case which meets the requirements at that point, and phase 2 will add additional functionality described by the extending use case. This can contain sequences that are always or sometimes performed after phase 2 is delivered (again contrary to popular misconception).
It can be used to extract out subsequences of the base use case, especially when they represent ‘exceptional’ complex behavior with its own alternative flows.

One important aspect to consider is that the extending use case can ‘insert’ behavior in several places in the base use case’s flow, not just in a single place as an included use case does. For this reason, it is highly unlikely that an extending use case will be suitable to extend more than one base use case.

As to dependency, the extending use case is dependent on the base use case and is again a one-way dependency, i.e. the base use case doesn’t need any reference to the extending use case in the sequence. That doesn’t mean you can’t demonstrate the extension points or add a x-ref to the extending use case elsewhere in the template, but the base use case must be able to work without the extending use case.

SUMMARY

I hope I’ve shown that the common misconception of “includes are always, extends are sometimes” is either wrong or at best simplistic. This version actually makes more sense if you consider all the issues about the directionality of the arrows the misconception presents – in the correct model it’s just dependency and doesn’t potentially change if you refactor the use case contents.

would be great if you could add some references for that claim — mibollma, Sep 26 '12 at 11:47
Sorry, creating a UML diagram in this fashion as software goes through iterations that add new functionality that was always intended be required in the end state would just be needlessly confusing and complex. I prefer Doug Knesek's approach, much simpler to understand and work with while not creating any unnecessary confusion or complexity. — BigMac66, Apr 22 '15 at 17:53
Although you are right to challenge the "includes are always and extends are sometimes" as it relates to Use Case instances, your choice to exploit "extend" semantics to support incremental delivery may lead others to think "extend" is ABOUT incremental delivery. — Doug Knesek, Oct 24 '15 at 17:35
Here's the UML 2.0 Specification document. It clearly defines what include vs. extend means for use cases: "16.3.3" at https://www.omg.org/spec/UML/2.0/Superstructure/PDF — Underlines, Nov 11 '20 at 07:41
Underlines, this is a large document, it would be more useful to add a page number to that response. — Andrew S, Dec 09 '21 at 14:39

score 109 · Answer 3 · edited Mar 26 '15 at 10:47

109

I often use this to remember the two:

My use case: I am going to the city.

includes -> drive the car

extends -> fill the petrol

"Fill the petrol" may not be required at all times, but may optionally be required based on the amount of petrol left in the car. "Drive the car" is a prerequisite hence I am including.

edited Mar 26 '15 at 10:47

Toadfish

1,112
1
12
22

answered Jul 03 '13 at 13:01

skipy

4,032
2
23
19

3

But, "fill the petrol" actually extends "going to the city", not the other way around, right? – Petr Hudeček Apr 08 '15 at 06:12
3

I think it depend on point of view Petr. Imho "fill the petrol" can actually extend drive the car as well. – Daniel Perník Apr 16 '15 at 19:27
5

Going to the city and filling the petrol sound like two completely unrelated things which just might happen by coincidence. – OdraEncoded Jun 20 '15 at 15:22
4

@OdraEncoded is correct. Fill petrol is not dependent on going to the city. – nonybrighto Apr 03 '17 at 15:32

score 77 · Answer 4 · answered Aug 06 '15 at 01:43

Use cases are used to document behavior, e.g. answer this question.

A behavior extends another if it is in addition to but not necessarily part of the behavior, e.g. research the answer.

Also note that researching the answer doesn't make much sense if you are not trying to answer the question.

A behavior is included in another if it is part of the including behavior, e.g. login to stack exchange.

To clarify, the illustration is only true if you want to answer here in stack overflow :).

These are the technical definitions from UML 2.5 pages 671-672.

I highlighted what I think are important points.

Extends

An Extend is a relationship from an extending UseCase (the extension) to an extended UseCase (the extendedCase) that specifies how and when the behavior defined in the extending UseCase can be inserted into the behavior defined in the extended UseCase. The extension takes place at one or more specific extension points defined in the extended UseCase.

Extend is intended to be used when there is some additional behavior that should be added, possibly conditionally, to the behavior defined in one or more UseCases.

The extended UseCase is defined independently of the extending UseCase and is meaningful independently of the extending UseCase. On the other hand, the extending UseCase typically defines behavior that may not necessarily be meaningful by itself. Instead, the extending UseCase defines a set of modular behavior increments that augment an execution of the extended UseCase under specific conditions.

...

Includes

Include is a DirectedRelationship between two UseCases, indicating that the behavior of the included UseCase (the addition) is inserted into the behavior of the including UseCase (the includingCase). It is also a kind of NamedElement so that it can have a name in the context of its owning UseCase (the includingCase). The including UseCase may depend on the changes produced by executing the included UseCase. The included UseCase must be available for the behavior of the including UseCase to be completely described.

The Include relationship is intended to be used when there are common parts of the behavior of two or more UseCases. This common part is then extracted to a separate UseCase, to be included by all the base UseCases having this part in common. As the primary use of the Include relationship is for reuse of common parts, what is left in a base UseCase is usually not complete in itself but dependent on the included parts to be meaningful. This is reflected in the direction of the relationship, indicating that the base UseCase depends on the addition but not vice versa.

...

I believe the included login example is incorrect. This implies that you must login every time you need to do answer question, what if you were already logged in, to do any other use case? — Ahmed Alhallag, Nov 01 '22 at 02:03

score 74 · Answer 5 · edited Jul 16 '18 at 19:05

74

To simplify,

for include

When the base use case is executed, the included use case is executed EVERYTIME.
The base use case required the completion of the included use case in order to be completed.

a typical example: between login and verify password

(login) --- << include >> ---> (verify password)

for the login process to success, "verify password" must be successful as well.

for extend

When the base use case is executed, the extended use case is executed only SOMETIMES
The extended use case will happen only when certain criteria are met.

a typical example: between login and show error message (only happened sometimes)

(login) <--- << extend >> --- (show error message)

"show error message" only happens sometimes when the login process failed.

edited Jul 16 '18 at 19:05

Mohammad Kanan

4,452
10
23
47

answered Jul 16 '18 at 18:21

bohbian

861
6
5

great example ! – Pavel Durov Jun 12 '20 at 08:18
3

So `include` is for "need to" whereas `extend` is for "may" – testing_22 Feb 27 '22 at 20:35
Good description, questionable examples ... are "verify password" and "show error message" use cases? Sounds more like things the system should do. (Use case = a case in which someone would use the system.) IMHO, "login" is not even a use case but an annoying action the user is forced to do by the system to work properly. – Stefan Steinegger Aug 15 '23 at 06:57

jimasp · Answer 6 · 2012-04-14T11:04:13.173

I think it's important to understand the intention of includes and extends:

"The include relationship is intended for reusing behaviour modeled by another use case, whereas the extend relationship is intended for adding parts to existing use cases as well as for modeling optional system services" (Overgaard and Palmkvist, Use Cases: Patterns and Blueprints. Addison-Wesley, 2004).

This reads to me as:

Include = reuse of functionality (i.e. the included functionality is used or could be used elsewhere in the system). Include therefore denotes a dependency on another use case.

Extends = adding (not reusing) functionality and also any optional functionality. Extends therefore can denote one of two things:
1. adding new features/capabilities to a use case (optional or not)
2. any optional use cases (existing or not).

Summary:
Include = reuse of functionality
Extends = new and/or optional functionality

You will most often find the 2nd usage (i.e. optional functionality) of extends, because if functionality is not optional, then most times it is built into the use case itself, rather than being an extension. At least that's been my experience. (Julian C points out that you sometimes see the 1st usage (i.e. adding new features) of extends when a project enters it's 2nd phase).

Etic · Answer 7 · 2016-10-28T00:42:15.330

23

I think what msdn explained here are quite easy to understand.

Include [5]

An including use case calls or invokes the included one. Inclusion is used to show how a use case breaks into smaller steps. The included use case is at the arrowhead end.

Extend [6]

Meanwhile, an extending use case adds goals and steps to the extended use case. The extensions operate only under certain conditions. The extended use case is at the arrowhead end.

edited Oct 28 '16 at 00:42

answered Oct 27 '16 at 09:01

Etic

291
4
9

1

You should at least quote the essence in your answer, not simply add a link to an answer. On top of that the explanation you reference isn't really good or precise either. – Geert Bellekens Oct 27 '16 at 12:17
Hi @GeertBellekens, I've added some detail to explain the difference between include and extend. IMHO the diagram itself clearly communicate the difference and that is what the diagram are used for. – Etic Oct 28 '16 at 00:47
I'm glad you added the explanations, but I still think that they aren't very good or precise. People (even, or especially if they write for msdn) should stop inventing their own definitions for something that is already defined in a standard. – Geert Bellekens Oct 28 '16 at 05:40

score 15 · Answer 8 · edited May 06 '18 at 18:43

Let's make this clearer. We use include every time we want to express the fact that the existence of one case depends on the existence of another.

EXAMPLES:

A user can do shopping online only after he has logged in his account. In other words, he can't do any shopping until he has logged in his account.

A user can't download from a site before the material had been uploaded. So, I can't download if nothing has been uploaded.

Do you get it?

It's about conditioned consequence. I can't do this if previously I didn't do that.

At least, I think this is the right way we use Include. I tend to think the example with Laptop and warranty from right above is the most convincing!

score 9 · Answer 9 · answered May 01 '11 at 19:53

whenever there are prerequisites to a usecase then,go for include.

for usecases having authentication,worst case scenario,or are optional then go for extend..

example:for a use case of seeking admission,appointment,ticket reservation YOU MUST FILL A form (registration or feedback form)....this is where include comes..

example:for a use case verifying login or sign in your account,your authentication is a must.also think of worst case scenarios.like returning book with fine..NOT getting a reservation..paying the bill AFTER DUE DATE..this is where extend comes to play...

do not overuse include and extend in the diagrams.

KEEP IT SIMPLE SILLY!!!

score 8 · Answer 10 · edited Apr 27 '17 at 08:35

Both <include> and <extend> are dependent on the base class but <extend> is optional i.e., it is derived from the base class but in the point of users view it may be used or may not be used.

<include> is incorporated in base class i.e., it is compulsary to use <include> in your use case or else it would be considered incomplete.

eg:

In ATM machine construction (according to users point of view):

1: Withdrawal,deposit of cash and checking the account comes under <extend> because it depends on the user whether to withdraw or deposit or check. These are optional things the user does.

2: "Enter the pin, placing card, removal of card" these are the things that come under <include> because the user must, and should, place a card and enter a valid pin for verification.

score 7 · Answer 11 · answered Oct 24 '12 at 10:29

7

"Include" is used to extend the base use case and it is a must condition i.e. included use case run must run successfully to complete base use.

e.g. Consider a case of Email Service, here "Login" is a included use case which must be run in order to send a Email (Base use case)

"Exclude" on the other hand is optional use case which extends the base use case, base use case can run successfully even without invoking/calling the extending use case.

e.g. Consider "Laptop Purchase" as base use case and "Additional Warranty" as extending use case, here you can run base use case "Laptop Purchase" even without taking additional warranty.

answered Oct 24 '12 at 10:29

sarbjit

3,786
9
38
60

perhaps the case of "making" payment would serve as an "includes" for purchasing a laptop? I say this as it's nice to have the examples 'together' in the same scenario. Also, making a payment is something that would be used in many different scenarios, so it seems like it might be a suitable candidate for <>. – baxx Apr 07 '16 at 16:04
2

`Login` is not a use case at all. It's a function performed to fulfill a pre-condition. – qwerty_so Dec 08 '19 at 11:33

score 7 · Answer 12 · answered Mar 21 '13 at 14:02

Also beware of the UML version : it's been a long time now that << uses >> and << includes >> have been replaced by << include >>, and << extends >> by << extend >> AND generalization.
For me that's often the misleading point : as an example the Stephanie's post and link is about an old version :

When paying for an item, you may choose to pay on delivery, pay using paypal or pay by card. These are all alternatives to the "pay for item" use case. I may choose any of these options depending on my preference.

In fact there is no really alternative to "pay for item" ! In nowadays UML, "pay on delivery" is an extend, and "pay using paypal"/"pay by card" are specializations.

score 4 · Answer 13 · edited Jun 20 '20 at 09:12

4

This is great resource with great explanation: What is include at use case? What is Extend at use case?

Extending use case typically defines optional behavior. It is independent of the extending use case

Include used to extract common parts of the behaviors of two or more use cases

edited Jun 20 '20 at 09:12

Community

1
1

answered Mar 04 '14 at 12:12

chameleon

145
3
6

You are not referencing the link correctly. It should be "Extended" not "Extending" – Ahmed Alhallag Nov 01 '22 at 02:39

Learner · Answer 14 · 2015-07-23T06:44:43.167

4

I don't recommend the use of this to remember the two:

My use case: I am going to the city.

includes -> drive the car

extends -> fill the petrol

I would rather you use: My use case: I am going to the city.

extends -> driving the car

includes -> fill the petrol

Am taught that extend relationship continues the behaviour of a base class. The base class functionalities have to be there. The include relationship on the other hand, are akin to functions that may be called. May is in bold.

This can be seen from agilemodeling Reuse in Use-Case Models

edited Jul 23 '15 at 06:44

answered Jul 23 '15 at 06:38

Learner

41
3

It rather should read "fill the petrol -> extends" since your main UC does not extend "fill petrol". Except you are a petrol company. – qwerty_so Apr 24 '17 at 22:04

score 4 · Answer 15 · answered Oct 23 '15 at 20:13

The difference between both has been explained here. But what has not been explained is the fact that <<include>> and <<extend>> should simply not be used at all.

If you read Bittner/Spence you know that use cases are about synthesis, not analysis. A re-use of use cases is nonsense. It clearly shows that you have cut your domain wrongly. Added value must be unique per se. The only re-use of added value I know is franchise. So if you are in burger business, nice. But everywhere else your task as BA is to try to find an USP. And that must be presented in good use cases.

Whenever I see people using one of those relations it is when they try to do functional decomposition. And that's plain wrong.

To put it simple: if you can answer your boss without hesitation "I have done ..." then the "..." is your use case since you got money for doing it. (That will also make clear that "login" is not a use case at all.)

In that respect, finding self standing use cases that are included or extend other use cases is very unlikely. Eventually you can use <<extend>> to show optionality of your system, i.e. some licensing schema which allows to include use cases for some licenses or to omit them. But else - just avoid them.

score 4 · Answer 16 · answered Apr 15 '17 at 00:46

The include relationship allows one use case to include the steps of another use case.

For example, suppose you have an Amazon Account and you want to check on an order, well it is impossible to check on the order without first logging into your account. So the flow of events would like so...

The extend relationship is used to add an extra step to the flow of a use case, that is usually an optional step...

Imagine that we are still talking about your amazon account. Lets assume the base case is Order and the extension use case is Amazon Prime. The user can choose to just order the item regularly, or, the user has the option to select Amazon Prime which ensure his order will arrive faster at higher cost.

However, note that the user does not have to select Amazon Prime, this is just an option, they can choose to ignore this use case.

What sort of use case should `Amazon Prime` be? It doesn't even contain a verb. — qwerty_so, Dec 08 '19 at 11:28

score 4 · Answer 17 · edited Jan 19 '12 at 06:27

Diagram Elements

Actors: Also referred to as Roles. Name and stereotype of an actor can be changed in its Properties tab.
Inheritance: Refinement relations between actors. This relation can carry a name and a stereotype.
Use cases: These can have Extension Points.
Extension Points: This defines a location where an extension can be added.
Associations: Between roles and use cases. It is useful to give associations speaking names.
Dependencies: Between use cases. Dependencies often have a stereotype to better define the role of the dependency. To select a stereotype, select the dependency from the diagram or the Navigation pane, then change the stereotype in the Properties tab. There are two special kinds of dependencies: <<extend>> and <<include>>, for which Poseidon offers own buttons (see below).
Extend relationship: A uni-directional relationship between two use cases. An extend relationship between use case B and use case A means that the behavior of B can be included in A.
Include relationship: A uni-directional relationship between two use cases. Such a relationship between use cases A and B means, that the behavior of B is always included in A.
System border: The system border is actually not implemented as model element in Poseidon for UML. You can simply draw a rectangle, send it to the background and use it as system border by putting all corresponding use cases inside the rectangle.

mrmashal · Answer 18 · 2016-04-01T02:17:01.473

3

Extends is used when you understand that your use case is too much complex. So you extract the complex steps into their own "extension" use cases.

Includes is used when you see common behavior in two use cases. So you abstract out the common behavior into a separate "abstract" use case.

(ref: Jeffrey L. Whitten, Lonnie D. Bentley, Systems analysis & design methods, McGraw-Hill/Irwin, 2007)

edited Apr 01 '16 at 02:17

answered Dec 11 '15 at 15:39

mrmashal

1,721
18
21

1

Extend has nothing to do with a use case that is simply too complex. That approach will lead to building a functional decomposition rather than an actual Use Case model. – Doug Knesek Jul 08 '16 at 15:26
1

I think software engineering concepts and, in general, everything that approaches human sciences becomes much opinion-based. I've included the ref (See page 248). Don't be too hard on it man :) – mrmashal Jul 11 '16 at 15:32

score 0 · Answer 19 · answered Feb 23 '13 at 09:42

I like to think of "includes" as a necessary prerequisite/accompaniment of the base use case. This means that the base use case cannot be considered complete without the use case it includes. I'll give the example of an e-commerce website that sells items to customers. There's no way you can pay for an item without first selecting that item and putting it in the cart. This implies that the use case "Pay for Item" includes "select item".

There are varying uses of extends but I like to think of it as an alternative that may or may not be used. For example - still on the e-commerce site. When paying for an item, you may choose to pay on delivery, pay using paypal or pay by card. These are all alternatives to the "pay for item" use case. I may choose any of these options depending on my preference.

For more clarity and the rules surrounding use cases, read my article here:

http://businessanalystlearnings.com/ba-techniques/2013/2/20/use-case-diagram-the-basics

Welcome to Stack Overflow! Thanks for posting your answer! Please be sure to read the [FAQ on Self-Promotion](http://stackoverflow.com/faq#promotion) carefully. Not a bad answer, really; but just be aware of what the FAQ says about self-promotional posts. — Andrew Barber, Feb 23 '13 at 09:44
UC diagram at the bottom of your link is just an anti-pattern. Neither `login` nor `create` account are use cases. Both are functions. Therefore -1 — qwerty_so, Dec 08 '19 at 11:23

Michail Markou · Answer 20 · 2022-03-21T13:06:56.220

-1

A way I remember it is by video games. For example, (the below is not for 100% of all cases but just an example of a use case)

Extends: The main menu extends some functionality, which means they have some functionality on them but not necessary to be pressed

Includes: in order to fire a weapon in a video game you must have one first.

edited Mar 21 '22 at 13:06

answered Mar 20 '22 at 19:24

Michail Markou

31
3
7

What's is the difference between include and extend in use case diagram?

20 Answers20

Relationships are dependencies

include

extend

SUMMARY

Linked

Related