有任何C#等价于Perl自动加载吗？

在C#中是否有任何方法可以动态拦截类中的方法调用，相当于Perl自动加载机制

举个例子，我有一个helper类，它有一个“core”方法，可以写入系统事件日志，还有几个方便的重载，以简化最常见的用法

现在，我看到了一个新兴的代码模式，我使用try。。。catch尝试写入条目，但忽略与实际事件日志处理相关的任何故障。例如，当尝试在事件日志已满时记录应用程序异常时，我希望应用程序以“真实”应用程序异常而不是“事件日志”异常崩溃

我目前刚刚创建了一组新的重载来封装它，但我真正想做的是动态处理这些方法，即对以“Try”开头的方法名的任何方法调用都会调用相应的“real”方法，封装在Try中。。接住。这在Perl中非常容易；-）但它甚至可以用C#完成吗

一些可能简化解释的代码：

public class SomeClass
{
    // Core functionality
    public static void WriteToLog(string message, EventLogEntryType type)
    {
        ...
    }

    // Overloaded methods for common uses
    public static void WriteToLog(SomeObject obj)
    {
        WriteToLog(obj.ToString(), EventLogEntryType.Information);
    }

    public static void WriteToLog(SomeException ex)
    {
        WriteToLog(ex.Message, EventLogEntryType.Error);
    }

    // Additional wrappers that ignores errors
    // These are what I'd like to handle dynamically instead of manually:
    public static void TryWriteToLog(SomeObject obj)
    {
        try 
        {
            WriteToLog(obj);
        }
        catch (Exception logException)
        {
            Console.WriteLine(logException.Message);
        }
    }

    public static void TryWriteToLog(SomeException ex)
    {
        try 
        {
            WriteToLog(ex);
        }
        catch (Exception logException)
        {
            Console.WriteLine(logException.Message);
        }
    }
}

哦。。。 让我大吃一惊的是，我边喝咖啡边想出来了，而且真的很管用。为了解释最初的代码片段，以下是我所做的：

using System;
using System.Dynamic;
using System.Reflection;

public class SomeClass : DynamicObject
{
    // Core functionality
    public static void WriteToLog(string message, EventLogEntryType type)
    {
        ...
    }

    // Overloaded methods for common uses
    public static void WriteToLog(SomeObject obj)
    {
        WriteToLog(obj.ToString(), EventLogEntryType.Information);
    }

    public static void WriteToLog(SomeException ex)
    {
        WriteToLog(ex.Message, EventLogEntryType.Error);
    }

    // Redirect all method calls that start with 'Try' to corresponding normal
    // methods, but encapsulate the method call in a try ... catch to ignore
    // log-related errors

    private static dynamic instance = new SomeClass();

    public static dynamic Instance { get { return instance; } }

    public override bool TryInvokeMember(InvokeMemberBinder binder, 
                                         object[] args, 
                                         out object result)
    {
        if (binder.Name.StartsWith("Try"))
        {
            try
            {
                result = this.GetType().InvokeMember(binder.Name.Substring(3),
                                                     BindingFlags.InvokeMethod, 
                                                     null, 
                                                     this,
                                                     args);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.InnerException.Message);
                result = null;
            }
            return true;
        }
        else
        {
            return base.TryInvokeMember(binder, args, out result);
        }
    }

现在可以调用以下方法，并且似乎可以按预期工作：

SomeClass.Instance.WriteToLog(SomeObject obj)
SomeClass.Instance.TryWriteToLog(SomeObject obj)
SomeClass.Instance.WriteToLog(SomeException ex)
SomeClass.Instance.TryWriteToLog(SomeException ex)
SomeClass.Instance.WriteToLog(string message, EventLogEntryType type)
SomeClass.Instance.TryWriteToLog(string message, EventLogEntryType type)

---

小提示：上面的代码已清理干净，可以发布在官方论坛上，可能无法直接使用。

可能与@Jamiec重复不完全相同，因为我对重定向函数调用感兴趣，而不仅仅是记录它。我自己找到了答案，但我暂时不回答这个问题，以防有人提出更好的解决方案。