Merge pull request #7 from MicrosoftLearning/lp2-m1-eric

Lp2 m1 eric - Clean-up of Lp2 M01 interfaces instructions/code

Author: eric-camplin

DownloadableCodeProjects/LP2_implement_interfaces/Interfaces_M1/Solution/ImplementInterfaces/IPerson.cs

@@ -6,15 +6,4 @@ public interface IPerson
         int Age { get; set; }
         void DisplayInfo();
     }
-
-    public class Student : IPerson
-    {
-        public string Name { get; set; } = string.Empty;
-        public int Age { get; set; } = 0;
-
-        public void DisplayInfo()
-        {
-            Console.WriteLine($"Student Name: {Name}, Age: {Age}");
-        }
-    }
 }

DownloadableCodeProjects/LP2_implement_interfaces/Interfaces_M1/Solution/ImplementInterfaces/Student.cs

@@ -0,0 +1,13 @@
+namespace ImplementInterfaces
+{
+    public class Student : IPerson
+    {
+        public string Name { get; set; } = string.Empty;
+        public int Age { get; set; } = 0;
+
+        public void DisplayInfo()
+        {
+            Console.WriteLine($"Student Name: {Name}, Age: {Age}");
+        }
+    }
+}

Instructions/Labs/l2p2-lp2-m1-exercise-implement-interfaces-project.md

@@ -45,12 +45,6 @@ This exercise includes the following tasks:
 
 To start, you need to create a new C# project in your development environment. This project will serve as the foundation for implementing interfaces and their respective classes.
 
-### What you'll learn
-
-- How to create a new C# console application using the .NET CLI.
-
-### Steps
-
 1. Open Visual Studio Code.
 1. Ensure that the C# Dev Kit extension is installed.
 1. Open the terminal in Visual Studio Code by selecting `View > Terminal`.
@@ -79,13 +73,11 @@ Ensure that the project has been created successfully by verifying the presence
 
 ---
 
-## Task 2: Define an interface with method signatures and properties
+## Task 2: Define the `IPerson` interface with method signatures and properties
 
 Next, you will define an interface that includes method signatures and properties. This interface will be used to enforce a contract for any class that implements it. The code defines an interface in C# which shows interfaces enforcing consistent behavior across classes.
 
-### Steps
-
-1. In the `ImplementInterfaces` project, create a new file named `IPerson.cs`.
+1. Create a new file named `IPerson.cs` in the `ImplementInterfaces` project.
 1. Add the following code to define the `IPerson` interface:
 
    ```csharp
@@ -100,18 +92,14 @@ Next, you will define an interface that includes method signatures and propertie
    }
    ```
 
-### Check your work
-
-Verify that the `IPerson` interface is correctly defined by checking the `IPerson.cs` file. The interface should include the `Name` and `Age` properties, as well as the `DisplayInfo` method signature.
+    *The `IPerson` interface has been defined to include the `Name` and `Age` properties, along with the `DisplayInfo` method signature, ensuring a consistent contract for implementing classes.*
 
 ---
 
-## Task 3: Implement the defined interface in a class
+## Task 3: Implement the defined `IPerson` interface in a class
 
 Now, you will create a class that implements the `IPerson` interface. This class will provide concrete implementations for the interface members. The code in this step implements an interface in a class and provides concrete implementations for the interface.
 
-### Steps
-
 1. In the `ImplementInterfaces` project, create a new file named `Student.cs`.
 1. Add the following code to implement the `IPerson` interface in the `Student` class:
 
@@ -131,18 +119,15 @@ Now, you will create a class that implements the `IPerson` interface. This class
    }
    ```
 
-### Check your work
-Ensure that the `Student` class correctly implements the `IPerson` interface by checking the `Student.cs` file. The class should provide implementations for the `Name` and `Age` properties, as well as the `DisplayInfo` method.
+    *The `Student` class has been implemented to adhere to the `IPerson` interface. It provides concrete implementations for the `Name` and `Age` properties, as well as the `DisplayInfo` method, ensuring compliance with the interface contract.*
 
 ---
 
-## Task 4: Create another class that implements different behavior
+## Task 4: Create a second class to implement `IPerson` interface with different behavior
 
 You will now create another class that implements the `IPerson` interface but with different behavior. Task 4 implements the same interface in multiple classes. This demonstrates how to provide unique behavior for each class using an interface.
 
-### Steps
-
-1. In the `ImplementInterfaces` project, create a new file named `Teacher.cs`.
+1. Create a new file named `Teacher.cs` in the `ImplementInterfaces` project.
 1. Add the following code to implement the `IPerson` interface in the `Teacher` class:
 
    ```csharp
@@ -161,18 +146,14 @@ You will now create another class that implements the `IPerson` interface but wi
    }
    ```
 
-### Check your work
-
-Verify that the `Teacher` class correctly implements the `IPerson` interface by checking the `Teacher.cs` file. The class should provide implementations for the `Name` and `Age` properties, as well as the `DisplayInfo` method.
+*You have created the `Teacher` class, which implements the `IPerson` interface. This class provides its own implementation for the `Name` and `Age` properties, as well as the `DisplayInfo` method, ensuring it adheres to the interface contract.*
 
 ---
 
-## Task 5: Demonstrate interface implementation
+## Task 5: Demonstrate the interface implementation
 
 In this task, you will demonstrate the use of the interface by creating instances of the `Student` and `Teacher` classes and calling their methods. This demonstrates how to use polymorphism to treat objects of different classes as the same interface type.
 
-### Steps
-
 1. Open the `Program.cs` file in the `ImplementInterfaces` project.
 1. Replace the existing code with the following:
 
@@ -195,41 +176,35 @@ In this task, you will demonstrate the use of the interface by creating instance
    }
    ```
 
-### Check your work
-
-Run the application using the following command:
-
-```bash
-dotnet run
-```
-
-You should see the output displaying the information for both the student and the teacher, demonstrating the interface implementation.
-
----
+    *The `Program.cs` file demonstrates how to use the `IPerson` interface to create polymorphic behavior. By creating instances of the `Student` and `Teacher` classes, you can observe how each class adheres to the interface contract while providing its own unique implementation of the `DisplayInfo` method.*
 
 ## Task 6: Test the implemented interfaces
 
 Next, you will test the implemented interfaces and their respective classes to ensure they function correctly. This section of code demonstrates how to test interface implementations in a C# application.
 
-### Steps
+1. Ensure that the `Program.cs` file contains the code to create instances of `Student` and `Teacher` and calls their `DisplayInfo` methods and all files are saved.
+1. Build the application using the following command:
+
+    ```bash
+    dotnet build
+    ```
+
+    *Ensure that the build completes successfully without any errors.*
 
-1. Ensure that the `Program.cs` file contains the code to create instances of `Student` and `Teacher` and calls their `DisplayInfo` methods.
 1. Run the application again using the following command:
 
    ```bash
    dotnet run
    ```
 
-1. Verify the output to ensure that the information for both the student and the teacher is displayed correctly.
-
-### Check your work
+1. Confirm that the application runs without errors and displays the correct information for both the student and the teacher. The output should look similar to the following:
 
-Confirm that the application runs without errors and displays the correct information for both the student and the teacher. The output should look similar to the following:
+    ```console
+    Student Name: Eric Solomon, Age: 20
+    Teacher Name: Kayla Lewis, Age: 35
+    ```
 
-```console
-Student Name: Eric Solomon, Age: 20
-Teacher Name: Kayla Lewis, Age: 35
-```
+    *Observe that the output confirms the successful implementation of the `IPerson` interface in both the `Student` and `Teacher` classes. Each class adheres to the interface contract while providing its unique implementation of the `DisplayInfo` method, demonstrating polymorphism in action.*
 
 ---