C# Method Examples

• Get Method Name
• Pass method as parameter
• Find called method
• Calculate method execution time
• Return multiple values from method
• Get all types implement an interface

C# Basic

• Application in C#
• Config in C#
• Error in C#
• Environment variables in C#

C# Data Type

• Byte in C#
• Number in C#
• String in C#
• List in C#
• Array in C#
• Dictionary in C#
• Enum in C#
• Structure in C#
• DateTime in C#

C# OOP

• Object in C#
• Method in C#

C# IO

• File in C#
• CSV in C#
• JSON in C#
• XML in C#

C# Graphics & UI

• Image in C#
• Color in C#
• Controls in C#

C# Advanced

• Clipboard in C#
• Excel Column in C#
• foreach in C#
• DataTable in C#
• Email in C#
• Guid in C#
• HTTP in C#
• LINQ in C#
• Stream in C#

How to find the method that called the current method in C#

In C#, you can use the StackTrace class to get information about the calling method or class. Here's how to do it:

Finding the Method that Called the Current Method

public void MethodA() {
    var stackTrace = new StackTrace();
    var callingMethod = stackTrace.GetFrame(1).GetMethod();
    Console.WriteLine("Method called from: " + callingMethod.Name);
}

public void MethodB() {
    MethodA();
}

// Example usage:
MethodB(); // Output: Method called from: MethodB

In this example, MethodA calls new StackTrace() to create a new StackTrace object, which represents the current call stack. The GetFrame method is then called with a parameter of 1, which returns the calling method (the method that called the current method) as a MethodBase object. The name of the calling method is then printed to the console.

Finding the Class Name that Called the Current Method

public void MethodA() {
    var stackTrace = new StackTrace();
    var callingMethod = stackTrace.GetFrame(1).GetMethod();
    var callingType = callingMethod.DeclaringType;
    Console.WriteLine("Class called from: " + callingType.Name);
}

public void MethodB() {
    MethodA();
}

// Example usage:
MethodB(); // Output: Class called from: Program

In this example, MethodA calls new StackTrace() to create a new StackTrace object, which represents the current call stack. The GetFrame method is then called with a parameter of 1, which returns the calling method (the method that called the current method) as a MethodBase object. The DeclaringType property is then called on the MethodBase object to get the Type object representing the class that contains the calling method. The name of the calling class is then printed to the console.

Finding the Full Name of the Calling Method

public void MethodA() {
    var stackTrace = new StackTrace();
    var callingMethod = stackTrace.GetFrame(1).GetMethod();
    var fullName = callingMethod.DeclaringType.FullName + "." + callingMethod.Name;
    Console.WriteLine("Method called from: " + fullName);
}

public void MethodB() {
    MethodA();
}

// Example usage:
MethodB(); // Output: Method called from: Program.MethodB

In this example, MethodA calls new StackTrace() to create a new StackTrace object, which represents the current call stack. The GetFrame method is then called with a parameter of 1, which returns the calling method (the method that called the current method) as a MethodBase object. The FullName property is then called on the Type object representing the class that contains the calling method, and the name of the calling method is appended using the . separator. The full name of the calling method is then printed to the console.

1. C# get calling method name:

   using System;
   using System.Diagnostics;
   
   public class CallerMethodExample
   {
       public void DisplayCallingMethod()
       {
           string callerMethodName = GetCallingMethod();
           Console.WriteLine($"Calling method: {callerMethodName}");
       }
   
       public string GetCallingMethod()
       {
           StackTrace stackTrace = new StackTrace();
           // Get the calling method name from the stack trace
           return stackTrace.GetFrame(1)?.GetMethod()?.Name;
       }
   
       public static void Main()
       {
           CallerMethodExample example = new CallerMethodExample();
           // Call a method that displays the calling method name
           example.DisplayCallingMethod();
       }
   }
   

