C# Labs - Reflection, Attributes & Testing

Lab 22: Reflection & Type Inspection

Expert

Coding Challenge

Your Task: Use reflection to inspect types at runtime, get properties, methods, and invoke members dynamically.

Detailed Requirements:
1. Get Type information:

Type type = typeof(Person);
// or at runtime:
Type type = obj.GetType();

2. List properties and methods:

PropertyInfo[] props = type.GetProperties();
MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);

3. Get and set property values dynamically:

PropertyInfo prop = type.GetProperty("Name");
prop.SetValue(obj, "Alice");
string name = (string)prop.GetValue(obj);

4. Invoke methods dynamically:

MethodInfo method = type.GetMethod("Greet");
object result = method.Invoke(obj, new object[] { "World" });

5. Create instances dynamically: Use Activator.CreateInstance.

💡 Pro Tips:
• Use BindingFlags to filter public/private, static/instance members
• GetProperties() returns only public properties by default
• Reflection is slower than direct calls - cache MethodInfo when possible
• Check for null before invoking to avoid exceptions

Expected Output:

Type: Person
Properties: Name, Age
Methods: Greet, ToString
Name value: Alice
Age value: 30
Greet result: Hello, World!

Requirements Checklist

Get Type using typeof or GetType()

List properties with GetProperties()

List methods with GetMethods()

Get/Set property values dynamically

Invoke method dynamically

Print reflection results

using System;
using System.Reflection;

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    
    public string Greet(string target) => $"Hello, {target}!";
    public override string ToString() => $"{Name} ({Age})";
}

