MessageQueuePermission Classe

Référence

Définition

Espace de noms:: System.Messaging

Assembly:: System.Messaging.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Permet de contrôler les autorisations d'accès du code pour la messagerie.

public ref class MessageQueuePermission sealed : System::Security::CodeAccessPermission, System::Security::Permissions::IUnrestrictedPermission

[System.Serializable]
public sealed class MessageQueuePermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission

[<System.Serializable>]
type MessageQueuePermission = class
    inherit CodeAccessPermission
    interface IUnrestrictedPermission

Public NotInheritable Class MessageQueuePermission
Inherits CodeAccessPermission
Implements IUnrestrictedPermission

Héritage: Object

CodeAccessPermission
MessageQueuePermission

Attributs: SerializableAttribute

Implémente: IUnrestrictedPermission

Exemples

L’exemple de code suivant crée plusieurs instances de MessageQueuePermission et illustre l’utilisation de la PermissionEntries propriété .


using System;
using System.Messaging;

public class MessageQueuePermissionExample
{
    public static void Main()
    {
        // Create a new instance of the class.
        MessageQueuePermissionExample example =
            new MessageQueuePermissionExample();

        // Create a message queue on the local computer.
        CreateQueue(".\\exampleQueue", false);

        // Demonstrate MessageQueuePermission's constructors.
        example.CreatePermission1();
        example.CreatePermission2();
        example.CreatePermission3();
        example.CreatePermission4();
        example.CreatePermission5();

        // Get and set MessageQueuePermission's PermissionEntries property.
        example.GetPermissionEntries();
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Demonstrates the following MessageQueuePermission constructor:
    // public #ctor ()
    public void CreatePermission1()
    {
        // Create a new instance of MessageQueuePermission.
        MessageQueuePermission permission = new MessageQueuePermission();
    }

    // Demonstrates the following MessageQueuePermission constructor:
    // public #ctor (MessageQueuePermissionAccess permissionAccess,
    //  String path)
    public void CreatePermission2()
    {
        // Create a new instance of MessageQueuePermission.
        MessageQueuePermission permission = new MessageQueuePermission(
            MessageQueuePermissionAccess.Receive,
            ".\\exampleQueue");
    }

    // Demonstrates the following MessageQueuePermission constructor:
    // public #ctor (MessageQueuePermissionAccess permissionAccess,
    //  String machineName, String label, String category)
    public void CreatePermission3()
    {
        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Create a new instance of MessageQueuePermission.
    string queueCategory = queue.Category.ToString();
    string machineName = queue.MachineName;
    string label = queue.Label;
        MessageQueuePermission permission = new MessageQueuePermission(
            MessageQueuePermissionAccess.Receive,
            machineName,
            label,
            queueCategory);
    }

    // Demonstrates the following MessageQueuePermission constructor:
    //public #ctor (MessageQueuePermissionEntry[] permissionAccessEntries)
    public void CreatePermission4()
    {
        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Create an array of type MessageQueuePermissionEntry.
        MessageQueuePermissionEntry[] entries =
            new MessageQueuePermissionEntry[1];

        // Create a new instance of MessageQueuePermissionEntry and place the
        // instance in the array.
    string machineName = queue.MachineName;
    string label = queue.Label;
        entries[0] = new MessageQueuePermissionEntry(
            MessageQueuePermissionAccess.Receive,
            machineName,
            label,
            queue.Category.ToString());

        // Create a new instance of MessageQueuePermission.
        MessageQueuePermission permission = new MessageQueuePermission(
            entries);
    }

    // Demonstrates the following MessageQueuePermission constructor:
    //public #ctor (PermissionState state)
    public void CreatePermission5()
    {
        // Create a new instance of MessageQueuePermission.
        MessageQueuePermission permission = new MessageQueuePermission(
            System.Security.Permissions.PermissionState.Unrestricted);
    }

    public void GetPermissionEntries()
    {
    
        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Create an array of type MessageQueuePermissionEntry.
        MessageQueuePermissionEntry[] entries =
            new MessageQueuePermissionEntry[1];

        // Create a new instance of MessageQueuePermissionEntry and place the
        // instance in the array.
    string machineName = queue.MachineName;
    string label = queue.Label;
        entries[0] = new MessageQueuePermissionEntry(
            MessageQueuePermissionAccess.Receive,
            machineName,
            label,
            queue.Category.ToString());

        // Create a new instance of MessageQueuePermission.
        MessageQueuePermission permission = new MessageQueuePermission(
            entries);

        // Create a new instance of MessageQueuePermissionEntryCollection and
        // use it to retrieve the permission's PermissionEntries property
        // value.
        MessageQueuePermissionEntryCollection collection =
            permission.PermissionEntries;

        // Loop through the collection.
        foreach(MessageQueuePermissionEntry entry in collection)
        {
            // Display the property values of each MessageQueuePermissionEntry.
            Console.WriteLine("PermissionAccess: {0}", entry.PermissionAccess);
            Console.WriteLine("MachineName: {0}", entry.MachineName);
            Console.WriteLine("Label: {0}", entry.Label);
            Console.WriteLine("Category: {0}", entry.Category.ToString());
        }
    }
}

Constructeurs

MessageQueuePermission()	Initialise une nouvelle instance de la classe MessageQueuePermission.
MessageQueuePermission(MessageQueuePermissionAccess, String)	Initialise une nouvelle instance de la classe MessageQueuePermission avec les niveaux d'accès spécifiés et le chemin de la file d'attente.
MessageQueuePermission(MessageQueuePermissionAccess, String, String, String)	Initialise une nouvelle instance de la classe MessageQueuePermission avec les niveaux d'accès, l'ordinateur à utiliser, la description de la file d'attente et la catégorie de la file d'attente spécifiés.
MessageQueuePermission(MessageQueuePermissionEntry[])	Initialise une nouvelle instance de la classe MessageQueuePermission avec les entrées de niveau d'accès d'autorisation spécifiées.
MessageQueuePermission(PermissionState)	Initialise une nouvelle instance de la classe MessageQueuePermission avec l’état d’autorisation spécifié.

Propriétés

PermissionEntries

Obtient la collection d'entrées d'autorisation pour cette demande d'autorisation.

Méthodes

Assert()	Déclare que le code appelant peut accéder à la ressource protégée par une demande d’autorisation via le code qui appelle cette méthode, même si les appelants situés plus haut dans la pile n’ont pas reçu l’autorisation d’accéder à la ressource. L’utilisation de Assert() peut créer des problèmes de sécurité. (Hérité de CodeAccessPermission)
Copy()	Crée et retourne une copie identique de l'objet d'autorisation en cours.
Demand()	Force un SecurityException au moment de l’exécution si tous les appelants figurant plus haut dans la pile des appels ne disposent pas des autorisations spécifiées par l’instance actuelle. (Hérité de CodeAccessPermission)
Deny()	Obsolète. Obsolète. Empêche les appelants plus hauts dans la pile des appels d’utiliser le code qui appelle cette méthode pour accéder à la ressource spécifiée par l’instance actuelle. (Hérité de CodeAccessPermission)
Equals(Object)	Détermine si l'objet CodeAccessPermission spécifié est égal à CodeAccessPermission en cours. (Hérité de CodeAccessPermission)
FromXml(SecurityElement)	Reconstruit un objet de sécurité avec un état spécifié à partir d’un encodage XML.
GetHashCode()	Obtient un code de hachage pour l’objet CodeAccessPermission qui peut être utilisé dans des structures de données et des algorithmes de hachage, comme une table de hachage. (Hérité de CodeAccessPermission)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
Intersect(IPermission)	Retourne un nouvel objet d'autorisation qui représente l'intersection entre l'objet d'autorisation en cours et l'objet d'autorisation spécifié.
IsSubsetOf(IPermission)	Retourne une valeur qui indique si l'objet d'autorisation en cours est un sous-ensemble de l'objet d'autorisation spécifié.
IsUnrestricted()	Retourne une valeur qui indique si l'autorisation peut être représentée comme illimitée sans aucune connaissance de la sémantique des autorisations.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
PermitOnly()	Empêche les appelants plus hauts dans la pile des appels d’utiliser le code qui appelle cette méthode pour accéder à toutes les ressources à l’exception de la ressource spécifiée par l’instance actuelle. (Hérité de CodeAccessPermission)
ToString()	Crée et retourne une chaîne représentant l’objet d’autorisation actuel. (Hérité de CodeAccessPermission)
ToXml()	Crée un codage XML de l’objet de sécurité et de son état actuel.
Union(IPermission)	Retourne un nouvel objet d'autorisation qui représente l'union entre l'objet d'autorisation en cours et l'objet d'autorisation spécifié.

S’applique à

Partager via