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."); }
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(); }