Order Your Paper From the most reliable Essay writing Service. 



1. Scope Statement.

In order to develop an effective project for IPMS within 12 weeks with limited costs using limited resources provided by Whitireia using IPMS to monitor and handle software company’s projects, roles, employee information, skill level and timetables for its client and third party

1.1 Functional requirement:

1. To everybody can use the IPMS well, they must can create at least four kind of roles in the system, one is the administrator, who can maintain the system; the second is normal employee who can login to update details, the third is project manager, the fourth is project team member. Each employee has only one unique employee ID.

2. IPMS must can add, update and search the project, and the project manager can assign each task to available employee. And the project manager can add, delete, update and search employees.

3. The employee must have a job code, job title and other details such as the date to commence, hourly rate etc.

4. IPMS can let project manager add new job titles and details. And add new client.

5. The system must be able to show who responsible to each different tasks

6. The program manager and the team member must can be print the report, and they must be able to fill daily record and time sheet.

8. The clients must be able to check the project’s time sheet.

9. The team member must be able to show the test result, and fix them.

10. The project must be show the project details.

1.2 Non-Functional Requirement (Optional Req)

User may or could

1. IPMS should add more skill levels, or delete.

2. E.g.: DB storage

3. Upgrades/ Maintenance

4. Reliability

5. Scalability

1.3 Technical Requirements

Software: OS-Windows 10, Visual Studio 2015, SQL Server 2014, Visio 2016, Word 2016, Excel2016, Languages: C#.

Hardware: CPU, Ram, Disk, Mainboard, MainBox

2. Case diagram.

3. IPMS’s design class details

4. Ten Questions.

4.1 Interface and Inherited.


The interface is a special abstract class; it cannot be instantiated, the same as abstract class (because it contains abstract members, and abstract members do not contain method body). When you want to declare the interface, C# required you to use the Interface keyword, the same as class.

There is no fields in the interface, so it is not possible to define explicit attributes in the interface. If you want to inherited interfaces, you must implement all the abstract members of the interface. And in inheritance class, no need to use the override keyword in interface members’ realization. And you must keep the same sign to achieve the interface. The different between abstract class and interface are: you can find the parent class when you use the abstract class, and hope the parent class inherited to some subclass members. If you use interface, it is a purely to achieve the norms of the class.

In this project, it can use the interface in print, like print the invoice, just getInvoice(), then use print interface, or getReport(), then use print interface. That mean it can print everything. Just print.


Inheritance allows us to define another class based on a class, which makes it easier to create and maintain an application. It also conducive to reuse code and save development time.

When creating a class, the programmer does not need to completely rewrite the new data members and member functions, only need to design a new class, inherited the existing members of the class can be. This existing class is called the base class, and this new class is called the derived class.

C# only supports single inheritance, that means a category can only inherit from a parent class. But we can use interfaces to implement multiple inheritance.

In this system, the project manager can look as the employee’s subclass, and inherited all the attribution from the employees’.

4.2 Polymorphism

“Polymorphism means that the sender of a stimulus does not need to know the receiving instance’s class. The receiving instance can be login to an arbitrary class.” Object-Oriented Software Engineering: A Use Case Driven Approach page 55.

In polymorphism, sender doesn’t explain the meaning of a message or event or stimulus, it is explained by the recipient (the object that received the message). So, in the runtime if the recipient is changed to different object or instance, the system will change the behavior.

In this system, if we need to calculate each employees’ wage, different kind of employee has different salary, but they all need to calculate wage, Here the procedure (calculate wage) is same, but each employee has different result way to do it, it depends on the Runtime().

Iemployee list[]= getAll employee();

For(i=0; list.length, i++)




4.3 Event Handlers and Delegate.

Delegate has the type-safe, secure managed feature to ensure that the delegate points to the existing function (method), if the delegate has not stored any way to call, the CLR will throw an exception. More precisely: Delegate is a special type of C #, used to define the method / function of the signature, delegate entity (instance) can store one or more method with signature.

It need 4 steps to declare a delegate: declare, create, point and invoke.

To declare an event within a class, you must first declare the delegate type for the event.

delegate <return type> <delegate-name> <parameter list>

After the class declares an event, the event can be processed as if it were processing the field of the delegate type indicated. If no client will be entrusted with the event, the field will be empty; Otherwise the field references the delegate that should be called when the event is called. Therefore, when the event is called, it is usually checked whether it is empty, and then call the event.

From the context of declaring events, the event is like a field, but access to that field is very restricted. Only can do the following:

Write a new delegate on this field.

Removes a delegate from a field (possibly a compound field).

Use the + = and – = operators to do this.

To start receiving an event call, first creates a delegate of the event type in the client coding, which should be referenced from the event call.

