AllowPartiallyTrustedCallersAttribute Classe

Définition

Espace de noms:

System.Security

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

AllowPartiallyTrustedCallersAttribute.cs

Permet à un assembly d’être appelé par du code partiellement approuvé. Sans cette déclaration, seuls les appelants entièrement approuvés sont en mesure d’utiliser l’assembly. Cette classe ne peut pas être héritée.

C#

[System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple=false, Inherited=false)]
public sealed class AllowPartiallyTrustedCallersAttribute : Attribute

Héritage

Object

Attribute

AllowPartiallyTrustedCallersAttribute

Attributs

AttributeUsageAttribute

Exemples

L’exemple suivant montre comment utiliser la classe AllowPartiallyTrustedCallersAttribute.

C#

// The following HTML code can be used to call the user control in this sample.
//
//		<OBJECT id="usercontrol" classid="usercontrol.dll#UserControl.UserControl1" width="800"
//		height="300" style="font-size:12;">

// To run this test control you must create a strong name key, snkey.snk, and 
// a code group that gives full trust to assemblies signed with snkey.snk.

// The user control displays an OpenFileDialog box, then displays a text box containing the name of 
// the file selected and a list box that displays the contents of the file.  The selected file must 
// contain text in order for the control to display the data properly.

// Caution  This sample demonstrates the use of the Assert method.  Calling Assert removes the 
// requirement that all code in the call chain must be granted permission to access the specified 
// resource, it can open up security vulnerabilities if used incorrectly or inappropriately. Therefore, 
// it should be used with great caution.  Assert should always be followed with a RevertAssert 
// command to restore the security settings.

using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Windows.Forms;
using System.IO;
using System.Security;
using System.Security.Permissions;
using System.Reflection;
using System.Runtime.CompilerServices;

// This strong name key is used to create a code group that gives permissions to this assembly.
[assembly: AssemblyKeyFile("snKey.snk")]
[assembly: AssemblyVersion("1.0.0.0")]

// The AllowPartiallyTrustedCallersAttribute requires the assembly to be signed with a strong name key.
// This attribute is necessary since the control is called by either an intranet or Internet
// Web page that should be running under restricted permissions.
[assembly:AllowPartiallyTrustedCallers]
namespace UserControl
{
    // The userControl1 displays an OpenFileDialog box, then displays a text box containing the name of 
    // the file selected and a list box that displays the contents of the file.  The selected file must 
    // contain text in order for the control to display the data properly.
    public class UserControl1 : System.Windows.Forms.UserControl
    {
        private System.Windows.Forms.TextBox textBox1;
        private System.Windows.Forms.ListBox listBox1;
        // Required designer variable.
        private System.ComponentModel.Container components = null;

              // Demand the zone requirement for the calling application.
              [ZoneIdentityPermission(SecurityAction.Demand, Zone = SecurityZone.Intranet)]
        public UserControl1()
        {
            // This call is required by the Windows.Forms Form Designer.
            InitializeComponent();

            // The OpenFileDialog box should not require any special permissions.
            OpenFileDialog fileDialog = new OpenFileDialog();
            if(fileDialog.ShowDialog() == DialogResult.OK)
            {
                // Reading the name of the selected file from the OpenFileDialog box
                // and reading the file requires FileIOPermission.  The user control should 
                // have this permission granted through its code group; the Web page that calls the 
                // control should not have this permission.  The Assert command prevents a stack walk 
                // that would fail because the caller does not have the required FileIOPermission.  
                // The use of Assert can open up security vulnerabilities if used incorrectly or 
                // inappropriately. Therefore, it should be used with great caution.
                // The Assert command should be followed by a RevertAssert as soon as the file operation 
                // is completed.
                new FileIOPermission(PermissionState.Unrestricted).Assert();
                textBox1.Text = fileDialog.FileName;
                // Display the contents of the file in the text box.
                FileStream fsIn = new FileStream(textBox1.Text, FileMode.Open, FileAccess.Read, 
                    FileShare.Read);
                StreamReader sr = new StreamReader(fsIn);
            
                // Process every line in the file
                for (String Line = sr.ReadLine(); Line != null; Line = sr.ReadLine()) 
                {
                    listBox1.Items.Add(Line);
                }
                // It is very important to call RevertAssert to restore the stack walk for
                // file operations.
                FileIOPermission.RevertAssert();
            }
        }

        // Clean up any resources being used.
        protected override void Dispose( bool disposing )
        {
            if( disposing )
            {
                if( components != null )
                    components.Dispose();
            }
            base.Dispose( disposing );
        }

