SoapServices 클래스

정의

네임스페이스:

System.Runtime.Remoting

어셈블리:

mscorlib.dll

SOAP 형식으로 원격 개체를 사용하고 게시하는 몇 가지 메서드를 제공합니다.

public ref class SoapServices

[System.Runtime.InteropServices.ComVisible(true)]
[System.Security.SecurityCritical]
public class SoapServices

[<System.Runtime.InteropServices.ComVisible(true)>]
[<System.Security.SecurityCritical>]
type SoapServices = class

Public Class SoapServices

상속

Object

SoapServices

특성

ComVisibleAttribute SecurityCriticalAttribute

예제

다음 코드 예제에서는 클래스의 멤버 SoapServices 를 사용하여 개체와 XML 형식 간에 Type 변환하는 방법을 보여 있습니다.

#using <System.Runtime.Remoting.dll>
using namespace System;
using namespace 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 ref class ExampleClass
   {
   public:

      // A field that will be serialized as an XML element.
      [System::Runtime::Remoting::Metadata::SoapField(
      XmlElementName="ExampleFieldElementName",
      XmlNamespace="http://example.org/ExampleFieldNamespace")]
      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)]
      String^ ExampleFieldUsingAttribute;

      [System::Runtime::Remoting::Metadata::SoapMethod(
      SoapAction="http://example.org/ExampleSoapAction#GetHello")]
      String^ GetHello( String^ name )
      {
         return String::Format( L"Hello, {0}", name );
      }

   };

}

