Responding to Z...
It's refreshing that you actually did some work. Alas, many
students come on the forum and just ask us to solve the problem
for them.
I need to present a new railway
information system. the system enables the customers to order a
ticket and to do a check-in with extra payment.
at first release, the customers can
do it only by phone, second release- by website, last release -
by smartphone app.
Is the attached diagram is good
enought?
It is pretty close; I mostly just have a couple of quibbles...
You have two Order A Ticket uses cases. Presumably they do the same
thing, so you only need one. Just have the Call and Web versions
link to the same one.
Check In, Pay Extra, and Pay for Ticket are a little different
because of Dispatcher vs. System. However, unless there is some sort
of very different and important logic within those uses cases for
those scenarios, you usually do not need to worry about that. (If
there is such logic, they need different names because they are not
the same use case.) Typically there will be some sort of context
identity for the scenario and the use case would simply have a
conditional step to send a message to the correct actor.
The general rule of thumb is that if the use cases have different
steps, they are not the same and require different names. OTOH, if
they have exactly the same steps (including conditional steps), then
they are the same and you only need one of them in the diagram.
[Caveat: in a very large use case, this could lead to arrows
cluttering things up badly. In that case, one can make the case that
if the have the same name they are the same and can appear in
different places for aesthetic reasons. However, everyone needs to
be on that page. In this case, I don't know what is in those use
cases, so I don't know whether they are same. I think you want to
avoid that kind of confusion in the audience when documenting the
diagram.]
I don't think you need dependency qualifiers here. Ordering a ticket
or checking in is always done in the scenario. All you are doing is
separating it out as logically distinct. (I am biased because the
methodology I use does not use dependency relationships at all
because they are really only relevant to OOP, not OOA/D where one
uses UML.)
Similarly, I don't think you need the include qualifiers here. The
rule of thumb I use is that I will use <<include>> only
if the invocation of that use case is conditional. The problem I
have with <<include>> is that one can argue any chain of
use cases that are not directly invoked by an actor are included
behavior in some use case that is invoked by an actor, so all the
relationships should be includes. I think one need some unambiguous
criteria for drawing a line in the sand for whether a use case is
"in" another use case or not.
--
Life is the only flaw in an otherwise perfect nonexistence
-- Schopenhauer
Imagine how much more difficult physics would be if electrons had feelings
-- Richard Feynman
Rene Descartes went into a bar. The bartender asked if he would like a drink. Descartes said, "I think not," and disappeared.
H. S. Lahman
H.la...@verizon.net
software blog: http://pathfinderpeople.blogs.com/hslahman/index.html
software book: Model Based Development, Addison-Wesley, 2011
geology book: The Evolution and Utilization of Marine Resources, MIT Press, 1972