CSIS 209 C# Programming

CSIS 209 Programming Assignment 1 Instructions

Adapted from: Deitel & Deitel (2017). Visual C# 2015 How to Program (6^th ed.).Pearson Education, Inc.

Write an application that asks the user to enter two integers and displays "The two numbers you entered are: ", followed by the two numbers on the screen.

Next , determine the sum, difference (result of first number minus the second number), product, and quotient (result of first number divided by the second number), and modulus (remainder of the first number divided by the second number) and print these values to the screen.

Finally, determine the larger of the two integers, and print to the screen "The larger of the two numbers is: ", followed by the larger integer. If the two numbers are equal, print "The two numbers are equal."

Use the example below to format your output.

CSIS 209 Programming Assignment 2 Salesperson Total Sales Application

Adapted from: Deitel & Deitel (2017). Visual C# 2015 How to Program (6th ed.). Pearson Education, Inc.
A large company pays its salespeople on a commission basis. The salespeople receive $200 per week plus 9% of their gross sales for that week. For example, a salesperson who sells $5,000 worth of merchandise in a week receives $200 plus 9% of $5,000, or a total of $650. You’ve been supplied with a list of the items sold by each salesperson. The values of these items are as follows:
Item Value
1 239.99
2 129.75
3 99.95
4 350.89

Develop a C# application that inputs one salesperson's items sold for the last week, then calculates and displays that salesperson's total sales. There's no limit to the number of items that can be sold by a salesperson. You do not have to implement this with classes and objects.

Technical Requirements:
Prompt the user to enter the salesperson's name, and store this name in a variable.
Prompt the user to enter an item number and a quantity sold of that item. Store these two entries in two separate variables called "intItem" and "intQuantity".
Using a DO-WHILE control structure, loop until the user enters -1 for the item number.
Calculate the amount of sales for an item and store the result in a variable called dblItemSales.
After the user enters an item number and a quantity, print to the screen: the salesperson's name "has sold " [intQuantity] "of item # [intItem].
Accumulate the total sales in a variable called dblTotalSales by using a SWITCH statement to select the correct value to be multiplied by the quantity sold and adding this result to a running total, which is stored in the variable dblTotalSales.
If the user enters a number other than 1, 2, 3, or 4, display the message "Invalid Entry" and re-prompt the user to enter an Item Number. Make sure you do not perform any calculations or prompt the user to enter a quantity if the item number is incorrect.
After accumulating the total sales for an employee (that is, after the user has entered a -1 to quit), print to the screen Salesperson [Salesperson’s name] sold a total of [total sales].

See below for examples of the required output.

CSIS 209 Programming Assignment 3

Adapted from: Deitel & Deitel (2017). Visual C# 2015 How to Program (6^th ed.).Pearson Education, Inc.

Write an application to simulate the rolling of two dice. The app should use an object of class Random one to the first die and again to roll the second die. The sum of the two values should then be calculated. Each die can show an integer from 1 to 6, so the sum of the values will vary from 2 to 12, with 7 being the most frequest sum and 2 and 12 the least frequest sums.

Your application should roll the dice 36,000 times. Use a one-dimensional array to tally the number of times each possible sum appears. Display the results in tabular format. Determine whether or the totals are reasonable (e.g. there are six ways to roll a 7, so approximately one-sixth of the rolls should be 7).

Requirements:
In the Main() method, you will declare an integer array to hold the tally of the rolls. Use the Random class to generate a random number between 1 and 6 for each of the die rolls.

Using a FOR loop, iterate 36,000 times to make the two die rolls, sum the results, then increase the count of the correct element in the array to record the result. (HINT: The array being used here WILL NOT be 36,000 elements long. It will only have a length of 10)

Using another FOR loop, print the results of roll counts contained in the array to the screen in two columns with headers. The first column will hold all the possible rolls of the two dice, with the count of how many times that roll combination was achieved in the second column.

When using the loop to print the results array, use the GetUpperBounds() method to determine how many times to loop. DO NOT assume that you will always get an array of length 10. Make the code smart enough to figure out how many times to loop no matter what the length of the array.

CSIS 209 Programming Assignment 4

Adapted from: Deitel & Deitel (2017). Visual C# 2015 How to Program (6^th ed.). Pearson Education, Inc.

