Usando o método Assert

Assert é um método pode ser chamado em classes de permissão de acesso a código e no PermissionSet classe. Você pode usar Declarar para permitir que seu código (e chamadores downstream) realizar ações que o código tem permissão para fazer, mas seus chamadores talvez não tenha permissão para fazer.Uma asserção de segurança altera o processo normal de que o tempo de execução executa durante uma verificação de segurança.Quando declarar uma permissão, ele faz com que o sistema de segurança para não verificar os chamadores do seu código para a permissão confirmado.

Cuidado:
Usar declarações com cuidado porque eles podem em em aberto brechas de segurança e prejudicar o mecanismo do tempo de execução para impor segurança ity restrições.

Declarações são úteis em situações em que uma biblioteca chama código não gerenciado ou faz uma telefonar que exige uma permissão que obviamente não está relacionada ao uso pretendido da biblioteca.Por exemplo, todo código gerenciado que chame código não gerenciado deve ter SecurityPermission com o UnmanagedCode sinalizar especificado.Código que não seja originária de computador local, sistema autônomo o código é baixado da intranet local, não recebem essa permissão por padrão.Portanto, a fim de código é baixado da intranet local para poder chamar uma biblioteca que usa código não gerenciado, ele deve ter a permissão afirmada pela biblioteca.Além disso, algumas bibliotecas podem fazer chamadas que são invisíveis para os chamadores e exigem permissões de acesso especiais.

Você também pode usar declarações em situações em que seu código acessa um recurso de forma completamente oculto de chamadores.Por exemplo, suponha que sua biblioteca adquire informações a partir de um banco de dados, mas no processo também lê informações de registro do computador.Como os desenvolvedores que usam a biblioteca não tem acesso à sua fonte, eles têm há maneira de saber que seu código requer RegistryPermission para usar seu código.Nesse caso, se você decidir que ele não é razoável ou necessárias para exigir que os chamadores do seu código tem permissão para acesso registro, você pode declarar permissão para ler o registro.Nesta situação, é apropriado para a biblioteca para declarar a permissão para isso que os chamadores sem RegistryPermission pode usar a biblioteca.

A declaração afeta a pilha walk somente se a permissão confirmada e uma permissão exigida por um chamador downstream forem do mesmo tipo e se a permissão usados desse sistema operacional for um subconjunto da permissão confirmado.Por exemplo, se você declarar FileIOPermission ler todos os arquivos na unidade C e uma demanda de downstream é feita para FileIOPermission ler arquivos em C:\Temp, a declaração poderia afetar a movimentação da pilha; no entanto, se a solicitação era para FileIOPermission para gravar na unidade C, a declaração não teria nenhum efeito.

Para executar declarações, seu código deve receber tanto a permissão que estiver declarando o SecurityPermission que representa o direito de fazer declarações. Embora poderia declarar uma permissão que seu código não foi concedido, a declaração seria inútil porque a verificação de segurança poderia falhar antes que a declaração poderia fazer com que ele seja bem-sucedida.

A ilustração a seguir mostra o que acontece quando você usar Declarar.Suponha que as instruções a seguir sejam verdadeiras sobre assemblies A, B, C, E e F e duas permissões P1 e P1A:

• P1A representa o direito de ler arquivos .txt na unidade C.

• P1 representa o direito de ler todos os arquivos na unidade C.

• P1A e P1 são os dois FileIOPermission tipos e P1A é um subconjunto de P1.

• Assemblies E e F receberam permissão P1A.

• Assembly C recebeu permissão P1.

• Os assemblies A e B tenham obtidos permissões nem P1 P1A.

• Método A está contido no assembly A, B método está contido no conjunto B e assim por diante.

Utilizando Assert

Nesse cenário, chamadas de método A B, B chamadas C, C chama E e E chama f.Método C declara a permissão ler arquivos na unidade C (permissão P1) e método demandas E permissão para ler os arquivos .txt na unidade C (permissão P1A).Quando a demanda de F é encontrada em time de execução, um exame da pilha é executado para verificar as permissões de todos os chamadores de F, começando com e.E já tem permissão P1A, para que a pilha walk continua a examinar as permissões de C, onde declaração da C seja descoberta.Como a permissão usados desse sistema operacional (P1A) é um subconjunto da permissão confirmado (P1), a pára de exame da pilha e a verificação de segurança automaticamente êxito.Não importa que os assemblies A e B não receberam permissão P1A.Ao declarar P1, método C garante que os chamadores podem acessar o recurso protegido pelo P1, mesmo que os chamadores não tiverem sido concedidos permissão para acessar o recurso.

Se você cria uma biblioteca de classes e uma classe acessa um recurso protegido, você deve, na maioria dos casos, fazer um demanda de segurança requerer que os chamadores da classe tenham a permissão apropriada.Se a classe, em seguida, executa uma operação para o qual você sabe a maioria dos seus ers telefonar irá não têm permissão, e se você estiver disposto a assumir a responsabilidade para permitir que esses ers telefonar telefonar seu código, pode declarar a permissão por telefonar ing o Declarar método em um objeto de permissão que representa a operação está executando o código.Usando Declarar dessa maneira permite ers telefonar normalmente pode não fazê-lo telefonar seu código.Portanto, se você declarar uma permissão, você deve estar-se de executar verificações de segurança apropriada com antecedência para evitar que seu componente que está sendo usado incorretamente.

