Message Osztály

Definíció

Névtér:: System.Messaging

Szerelvény:: System.Messaging.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Hozzáférést biztosít a Message Queuing-üzenetek definiálásához szükséges tulajdonságokhoz.

public ref class Message : System::ComponentModel::Component

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Öröklődés: Object

MarshalByRefObject

Component
Message

Példák

Az alábbi példakód egy üzenettörzs formázását mutatja be a használatával BinaryMessageFormatter.

using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

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

            // Create a queue on the local computer.
            CreateQueue(".\\myQueue");
            
            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Creates a new queue.
        //**************************************************

        public static void CreateQueue(string queuePath)
        {
            try	
            {
                if(!MessageQueue.Exists(queuePath))
                {
                    MessageQueue.Create(queuePath);
                }
                else
                {
                    Console.WriteLine(queuePath + " already exists.");
                }
            }
            catch (MessageQueueException e)
            {
                Console.WriteLine(e.Message);
            }
        }

        //**************************************************
        // Sends an image to a queue, using the BinaryMessageFormatter.
        //**************************************************
        
        public void SendMessage()
        {
            try{

                // Create a new bitmap.
                // The file must be in the \bin\debug or \bin\retail folder, or
                // you must give a full path to its location.
                Image myImage = Bitmap.FromFile("SentImage.bmp");

                // Connect to a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");
                
                Message myMessage = new Message(myImage, new BinaryMessageFormatter());

                // Send the image to the queue.
                myQueue.Send(myMessage);
            }
            catch(ArgumentException e)
            {
                Console.WriteLine(e.Message);
            }

            return;
        }

        //**************************************************
        // Receives a message containing an image.
        //**************************************************
        
        public  void ReceiveMessage()
        {
                        
            try
            {

                // Connect to the a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");

                // Set the formatter to indicate body contains an Order.
                myQueue.Formatter = new BinaryMessageFormatter();

                // Receive and format the message.
                System.Messaging.Message myMessage = myQueue.Receive();
                Bitmap myImage = (Bitmap)myMessage.Body;
                
                // This will be saved in the \bin\debug or \bin\retail folder.
                myImage.Save("ReceivedImage.bmp",System.Drawing.Imaging.ImageFormat.Bmp);
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }

            catch (IOException e)
            {
                // Handle file access exceptions.
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging
Imports System.Drawing
Imports System.IO


Namespace MyProj
    _
   
   
   Public Class MyNewQueue
      
      
      '**************************************************
      ' Provides an entry point into the application.
      '		 
      ' This example sends and receives a message from
      ' a queue.
      '**************************************************
      Public Shared Sub Main()
         ' Create a new instance of the class.
         Dim myNewQueue As New MyNewQueue()
         
         ' Create a queue on the local computer.
         CreateQueue(".\myQueue")
         
         ' Send a message to a queue.
         myNewQueue.SendMessage()
         
         ' Receive a message from a queue.
         myNewQueue.ReceiveMessage()
         
         Return
      End Sub
      
      
      '**************************************************
      ' Creates a new queue.
      '**************************************************
      Public Shared Sub CreateQueue(queuePath As String)
         Try
            If Not MessageQueue.Exists(queuePath) Then
               MessageQueue.Create(queuePath)
            Else
               Console.WriteLine((queuePath + " already exists."))
            End If
         Catch e As MessageQueueException
            Console.WriteLine(e.Message)
         End Try
      End Sub
       
      
      '**************************************************
      ' Sends an image to a queue, using the BinaryMessageFormatter.
      '**************************************************
      Public Sub SendMessage()
         Try
            
            ' Create a new bitmap.
            ' The file must be in the \bin\debug or \bin\retail folder, or
            ' you must give a full path to its location.
            Dim myImage As Image = Bitmap.FromFile("SentImage.bmp")
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            Dim myMessage As New Message(myImage, New BinaryMessageFormatter())
            
            ' Send the image to the queue.
            myQueue.Send(myMessage)
         Catch e As ArgumentException
            Console.WriteLine(e.Message)
         End Try 
         
         Return
      End Sub
      
      
      
      '**************************************************
      ' Receives a message containing an image.
      '**************************************************
      Public Sub ReceiveMessage()
         
         Try
            
            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New BinaryMessageFormatter()
            
            ' Receive and format the message. 
            Dim myMessage As System.Messaging.Message = myQueue.Receive()
            Dim myImage As Bitmap = CType(myMessage.Body, Bitmap)
            
            ' This will be saved in the \bin\debug or \bin\retail folder.
            myImage.Save("ReceivedImage.bmp", System.Drawing.Imaging.ImageFormat.Bmp)
         
         
         
         'Catch
         ' Handle Message Queuing exceptions.
         
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         
         Catch e As IOException
         End Try
         ' Handle file access exceptions.
         
         ' Catch other exceptions as necessary.
         Return
      End Sub
   End Class
End Namespace 'MyProj

Az alábbi példakód egy üzenettörzs formázását mutatja be a használatával XmlMessageFormatter.

#using <system.dll>
#using <system.messaging.dll>
#using <system.drawing.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};

ref class MyNewQueue
{
public:
   static void CreateQueue( String^ queuePath )
   {
      try
      {
         if (  !MessageQueue::Exists( queuePath ) )
         {
            MessageQueue::Create( queuePath );
         }
         else
         {
            Console::WriteLine(  "{0} already exists.", queuePath );
         }
      }
      catch ( MessageQueueException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   void SendMessage()
   {
      try
      {
         // Create a new order and set values.
         Order^ sentOrder = gcnew Order;
         sentOrder->orderId = 3;
         sentOrder->orderTime = DateTime::Now;

         // Connect to a queue on the local computer.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

         // Create the new order.
         Message^ myMessage = gcnew Message( sentOrder );

         // Send the order to the queue.
         myQueue->Send( myMessage );
      }
      catch ( ArgumentException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      return;
   }

   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = dynamic_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Create a queue on the local computer.
   MyNewQueue::CreateQueue( ".\\myQueue" );

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

    // The following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

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

            // Create a queue on the local computer.
            CreateQueue(".\\myQueue");
            
            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Creates a new queue.
        //**************************************************

        public static void CreateQueue(string queuePath)
        {
            try	
            {
                if(!MessageQueue.Exists(queuePath))
                {
                    MessageQueue.Create(queuePath);
                }
                else
                {
                    Console.WriteLine(queuePath + " already exists.");
                }
            }
            catch (MessageQueueException e)
            {
                Console.WriteLine(e.Message);
            }
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            try
            {

                // Create a new order and set values.
                Order sentOrder = new Order();
                sentOrder.orderId = 3;
                sentOrder.orderTime = DateTime.Now;

                // Connect to a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");

                // Create the new order.
                Message myMessage = new Message(sentOrder);

                // Send the order to the queue.
                myQueue.Send(myMessage);
            }
            catch(ArgumentException e)
            {
                Console.WriteLine(e.Message);
            }

            return;
        }

        //**************************************************
        // Receives a message containing an order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

                // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging
Imports System.Drawing
Imports System.IO



   
' The following example 
' sends to a queue and receives from a queue.
Public Class Order
      Public orderId As Integer
      Public orderTime As DateTime
End Class

   
  
' Provides a container class for the example.

Public Class MyNewQueue
      
      

   ' Provides an entry point into the application.
   '		 
   ' This example sends and receives a message from
   ' a queue.

   Public Shared Sub Main()
      ' Create a new instance of the class.
      Dim myNewQueue As New MyNewQueue()
        
      ' Create a queue on the local computer.
      CreateQueue(".\myQueue")
         
      ' Send a message to a queue.
      myNewQueue.SendMessage()
       
      ' Receive a message from a queue.
      myNewQueue.ReceiveMessage()
         
      Return
   End Sub
      
      

      ' Creates a new queue.
   Public Shared Sub CreateQueue(queuePath As String)
      Try
         If Not MessageQueue.Exists(queuePath) Then
            MessageQueue.Create(queuePath)
         Else
            Console.WriteLine((queuePath + " already exists."))
         End If
      Catch e As MessageQueueException
         Console.WriteLine(e.Message)
      End Try
   End Sub
       
      

      ' Sends an Order to a queue.

   Public Sub SendMessage()
      Try
            
            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            
            
            ' Create the new order.
            Dim myMessage As New Message(sentOrder)
            
            ' Send the order to the queue.
            myQueue.Send(myMessage)
      Catch e As ArgumentException
            Console.WriteLine(e.Message)
      End Try 
         
      Return
   End Sub
      
      
      
 
      ' Receives a message containing an order.
 
   Public Sub ReceiveMessage()
         ' Connect to the a queue on the local computer.
         Dim myQueue As New MessageQueue(".\myQueue")
         
         ' Set the formatter to indicate body contains an Order.
         myQueue.Formatter = New XmlMessageFormatter(New Type() {GetType(Order)})
         
         Try
            ' Receive and format the message. 
            Dim myMessage As Message = myQueue.Receive()
            Dim myOrder As Order = CType(myMessage.Body, Order)
            
            ' Display message information.
            Console.WriteLine(("Order ID: " + myOrder.orderId.ToString()))
            Console.WriteLine(("Sent: " + myOrder.orderTime.ToString()))
         
  
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return
   End Sub
End Class

Megjegyzések

Az osztály segítségével Message betekinthet vagy fogadhat üzeneteket egy üzenetsorból, vagy finoman szabályozhatja az üzenet tulajdonságait, amikor üzenetet küld egy üzenetsorba.

MessageQueue Az osztályt akkor Message használja, amikor betekint vagy üzeneteket fogad az üzenetsorokból, mert mind a MessageQueue.Peek MessageQueue.Receive metódusok létrehozzák az Message osztály új példányát, és beállítják a példány tulajdonságait. Az Message osztály írásvédett tulajdonságai az üzenetek üzenetsorból való beolvasására vonatkoznak, míg az olvasási/írási tulajdonságok az üzenetek küldésére és beolvasására vonatkoznak. Amikor MessageQueue betekint vagy üzenetet fogad egy üzenetsorból, annak tulajdonsága MessageReadPropertyFilter határozza meg, hogy az üzenet mely tulajdonságait kéri le a rendszer.

Az MessageQueue osztály metódusa Send lehetővé teszi az üzenetsorba küldött üzenetek bármilyen objektumtípusának megadását. A példány tulajdonságával MessageQueue megadhatja az DefaultPropertiesToSend üzenetsorba küldött általános üzenetek beállításait. A beállítások típusai közé tartozik a formázó, a címke, a titkosítás és a hitelesítés. A megfelelő DefaultPropertiesToSend tagok értékeit is megadhatja, amikor koordinálja az üzenetkezelő alkalmazást, hogy reagáljon a nyugtázási és jelentési üzenetekre. Ha egy Message példányt használ az üzenetsorba való üzenetküldéshez, rugalmasan érheti el és módosíthatja ezen tulajdonságok nagy részét – akár egyetlen üzenet, akár üzenetenkénti alapon. Message a tulajdonságok elsőbbséget élveznek a DefaultPropertiesToSend.

Az üzenetadatok a Body tulajdonságban és kisebb mértékben AppSpecific Extension a tulajdonságokban vannak tárolva. Az üzenetadatok titkosítása, szerializálása vagy deszerializálása esetén a rendszer csak a Body tulajdonság tartalmát érinti.

A tulajdonság tartalma Body az üzenet elküldésekor szerializálva lesz a Formatter megadott tulajdonság használatával. A szerializált tartalom a BodyStream tulajdonságban található. A tulajdonságot közvetlenül is beállíthatja BodyStream , például úgy, hogy egy fájlt küldjön egy üzenet adattartalmaként. Az üzenet elküldése előtt bármikor módosíthatja a Body Formatter tulajdonságokat, és híváskor Sendaz adatok megfelelően szerializálva lesznek.

A tulajdonság által definiált tulajdonságok csak olyan MessageQueue.DefaultPropertiesToSend üzenetekre vonatkoznak, amelyek nem típusúak Message. Ha megadja egy DefaultPropertiesToSend MessageQueueadott tulajdonságot, az adott üzenetsorba küldött példány azonos nevű tulajdonságai Message miatt ezek az alapértelmezett tulajdonságok figyelmen kívül lesznek hagyva.

Egy példány kezdeti tulajdonságértékeinek Messagelistáját a Message konstruktorban találja.

Konstruktorok

Name	Description
Message()	Inicializálja az Message osztály új példányát egy üres törzstel.
Message(Object, IMessageFormatter)	Inicializálja az osztály új példányát a Message megadott formázó használatával, hogy szerializálja a megadott objektumot az üzenet törzsébe.
Message(Object)	Inicializálja az Message osztály új példányát a XmlMessageFormatter megadott objektum szerializálásával az üzenet törzsébe.

Mezők

Name	Description
InfiniteTimeout	Azt adja meg, hogy nincs időtúllépés.

Tulajdonságok

Name	Description
AcknowledgeType	Lekéri vagy beállítja a küldő alkalmazásnak visszaküldött nyugtázási üzenet típusát.
Acknowledgment	Lekéri az üzenet által képviselt nyugtázás besorolását.
AdministrationQueue	Lekéri vagy beállítja a Message Queuing által létrehozott nyugtázási üzeneteket fogadó üzenetsort.
AppSpecific	További alkalmazásspecifikus információkat kér le vagy állít be.
ArrivedTime	Lekéri azt az időt, amikor az üzenet megérkezett a célsorba.
AttachSenderId	Lekéri vagy beállít egy értéket, amely jelzi, hogy a feladó azonosítóját csatolni kell-e az üzenethez.
Authenticated	Olyan értéket kap, amely jelzi, hogy az üzenet hitelesítése megtörtént-e.
AuthenticationProviderName	Lekéri vagy beállítja az üzenet digitális aláírásának létrehozásához használt titkosítási szolgáltató nevét.
AuthenticationProviderType	Lekéri vagy beállítja az üzenet digitális aláírásának létrehozásához használt titkosítási szolgáltató típusát.
Body	Lekéri vagy beállítja az üzenet tartalmát.
BodyStream	Lekéri vagy beállítja az információt az üzenet törzsében.
BodyType	Lekéri vagy beállítja az üzenet törzsének adattípusát.
CanRaiseEvents	Beolvas egy értéket, amely jelzi, hogy az összetevő képes-e eseményt létrehozni. (Öröklődés forrása Component)
ConnectorType	Lekéri vagy beállít egy értéket, amely azt jelzi, hogy a Message Queuing által általában beállított egyes üzenettulajdonságokat a küldő alkalmazás állította be.
Container	Lekéri a IContainer .Component (Öröklődés forrása Component)
CorrelationId	Lekéri vagy beállítja a nyugtázási, jelentési és válaszüzenetek által használt üzenetazonosítót az eredeti üzenetre való hivatkozáshoz.
DesignMode	Olyan értéket kap, amely jelzi, hogy az Component aktuálisan tervezési módban van-e. (Öröklődés forrása Component)
DestinationQueue	Lekéri a kívánt üzenetsort.
DestinationSymmetricKey	Lekéri vagy beállítja az alkalmazás által titkosított üzenetek vagy az idegen üzenetsorokra küldött üzenetek titkosításához használt szimmetrikus kulcsot.
DigitalSignature	Lekéri vagy beállítja a Message Queuing által az üzenet hitelesítéséhez használt digitális aláírást.
EncryptionAlgorithm	Lekéri vagy beállítja a titkos üzenetek törzsének titkosításához használt titkosítási algoritmust.
Events	Lekéri az ehhez Componentcsatolt eseménykezelők listáját. (Öröklődés forrása Component)
Extension	Lekéri vagy beállítja az üzenethez társított további, alkalmazás által definiált információkat.
Formatter	Lekéri vagy beállítja az objektum szerializálásához használt formázót, vagy deszerializál egy objektumot az üzenettörzsből.
HashAlgorithm	Lekéri vagy beállítja azt a kivonatolási algoritmust, amelyet a Message Queuing használ egy üzenet hitelesítésekor vagy egy üzenet digitális aláírásának létrehozásakor.
Id	Lekéri az üzenet azonosítóját.
IsFirstInTransaction	Olyan értéket kap, amely jelzi, hogy az üzenet volt-e az első üzenet egy tranzakcióban.
IsLastInTransaction	Olyan értéket kap, amely jelzi, hogy az üzenet volt-e az utolsó üzenet egy tranzakcióban.
Label	Lekéri vagy beállít egy alkalmazás által definiált Unicode-sztringet, amely leírja az üzenetet.
LookupId	Az MSMQ 3.0-ban bevezetett. Lekéri az üzenet keresési azonosítóját.
MessageType	Lekéri az üzenet típusát: `Normal`, `Acknowledgment`vagy `Report`.
Priority	Lekéri vagy beállítja az üzenet prioritását, amely meghatározza, hogy az üzenet hol legyen elhelyezve az üzenetsorban.
Recoverable	Lekéri vagy beállít egy értéket, amely jelzi, hogy az üzenet biztosan kézbesítve lesz-e számítógéphiba vagy hálózati probléma esetén.
ResponseQueue	Lekéri vagy beállítja az alkalmazás által létrehozott válaszüzeneteket fogadó üzenetsort.
SecurityContext	Lekéri vagy beállítja egy üzenet biztonsági környezetét.
SenderCertificate	Lekéri vagy beállítja az üzenetek hitelesítéséhez használt biztonsági tanúsítványt.
SenderId	Lekéri a küldő felhasználó azonosítóját.
SenderVersion	Lekéri az üzenet küldéséhez használt Message Queuing verzióját.
SentTime	Lekéri azon a számítógépen a dátumot és időt, amelyet a forrássor-kezelő küldött az üzenetnek.
Site	Lekéri vagy megadja a ISite értékét a Component-hez. (Öröklődés forrása Component)
SourceMachine	Lekéri azt a számítógépet, amelyről az üzenet származik.
TimeToBeReceived	Lekéri vagy beállítja az üzenet címzett üzenetsorból való fogadásának maximális időtartamát.
TimeToReachQueue	Lekéri vagy beállítja az üzenet üzenetsorra való elérésének maximális időtartamát.
TransactionId	Lekéri annak a tranzakciónak az azonosítóját, amelynek az üzenet része volt.
TransactionStatusQueue	Lekéri a tranzakciós állapotsort a forrásszámítógépen.
UseAuthentication	Lekéri vagy beállít egy értéket, amely jelzi, hogy az üzenet hitelesítése megtörtént-e (vagy kötelező) az üzenet elküldése előtt.
UseDeadLetterQueue	Lekéri vagy beállít egy értéket, amely jelzi, hogy a nem kézbesíthető üzenet másolatát el kell-e küldeni egy kézbesítetlen üzenetsorba.
UseEncryption	Lekéri vagy beállít egy értéket, amely jelzi, hogy az üzenet privát legyen-e.
UseJournalQueue	Lekéri vagy beállít egy értéket, amely jelzi, hogy az üzenet másolatát meg kell-e őrizni a számítógép naplójában az eredeti számítógépen.
UseTracing	Lekéri vagy beállít egy értéket, amely jelzi, hogy nyomon kell-e követni egy üzenetet a célsor felé haladva.

Metódusok

Name	Description
CreateObjRef(Type)	Létrehoz egy objektumot, amely tartalmazza a távoli objektumokkal való kommunikációhoz használt proxy létrehozásához szükséges összes releváns információt. (Öröklődés forrása MarshalByRefObject)
Dispose()	Felszabadítja a .-hez használt összes erőforrást Component. (Öröklődés forrása Component)
Dispose(Boolean)	Felszabadítja a felügyelt erőforrások által Component használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat. (Öröklődés forrása Component)
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Elavult. Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetService(Type)	Olyan objektumot ad vissza, amely az általa vagy annak által Component Containernyújtott szolgáltatást jelöli. (Öröklődés forrása Component)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
InitializeLifetimeService()	Elavult. Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
ToString()	String A ( ha van) nevet tartalmazó értéket Componentad vissza. Ezt a módszert nem szabad felülírni. (Öröklődés forrása Component)

esemény

Name	Description
Disposed	Akkor fordul elő, ha az összetevőt a metódus hívása megsemmisíti Dispose() . (Öröklődés forrása Component)

A következőre érvényes:

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?