[System::Security::Permissions::SecurityPermissionAttribute(
System::Security::Permissions::SecurityAction::LinkDemand,
Flags=System::Security::Permissions::SecurityPermissionFlag::Infrastructure)]
int main()
{
   // Convert a CLR namespace and assembly name into an XML namespace.
   String^ xmlNamespace = SoapServices::CodeXmlNamespaceForClrTypeNamespace(
      L"ExampleNamespace", L"AssemblyName" );
   Console::WriteLine( L"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,typeNamespace,assemblyName );
   Console::WriteLine( L"The name of the CLR namespace is {0}.", typeNamespace );
   Console::WriteLine( L"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(
      ExampleNamespace::ExampleClass::typeid,xmlElement,xmlNamespace );
   
   // Print whether the requested value was flagged
   // with a SoapTypeAttribute.
   if ( isSoapTypeAttribute )
   {
      Console::WriteLine( L"The requested value was flagged "
      L"with the SoapTypeAttribute." );
   }
   else
   {
      Console::WriteLine( L"The requested value was not flagged "
      L"with the SoapTypeAttribute." );
   }
   
   // Print the XML element and the XML namespace.
   Console::WriteLine( L"The XML element for the type "
   L"ExampleNamespace.ExampleClass is {0}.", xmlElement );
   Console::WriteLine( L"The XML namespace for the type "
   L"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( ExampleNamespace::ExampleClass::typeid,xmlTypeName,xmlTypeNamespace );
   
   // Print whether the requested value was flagged
   // with a SoapTypeAttribute.
   if ( isSoapTypeAttribute )
   {
      Console::WriteLine( L"The requested value was flagged "
      L"with the SoapTypeAttribute." );
   }
   else
   {
      Console::WriteLine( L"The requested value was not flagged "
      L"with the SoapTypeAttribute." );
   }
   
   // Print the XML type name and the XML type namespace.
   Console::WriteLine( L"The XML type for the type "
   L"ExampleNamespace.ExampleClass is {0}.", xmlTypeName );
   Console::WriteLine( L"The XML type namespace for the type "
   L"ExampleNamespace.ExampleClass is {0}.", xmlTypeNamespace );

   // Print the XML namespace for a method invocation and its
   // response.
   System::Reflection::MethodBase^ getHelloMethod =
      ExampleNamespace::ExampleClass::typeid->GetMethod( L"GetHello" );
   String^ methodCallXmlNamespace =
      SoapServices::GetXmlNamespaceForMethodCall( getHelloMethod );
   String^ methodResponseXmlNamespace =
      SoapServices::GetXmlNamespaceForMethodResponse( getHelloMethod );
   Console::WriteLine( L"The XML namespace for the invocation of the method "
   L"GetHello in ExampleClass is {0}.", methodResponseXmlNamespace );
   Console::WriteLine( L"The XML namespace for the response of the method "
   L"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( L"The namespace {0} is a CLR namespace.",
         clrNamespace );
   }
   else
   {
      Console::WriteLine( L"The namespace {0} is not a CLR namespace.",
         clrNamespace );
   }
   
   // Print the XML namespace for the CLR types.
   Console::WriteLine( L"The XML namespace for the CLR types "
   L"is {0}.", SoapServices::XmlNsForClrType );

   // Print the XML namespace for the CLR types
   // that have an assembly but no common language runtime namespace.
   Console::WriteLine( L"The XML namespace for the CLR types "
      L"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( L"The XML namespace for the CLR types "
   L"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( L"The XML namespace for the CLR types "
   L"that have both an assembly and a namespace, is {0}.",
      SoapServices::XmlNsForClrTypeWithNsAndAssembly );

   // Get the SOAP action for the method.
   System::Reflection::MethodBase^ getHelloMethodBase =
      ExampleNamespace::ExampleClass::typeid->GetMethod( L"GetHello" );
   String^ getHelloSoapAction =
      SoapServices::GetSoapActionFromMethodBase( getHelloMethodBase );
   Console::WriteLine( L"The SOAP action for the method "
   L"ExampleClass.GetHello is {0}.", getHelloSoapAction );
   bool isSoapActionValid =
      SoapServices::IsSoapActionValidForMethodBase(
         getHelloSoapAction, getHelloMethodBase );
   if ( isSoapActionValid )
   {
      Console::WriteLine( L"The SOAP action, {0}, "
      L"is valid for ExampleClass.GetHello", getHelloSoapAction );
   }
   else
   {
      Console::WriteLine( L"The SOAP action, {0}, "
      L"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,encodedTypeName,encodedMethodName );
   Console::WriteLine( L"The type name encoded in this SOAP action is {0}.",
      encodedTypeName );
   Console::WriteLine( L"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( ExampleNamespace::ExampleClass::typeid );
   
   // Get the name and the type of a field that will be
   // serialized as an XML element.
   Type^ containingType = ExampleNamespace::ExampleClass::typeid;
   String^ xmlElementNamespace = L"http://example.org/ExampleFieldNamespace";
   String^ xmlElementName = L"ExampleFieldElementName";
   Type^ fieldType;
   String^ fieldName;
   SoapServices::GetInteropFieldTypeAndNameFromXmlElement(
      containingType,xmlElementName,xmlElementNamespace,fieldType,fieldName );
   Console::WriteLine( L"The type of the field is {0}.", fieldType );
   Console::WriteLine( L"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 =
      L"http://example.org/ExampleAttributeNamespace";
   String^ xmlAttributeName = L"ExampleFieldAttributeName";
   SoapServices::GetInteropFieldTypeAndNameFromXmlAttribute(
      containingType,xmlAttributeName,xmlAttributeNamespace,fieldType,fieldName );
   Console::WriteLine( L"The type of the field is {0}.", fieldType );
   Console::WriteLine( L"The name of the field is {0}.", fieldName );

   String^ interopTypeXmlElementName = L"ExampleClassElementName";
   String^ interopTypeXmlNamespace = L"http://example.org/ExampleXmlNamespace";
   Type^ interopType = SoapServices::GetInteropTypeFromXmlElement(
      interopTypeXmlElementName, interopTypeXmlNamespace );
   Console::WriteLine( L"The interop type is {0}.", interopType );
   String^ interopTypeXmlTypeName = L"ExampleXmlTypeName";
   String^ interopTypeXmlTypeNamespace =
      L"http://example.org/ExampleXmlTypeNamespace";
   interopType = SoapServices::GetInteropTypeFromXmlType(
      interopTypeXmlTypeName,interopTypeXmlTypeNamespace );
   Console::WriteLine( L"The interop type is {0}.", interopType );

   // Get the method base object for the GetHello method.
   System::Reflection::MethodBase^ methodBase = 
     ExampleNamespace::ExampleClass::typeid->GetMethod( L"GetHello" );
   
   // Print its current SOAP action.
   Console::WriteLine( L"The SOAP action for the method "
      L"ExampleClass.GetHello is {0}.",
      SoapServices::GetSoapActionFromMethodBase( methodBase ) );
   
   // Set the SOAP action of the GetHello method to a new value.
   String^ newSoapAction = L"http://example.org/ExampleSoapAction#NewSoapAction";
   SoapServices::RegisterSoapActionForMethodBase( methodBase, newSoapAction );
   Console::WriteLine( L"The SOAP action for the method "
      L"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( L"The SOAP action for the method "
      L"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 = ExampleNamespace::ExampleClass::typeid;
   SoapServices::PreLoad( exampleType );

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

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

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
{
    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);
    }
}

설명

이 클래스는 링크 요청을 만듭니다. 즉시 호출자에게 인프라 권한이 없는 경우 보안 예외가 throw됩니다.

속성

Name	Description
XmlNsForClrType	공용 언어 런타임 형식에 대한 XML 네임스페이스 접두사를 가져옵니다.
XmlNsForClrTypeWithAssembly	어셈블리가 있지만 네이티브 네임스페이스가 없는 공용 언어 런타임 클래스의 XML 인코딩에 사용해야 하는 기본 XML 네임스페이스 접두사를 가져옵니다.
XmlNsForClrTypeWithNs	mscorlib.dll 파일의 일부인 공용 언어 런타임 클래스의 XML 인코딩에 사용해야 하는 XML 네임스페이스 접두사를 가져옵니다.
XmlNsForClrTypeWithNsAndAssembly	공용 언어 런타임 네임스페이스와 어셈블리가 모두 있는 공용 언어 런타임 클래스의 XML 인코딩에 사용해야 하는 기본 XML 네임스페이스 접두사를 가져옵니다.

메서드

Name	Description
CodeXmlNamespaceForClrTypeNamespace(String, String)	제공된 네임스페이스 및 어셈블리 이름에서 공용 언어 런타임 형식 네임스페이스 이름을 반환합니다.
DecodeXmlNamespaceForClrTypeNamespace(String, String, String)	제공된 공용 언어 런타임 네임스페이스에서 XML 네임스페이스 및 어셈블리 이름을 디코딩합니다.
Equals(Object)	지정된 개체가 현재 개체와 같은지 여부를 확인합니다. (다음에서 상속됨 Object)
GetHashCode()	기본 해시 함수로 사용됩니다. (다음에서 상속됨 Object)
GetInteropFieldTypeAndNameFromXmlAttribute(Type, String, String, Type, String)	XML 특성 이름, 네임스페이스 및 포함하는 개체의 Type 필드 형식을 검색합니다.
GetInteropFieldTypeAndNameFromXmlElement(Type, String, String, Type, String)	Type 제공된 XML 요소 이름, 네임스페이스 및 포함하는 형식에서 필드의 이름과 이름을 검색합니다.
GetInteropTypeFromXmlElement(String, String)	Type 지정된 XML 요소 이름 및 네임스페이스를 사용하여 인식할 수 없는 개체 형식을 역직렬화하는 동안 사용해야 하는 개체를 검색합니다.
GetInteropTypeFromXmlType(String, String)	Type 지정된 XML 형식 이름 및 네임스페이스를 사용하여 인식할 수 없는 개체 형식을 역직렬화하는 동안 사용해야 하는 개체를 검색합니다.
GetSoapActionFromMethodBase(MethodBase)	지정된 MethodBase메서드에 지정된 메서드와 연결된 SOAPAction 값을 반환합니다.
GetType()	현재 인스턴스의 Type 가져옵니다. (다음에서 상속됨 Object)
GetTypeAndMethodNameFromSoapAction(String, String, String)	지정된 SOAPAction 값과 연결된 메서드의 형식 및 메서드 이름을 결정합니다.
GetXmlElementForInteropType(Type, String, String)	지정된 형식을 serialize할 때 사용해야 하는 XML 요소 정보를 반환합니다.
GetXmlNamespaceForMethodCall(MethodBase)	지정된 MethodBase메서드의 원격 호출 중에 사용되는 XML 네임스페이스를 검색합니다.
GetXmlNamespaceForMethodResponse(MethodBase)	지정된 MethodBase메서드에 대한 원격 호출에 대한 응답을 생성하는 동안 사용되는 XML 네임스페이스를 검색합니다.
GetXmlTypeForInteropType(Type, String, String)	지정된 Type형식을 serialize할 때 사용해야 하는 XML 형식 정보를 반환합니다.
IsClrTypeNamespace(String)	지정된 네임스페이스가 공용 언어 런타임의 네이티브인지 여부를 나타내는 부울 값을 반환합니다.
IsSoapActionValidForMethodBase(String, MethodBase)	지정된 SOAPAction이 지정된 MethodBaseSOAPAction에 허용되는지 여부를 확인합니다.
MemberwiseClone()	현재 Object단순 복사본을 만듭니다. (다음에서 상속됨 Object)
PreLoad(Assembly)	각 형식과 연결된 정보에 있는 지정한 Assembly 정보에서 찾은 SoapTypeAttribute 모든 Type 것을 미리 로드합니다.
PreLoad(Type)	형식에 설정된 SoapTypeAttribute 값에 따라 지정된 Type 값을 미리 로드합니다.
RegisterInteropXmlElement(String, String, Type)	지정된 XML 요소 이름 및 네임스페이스를 역직렬화에 사용해야 하는 런타임 형식과 연결합니다.
RegisterInteropXmlType(String, String, Type)	지정된 XML 형식 이름 및 네임스페이스를 역직렬화에 사용해야 하는 런타임 형식과 연결합니다.
RegisterSoapActionForMethodBase(MethodBase, String)	제공된 SOAPAction 값을 채널 싱크에서 사용하기 위해 지정된 MethodBase 값과 연결합니다.
RegisterSoapActionForMethodBase(MethodBase)	지정된 값을 캐시된 MethodBase SOAPAction과 연결합니다.
ToString()	현재 개체를 나타내는 문자열을 반환합니다. (다음에서 상속됨 Object)