**Course Title:** Mastering Go: From Basics to Advanced Development **Section Title:** Advanced Topics: Reflection and Contexts **Topic:** Implement reflection and context in a Go application.(Lab topic) **Overview:** In this lab topic, we will put into practice the concepts of reflection and context in Go. We will create a simple application that utilizes the `reflect` package to inspect and dynamically call methods on a struct. We will also explore how to use the `context` package to manage request scope and cancellation. **Lab Structure:** Our lab will consist of two main parts: 1. **Reflection**: We will define a struct with methods, and then use the `reflect` package to dynamically inspect and call these methods. 2. **Context**: We will create a simple application that uses the `context` package to manage request scope and cancellation. **Part 1: Reflection** Let's start with the `reflection` part of the lab. We will define a struct `Calculator` with three methods: `Add`, `Subtract`, and `Multiply`. ```go package main import ( "fmt" "reflect" ) type Calculator struct{} func (c *Calculator) Add(a, b int) int { return a + b } func (c *Calculator) Subtract(a, b int) int { return a - b } func (c *Calculator) Multiply(a, b int) int { return a * b } func main() { // Create a new Calculator instance calculator := &Calculator{} // Use reflection to get the methods of the Calculator struct v := reflect.ValueOf(calculator) methods := []reflect.Method{} for i := 0; i < v.NumMethod(); i++ { methods = append(methods, v.Method(i)) } // Print the methods for _, method := range methods { fmt.Printf("Method: %s\n", method.Name) } // Dynamically call the Add method addMethod := v.MethodByName("Add") if addMethod.IsValid() { results := addMethod.Call([]reflect.Value{reflect.ValueOf(5), reflect.ValueOf(3)}) fmt.Printf("Result: %d\n", results[0].Int()) } } ``` In this example, we use the `reflect` package to: 1. Create a new `Calculator` instance. 2. Get the methods of the `Calculator` struct using `reflect.ValueOf` and `v.NumMethod()`. 3. Print the methods using a loop. 4. Dynamically call the `Add` method using `v.MethodByName` and `addMethod.Call`. **Part 2: Context** Now, let's move on to the `context` part of the lab. We will create a simple application that uses the `context` package to manage request scope and cancellation. ```go package main import ( "context" "fmt" "time" ) func longRunningOperation(ctx context.Context) { fmt.Println("Starting long-running operation...") select { case <-ctx.Done(): fmt.Println("Operation cancelled.") return case <-time.After(5 * time.Second): fmt.Println("Operation completed.") } } func main() { // Create a new context with a cancellation deadline ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() go longRunningOperation(ctx) // Wait for the operation to complete or cancel select { case <-ctx.Done(): fmt.Println("Main function exiting.") return } } ``` In this example, we use the `context` package to: 1. Create a new context with a cancellation deadline using `context.WithTimeout`. 2. Define a `longRunningOperation` function that checks for cancellation using `ctx.Done`. 3. Start the long-running operation in a separate goroutine using `go`. 4. Wait for the operation to complete or cancel using a `select` statement. **Key Takeaways:** * The `reflect` package allows you to dynamically inspect and call methods on a struct. * The `context` package helps manage request scope and cancellation. * Use `context.WithTimeout` to create a new context with a cancellation deadline. **Practice:** Try experimenting with different types and methods using reflection. Also, explore the `context` package to learn more about its features. **Additional Resources:** * Go `reflect` package documentation: <https://pkg.go.dev/reflect> * Go `context` package documentation: <https://pkg.go.dev/context> **Have Questions or Need Help?** Leave a comment below with your questions or feedback. We're here to help. Next, we will cover **Project presentations: sharing final projects and code walkthroughs** in the section **Final Project and Review**.