public static void Main()
{
int employee_type;
Console.WriteLine("Select type of employee:");
Console.WriteLine("_________________________");
Console.WriteLine("1.Montly Employee");
Console.WriteLine("1.daily Employee");
Console.WriteLine("1.One Time employee");
employee_type = Convert.ToInt32(Console.ReadLine());
if (employee_type == 1)
{
MonhtlyEmployee emp = new MonhtlyEmployee();
emp.salary_calc();
}
else if (employee_type == 2)
{
HourlyEmployee emp = new HourlyEmployee();
emp.salary_calc();
}
else if (employee_type == 3)
{
OneTimeEmployee emp = new OneTimeEmployee();
emp.salary_calc();
}
else
{
Console.WriteLine("Invalid choice");
}
}
static void Main()
{
// create derived-class objects
var salariedEmployee = new SalariedEmployee("John", "Smith",
"111-11-1111", 800.00M);
var hourlyEmployee = new HourlyEmployee("Karen", "Price",
"222-22-2222", 16.75M, 40.0M);
var commissionEmployee = new CommissionEmployee("Sue", "Jones",
"333-33-3333", 10000.00M, .06M);
var basePlusCommissionEmployee =
new BasePlusCommissionEmployee("Bob", "Lewis",
"444-44-4444", 5000.00M, .04M, 300.00M);
Console.WriteLine("Employees processed individually:\n");
Console.WriteLine($"{salariedEmployee}\nearned: " +
$"{salariedEmployee.Earnings():C}\n");
Console.WriteLine(
$"{hourlyEmployee}\nearned: {hourlyEmployee.Earnings():C}\n");
Console.WriteLine($"{commissionEmployee}\nearned: " +
$"{commissionEmployee.Earnings():C}\n");
Console.WriteLine($"{basePlusCommissionEmployee}\nearned: " +
$"{basePlusCommissionEmployee.Earnings():C}\n");
// create List<Employee> and initialize with employee objects
var employees = new List <Employee>()
{
salariedEmployee,
hourlyEmployee, commissionEmployee, basePlusCommissionEmployee
};
Console.WriteLine("Employees processed polymorphically:\n");
// generically process each element in employees
foreach (var currentEmployee in employees)
{
Console.WriteLine(currentEmployee); // invokes ToString
// determine whether element is a BasePlusCommissionEmployee
if (currentEmployee is BasePlusCommissionEmployee)
{
// downcast Employee reference to
// BasePlusCommissionEmployee reference
var employee = (BasePlusCommissionEmployee)currentEmployee;
employee.BaseSalary *= 1.10M;
Console.WriteLine("new base salary with 10% increase is: " +
$"{employee.BaseSalary:C}");
}
Console.WriteLine($"earned: {currentEmployee.Earnings():C}\n");
}
// get type name of each object in employees
for (int j = 0; j < employees.Count; j++)
{
Console.WriteLine(
$"Employee {j} is a {employees[j].GetType()}");
}
}
public static void Main(string[] args)
{
// create five-element Employee array
Employee[] employees = new Employee[5];
// initialize array with Employees
employees[0] = new SalariedEmployee("John", "Smith",
"111-11-1111", 800M);
employees[1] = new HourlyEmployee("Karen", "Price",
"222-22-2222", 16.75M, 40M);
employees[2] = new CommissionEmployee("Sue", "Jones",
"333-33-3333", 10000M, .06M);
employees[3] = new BasePlusCommissionEmployee("Bob", "Lewis",
"444-44-4444", 5000M, .04M, 300M);
employees[4] = new PieceWorker("Tony", "Rosella", "555-55-5555", 15.50M, 20M);
Console.WriteLine("Employees processed polymorphically:\n");
// generically process each element in array employees
foreach (var currentEmployee in employees)
{
Console.WriteLine(currentEmployee); // invokes ToString
Console.WriteLine("earned {0:C}\n",
currentEmployee.Earnings());
} // end foreach
} // end Main
public void EmployeeAgeTestEqual()
{
var test = new HourlyEmployee("a", "a", 1, 2, 10, 40);
var resealt = test.Age;
Assert.AreEqual(1, resealt);
}
public void CanMakeHourlyEmployee()
{
var employee = new HourlyEmployee(40, 10);
Assert.IsTrue(employee.HourlyRate == 10m);
Assert.IsTrue(employee.WeeklyHourAllotment == 40m);
}
public void EmployeeTests()
{
Employee jenny = new Employee();
HourlyEmployee michael = new HourlyEmployee();
SalaryEmployee pepper = new SalaryEmployee();
michael.HoursWorked = 55;
michael.HourlyWage = 20;
pepper.Salary = 84000;
List <Employee> allEmployees = new List <Employee>();
allEmployees.Add(jenny);
allEmployees.Add(michael);
allEmployees.Add(pepper); // despite technically being different types, since they all inherit from Employee they can all go in the list
foreach (Employee worker in allEmployees)
{
if (worker.GetType() == typeof(SalaryEmployee))
{
SalaryEmployee sEmployee = (SalaryEmployee)worker;
Console.WriteLine($"This is a salaried employee who makes {sEmployee.Salary}");
}
else if (worker is HourlyEmployee hourlyWorker) // this is called pattern matching; turns worker to type HourlyEmployee (if it can; if it can't it returns false, fails the if, and moves on) and creates new variable hourlyWorker.
// Basically, if worker is of type HourlyEmployee (in addition to its explicit type of Employee), then they become are assigned to variable hourlyWorker which is explicitly of type HourlyEmployee
{
Console.WriteLine($"{worker.Name} has worked {hourlyWorker.HoursWorked} hours!");
}
}
}
public static void Main( string[] args )
{
// create five-element Employee array
Employee[] employees = new Employee[ 5 ];
// initialize array with Employees
employees[ 0 ] = new SalariedEmployee( "John", "Smith",
"111-11-1111", 800M );
employees[ 1 ] = new HourlyEmployee( "Karen", "Price",
"222-22-2222", 16.75M, 40M );
employees[ 2 ] = new CommissionEmployee( "Sue", "Jones",
"333-33-3333", 10000M, .06M );
employees[ 3 ] = new BasePlusCommissionEmployee( "Bob", "Lewis",
"444-44-4444", 5000M, .04M, 300M );
employees[4] = new PieceWorker("Tony", "Rosella", "555-55-5555", 15.50M, 20M);
Console.WriteLine( "Employees processed polymorphically:\n" );
// generically process each element in array employees
foreach ( var currentEmployee in employees )
{
Console.WriteLine( currentEmployee ); // invokes ToString
Console.WriteLine( "earned {0:C}\n",
currentEmployee.Earnings() );
} // end foreach
}
public void EmployeeWeeklyPayTestEqual()
{
var test = new HourlyEmployee("a", "a", 1, 2, 10, 40);
var resealt = test.WeeklyPay;
Assert.AreEqual(400, resealt);
}
public void EmployeeTests()
{
Employee jarvis = new Employee();
HourlyEmployee tony = new HourlyEmployee();
SalaryEmployee pepper = new SalaryEmployee();
tony.HoursWorked = 55;
tony.HourlyWage = 9003;
pepper.Salary = 200000;
List <Employee> allEmployees = new List <Employee>();
allEmployees.Add(jarvis); //we never added any info so in the foreach loop it will be blank
allEmployees.Add(tony); // we never set his name so in the foreach loop nothing will appear for worker.Name
allEmployees.Add(pepper);
//tony.Name = "Tony Stark";
tony.SetFirstName("Tony");
tony.SetLastName("Stark");
foreach (Employee worker in allEmployees)
{
if (worker.GetType() == typeof(SalaryEmployee))
{
SalaryEmployee sEmployee = (SalaryEmployee)worker; //casting because worker is of type List<Employee> and not SalaryEmployee
Console.WriteLine($"This is a salary employee that makes {sEmployee.Salary}");
}
else if (worker is HourlyEmployee hourlyWorker) //pattern matching-- so we don't have to cast like the below
{
//HourlyEmployee hEmployee = (HourlyEmployee)hourlyWorker; -- casting
Console.WriteLine($"{worker.Name} has worked {hourlyWorker.HoursWorked} hours!");
}
}
}
public void EmployeeTests()
{
Employee jarvis = new Employee();
HourlyEmployee tony = new HourlyEmployee();
SalaryEmployee pepper = new SalaryEmployee();
tony.HoursWorked = 55;
tony.HourlyWage = 9003;
pepper.Salary = 20000;
List <Employee> allEmployees = new List <Employee>();
allEmployees.Add(jarvis);
allEmployees.Add(tony);
allEmployees.Add(pepper);
//tony.name = "tony stark";
tony.SetFirstName("Tony");
tony.SetLastName("Stark");
foreach (Employee worker in allEmployees)
{
if (worker.GetType() == typeof(SalaryEmployee))
{
SalaryEmployee sEmployee = (SalaryEmployee)worker;
Console.WriteLine($"This is a salary employee that makes {sEmployee.Salary}");
}
else if (worker is HourlyEmployee hourlyWorker) // Pattern Matching
{
//HourlyEmployee hEmployee = (HourlyEmployee)hourlyWorker;
Console.WriteLine($"{worker.Name} has worked {hourlyWorker.HoursWorked} hours!");
}
}
}
public void EmployeeTests()
{
Employee jarvis = new Employee();
HourlyEmployee tony = new HourlyEmployee();
SalaryEmployee pepper = new SalaryEmployee();
tony.HoursWorked = 55;
tony.HourlyWage = 9003;
pepper.Salary = 200000;
List <Employee> allEmployees = new List <Employee>();
allEmployees.Add(jarvis);
allEmployees.Add(tony);
allEmployees.Add(pepper);
foreach (Employee worker in allEmployees)
{
if (worker.GetType() == typeof(SalaryEmployee))
{
SalaryEmployee sEmployee = (SalaryEmployee)worker;
Console.WriteLine($"This is a salary employee that makes{sEmployee.Salary}");
}
else if (worker is HourlyEmployee hourlyWorker)
{
HourlyEmployee hEmployee = (HourlyEmployee)hourlyWorker;
Console.WriteLine($"{ worker.Name} HashSet worked { hourlyWorker.HoursWorked} hours!");
}
}
}
public void Test_Salary_Returns_Yearly_Salary()
{
HourlyEmployee hourlyEmployee = new HourlyEmployee("David", "Barnes", 10.00m);
Assert.AreEqual(20800.00m, hourlyEmployee.Salary);
Assert.IsInstanceOfType(hourlyEmployee, typeof(HourlyEmployee));
}
public void EmployeeTests()
{
Employee jarvis = new Employee();
HourlyEmployee tony = new HourlyEmployee();
tony.HoursWorked = 12;
tony.HourlyWage = 15000;
SalaryEmployee friday = new SalaryEmployee();
friday.Salary = 1000000;
List <Employee> allEmployees = new List <Employee>();
allEmployees.Add(jarvis);
allEmployees.Add(tony);
allEmployees.Add(friday);
//var employee = allEmployees[1];
foreach (Employee worker in allEmployees)
{
if (worker.GetType() == typeof(SalaryEmployee))
{
SalaryEmployee sEmployee = (SalaryEmployee)worker;
Console.WriteLine($"This is a salary employee that makes {sEmployee.Salary}.");
}
else if (worker is HourlyEmployee hourlyWorker) // Pattern Matching
{
// Casting
HourlyEmployee hEmployee = (HourlyEmployee)worker;
Console.WriteLine(hourlyWorker.HoursWorked);
}
}
}
public void EmployeeTests()
{
Employee jarvis = new Employee(); // newing up new instance of the employee class named jarvis
HourlyEmployee tony = new HourlyEmployee(); // new instance of the hourly employee class named tony
SalaryEmployee pepper = new SalaryEmployee(); //new instance of salary employee class named pepper
tony.HoursWorked = 55;
tony.HourlyWage = 9003;
pepper.Salary = 200000;
List <Employee> allEmployees = new List <Employee>();
allEmployees.Add(jarvis);
allEmployees.Add(tony);
allEmployees.Add(pepper); //adds all these employess to the list of employees
//tony.Name = "Tony Stark"
tony.SetFirstName("Tony"); // sets the property of the first name and the field _firstName
tony.SetLastName("Stark"); // sets the property of the last name and the field _LastName
foreach (Employee worker in allEmployees) //iterates through the list loops through this list and reassigns the variable worker each time the loop reaches the start of the list the list so first time through it is assigned the variable of jarvis, second time through the list it is assigned the values of tony, last time through the list it is assigned the value of pepper. Once it has run through the all the employees in the allemployee list the program stops.
{
if (worker.GetType() == typeof(SalaryEmployee)) // if worker is a salaryEmployee //will run through jarvis, tony, and pepper because they are all within the list of allemployees
{
SalaryEmployee sEmployee = (SalaryEmployee)worker;
Console.WriteLine($"this is a salary employee that makes {sEmployee.Salary}"); // ?
}
else if (worker is HourlyEmployee hourlyWorker) // pattern matching it is taking worker turning into hourly worker then creating new variable within the if statement
{
//HourlyEmployee hEmployee = (HourlyEmployee)hourlyWorker;
Console.WriteLine($"{worker.Name} has worked {hourlyWorker.HoursWorked} hours!");
}
}
}
public void EmployeeCalculatePayTestEqual()
{
var test = new HourlyEmployee("a", "a", 1, 2, 10, 40);
var resealt = test.CalculatePay();
Assert.AreEqual("$263.40", resealt);
}
public static void RunTests()
{
Console.WriteLine("Testing People Classes.");
Employee john = new FullTimeEmployee("John", "Doe")
{
Department = "Criminal",
Salary = TaxCalculator.TaxCalculator.DollarsToCents(5000)
};
Employee kane = new HourlyEmployee("Kane", "Cillian")
{
Department = "Marketing",
Rate = TaxCalculator.TaxCalculator.DollarsToCents(50),
HoursWorked = new Workload(20, 30, 35, 40)
};
Student vladt = new Student("Vlad", "T")
{
TakenClasses = new List<ClassResult> {
new ClassResult("C#", ClassResult.Grades.F),
new ClassResult("JavaScript", ClassResult.Grades.C),
new ClassResult("Calculus", ClassResult.Grades.D)
}
};
Console.WriteLine(john);
Console.WriteLine(kane);
Console.WriteLine(vladt);
Console.WriteLine(Environment.NewLine + vladt.GenerateTranscript());
}
public void Employee()
{
Employee jarvis = new Employee();//objects to work with
HourlyEmployee tony = new HourlyEmployee();
SalaryEmployee pepper = new SalaryEmployee();
tony.HoursWorked = 55;
tony.HourlyWage = 9003;
pepper.Salary = 2000000;
List <Employee> allEmployees = new List <Employee>();//rules of list that lists can hold ONE thing
allEmployees.Add(jarvis);
allEmployees.Add(tony);
allEmployees.Add(pepper); //no error bc they are inherite from the base class
//tony.SetFirstName = "Tony Stark"; this line does not work as it is read only
//tony.SetFirstName("Tony"); this line works and is a preference choice on how to write this
foreach (Employee worker in allEmployees)
{
if (worker.GetType() == typeof(SalaryEmployee))
{
SalaryEmployee sEmployee = (SalaryEmployee)worker; //casting
Console.WriteLine($"This is a salary employee that makes {sEmployee.Salary}");
}
else if (worker is HourlyEmployee hourlyWorker) //pattern matching taking working turning it into hourley worker and making a new variable in the IF statement
{
//HourlyEmployee hEmployee = (HourlyEmployee)hourlyWorker;
Console.WriteLine($"{worker.Name} has worked {hourlyWorker.HoursWorked} hours!");
}
}//polymorphism is the P in API ... classes related thru inheritance ...uses methods to preform tasks in different ways ...one method that can do serval functionality
}
public void Setup()
{
_employeeRepository = new Mock <IEmployeeRepository>();
var hourlyEmp = new HourlyEmployee();
hourlyEmp.Id = 1;
hourlyEmp.Name = "Juan";
hourlyEmp.ContractTypeName = "HourlySalaryEmployee";
hourlyEmp.RoleId = 1;
hourlyEmp.RoleName = "Administrator";
hourlyEmp.RoleDescription = "";
hourlyEmp.HourlySalary = 60000;
hourlyEmp.MonthlySalary = 80000;
var monthlyEmp = new MonthlyEmployee();
monthlyEmp.Id = 2;
monthlyEmp.Name = "Sebastian";
monthlyEmp.ContractTypeName = "MonthlySalaryEmployee";
monthlyEmp.RoleId = 2;
monthlyEmp.RoleName = "Contractor";
monthlyEmp.RoleDescription = "";
monthlyEmp.HourlySalary = 60000;
monthlyEmp.MonthlySalary = 80000;
var employees = new List <IEmployee>();
employees.Add(hourlyEmp);
employees.Add(monthlyEmp);
_employeeRepository.Setup(er => er.GetEmployees()).Returns(Task.FromResult(employees));
_employeeService = new EmployeeService(_employeeRepository.Object);
}
public void SuccessGettingEmployeesById()
{
//Arrange
var employees = GetFakeEmployees();
var employeesRepository = new Mock <IEmployeeRepository>();
employeesRepository.Setup(repo => repo.GetEmployees()).Returns(employees);
var expectedResponse = new HourlyEmployee()
{
Id = 1,
HourlySalary = 6000,
MonthlySalary = 8000,
Name = "Juan"
};
var employeeService = new EmployeeService(employeesRepository.Object, new EmployeeFactory());
//Act
var responseEmployee = employeeService.GetEmployeeById(1);
//Assert
Assert.AreEqual(responseEmployee.Id, expectedResponse.Id);
Assert.AreEqual(responseEmployee.Name, expectedResponse.Name);
}
public void EmployeeTests()
{
Employee julian = new Employee();
HourlyEmployee bubbles = new HourlyEmployee();
SalaryEmployee ricky = new SalaryEmployee();
List <Employee> allEmployees = new List <Employee>();
allEmployees.Add(julian);
allEmployees.Add(bubbles);
allEmployees.Add(ricky);
//var employee = allEmployees[1];
foreach (Employee worker in allEmployees)
{
if (worker.GetType() == typeof(SalaryEmployee))
{
SalaryEmployee sEmployee = (SalaryEmployee)worker;
Console.WriteLine($"This is a salary employee that makes {sEmployee.Salary}.");
}
else if (worker is HourlyEmployee hourlyWorker)
{
HourlyEmployee hEmployee = (HourlyEmployee)worker;
Console.WriteLine(hourlyWorker.Hours);
}
/* Abstraction
* Polymorphism
* Inheritance - one class recieving the traits/properties of another class (hourlyEmployee and Employee)
* Encapsulation
*/
}
}
public void EmployeeIDTestEqual()
{
var test = new HourlyEmployee("a", "a", 1, 2, 10, 40);
var resealt = test.EmployeeId;
Assert.AreEqual(2, resealt);
}
static void Main(string[] args)
{
HourlyEmployee employee = new HourlyEmployee();
employee.Name = "Joe Dirt"; //inherited from base class
employee.EmployeeId = 5; //inherited from base class
employee.HourlyRate = 10.50M; //extended from base class
}
public void EmployeeTests()
{
Employee Jarvis = new Employee();
HourlyEmployee tony = new HourlyEmployee();
SalariedEmployee Friday = new SalariedEmployee();
List <Employee> allEmployees = new List <Employee>();
allEmployees.Add(Jarvis);
allEmployees.Add(tony);
allEmployees.Add(Friday);
foreach (Employee wageslave in allEmployees)
{
if (wageslave.GetType() == typeof(SalariedEmployee))
{
SalariedEmployee sEmployee = (SalariedEmployee)wageslave;
Console.WriteLine("Irrelevant");
}
else if (wageslave is HourlyEmployee HourlyWorker)//pattern matching
{
Console.WriteLine("this is an hourly employee");
Console.WriteLine(HourlyWorker.HourlyWage);
}
else
{
Console.WriteLine("WHO KNOWS");
}
}
}
public void PopulateEditFields(HourlyEmployee employee){
EnableCommonFields(true);
EnableHourlyFields(true);
EnableSalaryFields(false);
HoursWorked = employee.PayInfo.HoursWorked.ToString();
HourlyRate = employee.PayInfo.HourlyRate.ToString();
this.PopulateStandardEditFields(employee);
}
public void InheritsIEmployee()
{
// Arrange | Act
var result = new HourlyEmployee();
// Assert
Assert.IsInstanceOf <IEmployee>(result);
}
static void Main( )
{
Employee m = new Manager("David Stevenson", "12345", 1200M);
Employee e1 = new HourlyEmployee("Jake", "23456", 35.0, 5.50M);
Console.WriteLine("{0} {1} {2:C}", m.EmployeeType, m.Name, m.Pay( ));
Console.WriteLine("{0} {1} {2:C}", e1.EmployeeType, e1.Name, e1.Pay( ));
}
public void EmployeeCalculateFICAPaidTestEqual()
{
var test = new HourlyEmployee("a", "a", 1, 2, 10, 40);
test.CalculatePay();
var resealt = test.fICA;
Assert.AreEqual(30.60m, resealt);
}
public void EmployeeCalculateFedTaxTestEqual()
{
var test = new HourlyEmployee("a", "a", 1, 2, 10, 40);
test.CalculatePay();
var resealt = test.FedTax;
Assert.AreEqual(106.00m, resealt);
}
public void UserOptionHourlyOnlyTest()
{
FillEmployees.UserOptions(3, Program.staff);
var employee = new HourlyEmployee("a", "a", 1, 2, 10, 40);
Program.staff.Add(employee);
var test = Program.staff[0];
Assert.IsNotNull(test);
}
private void AddLineItemToPage(List <LineItem> page, HourlyEmployee employee)
{
var reportItem = new LineItem
{
Name = employee.Name,
Pay = employee.CalculatePay()
};
page.Add(reportItem);
}
//Constructor
public PayrollSystemTest()
{
payableObjects[0] = new SalariedEmployee("John", "Smith", "111-11-1111", 700M);
payableObjects[1] = new SalariedEmployee("Antonio", "Smith", "555-55-5555", 800M);
payableObjects[2] = new SalariedEmployee("Victor", "Smith", "444-44-4444", 600M);
payableObjects[3] = new HourlyEmployee("Karen", "Price", "222-22-2222", 16.75M, 40M);
payableObjects[4] = new HourlyEmployee("Ruben", "Zamora", "666-66-6666", 20.00M, 40M);
payableObjects[5] = new CommissionEmployee("Sue", "Jones", "333-33-3333", 10000M, .06M);
payableObjects[6] = new BasePlusCommissionEmployee("Bob", "Lewis", "777-77-7777", 5000M, .04M, 300M);
payableObjects[7] = new BasePlusCommissionEmployee("Lee", "Duarte", "888-88-888", 5000M, .04M, 300M);
}
public void WhenHorlyRateNotSpecified_ThrowException()
{
// Arrange
var employeeId = new EmployeeId("foo");
var name = new Name("bar", null, "hee", null, null);
var address = new FakeAddress();
Action action = () => HourlyEmployee.CreateNew(employeeId, name, address, null);
// Act & Assert
action.Should().Throw <EmployeeDomainException>().WithMessage("Hourly rate must not be null.");
}
//Constructor
public PayrollSystemTest()
{
payableObjects[0] = new SalariedEmployee("John", "Smith", "111-11-1111", 700M);
payableObjects[1] = new SalariedEmployee("Antonio", "Smith", "555-55-5555", 800M);
payableObjects[2] = new SalariedEmployee("Victor", "Smith", "444-44-4444", 600M);
payableObjects[3] = new HourlyEmployee("Karen", "Price", "222-22-2222", 16.75M, 40M);
payableObjects[4] = new HourlyEmployee("Ruben", "Zamora", "666-66-6666", 20.00M, 40M);
payableObjects[5] = new CommissionEmployee("Sue", "Jones", "333-33-3333", 10000M, .06M);
payableObjects[6] = new BasePlusCommissionEmployee("Bob", "Lewis", "777-77-7777", 5000M, .04M, 300M);
payableObjects[7] = new BasePlusCommissionEmployee("Lee", "Duarte", "888-88-888", 5000M, .04M, 300M);
}
public void CalculatesMonthlyRenumeration()
{
// Arrange
IEmployee salariedEmployee = new HourlyEmployee();
IEmployeeVisitor visitor = new CalculateRenumeration();
// Act
var result = salariedEmployee.Accept(visitor);
// Assert
Assert.AreEqual("renumeration", result);
}
public static void Main( string [] args)
{
bool loop = true;
while(loop == true)
{
Console.WriteLine("Welcome to Employee Builder: ");
Console.Read();
//instantiate Employee Array
Employee[] Employees = new Employee[5];
//fill array with different 'Employee' Derived Types all functioning under their own version of the 'Employee' Methods.
Employees[0] = new BasePlusCommissionEmployee("Jerry", "Redmond", "000-00-0000", 500.00M, .8M, 700M);
Employees[1] = new CommissionEmployee("Carlos", "Reese", "111-11-1111", 999.00M, .45M);
Employees[2] = new HourlyEmployee("Mike", "Luongo", "222-22-2222", 15.00M, 45M);
Employees[3] = new PieceWorker("Marcus", "Shepherd", "333-33-3333", 3.50M, 100M);
Employees[4] = new SalariedEmployee("Larry", "Peters", "444-44-4444", 75000M);
//Employees[5] = new PieceWorker("Hakeem", "Rogers", "555-55-5555", 5.0M,1);
Console.WriteLine("Employees Earnings & System Signature through ToString: \n\n{0}\t\t{1}", "Earnings:", "String:");
foreach(Employee employee in Employees)
{
Console.WriteLine( employee.GetPaymentAmount() );
}//end foreach
for (int i = 0; i <= 4; i++)
{
if (Employees[i].GetType is BasePlusCommissionEmployee)
{
BasePlusCommissionEmployee employee =
(BasePlusCommissionEmployee)Employees[i];
employee.BaseSalary = employee.BaseSalary * 1.1M;
}//end if
Console.WriteLine("\n" + Employees[i].GetPaymentAmount() /* + "\t\t" + Employees[i].Earnings() + Employees[i].*/);
}//end for statement printing GetPaymentAmount
Console.ReadLine();
}//End while
}
public static void Main(string[] args)
{
// create six-element IPayable array
IPayable[] payableObjects = new IPayable[6];
// populate array with objects that implement IPayable
payableObjects[0] = new Invoice("01234", "seat", 2, 375.00M);
payableObjects[1] = new Invoice("56789", "tire", 4, 79.95M);
payableObjects[2] = new SalariedEmployee("John", "Smith",
"111-11-1111", 800.00M);
/***** Modified code for assignment *****/
// Add three new payable objects
payableObjects[3] = new HourlyEmployee("Robert", "Millsaps", "222-22-2222", 12.5M, 20M);
payableObjects[4] = new CommissionEmployee("Albert", "Einstein", "333-33-3333", 1000M, 0.314159M);
payableObjects[5] = new BasePlusCommissionEmployee("Bill", "Gates", "444-44-4444", 1000M, 0.314159M, 1000000M);
// Iterate over all payable objects
foreach (IPayable currentPayable in payableObjects)
{
// Output string representation
Console.WriteLine(currentPayable);
// Increase base salary by 10% for Base Plus Commission Employee
if (currentPayable is BasePlusCommissionEmployee)
{
BasePlusCommissionEmployee employee = (BasePlusCommissionEmployee)currentPayable;
employee.BaseSalary *= 1.10M;
// Output new base salary
Console.WriteLine("new base salary with 10% increase is: {0:C}", employee.BaseSalary);
}
// Output payment for each payable object
Console.WriteLine("payment due: {0:C}", currentPayable.GetPaymentAmount());
Console.WriteLine();
}
// Freeze console window
Console.ReadLine();
/***** End Modified code for assignment *****/
}
static void Main(string[] args)
{
// Test each class by entering employee via constructor and printing details
HourlyEmployee Hire1 = new HourlyEmployee("Joe","Dunn","070723889",1000,40);
Console.WriteLine(Hire1);
Console.WriteLine("{0}\t {1}\n","Total earnings:",Hire1.Earnings());
SalariedEmployee Hire2 = new SalariedEmployee("John", "Rex", "970723889", 80000);
Console.WriteLine(Hire2);
Console.WriteLine("{0}\t {1}\n", "Total earnings:", Hire2.Earnings());
BasePlusCommissionEmployee Hire3 = new BasePlusCommissionEmployee("Reg", "Smith", "370723889", 10000, 1/5, 40000);
Console.WriteLine(Hire3);
Console.WriteLine("{0}\t {1}\n", "Total earnings:", Hire3.Earnings());
CommissionEmployee Hire4 = new CommissionEmployee("Lisa", "Pepper", "170723889", 100000, 1 / 5);
Console.WriteLine(Hire4);
Console.WriteLine("{0}\t {1}\n", "Total earnings:", Hire4.Earnings());
Console.Read();
}
public static void Main(string [] args)
{
// create four-element IPayable array
IPayable[] payableObjects = new IPayable[6];
// populate array with objects that implement IPayable
payableObjects[0] = new Invoice("01234", "seat", 2, 375.00M);
payableObjects[1] = new Invoice("56789", "tire", 4, 79.95M);
payableObjects[2] = new SalariedEmployee("John", "Smith", "111-11-1111", 800.00M);
payableObjects[3] = new HourlyEmployee("Bob", "Bobson", "222-22-2222", 16.75M, 40M );
payableObjects[4] = new CommissionEmployee("Sally", "Seashore", "333-33-3333", 10000M, .06M );
payableObjects[5] = new BasePlusCommissionEmployee("Bob", "Lewis", "444-44-4444", 5000M, .04M, 300M, .1M);
Console.WriteLine("Invoices and Employees process polymorphically:\n");
// generically process each element in array payableObjects
foreach (var currentPayable in payableObjects)
{
// output currentPayable and its appropriate payment amount
Console.WriteLine("{0}\npayment due: {1:C}\n", currentPayable, currentPayable.GetPaymentAmount());
} // end foreach
}
public static void Main(string[] args)
{
// create derived class objects
SalariedEmployee salariedEmployee =
new SalariedEmployee("John", "Smith", "111-11-1111", 800.00M);
HourlyEmployee hourlyEmployee =
new HourlyEmployee("Karen", "Price",
"222-22-2222", 16.75M, 40.0M);
CommissionEmployee commissionEmployee =
new CommissionEmployee("Sue", "Jones",
"333-33-3333", 10000.00M, .06M);
BasePlusCommissionEmployee basePlusCommissionEmployee =
new BasePlusCommissionEmployee("Bob", "Lewis",
"444-44-4444", 5000.00M, .04M, 300.00M);
Console.WriteLine("Employees processed individually:\n");
Console.WriteLine("{0}\nearned: {1:C}\n",
salariedEmployee, salariedEmployee.Earnings());
Console.WriteLine("{0}\nearned: {1:C}\n",
hourlyEmployee, hourlyEmployee.Earnings());
Console.WriteLine("{0}\nearned: {1:C}\n",
commissionEmployee, commissionEmployee.Earnings());
Console.WriteLine("{0}\nearned: {1:C}\n",
basePlusCommissionEmployee,
basePlusCommissionEmployee.Earnings());
// create four-element Employee array
Employee[] employees = new Employee[4];
// initialize array with Employees of derived types
employees[0] = salariedEmployee;
employees[1] = hourlyEmployee;
employees[2] = commissionEmployee;
employees[3] = basePlusCommissionEmployee;
Console.WriteLine("Employees processed polymorphically:\n");
// generically process each element in array employees
processEmployees(employees);
// get type name of each object in employees array
for (int j = 0; j < employees.Length; j++)
Console.WriteLine("Employee {0} is a {1}", j,
employees[j].GetType());
Console.WriteLine("\nEMPLOYEES PROCESSED BY IPAYABLE\n");
//Create IPayable array
IPayable[] payableObjects = new IPayable[8];
payableObjects[0] = new SalariedEmployee(
"John", "Smith", "111-11-1111", 700M);
payableObjects[1] = new SalariedEmployee(
"Antonio", "Smith", "555-55-5555", 800M);
payableObjects[2] = new SalariedEmployee(
"Victor", "Smith", "444-44-4444", 600M);
payableObjects[3] = new HourlyEmployee(
"Karen", "Price", "222-22-2222", 16.75M, 40M);
payableObjects[4] = new HourlyEmployee(
"Ruben", "Zamora", "666-66-6666", 20.00M, 40M);
payableObjects[5] = new CommissionEmployee(
"Sue", "Jones", "333-33-3333", 10000M, .06M);
payableObjects[6] = new BasePlusCommissionEmployee(
"Bob", "Lewis", "777-77-7777", 5000M, .04M, 300M);
payableObjects[7] = new BasePlusCommissionEmployee(
"Lee", "Duarte", "888-88-888", 5000M, .04M, 300M);
// generically process each element in array employees
processEmployees(payableObjects);
//bubble sort and pointer
Console.WriteLine("\nIPAYABLES SORTED BY SSN:\n");
BubbleSort(payableObjects, SSNAscending);
foreach (Employee currentEmployee in payableObjects)
{
Console.WriteLine(currentEmployee); // invokes ToString
Console.WriteLine(
"earned {0:C}\n", currentEmployee.Earnings());
} // end foreach
//IComparer
Console.WriteLine("\nIPAYABLES SORTED BY LAST NAME ASCENDING\n");
ArrayList comparerSample = new ArrayList();
//populate ArrayList for IComparer and IComprable
foreach (IPayable currentPayable in payableObjects)
{
comparerSample.Add(currentPayable);
}//end foreach
IComparer lastAscend = new SortLastNAscending();
comparerSample.Sort(lastAscend);
foreach (Employee currentEmployee in comparerSample)
{
Console.WriteLine(currentEmployee); // invokes ToString
Console.WriteLine(
"earned {0:C}\n", currentEmployee.Earnings());
} // end foreach
//IComparable implementation
Console.WriteLine("\nIPAYABLES SORTED BY SALARY DESCEDNING\n");
comparerSample.Sort();
foreach (Employee currentEmployee in comparerSample)
{
Console.WriteLine(currentEmployee); // invokes ToString
Console.WriteLine(
"earned {0:C}\n", currentEmployee.Earnings());
} // end foreach
}
public static void Main(string[] args)
{
IPayable[] payableObjects = new IPayable[8];
payableObjects[0] = new SalariedEmployee("John", "Smith", "111-11-1111", 700M);
payableObjects[1] = new SalariedEmployee("Antonio", "Smith", "555-55-5555", 800M);
payableObjects[2] = new SalariedEmployee("Victor", "Smith", "444-44-4444", 600M);
payableObjects[3] = new HourlyEmployee("Karen", "Price", "222-22-2222", 16.75M, 40M);
payableObjects[4] = new HourlyEmployee("Ruben", "Zamora", "666-66-6666", 20.00M, 40M);
payableObjects[5] = new CommissionEmployee("Sue", "Jones", "333-33-3333", 10000M, .06M);
payableObjects[6] = new BasePlusCommissionEmployee("Bob", "Lewis", "777-77-7777", 5000M, .04M, 300M);
payableObjects[7] = new BasePlusCommissionEmployee("Lee", "Duarte", "888-88-888", 5000M, .04M, 300M);
/*
Console.WriteLine("Not sorted in any way yet \n");
for (int j = 0; j < payableObjects.Length; j++) {
Console.WriteLine("Employee new {0} is a {1}", j,
payableObjects[j]);
}
*/
foreach (IPayable p in payableObjects) {
Console.WriteLine(p + "\n");
}
string menuOption;
bool menuLogic = true;
while (menuLogic) {
Console.WriteLine("1: Sort last name in ascending order using IComparable");
Console.WriteLine("2: Sort pay amount in descending order using IComparer");
Console.WriteLine("3: Sort by social security number in ascending order using a selection sort and delegate");
Console.WriteLine("4: Exit");
menuOption = Console.ReadLine();
switch (menuOption) {
case "1":
Array.Sort(payableObjects);
foreach (IPayable p in payableObjects) {
Console.WriteLine(p + "\n");
}
Console.WriteLine();
break;
case "2":
Array.Sort(payableObjects, Employee.payAmountSorter());
foreach (IPayable p in payableObjects) {
Console.WriteLine(p + "\n");
}
Console.WriteLine();
break;
case "3":
PayrollSystemTest payRoll = new PayrollSystemTest();
ComparerSSN ssnSort = new ComparerSSN(Employee.SortAsSSN);
payRoll.SelectionSort(payableObjects, ssnSort);
break;
case "4":
Console.WriteLine("Option 4 ");
menuLogic = false;
break;
}
}
Console.ReadKey();
}