Then it uses + = to write the delegate to any other delegate that the event may connect to.

When the client coding completes the receive event call, it will use the operator – = to remove its delegate from the event.

There are three handlers in my design for the IPMS. They are login handler, print invoice handler, print report handler, and fix handler.

public class ProjectmanagerAA


public static void PintReport()


   //Print the project report!



public static void PintInvoice()


   //Print the Invoice of the project




class Teammember


    public delegate void PintReportEventHandler();

    public static void Main(string[] args)


        PintReportEventHandler printDelegate = new PintReportEventHandler(ProjectmanagerAA.PintReport);

        printDelegate += ProjectmanagerAA.PintInvoice;





4.4 Controller class

The controller class happened in MVC software architecture model, and MVC is one of the architectural pattern. That means the IPMS system is divided into three core parts: Model, View, Controller.

View is provided to the user’s user interface, is the program shell.

Model is the core of the “data layer”, that is, the program needs to operate the data or information.

Controller is responsible for the user from the “view layer” input instructions, select the “data layer” in the data, and then its corresponding operation, produce in the result.

From the design class, I added many methods and events in the controller, if changed some code out of the controller, there is no effect to the controller. It can protect the algorithm in the controller. Then I can reuse the code easily. The controller can increase maintenance, scalability, and flexibility of the program. It good for testing. The code hierarchy is clear. They are through subclasses to complete the operation.

The details in controller:





















4.5 Design Pattern(s)

I chose the following design patterns when I design it, but it very difficult for me to draw all of them in the design class, I will try to used them all in the system.

1) Template Method: “Define the skeleton of an algorithm in operation, and delay some steps into subclasses. Template Method makes it possible for subclasses to redefine some of the specific steps of the algorithm without changing the structure of an algorithm.” ——- “design pattern” GOF.

If we need to simply read the Employee database records and display the table. For database operations, we know that no matter which table to read, it should generally go through the following steps:

1. Connect to the database (Connect)

2. Execute the query command (Select)

3. Display data

4. Disconnect the database connection (Disconnect)

These steps are fixed, but the query for each specific data table is not the same. Obviously, this requires an abstract role that gives top-level implementation. As shown below:

public abstract class DataAccessObject


    protected string connectionString;

    protected DataSet dataSet;

    protected virtual void Connect()


        connectionString =

            “Server=.;User Id=sa;Password=;Database=Northwind”;


   protected abstract void Select();

   protected abstract void Display();

   protected virtual void Disconnect()


        connectionString = “”;


    // The “Template Method”

    public void Run()








Obviously in this framework DataAccessObject gives a fixed outline, the method Run() is the template method, Template Method model also hence the name. And for the Select() and Display() these two abstract methods are left to the specific sub-class to achieve.

2) Command Pattern: The Command pattern encapsulates the command, separating the responsibility of the commander and the responsibility of the commander. We know that a class is a set of operations and the corresponding set of variables.

3) Observer Pattern: it can be used in the task class, once a task completed, via observer pattern to notify the project manager and project team and showing the team member is available, then project manager can give the member a new task.

4) Chain of Responsibility Pattern: let multiple objects have the opportunity to handle the request, thereby avoiding the coupling between the sender and the receiver of the request. Connect these objects into a chain, and pass the request along the chain, until there is an object to deal with it so far.

This happened when the project manager assign the tasks to the project member.

5) Strategy Pattern: “Define a system of algorithms that encapsulate them one by one and make them replace each other. This mode allows the algorithm to change independently of the customer who uses it.” ——– “design pattern” GOF.

It used in our controller class, we protect all the algorithm in the controller, and we give it an interface to access.

6) State Pattern: We have to have the state pattern, Objects have different states and tend to exercise different behaviors. We have many status need to record in this system, employees’ status, project status, task status etc. and the handler is a typical state pattern.

7) Singleton Pattern used in Invoice, each project has only one Invoice.

8) Prototype Pattern used to isolate the coupling between the user of the class object and the specific type (variable class) which also requires this some “variable classes” have “stable interfaces”. It is used in the system, like the controller.

9) Facade Pattern: In the software development system, the use of Facade Pattern simplifies the simplification of the interaction between the client and the subsystem. Decoupling the dependencies between the internal subsystems of the complex system and the client program. In this system, it can be used in project manager, the project manager need to deal with lots of works for the project team and the project.

10) Proxy Pattern is used here like the interface class.

4.6 Database


ADO.NET has three database client namespaces: one for SQL Server, another for Open Database Connectivity (ODBC) data sources and a third for any database exposed through OLE DB. Data-sharing consumer applications can use ADO.NET to connect to data sources and retrieve, manipulate, and update data.

Connect database code: