Merge pull request #49161 from wwlpublish/814a34e28d92b7dc8ab942b681676c074f2e486813bd980a8fdd7a7326dd3a9b-live

PMEds28 · web-flow · commit 28eb8f246847 · 2025-02-13T10:27:56.000Z
Modules/M01-discover-interfaces
diff --git a/learn-pr/wwl-azure/discover-interfaces/1-introduction.yml b/learn-pr/wwl-azure/discover-interfaces/1-introduction.yml
@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.discover-interfaces.introduction
+title: Introduction
+metadata:
+  title: Introduction
+  description: "Introduction to C# interfaces."
+  ms.date: 02/13/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 2
+content: |
+  [!include[](includes/1-introduction.md)]
diff --git a/learn-pr/wwl-azure/discover-interfaces/2-understand-interfaces.yml b/learn-pr/wwl-azure/discover-interfaces/2-understand-interfaces.yml
@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.discover-interfaces.understand-interfaces
+title: Understand interfaces
+metadata:
+  title: Understand interfaces
+  description: "Understand interfaces in C# code."
+  ms.date: 02/13/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 3
+content: |
+  [!include[](includes/2-understand-interfaces.md)]
diff --git a/learn-pr/wwl-azure/discover-interfaces/3-create-interface-properties.yml b/learn-pr/wwl-azure/discover-interfaces/3-create-interface-properties.yml
@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.discover-interfaces.create-interface-properties
+title: Implement interface properties
+metadata:
+  title: Implement interface properties
+  description: "Implement interface properties in C# code."
+  ms.date: 02/13/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 4
+content: |
+  [!include[](includes/3-create-interface-properties.md)]
diff --git a/learn-pr/wwl-azure/discover-interfaces/4-create-interface-methods.yml b/learn-pr/wwl-azure/discover-interfaces/4-create-interface-methods.yml
@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.discover-interfaces.create-interface-methods
+title: Create interface methods
+metadata:
+  title: Create interface methods
+  description: "Create interface methods in C# code."
+  ms.date: 02/13/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 4
+content: |
+  [!include[](includes/4-create-interface-methods.md)]
diff --git a/learn-pr/wwl-azure/discover-interfaces/5-understand-value-interfaces.yml b/learn-pr/wwl-azure/discover-interfaces/5-understand-value-interfaces.yml
@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.discover-interfaces.understand-value-interfaces
+title: Understand the value of interfaces
+metadata:
+  title: Understand the value of interfaces
+  description: "Understand the value of interfaces in C# code."
+  ms.date: 02/13/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 5
+content: |
+  [!include[](includes/5-understand-value-interfaces.md)]
diff --git a/learn-pr/wwl-azure/discover-interfaces/6-exercise-implement-interfaces-project.yml b/learn-pr/wwl-azure/discover-interfaces/6-exercise-implement-interfaces-project.yml
@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.discover-interfaces.exercise-implement-interfaces-project
+title: 'Exercise: Implement interfaces in project'
+metadata:
+  title: 'Exercise: Implement interfaces in project'
+  description: "Exercise: Implement interfaces in project with C#."
+  ms.date: 02/13/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 20
+content: |
+  [!include[](includes/6-exercise-implement-interfaces-project.md)]
diff --git a/learn-pr/wwl-azure/discover-interfaces/7-knowledge-check.yml b/learn-pr/wwl-azure/discover-interfaces/7-knowledge-check.yml
@@ -0,0 +1,58 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.discover-interfaces.knowledge-check
+title: Knowledge check
+metadata:
+  title: Knowledge check
+  description: "Knowledge check."
+  ms.date: 02/13/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 2
+quiz:
+  title: "Check your knowledge"
+  questions:
+  - content: "Which of the following is true about properties in an interface?"
+    choices:
+    - content: "They can have instance data fields."
+      isCorrect: false
+      explanation: "Incorrect. Properties in an interface don't declare instance data fields."
+    - content: "They typically don't have a body."
+      isCorrect: true
+      explanation: "Correct. Interface properties typically don't have a body; they only define accessors."
+    - content: "They must be static."
+      isCorrect: false
+      explanation: "Incorrect. Interface properties aren't required to be static."
+  - content: "You're implementing an interface in a class. What must you ensure?"
+    choices:
+    - content: "Provide public, nonstatic implementations for all interface members."
+      isCorrect: true
+      explanation: "Correct. When a class implements an interface, it must provide public, nonstatic implementations for all interface members."
+    - content: "Provide private implementations for all interface members."
+      isCorrect: false
+      explanation: "Incorrect. Interface members must be implemented as public, not private."
+    - content: "Provide static implementations for all interface members."
+      isCorrect: false
+      explanation: "Incorrect. Interface members should be implemented as nonstatic."
+  - content: "In a scenario where you need to implement an interface in a class, what syntax is used?"
+    choices:
+    - content: "class ClassName : InterfaceName"
+      isCorrect: true
+      explanation: "Correct. The correct syntax to implement an interface in a class is 'class ClassName : InterfaceName'."
+    - content: "class ClassName implements InterfaceName"
+      isCorrect: false
+      explanation: "Incorrect. The 'implements' keyword isn't used in C#; the correct keyword is ':'."
+    - content: "class ClassName extends InterfaceName"
+      isCorrect: false
+      explanation: "Incorrect. The 'extends' keyword isn't used in C#; the correct keyword is ':'."
+  - content: "What is a key benefit of using interfaces in C# programming?"
+    choices:
+    - content: "They allow for better code organization and flexibility."
+      isCorrect: true
+      explanation: "Correct. Interfaces provide a way to define contracts for classes, enabling better code organization and flexibility."
+    - content: "They allow classes to inherit from multiple base classes."
+      isCorrect: false
+      explanation: "Incorrect. Interfaces don't allow multiple inheritance of classes; they allow a class to implement multiple interfaces."
+    - content: "They provide default implementations for all members."
+      isCorrect: false
+      explanation: "Incorrect. Interfaces may define default implementations for some members starting with C# 8.0, but this isn't their primary benefit."
diff --git a/learn-pr/wwl-azure/discover-interfaces/8-summary.yml b/learn-pr/wwl-azure/discover-interfaces/8-summary.yml
@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.discover-interfaces.summary
+title: Summary
+metadata:
+  title: Summary
+  description: "Summary."
+  ms.date: 02/13/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 2
+content: |
+  [!include[](includes/8-summary.md)]
diff --git a/learn-pr/wwl-azure/discover-interfaces/includes/1-introduction.md b/learn-pr/wwl-azure/discover-interfaces/includes/1-introduction.md
@@ -0,0 +1,19 @@
+Interfaces in C#/.NET programming play a crucial role in defining contracts for classes, enabling polymorphism, and organizing code efficiently.
+
+You're a software developer at a company that is building a new application. Your task is to implement various interfaces in a C# project to ensure that different components of the application can interact seamlessly.
+
+In this module, you learn how to design an interface with properties in .NET, develop a class that implements the interface, and formulate property definitions within the interface.
+
+## Learning objectives
+
+- Design an interface property.
+- Design an interface method.
+- Implements an interface in a class.
+- Understand the value of interfaces.
+
+## Prerequisites
+
+- Visual Studio Code installed with the C# Dev Kit.
+- Basic knowledge of the Visual Studio Code IDE.
+- Basic understanding of the C# programming language.
+- Familiarity with classes.
diff --git a/learn-pr/wwl-azure/discover-interfaces/includes/2-understand-interfaces.md b/learn-pr/wwl-azure/discover-interfaces/includes/2-understand-interfaces.md
@@ -0,0 +1,25 @@
+An interface is like a to-do list or a contract. It outlines what jobs need to be done, without specifying how these jobs should be done. The contract nature of interfaces allows for multiple classes to accomplish the same tasks in their own unique ways.
+
+### Interfaces are like a contract
+
+Each of them - the car, the person, and the horse - has its own unique way of moving. An interface could be used to define the contract requirement "You need to be able to move," but the interface doesn't define how to move.
+
+### Parts of an interface
+
+In C#, an interface outlines the required properties and methods. An interface doesn't hold any data itself, but it does specify what kind of information should be provided through properties. For instance, in a "Move" interface, 'X' and 'Y' could be properties, representing location coordinates. These properties enable the retrieval or modification of their values.
+
+Additionally, interfaces define methods, which are actions that can be performed. However, they don't provide the implementation for these methods. For example, the "Move" interface could include a contract requiring a "Dance" method. However, what exactly happens when the "Dance" method is called by the objects that use this interface, whether it's a car, person, or horse.
+
+### Use an interface
+
+To utilize an interface, entities like a car, a person, or a horse from the "move" example adopt it as part of their functionality. The car, for instance, needs to understand how to perform all the tasks listed in the interface. This process of adopting an interface by the car is known as 'implementing' the interface. In this process, the car agrees to follow the 'contract' set by the interface, defining its own unique ways to complete the tasks such as moving by "driving." Similarly, the person and the horse would also implement the interface, each defining their own unique ways to 'move' such as "run" or "gallop."
+
+Consider the classes "Person" and "Horse." Both implement the "Move" interface, and it's the responsibility of "Person" and "Horse" classes to define ways to "Move."
+
+In the "Person" class, 'Move' could mean walking, jogging, or running. In the "Horse" class, 'Move' could mean walking, trotting, or galloping. Even though they move in different ways, both classes fulfill the 'Move' job requirement from the "Move" interface.
+
+### Why use an interface?
+
+The properties defined by an interface are useful because they ensure that all classes handle information in the same way. An interface makes your related classes more consistent and easier to work with. As long as they all use the same interface, you can write instructions that work with all kinds of different classes.
+
+Implementing an interface is like signing a contract, agreeing to do certain jobs outlined by the interface. The "contract" enforcement provided by interfaces aids in building complex classes that can be easily maintained and updated.
diff --git a/learn-pr/wwl-azure/discover-interfaces/includes/3-create-interface-properties.md b/learn-pr/wwl-azure/discover-interfaces/includes/3-create-interface-properties.md
@@ -0,0 +1,54 @@
+As a developer tasked with creating your project's interfaces, you start the process by designing an interface with **properties**. Then, you develop a class that implements these properties.
+
+An interface in C# is like a blueprint. It outlines the features (properties or methods) that classes need to have if they want to use this interface. For this project, you define an interface that defines properties only (without methods).
+
+- Use the `interface` keyword to create an interface.
+- Define properties in the interface without a body.
+- Interfaces can optionally provide default implementations for members, including properties, but it happens infrequently.
+
+The following code creates an `IVehicle` interface with `Speed` and `Color` properties:
+
+```csharp
+public interface IVehicle
+{
+    int Speed { get; set; }
+    string Color { get; set; }
+}
+```
+
+Interface properties typically don't have any code inside them, they just specify the type of data (like `int` or `string`) and whether you can read from them, write to them, or do both. When you implement these properties in a class, you'll write the actual code for getting (reading) and setting (writing) the values. For example, if an interface has a `Speed` property, you will decide how to store and retrieve the speed value in your class.
+
+## Develop a class that implements the interface
+
+When a class, like `Car`, decides to implement an interface, such as `IVehicle`, it's like saying "I'm going to build a vehicle." The `Car` must include all the features (properties or methods) outlined in the `IVehicle` blueprint.
+
+- The `Car : IVehicle` syntax is used to indicate that `Car` is implementing the `IVehicle` interface. You use the familiar syntax, the same as used for inheritance.
+- The `Car` must provide public, nonstatic implementations for all the features listed in the `IVehicle` blueprint.
+- If `Car` decides to implement multiple blueprints (interfaces) that have similar features, it needs to be clear about which feature comes from which blueprint.
+
+Here's how `Car` implements the `IVehicle` interface in code:
+
+```csharp
+public class Car : IVehicle
+{
+    private int _speed;
+    private string _color;
+
+    public int Speed
+    {
+        get { return _speed; }
+        set { _speed = value; }
+    }
+
+    public string Color
+    {
+        get { return _color; }
+        set { _color = value; }
+    }
+}
+```
+
+> [!NOTE]
+> The `:` symbol is used to indicate that `Car` implements `IVehicle`, similar to how `:` is used to indicate inheritance.
+
+In this example, `Car` is a class that implements the `IVehicle` interface and provides its own versions of `Speed` and `Color`. It's like building a vehicle based on the `IVehicle` blueprint but adding its own unique touches to the speed and color.
diff --git a/learn-pr/wwl-azure/discover-interfaces/includes/4-create-interface-methods.md b/learn-pr/wwl-azure/discover-interfaces/includes/4-create-interface-methods.md
@@ -0,0 +1,59 @@
+As a developer tasked with creating your project's interfaces, you start adding interface **methods** in addition to the interfaces with only **properties**. To test the interface, you develop a class that implements these methods.
+
+An interface is a set of related functions that a class must implement. It can include methods, properties, events, and indexers.
+
+For example, consider an interface named `IVehicle` that includes a `Drive` method and properties for `Speed` and `Color`:
+
+```csharp
+public interface IVehicle
+{
+    int Speed { get; set; }
+    string Color { get; set; }
+    void Drive();
+}
+```
+
+> [!NOTE]
+> How the `Drive` method is declared without a body in the interface. When adding methods to an interface, include the method's signature in the interface declaration, but not its body. The class implementing the interface provides the method's body.
+
+## Construct a class that implements the interface
+
+Implementing an interface in a class is the same for classes with properties, methods or both. When creating a class that implements an interface, adhere to these guidelines:
+
+- Provide implementations for all the interface's members. 
+- Declare the interface as part of the class definition and supply the required method bodies.
+
+> [!NOTE]
+> A class can implement multiple interfaces, allowing it to include behavior from multiple sources. However, a class can only inherit from a single class. If a base class implements an interface, any class derived from the base class inherits that implementation.
+
+Examine the following `Car` class example, which implements the `IVehicle` interface:
+
+```csharp
+public class Car : IVehicle
+{
+    private int _speed;
+    private string _color;
+
+    public int Speed
+    {
+        get { return _speed; }
+        set { _speed = value; }
+    }
+
+    public string Color
+    {
+        get { return _color; }
+        set { _color = value; }
+    }
+
+    public void Drive()
+    {
+        // Implementation of the Drive method
+        Console.WriteLine("The car is driving.");
+    }
+}
+```
+
+In this example, the `Drive` method is implemented to display a message when called. This is just a simple implementation for demonstration purposes. In a real-world application, the `Drive` method could contain more complex code that controls how the car drives.
+
+Interfaces define a contract of method signatures and properties that a class is required to implement. When a class implements an interface, it provides the actual code for these methods, effectively turning the method signatures into functional routines. This process allows a class to adopt diverse behaviors by implementing multiple interfaces. As you continue to develop and define methods within interfaces, you'll find that using interfaces effectively can lead to cleaner, more efficient, and manageable code.
diff --git a/learn-pr/wwl-azure/discover-interfaces/includes/5-understand-value-interfaces.md b/learn-pr/wwl-azure/discover-interfaces/includes/5-understand-value-interfaces.md
diff --git a/learn-pr/wwl-azure/discover-interfaces/includes/6-exercise-implement-interfaces-project.md b/learn-pr/wwl-azure/discover-interfaces/includes/6-exercise-implement-interfaces-project.md
diff --git a/learn-pr/wwl-azure/discover-interfaces/includes/8-summary.md b/learn-pr/wwl-azure/discover-interfaces/includes/8-summary.md
diff --git a/learn-pr/wwl-azure/discover-interfaces/index.yml b/learn-pr/wwl-azure/discover-interfaces/index.yml
diff --git a/learn-pr/wwl-azure/discover-interfaces/media/button-start-exercise.png b/learn-pr/wwl-azure/discover-interfaces/media/button-start-exercise.png