Por exemplo, suponha que sua classe altamente confiáveis da biblioteca tem um método que exclui os arquivos.Ele acessa o arquivo chamando uma função não gerenciada Win32.Um chamador chama Excluir método, passando o nome do arquivo a ser excluído, C:\teste.txt.Dentro de Excluir método, o código cria um FileIOPermission objeto que representa o acesso de gravar para C:\teste.txt. (Acesso de gravar é necessária para excluir um arquivo.) Your code then invokes an imperative security check by calling the FileIOPermission object's Demand method.Se um o ers telefonar no telefonar pilha não tem essa permissão, um SecurityException é lançada. Se nenhuma exceção é lançada, sabe que todos os chamadores têm o direito de acesso C:\teste.txt.Como você acha que a maioria dos seus ers telefonar não terá permissão para acessar código não gerenciado, seu código, em seguida, cria um SecurityPermission objeto que representa o direito de telefonar não gerenciados código e do telefonar s o objeto Declarar método.Por fim, ele chama a função Win32 não gerenciada para excluir C:\Texto.txt e retorna o controle ao chamador.

Cuidado:

Você deve certificar-se de que seu código não usa asserções em situações em que seu código pode ser usado por Outros código para acessar um recurso é protec Ted pela permissão que está declarando.Por exemplo, no código que grava em um arquivo cujo nome é especificado pelo chamador sistema autônomo um parâmetro, você poderia não declarar o FileIOPermission para gravar em arquivos porque o código seria em aberto para uso impróprio por um terceiro de terceiros.

Quando você usar a sintaxe de segurança imperativa, chamando o Declarar método em várias permissões no mesmo método faz com que uma exceção de segurança seja lançada.Em vez disso, você deve criar um PermissionSet de objeto, passá-lo as permissões individuais que você deseja chamar e, em seguida, telefonar o Declarar método a PermissionSet objeto.Você pode telefonar o Declararmétodo mais de uma vez quando você usa a sintaxe de segurança declarativa.

O exemplo a seguir mostra a sintaxe declarativa para a substituição de verificações de segurança usando o Declarar método.Observe que o FileIOPermissionAttribute sintaxe assume dois valores: a SecurityAction enumeração e a localização do arquivo ou pasta para a qual deve ser concedida permissão. A telefonar para Declarar faz com que as demandas por acesso a C:\Log.txt para ter êxito, mesmo que os chamadores não são verificados para permissão para acessar o arquivo.

[Visual Basic]

Option Explicit
Option Strict

Imports System
Imports System.IO
Imports System.Security.Permissions

Namespace LogUtil
   Public Class Log
      Public Sub New()

      End Sub

     <FileIOPermission(SecurityAction.Assert, All := "C:\Log.txt")> Public Sub 
      MakeLog()
         Dim TextStream As New StreamWriter("C:\Log.txt")
         TextStream.WriteLine("This  Log was created on {0}", DateTime.Now) '
         TextStream.Close()
      End Sub
   End Class
End Namespace

namespace LogUtil
{
   using System;
   using System.IO;
   using System.Security.Permissions;

   public class Log
   {
      public Log()
      {    
      }   
      [FileIOPermission(SecurityAction.Assert, All = @"C:\Log.txt")]
      public void MakeLog()
      {   
         StreamWriter TextStream = new StreamWriter(@"C:\Log.txt");
         TextStream.WriteLine("This  Log was created on {0}", DateTime.Now);
         TextStream.Close();
      }
   }
} 

Os fragmentos de código a seguir mostram a sintaxe fundamental para a substituição de verificações de segurança usando o Declarar método.Neste exemplo, uma instância do FileIOPermission objeto for declarado.Seu construtor é passado FileIOPermissionAccess.AllAccess para definir o tipo de acesso permitido, seguido por uma seqüência de caracteres que descreve o local do arquivo.Uma vez o FileIOPermission objeto é definido, você precisa apenas chamar seu Declarar método para substituir a verificação de segurança.

[Visual Basic]

Option Explicit
Option Strict
Imports System
Imports System.IO
Imports System.Security.Permissions
Namespace LogUtil
   Public Class Log
      Public Sub New()
      End Sub 'New
      
      Public Sub MakeLog()
         Dim FilePermission As New FileIOPermission(FileIOPermissionAccess.AllAccess, "C:\Log.txt")
         FilePermission.Assert()
         Dim TextStream As New StreamWriter("C:\Log.txt")
         TextStream.WriteLine("This  Log was created on {0}", DateTime.Now)
         TextStream.Close()
      End Sub
   End Class
End Namespace 

namespace LogUtil
{
   using System;
   using System.IO;
   using System.Security.Permissions;

   public class Log
   {
      public Log()
      {    
      }   
      public void MakeLog()
      {
         FileIOPermission FilePermission = new FileIOPermission(FileIOPermissionAccess.AllAccess,@"C:\Log.txt"); 
         FilePermission.Assert();
         StreamWriter TextStream = new StreamWriter(@"C:\Log.txt");
         TextStream.WriteLine("This  Log was created on {0}", DateTime.Now);
         TextStream.Close();
      }
   }
}

Consulte também

Conceitos

Substituindo verificações de segurança

Demandas de segurança

Referência

PermissionSet

SecurityPermission

FileIOPermission

SecurityAction

Outros recursos

Estendendo metadados usando atributos

Segurança de Acesso de código