C# 用设计模式C优雅地解决一个问题#

我有个问题

我需要找到一种方法来动态实例化类，并根据一些用户权限和用户可以请求的分组动态激活这些类中的方法

例如：

1。用户权限“A”

调用类1,4,6

调用类1中的方法2,7

调用类4中的方法1,2

调用类6中的方法1,2

2。用户权限“B”

调用类2,3,5

调用类2中的方法2,7

调用类3中的方法1,2

调用类5中的方法1,2

我只是用不同的权限做了这些例子。但它也可以包含分组，这意味着可以为每个权限调用不同的类和不同的方法（某种子集）

我可以用开关/外壳做任何事情，但我正在寻找一种更优雅的方式

注:

有很多可能性，因为有许多类和方法，因为用户可以要求许多不同类型的分组

我不知道通过许可的最佳方式是什么

我在想，也许命令模式或装饰师可以在这里提供帮助

---

非常感谢您的回答

听起来您正在寻找类似于

CodeAccessPermissionAttribute

的东西-请参阅以获取详细信息。我可能会推荐一种类似的模式；定义具有属性的对象以关联其权限状态，然后您的用户将落入具有或没有权限执行具有特定属性的方法的角色

假设您可以访问这些类，一种方法是使用代理类和属性：

class PermissionVerifier {
    public void ExecuteIfHasPermission(Permission perm, Action action) {
        if (GetCurrentUser().HasPermission(perm)) // assumes singleton-like
                                                  // access or injected user
            action();
        throw CreatePermissionException(perm);
    }
}

class A {
    // make it obvious what permissions are required for execution
    [RequiresPermission(Permissions.CanExecuteClassAMethod1)]
    public virtual void Method1() {
        //...
    }

}    

class AProxy: A {
    private PermissionVerifier verifier;

    public override void Method1() {
        ExecuteIfHasPermission(
            GetCurrentMethodRequiresPermissionAttribute(), // reflection
            () => base.Method1());
    }
    private ExecuteIfHasPermission(Permission perm, Action action) {
        verifier.ExecuteIfHasPermission(perm, action);
    }
}

---

如果不手动创建代理，而是使用拦截所有方法的动态代理生成器，则可以显式执行权限检查，而无需手动编写大量样板代码。

您还可以查看。

您可以通过使用Func将字符串与类和方法调用联系起来。在处理许多排列时，它为您提供了很大的灵活性。下面有一个代码示例，但是您可以使用枚举而不是字符串作为键

这不一定是一种模式，但可以与前面提到的几种模式一起使用

public void Call(Stream str)
    {
        //Single Permission
        Generate["PermissionA"](str);

        //Say this user has multiple permissions, you can iterate over them
        IEnumerable<string> userPerms = GetUserPerms();
        foreach (var perm in userPerms)
        {
            Generate[perm](str);
        }
    }

    public static Dictionary<string, Func<Stream, object>> Generate
    {
        get
        {
            var ret = new Dictionary<string, Func<Stream, object>>();

            ret.Add("PermissionA",  (s) => 
                                        {
                                            Class1 cl1 = new Class1(s);
                                            Class4 cl4 = new Class4(s);
                                            Class6 cl6 = new Class6(s);

                                            cl1.Method2();
                                            cl1.Method7();
                                            cl4.Method1();
                                            cl4.Method2();
                                            cl6.Method1();
                                            cl6.Method2();

                                            cl1.DoXml();
                                            cl4.DoXml();
                                            cl6.DoXml();

                                            return "";
                                        });

            ret.Add("PermissionB", (s) => 
                                        {
                                            Class2 cl2 = new Class2(s);
                                            Class3 cl3 = new Class3(s);
                                            Class5 cl5 = new Class5(s);

                                            cl2.Method2();
                                            cl2.Method7();
                                            cl3.Method1();
                                            cl3.Method2();
                                            cl5.Method1();
                                            cl5.Method2();

                                            cl2.DoXml();
                                            cl3.DoXml();
                                            cl5.DoXml();

                                            return "";
                                        });

            return ret;
        }
    }

公共作废调用（Stream str）
{
//单一权限
生成[“许可证”]（str）；
//假设此用户具有多个权限，则可以对其进行迭代
IEnumerable userPerms=GetUserPerms（）；
foreach（userPerms中的var perm）
{
生成[perm]（str）；
}
}
公共静态字典生成
{
得到
{
var ret=新字典（）；
ret.Add（“许可证”、（s）=>
{
类别1 cl1=新类别1（s）；
类别4 cl4=新类别4；
类别6 cl6=新的类别6；
cl1.Method2（）；
cl1.Method7（）；
cl4.Method1（）；
cl4.Method2（）；
cl6.Method1（）；
cl6.Method2（）；
DoXml（）；
DoXml（）；
cl6.DoXml（）；
返回“”；
});
ret.Add（“许可证B”，（s）=>
{
Class2 cl2=新的Class2（s）；
类别3 cl3=新类别3；
类别5 cl5=新的类别5；
cl2.Method2（）；
cl2.Method7（）；
cl3.Method1（）；
cl3.Method2（）；
cl5.Method1（）；
cl5.Method2（）；
DoXml（）；
DoXml（）；
DoXml（）；
返回“”；
});
返回ret；
}
}

您是否有权访问这些类或它们是第三方库？看起来您可能有一个三步算法，也许这可以通过来表示。如果没有这些类/方法的具体示例，很难给出建议。您说它们是不同的方法，但它们是否都有一个共同的最终目标（验证用户、分配资源等）？这些类和方法在做什么，它们需要根据用户权限实例化/执行？你能提供一些上下文吗？我正在处理一个web服务，比如Alexa web服务（AWS），它将响应用户的请求。您可以在其中请求例如“urlinfo”，在urlinfo中您可以请求特定的信息。当然，如果你有正确的权限。