Write a recursive method called Power(base, exponent) that, when called, returns base exponent.
For example, Power ( 3, 4 ) = 3 * 3 * 3 * 3.
Assume that exponent is an integer greater than or equal to 1. The recursion step should use the relationship:
base exponent = base * base exponent - 1
The terminating condition occurs when exponent is equal to 1 because
base¹ = base
Incorporate this method into an application that enables the user to enter the base and exponent.

Requirements:
In the Main() method, declare three arrays of long data types: baseNumbers, exponents, and results. Each array should be created to hold exactly 5 members.

Using a FOR loop, populate the baseNumbers array with random integers between 1 and 50 and populate the exponents array with random integers between 1 and 10. Use a random number generator to create these random numbers.

Using another FOR loop, call the Power method, passing it a member of the baseNumbers array and a member of the exponents array for each iteration of the loop. Store the returned values in the results array.

The Power method should use the algorithm described above and MUST be recursive, taking two longs as arguments and returning a long data type.

Create another method called PrintArrays that takes as arguments the three arrays you created above and returns void. The method should print a header as "Base", "Exponent", and "Result" with each word separated with a single tab character. Using a FOR loop, iterate over each array using the GetUpperBound method to determine the condition for which the loop terminates. For each iteration of the loop, print out the base, exponent, and result from each array under the appropriate column headings. (Hint: You may need to use one or more tabs to separate the data values to make them line up with the headers above.)

The Main() method should call the PrintArrays method, passing in the three arrays as arguments.

CSIS 209 Programming Assignment 4 SavingsAccount Program

Adapted from: Deitel & Deitel (2017). Visual C# 2015 How to Program (6th ed.). Pearson Education, Inc.

Create a class called SavingsAccount. Use a static variable called annualInterestRate to store the annual interest rate for all account holders. Each object of the class contains a private instance variable savingsBalance, indicating the amount the saver currently has on deposit. Provide method CalculateMonthlyInterest to calculate the monthly interest by multiplying the savingsBalance by annualInterestRate divided by 12 – this interest should be added to savingsBalance. Provide static method setAnnualInterestRate to set the annualInterestRate to a new value.

Write an application to test class SavingsAccount. Create three savingsAccount objects, saver1, saver2, and saver3 with balances of $2,000.00, $3,000.00, and 0.00, respectively. Set annualInterestRate to 4%, then calculate the monthly interest and display the new balances for both savers. Then set the annualInterestRate to 5%, calculate the next month’s interest and display the new balances for both savers.

Technical Requirements:
Create SavingsAccount class with static variable annualInterestRate and private instance variables savingsBalance (double) and savingsAccountName (string).
Create a mutator method to set the savingsAccountName. Call this method setSavingsAccountName. The method should take a string argument and return void.
Create an accessor method to retrieve the savingsAccountName. Call this method getSavingsAccountName. The method should take no arguments and return a string (i.e. the savingsAccountName).
Create a mutator method to set the savingsBalance. Call this method setSavingsBalance. The method should take a double argument and return void.
Create an accessor method to retrieve the savingsBalance. Call this method getSavingsBalance. The method should take no arguments and return a double (i.e. the savingsBalance).
Include two constructors. The first takes no arguments and sets the savingsBalance variables to zero and sets the savingsAccountName to an empty string by calling the second (i.e. two argument) constructor with 0 and an empty string. The second constructor takes one double argument (the savingsBalance) and one string argument (the savingsAccountName), and sets the savingsBalance by calling the setSavingsBalance method and setSavingsAccountName method, respectively.
Create CalculateMonthlyInterest method with formula. The method should return void.
Create setAnnualInterestRate method to take a double argument representing the annualInterestRate and return void.
Create PrintSavingsAccount method to display the savingsBalance, savingsAccountName, and annualInterestRate for an object. Use the output shown below as a guideline for the display.
Create a separate class called SavingsAccountTest, which contains the Main() method.
In the Main() method, create three savingsAccount objects called saver1, saver2, and saver3. Initialize saver1 and saver2 with the balances listed above and the names "Saver_One" and "Saver_Two", respectively. Do not initialize saver3 with anything. Instead, create the object by invoking its zero-argument constructor, which will initialize its balance to 0 and its name to an empty string.
In the Main() method, call setAnnualInterestRate to set the interest rate to 4%.
Next, call the setSavingsAccountName for saver3 to set its name to "Saver_Three". Then, call the setSavingsAccountBalance for saver3 to set its balance to $50,000.
Print the results by calling PrintSavingsAccount for each object.
Next, call the CalculateAnnualInterestRate method for all three saver objects.
Print the results again by calling PrintSavingsAccount for each object.
Next, change the annualInterestRate to 5% by calling the setAnnualInterestRate method.
Print the results again by calling PrintSavingsAccount for each object.

