pull base content,head:MicrosoftDocs:main,into:wwlpublishsync

Author: wwlpublish

learn-pr/wwl-azure/design-resilient-code-interfaces/1-introduction.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.introduction
+title: Introduction
+metadata:
+  title: Introduction
+  description: "Introduction to designing resilient code with interfaces in C#."
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 2
+content: |
+  [!include[](includes/1-introduction.md)]

learn-pr/wwl-azure/design-resilient-code-interfaces/2-examine-interface-designs.yml

@@ -0,0 +1,49 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.examine-interface-designs
+title: Examine interface designs
+metadata:
+  title: Examine interface designs
+  description: "Examine interface designs and SOLID design principles."
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 5
+content: |
+  [!include[](includes/2-examine-interface-designs.md)]
+quiz:
+  title: "Check your knowledge"
+  questions:
+  - content: "What does code standardization primarily aim to achieve?"
+    choices:
+    - content: "Reduce the number of programming languages used."
+      isCorrect: false
+      explanation: "Incorrect. Code standardization is about creating rules for writing code, not about the number of languages used."
+    - content: "Make the code consistent and easy to read and modify across a project."
+      isCorrect: true
+      explanation: "Correct. Code standards establish rules for writing code that make it easier to read and modify."
+    - content: "Increase the complexity of the codebase."
+      isCorrect: false
+      explanation: "Incorrect. Code standardization helps make code easier to read and modify, not more complex."
+  - content: "What is the Single Responsibility Principle?"
+    choices:
+    - content: "A class should have only one reason to change."
+      isCorrect: true
+      explanation: "Correct. The Single Responsibility Principle states that a class should have a single, clear responsibility and only one reason to change."
+    - content: "A class should have multiple reasons for change."
+      isCorrect: false
+      explanation: "Incorrect. Multiple reasons for change indicate that the class is handling more than one responsibility, which violates the principle."
+    - content: "A class should have no reasons for change."
+      isCorrect: false
+      explanation: "Incorrect. A class must be designed to fulfill its specific responsibility, so it may need to change when that responsibility evolves."
+  - content: "According to the Dependency Inversion Principle (DIP), what should classes depend on for defining required behavior?"
+    choices:
+    - content: "Other classes directly"
+      isCorrect: false
+      explanation: "Incorrect. Directly depending on other classes creates tight coupling, making the code less flexible and harder to maintain."
+    - content: "Interfaces or abstract classes"
+      isCorrect: true
+      explanation: "Correct. The DIP states that classes should depend on interfaces or abstract classes, not other classes directly."
+    - content: "Specific properties of other classes"
+      isCorrect: false
+      explanation: "Incorrect. Depending on specific properties of other classes introduces rigid dependencies, which the DIP seeks to avoid."

learn-pr/wwl-azure/design-resilient-code-interfaces/3-implement-explicit-interface-members.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.implement-explicit-interface-members
+title: Implement explicit interface members in a class
+metadata:
+  title: Implement explicit interface members in a class
+  description: "Implement explicit interface members in a class using C#."
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 6
+content: |
+  [!include[](includes/3-implement-explicit-interface-members.md)]

learn-pr/wwl-azure/design-resilient-code-interfaces/4-use-combine-multiple-interfaces.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.use-combine-multiple-interfaces
+title: Use and combine multiple interfaces
+metadata:
+  title: Use and combine multiple interfaces
+  description: "Use and combine multiple interfaces in your C# classes."
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 5
+content: |
+  [!include[](includes/4-use-combine-multiple-interfaces.md)]

learn-pr/wwl-azure/design-resilient-code-interfaces/5-understand-tightly-coupled-code.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.understand-tightly-coupled-code
+title: Understand tightly coupled code
+metadata:
+  title: Understand tightly coupled code
+  description: "Discover how tightly coupled code impacts the maintainability applications."
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 5
+content: |
+  [!include[](includes/5-understand-tightly-coupled-code.md)]

learn-pr/wwl-azure/design-resilient-code-interfaces/6-refactor-use-interfaces.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.refactor-use-interfaces
+title: Refactor using interfaces
+metadata:
+  title: Refactor using interfaces
+  description: "Use interfaces in refactoring to reduce dependencies."
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 6
+content: |
+  [!include[](includes/6-refactor-use-interfaces.md)]

