Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe SoapServices

 

Data di pubblicazione: ottobre 2016

Fornisce diversi metodi per l'utilizzo e pubblicare oggetti remoti in formato SOAP.

Spazio dei nomi:   System.Runtime.Remoting
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Runtime.Remoting.SoapServices

[SecurityCriticalAttribute]
[ComVisibleAttribute(true)]
public class SoapServices

NomeDescrizione
System_CAPS_pubpropertySystem_CAPS_staticXmlNsForClrType

Ottiene il prefisso dello spazio dei nomi XML per tipi common language runtime.

System_CAPS_pubpropertySystem_CAPS_staticXmlNsForClrTypeWithAssembly

Ottiene il prefisso dello spazio dei nomi XML predefinito che deve essere utilizzato per XML, codifica di una classe common language runtime che dispone di un assembly, ma non native dello spazio dei nomi.

System_CAPS_pubpropertySystem_CAPS_staticXmlNsForClrTypeWithNs

Ottiene il prefisso dello spazio dei nomi XML che deve essere utilizzato per XML codifica di una classe common language runtime che fa parte del file mscorlib. dll.

System_CAPS_pubpropertySystem_CAPS_staticXmlNsForClrTypeWithNsAndAssembly

Ottiene il prefisso dello spazio dei nomi XML predefinito che deve essere utilizzato per XML codifica di una classe common language runtime con lo spazio dei nomi common language runtime e un assembly.

NomeDescrizione
System_CAPS_pubmethodSystem_CAPS_staticCodeXmlNamespaceForClrTypeNamespace(String, String)

Restituisce il nome tipo dello spazio dei nomi di common language runtime dai nomi di spazio dei nomi e assembly forniti.

System_CAPS_pubmethodSystem_CAPS_staticDecodeXmlNamespaceForClrTypeNamespace(String, String, String)

Decodifica i nomi di assembly e lo spazio dei nomi XML dello spazio dei nomi di common language runtime fornito.

System_CAPS_pubmethodEquals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object.)

System_CAPS_protmethodFinalize()

Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object.)

System_CAPS_pubmethodGetHashCode()

Funge da funzione hash predefinita.(Ereditato da Object.)

System_CAPS_pubmethodSystem_CAPS_staticGetInteropFieldTypeAndNameFromXmlAttribute(Type, String, String, Type, String)

Recupera il tipo di campo dal nome dell'attributo XML, spazio dei nomi e Type dell'oggetto contenitore.

System_CAPS_pubmethodSystem_CAPS_staticGetInteropFieldTypeAndNameFromXmlElement(Type, String, String, Type, String)

Recupera il Type e il nome di un campo il nome dell'elemento XML fornito, lo spazio dei nomi e tale tipo.

System_CAPS_pubmethodSystem_CAPS_staticGetInteropTypeFromXmlElement(String, String)

Recupera il Type che deve essere utilizzata durante la deserializzazione di un tipo di oggetto non riconosciuto con il nome dell'elemento XML specificato e lo spazio dei nomi.

System_CAPS_pubmethodSystem_CAPS_staticGetInteropTypeFromXmlType(String, String)

Recupera l'oggetto Type che deve essere utilizzata durante la deserializzazione di un tipo di oggetto non riconosciuto con il nome del tipo XML specificato e lo spazio dei nomi.

System_CAPS_pubmethodSystem_CAPS_staticGetSoapActionFromMethodBase(MethodBase)

Restituisce il valore SOAPAction associato al metodo specificato nel determinato MethodBase.

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_pubmethodSystem_CAPS_staticGetTypeAndMethodNameFromSoapAction(String, String, String)

Determina il nome di metodo e il tipo del metodo associato al valore SOAPAction specificato.

System_CAPS_pubmethodSystem_CAPS_staticGetXmlElementForInteropType(Type, String, String)

Restituisce informazioni sugli elementi XML che deve essere utilizzati durante la serializzazione del tipo specificato.

System_CAPS_pubmethodSystem_CAPS_staticGetXmlNamespaceForMethodCall(MethodBase)

Recupera lo spazio dei nomi XML utilizzato durante le chiamate remote del metodo specificato nel determinato MethodBase.

System_CAPS_pubmethodSystem_CAPS_staticGetXmlNamespaceForMethodResponse(MethodBase)