CSIS 209 Programming Assignment 5 Account Inheritance Program

Adapted from: Deitel & Deitel (2017). Visual C# 2015 How to Program (6th ed.). Pearson Education, Inc.

Create an inheritance hierarchy that a bank might use to represent customer's bank accounts. All customers at this back can deposit (i.e. credit) money into their accounts and withdraw (i.e. debit) money from their accounts. More specific types of accounts also exist. Savings accounts, for instance, earn interest on the money they hold. Checking accounts, on the other hand, charge a fee per transaction.

Create base class Account and derived classes SavingsAccount and CheckingAccount that inherit from class Account. Base class Account should include the following private instance variables: Balance, which is of type decimal to represent the account balance; AccountName, which is of type string and represents the account holder's last name; and AccountNumber, which is an integer type that represents the account’s number. The class should provide a constructor that receives an account’s name, account number, and an initial balance. It should use initialize these instance variables using the appropriate mutator methods (i.e. setAccountName, setAccountNumber, and setBalance). The setBalance method should validate the initial balance to ensure that it's greater than or equal to 0.0; if not, set the balance to 0. You should also include the appropriate accessor (i.e. "get") methods. Also, the class should provide two other public methods: Method Credit should add an amount to the current balance. Method Debit should withdraw money from the Account and ensure that the debit amount does not exceed the Account’s balance. If it does, the balance should be left unchanged, and the method should print the message "Insufficient Funds." Base class Account should also have a method called PrintAccount that prints the account’s name, number, and balance.

Derived class SavingsAccount should inherit the functionality of an Account, but also include a decimal instance variable indicating the interest rate (double) assigned to the Account. Call this variable InterestRate. SavingsAccount's constructor should receive the account's name, account number, initial balance, and an initial value for the interest rate. The constructor should call the base class constructor to initialize the account's name, number, and balance. It should also call a method in its own class, setInterestRate, which should set the InterestRate variable and validate that the rate is a positive number. If the interest rate passed in is negative, set the interest rate to zero. SavingsAccount should provide public method CalculateInterest that takes no arguments and returns a decimal indicating the amount of interest earned by an account. Method CalculateInterest should determine this amount by multiplying the interest rate by the account balance. [Note: SavingsAccount should inherit methods Credit and Debit without modifying them.] Finally, create a method in this derived class that overrides the PrintAccount method in the base class. In it, call the base class method to print out the account's name, number, and balance, and include code in the derived class’s method to print out the information specific to the derived class (i.e. InterestRate).