        #region Component Designer generated code
        /// <summary>
        /// Required method for Designer support - do not modify 
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.textBox1 = new System.Windows.Forms.TextBox();
            this.listBox1 = new System.Windows.Forms.ListBox();
            this.SuspendLayout();
            // 
            // textBox1
            // 
            this.textBox1.Location = new System.Drawing.Point(208, 112);
            this.textBox1.Name = "textBox1";
            this.textBox1.Size = new System.Drawing.Size(320, 20);
            this.textBox1.TabIndex = 0;
            this.textBox1.Text = "textBox1";
            this.textBox1.TextChanged += new System.EventHandler(this.textBox1_TextChanged);
            // 
            // listBox1
            // 
            this.listBox1.Location = new System.Drawing.Point(200, 184);
            this.listBox1.Name = "listBox1";
            this.listBox1.Size = new System.Drawing.Size(336, 108);
            this.listBox1.TabIndex = 1;
            // 
            // UserControl1
            // 
            this.Controls.Add(this.listBox1);
            this.Controls.Add(this.textBox1);
            this.Name = "UserControl1";
            this.Size = new System.Drawing.Size(592, 400);
            this.Load += new System.EventHandler(this.UserControl1_Load);
            this.ResumeLayout(false);
        }
        #endregion

        private void UserControl1_Load(object sender, System.EventArgs e)
        {
        }

        private void textBox1_TextChanged(object sender, System.EventArgs e)
        {
        }
    }
}

Remarques

Important

Le code partiellement approuvé n’est plus pris en charge. Cet attribut n’a aucun effet dans .NET Core.

Note

.NET Framework 4 introduit de nouvelles règles de sécurité qui affectent le comportement de l’attribut AllowPartiallyTrustedCallersAttribute (voir Security-Transparent Code, Niveau 2). Dans .NET Framework 4, tout le code par défaut est transparent en matière de sécurité, c’est-à-dire partiellement approuvé. Toutefois, vous pouvez annoter des types et des membres individuels pour leur attribuer d’autres attributs de transparence. Pour cela et d’autres modifications de sécurité, consultez modifications de sécurité.

Les assemblys .NET Framework version 2.0 () doivent être nommés de manière forte pour utiliser efficacement l’attribut AllowPartiallyTrustedCallersAttribute (APTCA). Les assemblys .NET Framework 4 () n’ont pas besoin d’être nommés de manière forte pour que l’attribut APTCA soit efficace, et ils peuvent contenir du code transparent, critique pour la sécurité et critique pour la sécurité. Pour plus d’informations sur l’application d’attributs au niveau de l’assembly, consultez Application des attributs.

Par défaut, si un assembly avec nom fort n’applique pas explicitement cet attribut au niveau de l’assembly, il peut être appelé uniquement par d’autres assemblys disposant d’une confiance totale. Cette restriction est appliquée en plaçant une LinkDemand pour FullTrust sur chaque méthode publique ou protégée sur chaque classe accessible publiquement dans l’assembly. Les assemblys destinés à être appelés par du code partiellement approuvé peuvent déclarer leur intention à l’aide de AllowPartiallyTrustedCallersAttribute. Un exemple de déclaration en C# est [assembly:AllowPartiallyTrustedCallers]; Un exemple en Visual Basic est <assembly:AllowPartiallyTrustedCallers>.

Attention

La présence de cet attribut au niveau de l’assembly empêche le comportement par défaut de placer FullTrustLinkDemand vérifications de sécurité et rend l’assembly pouvant être appelé à partir d’un autre assembly (partiellement ou entièrement approuvé).

Lorsque l’attribut APTCA est présent, toutes les autres fonctions de vérification de sécurité comme prévu, y compris tous les attributs de sécurité déclaratifs au niveau de la classe ou de méthode présents. Cet attribut bloque uniquement la demande implicite et entièrement approuvée de l’appelant.

Il ne s’agit pas d’un attribut de sécurité déclaratif, mais d’un attribut normal (il dérive de System.Attribute, pas de System.Security.Permissions.SecurityAttribute).

Pour plus d’informations, consultez Utilisation de bibliothèques à partir d’un code partiellement approuvé.

Constructeurs

AllowPartiallyTrustedCallersAttribute()

Initialise une nouvelle instance de la classe AllowPartiallyTrustedCallersAttribute.

Propriétés

PartialTrustVisibilityLevel	Obtient ou définit la visibilité de confiance partielle par défaut pour le code marqué avec l’attribut AllowPartiallyTrustedCallersAttribute (APTCA).
TypeId	En cas d’implémentation dans une classe dérivée, obtient un identificateur unique pour cette Attribute. (Hérité de Attribute)

Méthodes

Equals(Object)	Retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de Attribute)
GetHashCode()	Retourne le code de hachage pour cette instance. (Hérité de Attribute)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
IsDefaultAttribute()	En cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut de la classe dérivée. (Hérité de Attribute)
Match(Object)	En cas de substitution dans une classe dérivée, retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de Attribute)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)

S’applique à