Recupera lo spazio dei nomi XML utilizzato durante la generazione di risposte per la chiamata al metodo specificato remoto il determinato MethodBase.

System_CAPS_pubmethodSystem_CAPS_staticGetXmlTypeForInteropType(Type, String, String)

Restituisce informazioni sul tipo XML che deve essere utilizzati durante la serializzazione di determinato Type.

System_CAPS_pubmethodSystem_CAPS_staticIsClrTypeNamespace(String)

Restituisce un valore booleano che indica se lo spazio dei nomi specificato è nativo di common language runtime.

System_CAPS_pubmethodSystem_CAPS_staticIsSoapActionValidForMethodBase(String, MethodBase)

Determina se il valore SOAPAction specificato è accettabile per un determinato MethodBase.

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.(Ereditato da Object.)

System_CAPS_pubmethodSystem_CAPS_staticPreLoad(Assembly)

Esegue il precaricamento ogni Type trovato nell'oggetto specificato Assembly dalle informazioni, vedere il SoapTypeAttribute associata a ogni tipo.

System_CAPS_pubmethodSystem_CAPS_staticPreLoad(Type)

Esegue il precaricamento di determinato Type in base ai valori impostati un SoapTypeAttribute sul tipo.

System_CAPS_pubmethodSystem_CAPS_staticRegisterInteropXmlElement(String, String, Type)

Associa il nome dell'elemento XML specificato e lo spazio dei nomi a un tipo in fase di esecuzione che deve essere utilizzato per la deserializzazione.

System_CAPS_pubmethodSystem_CAPS_staticRegisterInteropXmlType(String, String, Type)

Associa il nome del tipo XML specificato e lo spazio dei nomi con il tipo in fase di esecuzione che deve essere utilizzato per la deserializzazione.

System_CAPS_pubmethodSystem_CAPS_staticRegisterSoapActionForMethodBase(MethodBase)

Associa l'oggetto specificato MethodBase SOAPAction memorizzato nella cache con esso.

System_CAPS_pubmethodSystem_CAPS_staticRegisterSoapActionForMethodBase(MethodBase, String)

Associa il valore SOAPAction fornito con il determinato MethodBase per l'utilizzo nei sink di canale.

System_CAPS_pubmethodToString()

Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object.)

Questa classe esegue una richiesta di collegamento. Se il chiamante immediato non dispone dell'autorizzazione di infrastruttura, viene generata un'eccezione di sicurezza. Per altre informazioni, vedere Link Demands.

Esempio di codice seguente viene illustrato come utilizzare i membri di SoapServices classe per la conversione tra un Type oggetto in un tipo XML.

using System;
using System.Runtime.Remoting;

namespace ExampleNamespace
{
    [System.Runtime.Remoting.Metadata.SoapTypeAttribute(
         XmlElementName="ExampleClassElementName",
         XmlNamespace="http://example.org/ExampleXmlNamespace",
         XmlTypeName="ExampleXmlTypeName",
         XmlTypeNamespace="http://example.org/ExampleXmlTypeNamespace")]
    public class ExampleClass
    {
        // A field that will be serialized as an XML element.
        [System.Runtime.Remoting.Metadata.SoapField(
             XmlElementName="ExampleFieldElementName",
             XmlNamespace="http://example.org/ExampleFieldNamespace")]
        public string ExampleFieldUsingElement;

        // A field that will be serialized as an XML attribute.
        [System.Runtime.Remoting.Metadata.SoapField(
             XmlElementName="ExampleFieldAttributeName",
             XmlNamespace="http://example.org/ExampleAttributeNamespace",
             UseAttribute=true)]
        public string ExampleFieldUsingAttribute;

        [System.Runtime.Remoting.Metadata.SoapMethod(
             SoapAction="http://example.org/ExampleSoapAction#GetHello")]
        public string GetHello(string name)
        {
            return "Hello, " + name;
        }
    }
}

