Como proibir chamar um método c#

Question

Quero permitir chamar o método apenas dos métodos específicos. Dê uma olhada no código abaixo.

  private static void TargetMethod()
  {
  }

  private static void ForbiddenMethod()
  {
     TargetMethod();
  }

  private static void AllowedMethod()
  {
     TargetMethod();
  }

Eu só preciso que o Method só possa chamar o TargetMethod. Como fazer isso usando classes de System.Security.Permissions?

Atualizada: Obrigado pelas suas respostas, mas não quero debater sobre o design do meu aplicativo. Eu só quero saber que é possível fazer isso usando a segurança .NET ou não?

Answer 1

O CAS não pode fazer isso se o código estiver em execução em plena confiança.

Se o código estiver executando em plena confiança (ou seja, um aplicativo local normal, não um aplicativo Silverlight ou algo executado da rede), todas as verificações do .NET CAS serão completamente ignoradas; Qualquer atributo de segurança é simplesmente ignorado.

Cas simplesmente caminha pela pilha para determinar as permissões, e você também pode fazer isso, como Darin apontou anteriormente, apenas verificando o StackTrace.

Answer 2

Você pode resolver isso usando design normal orientado a objetos. Jogada AllowedMethod para uma nova aula e fazer ForbiddenMethod Um método privado dessa classe:

public class MyClass
{
    public void AllowedMethod() { // ... }

    private void TargetMethod() { // ... }
}

Permitido Method tem acesso a membros particulares, mas ninguém mais tem.

Answer 3

Eu acredito que você deve tentar estruturar seu código em classes significativas e usar os modificadores de acesso padrão (private, protected, public, internal). Existe algum motivo específico para que isso não resolvesse seu problema?

A única alternativa em que consigo pensar envolveria atravessar a pilha de chamadas de dentro do callee, mas isso provavelmente produziria a bagunça do código e o desempenho abaixo do ideal.

Answer 4

Você pode examinar a pilha de chamadas para fazer isso, mas é bastante lento. Eu não recomendaria se puder ser evitado.

Se você ainda quiser fazer isso, precisará ter cuidado para evitar o método que também se envolve, ou seu código poderá parar de trabalhar de repente em compilações de liberação.

[MethodImpl(MethodImplOptions.NoInlining)]
private static void TargetMethod()
{
    StackFrame fr = new StackFrame(1, false);
    Console.WriteLine(fr.GetMethod().Name);
}

Até onde eu sei, não há atributos prontos para a caixa para fazer isso.

Answer 5

Não tenho certeza se isso é alcançável System.Security.Permissions, mas por dentro TargetMethod Você pode pegar o chamador e agir de acordo:

StackTrace stackTrace = new StackTrace();
Console.WriteLine(stackTrace.GetFrame(1).GetMethod().Name);

Answer 6

Você pode usar objetos CodeAccesspermission. Você teria que implementar a interface em seu próprio objeto para que ele funcione como você está sugerindo.

http://msdn.microsoft.com/en-us/library/system.security.codeaccesspermission.aspx

Answer 7

Usando atributos, você pode resolver esse problema.

Use atribuições condicionais.

No topo

#define "Show" 


  public void TargetMethod()
    {
      //Code
    }
   [ Conditional("Hidden")]
   public void HiddenMethod()
    {
       TargetMethod()
    }
 [ Conditional("Show")]
  public void AllowMethod()
    {
       TargetMethod()
    }

Um de seus methos será chamado.