2. Finding the calling method stack trace in C#:

   using System;
   using System.Diagnostics;
   
   public class CallerMethodExample
   {
       public void DisplayCallingMethod()
       {
           StackTrace stackTrace = new StackTrace();
           // Get the entire stack trace
           Console.WriteLine("Calling method stack trace:");
           foreach (StackFrame frame in stackTrace.GetFrames())
           {
               Console.WriteLine(frame.GetMethod()?.Name);
           }
       }
   
       public static void Main()
       {
           CallerMethodExample example = new CallerMethodExample();
           // Call a method that displays the calling method stack trace
           example.DisplayCallingMethod();
       }
   }
   

3. Determining the caller method in C#:

   using System;
   using System.Diagnostics;
   
   public class CallerMethodExample
   {
       public void DisplayCallingMethod()
       {
           string callerMethodName = GetCallingMethod();
           Console.WriteLine($"Calling method: {callerMethodName}");
       }
   
       public string GetCallingMethod()
       {
           // Use Environment.StackTrace to get the calling method
           string stackTrace = Environment.StackTrace;
           int startIndex = stackTrace.IndexOf("at ") + 3;
           int endIndex = stackTrace.IndexOf("(", startIndex);
           return stackTrace.Substring(startIndex, endIndex - startIndex);
       }
   
       public static void Main()
       {
           CallerMethodExample example = new CallerMethodExample();
           // Call a method that displays the calling method name
           example.DisplayCallingMethod();
       }
   }
   

4. Retrieve caller method information in C#:

   using System;
   using System.Diagnostics;
   
   public class CallerMethodExample
   {
       public void DisplayCallingMethod()
       {
           string callerMethodName = GetCallingMethod();
           Console.WriteLine($"Calling method: {callerMethodName}");
       }
   
       public string GetCallingMethod()
       {
           // Use Environment.StackTrace to get the calling method
           string stackTrace = Environment.StackTrace;
           int startIndex = stackTrace.IndexOf("at ") + 3;
           int endIndex = stackTrace.IndexOf("(", startIndex);
           return stackTrace.Substring(startIndex, endIndex - startIndex);
       }
   
       public static void Main()
       {
           CallerMethodExample example = new CallerMethodExample();
           // Call a method that displays the calling method name
           example.DisplayCallingMethod();
       }
   }
   

5. C# get method caller using reflection:

   using System;
   using System.Diagnostics;
   using System.Reflection;
   
   public class CallerMethodExample
   {
       public void DisplayCallingMethod()
       {
           string callerMethodName = GetCallingMethod();
           Console.WriteLine($"Calling method: {callerMethodName}");
       }
   
       public string GetCallingMethod()
       {
           // Use reflection to get the calling method name
           MethodBase method = new StackFrame(1).GetMethod();
           return method?.Name;
       }
   
       public static void Main()
       {
           CallerMethodExample example = new CallerMethodExample();
           // Call a method that displays the calling method name
           example.DisplayCallingMethod();
       }
   }
   

6. C# find method that called another method:

   using System;
   using System.Diagnostics;
   
   public class CallerMethodExample
   {
       public void DisplayCallingMethod()
       {
           string callerMethodName = GetCallingMethod();
           Console.WriteLine($"Calling method: {callerMethodName}");
       }
   
       public void IntermediateMethod()
       {
           // Call another method
           DisplayCallingMethod();
       }
   
       public string GetCallingMethod()
       {
           // Use StackTrace to find the method that called another method
           StackTrace stackTrace = new StackTrace();
           StackFrame callerFrame = stackTrace.GetFrame(2); // 2 to get the calling method
           return callerFrame?.GetMethod()?.Name;
       }
   
       public static void Main()
       {
           CallerMethodExample example = new CallerMethodExample();
           // Call a method that eventually calls another method
           example.IntermediateMethod();
       }
   }
   

7. C# get calling method from another class:

   using System;
   using System.Diagnostics;
   
   public class CallerMethodExample
   {
       public void DisplayCallingMethod()
       {
           string callerMethodName = GetCallingMethod();
           Console.WriteLine($"Calling method: {callerMethodName}");
       }
   }
   
   public class AnotherClass
   {
       public void CallMethodFromAnotherClass()
       {
           CallerMethodExample example = new CallerMethodExample();
           example.DisplayCallingMethod();
       }
   }
   
   public class MainClass
   {
       public static void Main()
       {
           AnotherClass anotherClass = new AnotherClass();
           // Call a method from another class
           anotherClass.CallMethodFromAnotherClass();
       }
   }
   

8. Find the method caller with CallerMemberName attribute in C#:

   using System;
   using System.Runtime.CompilerServices;
   
   public class CallerMethodExample
   {
       public void DisplayCallingMethod([CallerMemberName] string callerMethodName = "")
       {
           Console.WriteLine($"Calling method: {callerMethodName}");
       }
   
       public void IntermediateMethod()
       {
           // Call another method
           DisplayCallingMethod();
       }
   
       public static void Main()
       {
           CallerMethodExample example = new CallerMethodExample();
           // Call a method that eventually calls another method
           example.IntermediateMethod();
       }
   }
   

9. C# get caller method from an asynchronous method:

   using System;
   using System.Diagnostics;
   using System.Threading.Tasks;
   
   public class CallerMethodExample
   {
       public async Task DisplayCallingMethodAsync()
       {
           await Task.Delay(1000);
           string callerMethodName = await GetCallingMethodAsync();
           Console.WriteLine($"Calling method: {callerMethodName}");
       }
   
       public async Task<string> GetCallingMethodAsync()
       {
           await Task.Delay(100);
           StackTrace stackTrace = new StackTrace();
           return stackTrace.GetFrame(1)?.GetMethod()?.Name;
       }
   
       public static async Task Main()
       {
           CallerMethodExample example = new CallerMethodExample();
           // Call an asynchronous method that displays the calling method name
           await example.DisplayCallingMethodAsync();
       }
   }
   

10. C# get calling method name dynamically:

    using System;
    using System.Diagnostics;
    
    public class CallerMethodExample
    {
        public void DisplayCallingMethod()
        {
            string callerMethodName = GetCallingMethod();
            Console.WriteLine($"Calling method: {callerMethodName}");
        }
    
        public string GetCallingMethod([System.Runtime.CompilerServices.CallerMemberName] string callerMethodName = "")
        {
            // Use CallerMemberName attribute for dynamic method name retrieval
            return callerMethodName;
        }
    
        public static void Main()
        {
            CallerMethodExample example = new CallerMethodExample();
            // Call a method that displays the calling method name
            example.DisplayCallingMethod();
        }
    }
    

11. Finding the caller method in a different assembly in C#:

    using System;
    using System.Diagnostics;
    using System.Reflection;
    
    public class CallerMethodExample
    {
        public void DisplayCallingMethod()
        {
            string callerMethodName = GetCallingMethod();
            Console.WriteLine($"Calling method: {callerMethodName}");
        }
    
        public string GetCallingMethod()
        {
            // Use reflection to get the calling method name in a different assembly
            MethodBase method = new StackFrame(1).GetMethod();
            string callingAssembly = method?.DeclaringType?.Assembly?.FullName;
            return $"{callingAssembly}.{method?.Name}";
        }
    
        public static void Main()
        {
            CallerMethodExample example = new CallerMethodExample();
            // Call a method that displays the calling method name
            example.DisplayCallingMethod();
        }
    }
    

12. C# trace calling method from a logging perspective:

    using System;
    using System.Diagnostics;
    
    public class LoggingExample
    {
        public void LogCallingMethod()
        {
            string callerMethodName = GetCallingMethod();
            Console.WriteLine($"Log: Calling method - {callerMethodName}");
        }
    
        public string GetCallingMethod()
        {
            StackTrace stackTrace = new StackTrace();
            // Get the calling method name from the stack trace
            return stackTrace.GetFrame(1)?.GetMethod()?.Name;
        }
    }
    
    public class MainClass
    {
        public static void Main()
        {
            LoggingExample loggingExample = new LoggingExample();
            // Log the calling method
            loggingExample.LogCallingMethod();
        }
    }