class ReflectionDemo
{
    static void Main()
    {
        // TODO: Create instance and get Type
        // var person = new Person { Name = "Alice", Age = 30 };
        // Type type = person.GetType();
        // Console.WriteLine($"Type: {type.Name}");
        
        // TODO: List properties
        // var props = type.GetProperties();
        // Console.WriteLine($"Properties: {string.Join(", ", props.Select(p => p.Name))}");
        
        // TODO: List declared methods (exclude inherited)
        // var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
        // Console.WriteLine($"Methods: {string.Join(", ", methods.Select(m => m.Name))}");
        
        // TODO: Get property values
        // var nameProp = type.GetProperty("Name");
        // var ageProp = type.GetProperty("Age");
        // Console.WriteLine($"Name value: {nameProp.GetValue(person)}");
        // Console.WriteLine($"Age value: {ageProp.GetValue(person)}");
        
        // TODO: Invoke method dynamically
        // var greetMethod = type.GetMethod("Greet");
        // var result = greetMethod.Invoke(person, new object[] { "World" });
        // Console.WriteLine($"Greet result: {result}");
        
        
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Get type: typeof(Person) or obj.GetType()

• Properties: type.GetProperties()

• Methods: type.GetMethods(BindingFlags.DeclaredOnly | ...)

• Invoke: method.Invoke(obj, new object[] { args })

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 23: Custom Attributes

Expert

Coding Challenge

Your Task: Create custom attributes, apply them to classes and members, then read them at runtime using reflection.

Detailed Requirements:
1. Define a custom attribute:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class InfoAttribute : Attribute
{
    public string Author { get; }
    public string Version { get; set; }
    public InfoAttribute(string author) { Author = author; }
}

2. Apply attribute to class and methods:

[Info("Alice", Version = "1.0")]
public class Calculator
{
    [Info("Bob")]
    public int Add(int a, int b) => a + b;
}

3. Read attributes at runtime:

var attr = type.GetCustomAttribute<InfoAttribute>();
if (attr != null) Console.WriteLine(attr.Author);

4. Check for attribute presence: Use IsDefined or GetCustomAttributes.

💡 Pro Tips:
• AttributeUsage controls where attribute can be applied
• Positional parameters are required; named parameters are optional
• AllowMultiple = true lets same attribute be applied multiple times
• Use generic GetCustomAttribute<T>() for cleaner code

Expected Output:

Class attribute: Author=Alice, Version=1.0
Method 'Add' has InfoAttribute: True
Method attribute: Author=Bob, Version=

Requirements Checklist

Define custom attribute class extending Attribute

Use AttributeUsage to specify targets

Apply attribute to class and method

Read class attribute with GetCustomAttribute

Read method attribute

Print attribute values

using System;
using System.Reflection;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class InfoAttribute : Attribute
{
    public string Author { get; }
    public string Version { get; set; } = "";
    public InfoAttribute(string author) { Author = author; }
}

[Info("Alice", Version = "1.0")]
public class Calculator
{
    [Info("Bob")]
    public int Add(int a, int b) => a + b;
    
    public int Subtract(int a, int b) => a - b;
}

class AttributesDemo
{
    static void Main()
    {
        // TODO: Get type and read class attribute
        // Type type = typeof(Calculator);
        // var classAttr = type.GetCustomAttribute<InfoAttribute>();
        // if (classAttr != null)
        //     Console.WriteLine($"Class attribute: Author={classAttr.Author}, Version={classAttr.Version}");
        
        // TODO: Read method attribute
        // var addMethod = type.GetMethod("Add");
        // bool hasAttr = addMethod.IsDefined(typeof(InfoAttribute));
        // Console.WriteLine($"Method 'Add' has InfoAttribute: {hasAttr}");
        
        // var methodAttr = addMethod.GetCustomAttribute<InfoAttribute>();
        // if (methodAttr != null)
        //     Console.WriteLine($"Method attribute: Author={methodAttr.Author}, Version={methodAttr.Version}");
        
        
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Define: class MyAttr : Attribute { ... }

• Usage: [AttributeUsage(AttributeTargets.Class)]

• Apply: [MyAttr("value")]

• Read: type.GetCustomAttribute<MyAttr>()

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 24: Unit Testing Patterns

Expert

Coding Challenge

Your Task: Write unit tests following Arrange-Act-Assert pattern, including edge cases and exception testing.

Detailed Requirements:
1. Create a simple test framework simulation:

static class Assert
{
    public static void AreEqual<T>(T expected, T actual, string msg = "")
    {
        if (!Equals(expected, actual))
            throw new Exception($"Assert failed: {msg} Expected {expected}, got {actual}");
    }
    public static void IsTrue(bool condition, string msg = "") { ... }
    public static void Throws<T>(Action action) where T : Exception { ... }
}

2. Write tests with Arrange-Act-Assert:

static void TestAdd()
{
    // Arrange
    var calc = new Calculator();
    // Act
    int result = calc.Add(2, 3);
    // Assert
    Assert.AreEqual(5, result, "Add should return sum");
}

3. Test edge cases: Zero, negative numbers, boundaries.
4. Test exceptions: Verify expected exceptions are thrown.
5. Run all tests and report results:

💡 Pro Tips:
• Each test should test ONE thing
• Use descriptive test names
• AAA pattern keeps tests organized
• Test both happy path and edge cases

Expected Output:

Running tests...
✓ TestAdd passed
✓ TestAddNegative passed
✓ TestDivide passed
✓ TestDivideByZeroThrows passed
4/4 tests passed

Requirements Checklist

Create Assert helper class with AreEqual, IsTrue

Write test using Arrange-Act-Assert pattern

Test edge case (negative numbers or zero)

Implement Assert.Throws for exception testing

Run multiple tests and count results

Print test results summary

using System;

// Simple Assert helper
static class Assert
{
    public static void AreEqual<T>(T expected, T actual, string msg = "")
    {
        if (!Equals(expected, actual))
            throw new Exception($"Assert failed: {msg} Expected {expected}, got {actual}");
    }
    
    public static void IsTrue(bool condition, string msg = "")
    {
        if (!condition) throw new Exception($"Assert failed: {msg}");
    }
    
    public static void Throws<T>(Action action) where T : Exception
    {
        try { action(); }
        catch (T) { return; } // Expected exception
        catch (Exception ex) { throw new Exception($"Expected {typeof(T).Name}, got {ex.GetType().Name}"); }
        throw new Exception($"Expected {typeof(T).Name} but no exception was thrown");
    }
}

// Class under test
class Calculator
{
    public int Add(int a, int b) => a + b;
    public int Divide(int a, int b) => b == 0 ? throw new DivideByZeroException() : a / b;
}

class UnitTestDemo
{
    static int passed = 0, total = 0;
    
    static void RunTest(string name, Action test)
    {
        total++;
        try { test(); Console.WriteLine($"✓ {name} passed"); passed++; }
        catch (Exception ex) { Console.WriteLine($"✗ {name} failed: {ex.Message}"); }
    }
    
    // TODO: Implement tests
    static void TestAdd()
    {
        // Arrange
        var calc = new Calculator();
        // Act
        int result = calc.Add(2, 3);
        // Assert
        Assert.AreEqual(5, result, "Add should return sum");
    }
    
    static void TestAddNegative()
    {
        var calc = new Calculator();
        Assert.AreEqual(-1, calc.Add(2, -3), "Add with negative");
    }
    
    static void TestDivide()
    {
        var calc = new Calculator();
        Assert.AreEqual(5, calc.Divide(10, 2));
    }
    
    static void TestDivideByZeroThrows()
    {
        var calc = new Calculator();
        Assert.Throws<DivideByZeroException>(() => calc.Divide(10, 0));
    }
    
    static void Main()
    {
        // TODO: Run all tests
        // Console.WriteLine("Running tests...");
        // RunTest("TestAdd", TestAdd);
        // RunTest("TestAddNegative", TestAddNegative);
        // RunTest("TestDivide", TestDivide);
        // RunTest("TestDivideByZeroThrows", TestDivideByZeroThrows);
        // Console.WriteLine($"{passed}/{total} tests passed");
        
        
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• AAA: Arrange (setup), Act (execute), Assert (verify)

• Assert.AreEqual: Assert.AreEqual(expected, actual)

• Exception test: Assert.Throws<DivideByZeroException>(() => ...)

• Test runner: wrap each test in try/catch to report pass/fail

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

C# Programming Labs

Reflection, Attributes & Testing - Module 8

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results