public class Demo
{
    [System.Security.Permissions.SecurityPermissionAttribute(
    System.Security.Permissions.SecurityAction.LinkDemand,
    Flags=System.Security.Permissions.SecurityPermissionFlag.Infrastructure)]
    public static void Main(string[] args)
    {
        // Convert a CLR namespace and assembly name into an XML namespace.
        string xmlNamespace = 
            SoapServices.CodeXmlNamespaceForClrTypeNamespace(
            "ExampleNamespace", "AssemblyName");
        Console.WriteLine("The name of the XML namespace is {0}.", 
            xmlNamespace);

        // Extract a CLR namespace and assembly name from an XML namespace.
        string typeNamespace;
        string assemblyName;
        SoapServices.DecodeXmlNamespaceForClrTypeNamespace(xmlNamespace,
            out typeNamespace, out assemblyName);
        Console.WriteLine("The name of the CLR namespace is {0}.", 
            typeNamespace);
        Console.WriteLine("The name of the CLR assembly is {0}.", 
            assemblyName);

        // Get the XML element name and the XML namespace for 
        // an Interop type.
        string xmlElement;
        bool isSoapTypeAttribute =
            SoapServices.GetXmlElementForInteropType(
            typeof(ExampleNamespace.ExampleClass), 
            out xmlElement, out xmlNamespace);

        // Print whether the requested value was flagged 
        // with a SoapTypeAttribute.
        if (isSoapTypeAttribute)
        {
            Console.WriteLine(
                "The requested value was flagged " +
                "with the SoapTypeAttribute.");
        }
        else 
        {
            Console.WriteLine(
                "The requested value was not flagged " +
                "with the SoapTypeAttribute.");
        }

        // Print the XML element and the XML namespace.
        Console.WriteLine(
            "The XML element for the type " +
            "ExampleNamespace.ExampleClass is {0}.",
            xmlElement);
        Console.WriteLine(
            "The XML namespace for the type " +
            "ExampleNamespace.ExampleClass is {0}.",
            xmlNamespace);

        // Get the XML type name and the XML type namespace for 
        // an Interop type.
        string xmlTypeName;
        string xmlTypeNamespace;
        isSoapTypeAttribute =
            SoapServices.GetXmlTypeForInteropType(
            typeof(ExampleNamespace.ExampleClass), 
            out xmlTypeName, out xmlTypeNamespace);

        // Print whether the requested value was flagged 
        // with a SoapTypeAttribute.
        if (isSoapTypeAttribute)
        {
            Console.WriteLine(
                "The requested value was flagged " +
                "with the SoapTypeAttribute.");
        }
        else 
        {
            Console.WriteLine(
                "The requested value was not flagged " +
                "with the SoapTypeAttribute.");
        }

        // Print the XML type name and the XML type namespace.
        Console.WriteLine(
            "The XML type for the type " +
            "ExampleNamespace.ExampleClass is {0}.",
            xmlTypeName);
        Console.WriteLine(
            "The XML type namespace for the type " +
            "ExampleNamespace.ExampleClass is {0}.",
            xmlTypeNamespace);

        // Print the XML namespace for a method invocation and its
        // response.
        System.Reflection.MethodBase getHelloMethod = 
            typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello");
        string methodCallXmlNamespace = 
            SoapServices.GetXmlNamespaceForMethodCall(getHelloMethod);
        string methodResponseXmlNamespace =
            SoapServices.GetXmlNamespaceForMethodResponse(getHelloMethod);
        Console.WriteLine(
            "The XML namespace for the invocation of the method " +
            "GetHello in ExampleClass is {0}.",
            methodResponseXmlNamespace);
        Console.WriteLine(
            "The XML namespace for the response of the method " +
            "GetHello in ExampleClass is {0}.",
            methodCallXmlNamespace);

        // Determine whether an XML namespace represents a CLR namespace.
        string clrNamespace = SoapServices.XmlNsForClrType;
        if (SoapServices.IsClrTypeNamespace(clrNamespace))
        {
            Console.WriteLine(
                "The namespace {0} is a CLR namespace.",
                clrNamespace);
        }
        else 
        {
            Console.WriteLine(
                "The namespace {0} is not a CLR namespace.",
                clrNamespace);
        }

        // Print the XML namespace for the CLR types.
        Console.WriteLine(
            "The XML namespace for the CLR types " + 
            "is {0}.",
            SoapServices.XmlNsForClrType);

        // Print the XML namespace for the CLR types 
        // that have an assembly but no common language runtime namespace.
        Console.WriteLine(
            "The XML namespace for the CLR types " +
            "that have an assembly but no namespace, is {0}.",
            SoapServices.XmlNsForClrTypeWithAssembly);

        // Print the XML namespace for the CLR types 
        // that are a part of the Mscorlib.dll.
        Console.WriteLine(
            "The XML namespace for the CLR types " +
            "that are part of the Mscorlib.dll, is {0}.",
            SoapServices.XmlNsForClrTypeWithNs);

        // Print the XML namespace for the CLR types 
        // that have both an assembly and a common language runtime 
        // namespace.
        Console.WriteLine(
            "The XML namespace for the CLR types " +
            "that have both an assembly and a namespace, is {0}.",
            SoapServices.XmlNsForClrTypeWithNsAndAssembly);


        // Get the SOAP action for the method.
        System.Reflection.MethodBase getHelloMethodBase = 
            typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello");
        string getHelloSoapAction =
            SoapServices.GetSoapActionFromMethodBase(getHelloMethodBase);
        Console.WriteLine(
            "The SOAP action for the method " +
            "ExampleClass.GetHello is {0}.", getHelloSoapAction);
        bool isSoapActionValid = SoapServices.IsSoapActionValidForMethodBase(
            getHelloSoapAction,
            getHelloMethodBase);
        if (isSoapActionValid)
        {
            Console.WriteLine(
                "The SOAP action, {0}, " + 
                "is valid for ExampleClass.GetHello", 
                getHelloSoapAction);
        }
        else
        {
            Console.WriteLine(
                "The SOAP action, {0}, " + 
                "is not valid for ExampleClass.GetHello", 
                getHelloSoapAction);
        }

        // Register the SOAP action for the GetHello method.
        SoapServices.RegisterSoapActionForMethodBase(getHelloMethodBase);

        // Get the type and the method names encoded into the SOAP action.
        string encodedTypeName;
        string encodedMethodName;
        SoapServices.GetTypeAndMethodNameFromSoapAction(
            getHelloSoapAction, 
            out encodedTypeName, 
            out encodedMethodName);
        Console.WriteLine(
            "The type name encoded in this SOAP action is {0}.",
            encodedTypeName);
        Console.WriteLine(
            "The method name encoded in this SOAP action is {0}.",
            encodedMethodName);

        // Get the name and the type of the field using its XML 
        // element name and its XML namespace. For this query to work,
        // the containing type must be preloaded, and the XML element 
        // name and the XML namespace must be explicitly declared on 
        // the field using a SoapFieldAttribute.

        // Preload the containing type.
        SoapServices.PreLoad(typeof(ExampleNamespace.ExampleClass));

        // Get the name and the type of a field that will be 
        // serialized as an XML element.
        Type containingType = typeof(ExampleNamespace.ExampleClass);
        string xmlElementNamespace = 
            "http://example.org/ExampleFieldNamespace";
        string xmlElementName = "ExampleFieldElementName";
        Type fieldType;
        string fieldName;
        SoapServices.GetInteropFieldTypeAndNameFromXmlElement(
            containingType, xmlElementName, xmlElementNamespace, 
            out fieldType, out fieldName);
        Console.WriteLine(
            "The type of the field is {0}.",
            fieldType);
        Console.WriteLine(
            "The name of the field is {0}.",
            fieldName);

        // Get the name and the type of a field that will be 
        // serialized as an XML attribute.
        string xmlAttributeNamespace = 
            "http://example.org/ExampleAttributeNamespace";
        string xmlAttributeName = "ExampleFieldAttributeName";
        SoapServices.GetInteropFieldTypeAndNameFromXmlAttribute(
            containingType, xmlAttributeName, xmlAttributeNamespace, 
            out fieldType, out fieldName);
        Console.WriteLine(
            "The type of the field is {0}.",
            fieldType);
        Console.WriteLine(
            "The name of the field is {0}.",
            fieldName);


        string interopTypeXmlElementName = 
            "ExampleClassElementName";
        string interopTypeXmlNamespace = 
            "http://example.org/ExampleXmlNamespace";
        Type interopType = SoapServices.GetInteropTypeFromXmlElement(
            interopTypeXmlElementName, 
            interopTypeXmlNamespace);
        Console.WriteLine("The interop type is {0}.", interopType);

        string interopTypeXmlTypeName = 
            "ExampleXmlTypeName";
        string interopTypeXmlTypeNamespace = 
            "http://example.org/ExampleXmlTypeNamespace";
        interopType = SoapServices.GetInteropTypeFromXmlType(
            interopTypeXmlTypeName, interopTypeXmlTypeNamespace);
        Console.WriteLine("The interop type is {0}.", interopType);

        // Get the method base object for the GetHello method.
        System.Reflection.MethodBase methodBase = 
            typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello");

        // Print its current SOAP action.
        Console.WriteLine(
            "The SOAP action for the method " +
            "ExampleClass.GetHello is {0}.",
            SoapServices.GetSoapActionFromMethodBase(methodBase));

        // Set the SOAP action of the GetHello method to a new value.
        string newSoapAction = 
            "http://example.org/ExampleSoapAction#NewSoapAction";
        SoapServices.RegisterSoapActionForMethodBase(
            methodBase, newSoapAction);
        Console.WriteLine(
            "The SOAP action for the method " +
            "ExampleClass.GetHello is {0}.",
            SoapServices.GetSoapActionFromMethodBase(methodBase));

        // Reset the SOAP action of the GetHello method to its default
        // value, which is determined using its SoapMethod attribute.
        SoapServices.RegisterSoapActionForMethodBase(methodBase);
        Console.WriteLine(
            "The SOAP action for the method " +
            "ExampleClass.GetHello is {0}.",
            SoapServices.GetSoapActionFromMethodBase(methodBase));

        // Register all types in the assembly with the SoapType attribute.
        System.Reflection.Assembly executingAssembly =
            System.Reflection.Assembly.GetExecutingAssembly();
        SoapServices.PreLoad(executingAssembly);

        // Register a specific type with the SoapType attribute.
        Type exampleType = typeof(ExampleNamespace.ExampleClass);
        SoapServices.PreLoad(exampleType);

        // Get the currently registered type for the given XML element 
        // and namespace.
        string registeredXmlElementName = 
            "ExampleClassElementName";
        string registeredXmlNamespace = 
            "http://example.org/ExampleXmlNamespace";
        Type registeredType = 
            SoapServices.GetInteropTypeFromXmlElement(
            registeredXmlElementName, 
            registeredXmlNamespace);
        Console.WriteLine(
            "The registered interop type is {0}.",
            registeredType);

        // Register a new type for the XML element and namespace.
        SoapServices.RegisterInteropXmlElement(
            registeredXmlElementName,
            registeredXmlNamespace, 
            typeof(String));

        // Get the currently registered type for the given XML element 
        // and namespace.
        registeredType = 
            SoapServices.GetInteropTypeFromXmlElement(
            registeredXmlElementName, 
            registeredXmlNamespace);
        Console.WriteLine(
            "The registered interop type is {0}.",
            registeredType);

        // Get the currently registered type for the given XML element 
        // and namespace.
        string registeredXmlTypeName = 
            "ExampleXmlTypeName";
        string registeredXmlTypeNamespace = 
            "http://example.org/ExampleXmlTypeNamespace";
        registeredType = 
            SoapServices.GetInteropTypeFromXmlType(
            registeredXmlTypeName, 
            registeredXmlTypeNamespace);
        Console.WriteLine(
            "The registered interop type is {0}.",
            registeredType);

        // Register a new type for the XML element and namespace.
        SoapServices.RegisterInteropXmlType(
            registeredXmlTypeName,
            registeredXmlTypeNamespace, 
            typeof(String));

        // Get the currently registered type for the given XML element 
        // and namespace.
        registeredType = 
            SoapServices.GetInteropTypeFromXmlType(
            registeredXmlTypeName, 
            registeredXmlTypeNamespace);
        Console.WriteLine(
            "The registered interop type is {0}.",
            registeredType);
    }
}

SecurityPermission

for operating with infrastructure code. Demand value: F:System.Security.Permissions.SecurityAction.LinkDemand; Permission Value: F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure

.NET Framework
Disponibile da 1.1

I membri statici pubblici ( Condiviso in Visual Basic) di questo tipo è thread safe. Non tutti i membri di istanza sono garantiti come thread safe.

Torna all'inizio
Mostra: