# Runtime\_CompilerServices\_CallerMemberNameAttribute

***

**1. Log Method Calls with Caller Member Name**

```csharp
public class Logger
{
    public static void Log(string message, [CallerMemberName] string callerMemberName = null)
    {
        Console.WriteLine($"{callerMemberName}: {message}");
    }
}

class Program
{
    static void Main()
    {
        Logger.Log("Hello World!"); // Output: Log: Hello World!
    }
}
```

**2. Identify Method Call Stack**

```csharp
public class StackTracer
{
    public static string GetCallerStack([CallerMemberName] string callerMemberName = null)
    {
        return $"{callerMemberName} -> {Environment.StackTrace}";
    }
}

class Program
{
    static void Main()
    {
        string stackTrace = StackTracer.GetCallerStack(); // Output: Main -> GetCallerStack -> Main
    }
}
```

**3. Trace Method Execution Time**

```csharp
public class Profiler
{
    public static void Profile(Action action, [CallerMemberName] string callerMemberName = null)
    {
        var start = DateTime.Now;
        action();
        var elapsed = (DateTime.Now - start).TotalMilliseconds;
        Console.WriteLine($"{callerMemberName}: {elapsed} ms");
    }
}

class Program
{
    static void Main()
    {
        Profiler.Profile(() => { Thread.Sleep(1000); }); // Output: Main: 1000 ms
    }
}
```

**4. Annotate Method with Caller Member Name**

```csharp
[CallerMemberName]
public int MyMethod()
{
    // Code here...
}

class Program
{
    static void Main()
    {
        Console.WriteLine(MyMethod()); // Output: MyMethod: 0
    }
}
```

**5. Pass Caller Member Name as Parameter**

```csharp
public class MyClass
{
    public void MyMethod([CallerMemberName] string callerMemberName = null)
    {
        Console.WriteLine($"Calling method: {callerMemberName}");
    }
}

class Program
{
    static void Main()
    {
        new MyClass().MyMethod(); // Output: Calling method: MyMethod
    }
}
```

**6. Log Method Calls with Caller Member Name and Arguments**

```csharp
public class ArgumentLogger
{
    public static void Log(string message, object[] arguments, [CallerMemberName] string callerMemberName = null)
    {
        Console.WriteLine($"{callerMemberName}: {message}");
        foreach (var arg in arguments)
        {
            Console.WriteLine($"  - {arg}");
        }
    }
}

class Program
{
    static void Main()
    {
        ArgumentLogger.Log("Calculating result:", new object[] { 1, 2, 3 });
        // Output:
        // Log: Calculating result:
        //   - 1
        //   - 2
        //   - 3
    }
}
```

**7. Identify Method Call Chain with Caller Member Name**

```csharp
public class CallChainTracer
{
    public static string GetCallerChain([CallerMemberName] string callerMemberName = null)
    {
        var chain = new List<string>();
        GetCallerChain(chain, callerMemberName);
        return string.Join(" -> ", chain);
    }

    private static void GetCallerChain(List<string> chain, string callerMemberName)
    {
        if (callerMemberName is null) return;
        chain.Add(callerMemberName);
        var calleeMemberName = GetCalleeMemberName();
        GetCallerChain(chain, calleeMemberName);
    }

    private static string GetCalleeMemberName([CallerMemberName] string calleeMemberName = null)
    {
        return calleeMemberName;
    }
}

class Program
{
    static void Main()
    {
        string callChain = CallChainTracer.GetCallerChain();
        Console.WriteLine(callChain); // Output: Main -> GetCallerChain -> GetCalleeMemberName -> GetCallerChain -> Main
    }
}
```

**8. Trace Method Execution Time with Caller Member Name**

```csharp
public class TimedProfiler
{
    public static void Profile(Action action, [CallerMemberName] string callerMemberName = null)
    {
        var start = DateTime.Now;
        action();
        var elapsed = (DateTime.Now - start).TotalMilliseconds;
        Console.WriteLine($"{callerMemberName}: {elapsed} ms");
    }
}

class Program
{
    static void Main()
    {
        TimedProfiler.Profile(() => { Thread.Sleep(1000); }); // Output: Main: 1000 ms
    }
}
```

**9. Log Method Calls with Caller Member Name and Exception**

```csharp
public class ExceptionLogger
{
    public static void Log(Exception exception, [CallerMemberName] string callerMemberName = null)
    {
        Console.WriteLine($"Exception in {callerMemberName}: {exception.Message}");
    }
}

class Program
{
    static void Main()
    {
        try
        {
            throw new Exception("Error message");
        }
        catch (Exception ex)
        {
            ExceptionLogger.Log(ex); // Output: Exception in Main: Error message
        }
    }
}
```

**10. Pass Caller Member Name as Output Parameter**

```csharp
public class OutputCallerMemberName
{
    public static void GetCallerMemberName(out string callerMemberName)
    {
        callerMemberName = null;
        GetCallerMemberName(ref callerMemberName);
    }

    private static void GetCallerMemberName(ref string callerMemberName, [CallerMemberName] string callerMemberNameInternal = null)
    {
        callerMemberName = callerMemberNameInternal;
    }
}

class Program
{
    static void Main()
    {
        string callerMemberName;
        OutputCallerMemberName.GetCallerMemberName(out callerMemberName);
        Console.WriteLine(callerMemberName); // Output: Main
    }
}
```

\*\*11. Identify Method Call Stack with Caller Member Name and Ar