AspNetCompatibilityRequirementsAttribute Classe

Définition

public ref class AspNetCompatibilityRequirementsAttribute sealed : Attribute, System::ServiceModel::Description::IServiceBehavior

[System.AttributeUsage(System.AttributeTargets.Class)]
public sealed class AspNetCompatibilityRequirementsAttribute : Attribute, System.ServiceModel.Description.IServiceBehavior

[<System.AttributeUsage(System.AttributeTargets.Class)>]
type AspNetCompatibilityRequirementsAttribute = class
    inherit Attribute
    interface IServiceBehavior

Public NotInheritable Class AspNetCompatibilityRequirementsAttribute
Inherits Attribute
Implements IServiceBehavior

Héritage

Object

Attribute

AspNetCompatibilityRequirementsAttribute

Attributs

AttributeUsageAttribute

Implémente

IServiceBehavior

Exemples

Les développeurs de services peuvent s’assurer que leur service est exécuté uniquement en mode de compatibilité ASP.NET en définissant la propriété sur la RequirementsMode AspNetCompatibilityRequirementsAttribute Required valeur comme indiqué dans l’exemple suivant

[ServiceContract(Namespace="http://Microsoft.ServiceModel.Samples")]
public interface ICalculatorSession
{
    [OperationContract]
    void Clear();
    [OperationContract]
    void AddTo(double n);
    [OperationContract]
    void SubtractFrom(double n);
    [OperationContract]
    void MultiplyBy(double n);
    [OperationContract]
    void DivideBy(double n);
    [OperationContract]
    double Equals();
}

<ServiceContract(Namespace:="http://Microsoft.ServiceModel.Samples")> _
Public Interface ICalculatorSession

    <OperationContract()> _
    Sub Clear()
    <OperationContract()> _
    Sub AddTo(ByVal n As Double)
    <OperationContract()> _
    Sub SubtractFrom(ByVal n As Double)
    <OperationContract()> _
    Sub MultiplyBy(ByVal n As Double)
    <OperationContract()> _
    Sub DivideBy(ByVal n As Double)
    <OperationContract()> _
    Function Equal() As Double
End Interface

[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Required)]
public class CalculatorService : ICalculatorSession
{
    double result
    {   // Store result in AspNet session.
        get
        {
            if (HttpContext.Current.Session["Result"] != null)
                return (double)HttpContext.Current.Session["Result"];
            return 0.0D;
        }
        set
        {
            HttpContext.Current.Session["Result"] = value;
        }
    }

    public void Clear()
    {
    }

    public void AddTo(double n)
    {
        result += n;
    }

    public void SubtractFrom(double n)
    {
        result -= n;
    }

    public void MultiplyBy(double n)
    {
        result *= n;
    }

    public void DivideBy(double n)
    {
        result /= n;
    }

    public double Equals()
    {
        return result;
    }
}

    <AspNetCompatibilityRequirements(RequirementsMode:=AspNetCompatibilityRequirementsMode.Required)> _
    Public Class CalculatorService
        Implements ICalculatorSession

        Property Result() As Double
            ' Store result in AspNet Session.
            Get
                If (HttpContext.Current.Session("Result") Is Nothing) Then
                    Return 0D
                End If
                Return HttpContext.Current.Session("Result")
            End Get
            Set(ByVal value As Double)
                HttpContext.Current.Session("Result") = value
            End Set
        End Property

        Public Sub Clear() _
 Implements ICalculatorSession.Clear
            Result = 0D
        End Sub

        Public Sub AddTo(ByVal n As Double) _
Implements ICalculatorSession.AddTo
            Result += n
        End Sub

        Public Sub SubtractFrom(ByVal n As Double) _
Implements ICalculatorSession.SubtractFrom

            Result -= n
        End Sub

        Public Sub MultiplyBy(ByVal n As Double) _
Implements ICalculatorSession.MultiplyBy

            Result *= n
        End Sub

        Public Sub DivideBy(ByVal n As Double) _
Implements ICalculatorSession.DivideBy

            Result /= n
        End Sub

        Public Function Equal() As Double _
Implements ICalculatorSession.Equal

            Return Result
        End Function
    End Class

Remarques

Lorsqu’il est appliqué à une classe d’implémentation de service, cet attribut indique si ce service nécessite ou prend en charge ASP.NET mode de compatibilité à activer pour le domaine d’application d’hébergement (AppDomain).

AppDomains hébergeant des services WCF peut s’exécuter en deux modes d’hébergement différents :

• Mode transports mixtes (par défaut) : dans ce mode, les services WCF ne participent pas au pipeline HTTP ASP.NET. Cela garantit qu’un service WCF se comporte de manière cohérente, indépendamment de l’environnement d’hébergement et du transport.

• ASP.NET mode de compatibilité : dans ce mode, les services WCF participent au pipeline HTTP ASP.NET de manière similaire aux services ASMX. ASP.NET fonctionnalités telles que l’autorisation de fichier, l’urlAuthorization et l’état de session HTTP s’appliquent aux services WCF exécutés en ce mode.

Le mode d'hébergement est contrôlé par l'indicateur de configuration d'application aspNetCompatibilityEnabled :

<system.serviceModel>

<serviceHostingEnvironment aspNetCompatibilityEnabled="true"/>

</system.serviceModel>

Cet indicateur est false par défaut et les services WCF s’exécutent donc en mode transports mixtes, sauf si vous optez explicitement dans le mode de compatibilité ASP.NET.

Pour plus d’informations sur le mode de compatibilité ASP.NET, consultez <serviceHostingEnvironment>.

Pour ce faire, utilisez la propriété RequirementsMode. Au moment de l’exécution, les applications peuvent détecter si ASP.NET mode de compatibilité est activé en vérifiant la valeur de la propriété AspNetCompatibilityEnabledstatique.

Constructeurs

Propriétés

Méthodes

Implémentations d’interfaces explicites

S’applique à