learn-pr/wwl-azure/design-resilient-code-interfaces/7-exercise-decouple-code-with-interfaces.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.exercise-decouple-code-with-interfaces
+title: 'Exercise: Decouple code with interfaces'
+metadata:
+  title: 'Exercise: Decouple code with interfaces'
+  description: "Exercise: Decouple code with interfaces in C# code."
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 25
+content: |
+  [!include[](includes/7-exercise-decouple-code-with-interfaces.md)]

learn-pr/wwl-azure/design-resilient-code-interfaces/8-knowledge-check.yml

@@ -0,0 +1,49 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.knowledge-check
+title: Knowledge check
+metadata:
+  title: Knowledge check
+  description: "Knowledge check"
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 2
+content: |
+  [!include[](includes/8-knowledge-check.md)]
+quiz:
+  title: "Check your knowledge"
+  questions:
+  - content: "Which solution allows access for explicit interface members in C#?"
+    choices:
+    - content: "By casting the class instance to the interface type."
+      isCorrect: true
+      explanation: "Correct. Explicit interface members are only accessible through the interface instance, so you need to cast the class instance to the interface type."
+    - content: "By using the `this` keyword within the class."
+      isCorrect: false
+      explanation: "Incorrect. Explicit interface members cannot be accessed using the `this` keyword within the class; they are only accessible through the interface instance."
+    - content: "By using reflection to invoke the members."
+      isCorrect: false
+      explanation: "Incorrect. While reflection can be used to invoke members, it is not the standard way to access explicit interface members. The correct approach is to cast the class instance to the interface type."
+  - content: "What is a key benefit of using interfaces to reduce code dependencies?"
+    choices:
+    - content: "Interfaces promote loose coupling and easier testing."
+      isCorrect: true
+      explanation: "Correct. Interfaces define a set of methods and properties that implementing classes must provide, promoting loose coupling and making the code easier to test and maintain."
+    - content: "Interfaces provide default implementations for all methods."
+      isCorrect: false
+      explanation: "Incorrect. Interfaces do not provide default implementations for methods; they only define the contract that implementing classes must follow."
+    - content: "Interfaces allow for multiple inheritance of classes."
+      isCorrect: false
+      explanation: "Incorrect. C# does not support multiple inheritance of classes. Interfaces allow a class to inherit behavior from multiple sources without multiple inheritance."
+  - content: "Imagine the scenario of developing a home automation application with different types of lights. Which approach allows mix and match capabilities in a single class?"
+    choices:
+    - content: "Implement multiple interfaces in the class."
+      isCorrect: true
+      explanation: "Correct. Implementing multiple interfaces in a class allows mix and match capabilities, providing a common API supported by various types."
+    - content: "Use multiple inheritance of classes."
+      isCorrect: false
+      explanation: "Incorrect. C# does not support multiple inheritance of classes. Implementing multiple interfaces is the correct approach."
+    - content: "Define all functionalities within a single interface."
+      isCorrect: false
+      explanation: "Incorrect. Defining all functionalities within a single interface can lead to a bloated interface. Implementing multiple interfaces is a better approach."

learn-pr/wwl-azure/design-resilient-code-interfaces/9-summary.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.wwl.design-resilient-code-interfaces.summary
+title: Summary
+metadata:
+  title: Summary
+  description: "Summary."
+  ms.date: 02/14/2025
+  author: wwlpublish
+  ms.author: eric
+  ms.topic: unit
+durationInMinutes: 2
+content: |
+  [!include[](includes/9-summary.md)]

learn-pr/wwl-azure/design-resilient-code-interfaces/includes/1-introduction.md

@@ -0,0 +1,19 @@
+Interfaces in C#/.NET programming are essential for creating resilient and maintainable code by reducing dependencies and enabling flexible design.
+
+In this module, you explore advanced concepts of interfaces in C#. You learn how to implement explicit interface members, combine multiple interfaces, and reduce code dependencies using interfaces.
+
+## Learning objectives
+
+- Apply SOLID design principles.
+- Implement explicit interface members in a class.
+- Use and combine multiple interfaces.
+- Reduce code dependencies with interfaces.
+- Build resilient code with 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.
+- Able to create and implement basic interfaces.
+- Familiar with classes, abstract classes, and inheritance.