C#4 拦截方法调用

发布于 2024-09-15 16:06:29 字数 495 浏览 22 评论 0原文

我有这个类:

public class MyClass {
     public string GetText() {
         return "text";
     }
}

我想要的是有一个通用的缓存方法。如果调用 GetText,我想拦截此调用,例如;

public T MethodWasCalled<T>(MethodInfo method) {
    if(Cache.Contains(method.Name)) {
        return Cache[method.Name] as T;
    }
    else {
        T result = method.Invoke();
        Cache.Add(method.Name, result);
        return result;
    }
}

我希望以上解释了我想要实现的目标。对此有什么好的策略呢?

I have this class:

public class MyClass {
     public string GetText() {
         return "text";
     }
}

What I want is to have a generic caching method. If GetText is called, I want to intercept this call, something like;

public T MethodWasCalled<T>(MethodInfo method) {
    if(Cache.Contains(method.Name)) {
        return Cache[method.Name] as T;
    }
    else {
        T result = method.Invoke();
        Cache.Add(method.Name, result);
        return result;
    }
}

I hope the above explains what I want to accomplish. What would be a good strategy for this?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(2

树深时见影 2024-09-22 16:06:29

PostSharp 的 Boundry Aspect 可能正是您所需要的。

一些详细说明:

PostSharp 是一个构建过程库,它在编译时将 IL 注入到二进制文件中,以公开常规 .NET 范围内不可用的功能。

边界方面允许您在成员访问之前和之后执行代码。实际上“包装”了调用,让您可以执行奇特的逻辑。

PostSharp's Boundry Aspect may be what you need.

Some Elaboration:

PostSharp is a build-process library that injects IL into your binary at compile time to expose functionality not availiable within the bounds of regular .NET.

The Boundry Aspect allows you to execute code before and after a member-access. In-effect "wrapping" the call, letting you do fancy logic.

全部不再 2024-09-22 16:06:29

如果您使用的是 .NET 4,请查看 Lazy< T>

public class MyClass {
    private Lazy<string> _text = new Lazy<string>(
        () => {
            return "text"; // expensive calculation goes here
        });

    public string GetText() {
        return _text.Value;
    }
}

lambda 内的代码只会执行一次。默认情况下它甚至是线程安全的。

If you're using .NET 4, take a look at Lazy<T>.

public class MyClass {
    private Lazy<string> _text = new Lazy<string>(
        () => {
            return "text"; // expensive calculation goes here
        });

    public string GetText() {
        return _text.Value;
    }
}

The code inside the lambda will only be executed once. It's even threadsafe by default.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文