Derived class CheckingAccount should inherit from base class Account and include a decimal instance variable that represents the fee charged per transaction. Call this variable FeeCharged. CheckingAccount's constructor should receive the account's name, account number, initial balance, as well as a parameter indicating a fee amount. Create a mutator method, setFeeAmount, and call it from the constructor. If the fee amount is negative, the setFeeAmount should set it to zero. Class CheckingAccount should redefine methods Credit and Debit so that they subtract the fee from the account balance whenever either transaction is performed successfully. CheckingAccount's versions of these methods should invoke the base-class Account to perform the updates to an account balance. CheckingAccount's Debit method should charge a fee only if money is actually withdrawn (i.e. the debit amount does not exceed the account balance.) [Hint: Define Account's Debit method so that it returns a bool indicating whether money was withdrawn. Then use the return value to determine whether a fee should be charged.] Finally, create a method in this derived class that overrides the PrintAccount method in the base class. In it, call the base class method to print out the account's name, number, and balance, and include code in the derived class’s method to print out the information specific to the derived class (i.e. FeeCharged).

After defining the classes in this hierarchy, write an application that creates one object of each derived class and tests their methods. Add interest to the SavingsAccount object by first invoking its CalculateInterest method, then passing the returned interest amount to the object's Credit method. The order of events should be performed as follows:
1. Create a new checking account object. Assign it an initial balance of $1,000. The account name should be your last name concatenated with the word "Checking", and the account number should be 1. The fee charged should be 3.00. Print a description of this transaction (i.e. "Created checking account with $1,000 balance.")
2. Create a new savings account object. Assign it an initial balance of $2,000. The account name should be your last name concatenated with the work "Savings", and the account number should be 2. The interest rate should be 5%. Print a description of this transaction (i.e. "Created savings account with $2,000 balance.")
3. Print the checking account object's information.
4. Print the savings account object's information
5. Deposit $100 in the checking account and print a description of this transaction (i.e. "Deposit $100 into checking.") (this should generate a fee charged as well)
6. Print the checking account object's information
7. Withdraw $50 from the checking account and print a description of this transaction (i.e. "Withdraw $50 from checking.") (this should generate a fee charged as well)
8. Print the checking account object's information
9. Try to withdraw $6,000 from the checking account and print a description of this transaction (i.e. "Withdraw $6,000 from checking.") (This should not generate a fee but instead produce an error message that the user has Insufficient Funds. The balance should remain unchanged.)
10. Print the savings account object's information
11. Deposit $3,000 in the savings account and print a description of this transaction (i.e. "Deposit $3,000 into savings.")
12. Print the savings account object's information
13. Withdraw $200 from the savings account and print a description of this transaction (i.e. "Withdraw $200 from savings.")
14. Print the savings account object's information
15. Calculate the interest on the savings account and print a description of this transaction (i.e. "Calculate Interest on savings.")
16. Print the savings account object's information
17. Try to withdraw $10,000 from the savings account (This should produce the Insufficient Funds error message and leave the balance unchanged.) Print a description of this transaction (i.e. "Withdraw $10,000 from savings.")
18. Print the savings account object's information

CSIS 209 Programming Assignment 6 Polymorphic Banking Application

Adapted from: Deitel & Deitel (2017). Visual C# 2015 How to Program (6th ed.). Pearson Education, Inc.

Develop a polymorphic banking application using the Account hierarchy you created in Assignment #5. Create the following two SavingsAccount objects and two CheckingAccount objects and store them in an array called "arrays" of Account references to the objects:
Account Name Account Number Initial Balance Fee Charged Interest Rate
[your name]-Savings-1 1 1,000 4%
[your name]-Savings-2 2 2,000 5%
[your name]-Checking-1 3 3,000 3.00
[your name]-Checking-2 4 4,000 4.00

Using a foreach loop, iterate over each account in the array. For each Account in the array, first print the account. Next, allow the user to specify an amount of money to withdraw from the Account using method Debit and an amount of money to deposit into the Account using method Credit. Specifically, for each account, prompt the user to enter an amount to deposit in the account and call the Credit method. Print the object.

Next, prompt the user to enter an amount to withdraw and call the Debit method. Print the object. After the user has made a deposit and a withdrawal from an account, calculate interest if the account is a SavingsAccount and print the object.

To perform this step, you must first determine the object’s type. If the Account is a SavingsAccount, calculate the amount of interest owed to the Account using method CalculateInterest and print the account a final time. If the account is a CheckingAccount, you do not need to CalculateInterest nor print the account a final time.

Hint: To determine if an account is a savings or checking account, use the .getType method which returns a string representing the Name or FullName property. Then use the ".Equals" method to determine if the returned string is equal to the name of the class. For example, acct.getType().Name returns the string "SavingsAccount" or "CheckingAccount". Once you have determined that an account is a SavingsAccount object, you must "cast" the account object into a SavingsAccount object in order to access its CalculateInterest method. I like to perform this in two steps: declare a different variable to hold the reference to the object that has been cast from an Account object into a SavingsAccount object. Then, using this new variable, invoke its CalculateInterest method. For example, at the beginning of the Main() method, I declare a variable of type SavingsAccount as follows:
SavingsAccount temp_account;

In my foreach loop, I have a variable called "acct" that is defined as an Account object. To downcast this Account object into a SavingsAccount object, I use the syntax:
temp_account = (SavingsAccount) acct;

At this point, because temp_account is a SavingsAccount object, I can invoke its CalculateInterest method:
temp_account.CalculateInterest();