Message Klass

Definition

Namnområde:: System.Messaging

Sammansättning:: System.Messaging.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Ger åtkomst till de egenskaper som behövs för att definiera ett Meddelandekömeddelande.

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

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Arv: Object

MarshalByRefObject

Component
Message

Exempel

I följande kodexempel visas hur du formaterar en meddelandetext med hjälp av 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

I följande kodexempel visas hur du formaterar en meddelandetext med hjälp av 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

Kommentarer

Message Använd klassen för att granska eller ta emot meddelanden från en kö, eller för att ha bra kontroll över meddelandeegenskaper när du skickar ett meddelande till en kö.

MessageQueue använder klassen när den Message granskar eller tar emot meddelanden från köer, eftersom både MessageQueue.Peek metoderna och MessageQueue.Receive skapar en ny instans av Message klassen och anger instansens egenskaper. Klassens Message skrivskyddade egenskaper gäller för att hämta meddelanden från en kö, medan läs-/skrivegenskaperna gäller för att skicka och hämta meddelanden. När MessageQueue du tittar på eller tar emot ett meddelande från en kö avgör dess MessageReadPropertyFilter egenskap vilka av meddelandets egenskaper som hämtas.

Med MessageQueue klassens Send metod kan du ange vilken objekttyp som helst för ett meddelande som skickas till kön. Du kan använda instansens MessageQueue egenskap för att ange inställningar för allmänna meddelanden som skickas DefaultPropertiesToSend till kön. Inställningarna omfattar formatering, etikett, kryptering och autentisering. Du kan också ange värden för lämpliga DefaultPropertiesToSend medlemmar när du samordnar meddelandeprogrammet för att svara på bekräftelse- och rapportmeddelanden. Om du använder en Message instans för att skicka ett meddelande till kön får du flexibiliteten att komma åt och ändra många av dessa egenskaper – antingen för ett enda meddelande eller på meddelande-för-meddelande-basis. Message egenskaper har företräde framför DefaultPropertiesToSend.

Meddelandedata lagras i egenskapen Body och i mindre utsträckning egenskaperna AppSpecific och Extension . När meddelandedata krypteras, serialiseras eller deserialiseras påverkas endast innehållet i Body egenskapen.

Innehållet i Body egenskapen serialiseras när meddelandet skickas med den Formatter egenskap som du anger. Det serialiserade innehållet finns i egenskapen BodyStream . Du kan också ange egenskapen BodyStream direkt, till exempel för att skicka en fil som datainnehåll i ett meddelande. Du kan ändra Body egenskaperna eller Formatter när som helst innan du skickar meddelandet, och data serialiseras korrekt när du anropar Send.

Egenskaperna som definieras av MessageQueue.DefaultPropertiesToSend egenskapen gäller endast för meddelanden som inte är av typen Message. Om du anger DefaultPropertiesToSend egenskapen för en MessageQueuegör de identiskt namngivna egenskaperna i en Message instans som skickas till kön att standardegenskaperna ignoreras.

En lista över initiala egenskapsvärden för en instans av Messagefinns i Message konstruktorn.

Konstruktorer

Name	Description
Message()	Initierar en ny instans av Message klassen med en tom brödtext.
Message(Object, IMessageFormatter)	Initierar en ny instans av Message klassen med den angivna formateringen för att serialisera det angivna objektet i meddelandets brödtext.
Message(Object)	Initierar en ny instans av klassen med hjälp XmlMessageFormatter av Message för att serialisera det angivna objektet i meddelandets brödtext.

Fält

Name	Description
InfiniteTimeout	Anger att det inte finns någon tidsgräns.

Egenskaper

Name	Description
AcknowledgeType	Hämtar eller anger vilken typ av bekräftelsemeddelande som ska returneras till det sändande programmet.
Acknowledgment	Hämtar klassificeringen av bekräftelse som det här meddelandet representerar.
AdministrationQueue	Hämtar eller ställer in kön som tar emot bekräftelsemeddelandena som Message Queuing genererar.
AppSpecific	Hämtar eller anger ytterligare programspecifik information.
ArrivedTime	Hämtar den tid då meddelandet kom till målkön.
AttachSenderId	Hämtar eller anger ett värde som anger om avsändar-ID:t ska kopplas till meddelandet.
Authenticated	Hämtar ett värde som anger om meddelandet autentiserades.
AuthenticationProviderName	Hämtar eller anger namnet på den kryptografiska provider som används för att generera meddelandets digitala signatur.
AuthenticationProviderType	Hämtar eller anger vilken typ av kryptografiprovider som används för att generera meddelandets digitala signatur.
Body	Hämtar eller anger innehållet i meddelandet.
BodyStream	Hämtar eller anger informationen i meddelandets brödtext.
BodyType	Hämtar eller anger den typ av data som meddelandetexten innehåller.
CanRaiseEvents	Hämtar ett värde som anger om komponenten kan generera en händelse. (Ärvd från Component)
ConnectorType	Hämtar eller anger ett värde som anger att vissa meddelandeegenskaper som vanligtvis anges av Message Queuing har angetts av det sändande programmet.
Container	Hämtar som IContainer innehåller Component. (Ärvd från Component)
CorrelationId	Hämtar eller anger den meddelandeidentifierare som används av bekräftelse-, rapport- och svarsmeddelanden för att referera till det ursprungliga meddelandet.
DesignMode	Hämtar ett värde som anger om det Component för närvarande är i designläge. (Ärvd från Component)
DestinationQueue	Hämtar den avsedda målkön för ett meddelande.
DestinationSymmetricKey	Hämtar eller anger den symmetriska nyckel som används för att kryptera programkrypterade meddelanden eller meddelanden som skickas till utländska köer.
DigitalSignature	Hämtar eller anger den digitala signatur som Message Queuing använder för att autentisera meddelandet.
EncryptionAlgorithm	Hämtar eller anger krypteringsalgoritmen som används för att kryptera brödtexten i ett privat meddelande.
Events	Hämtar listan över händelsehanterare som är kopplade till den här Component. (Ärvd från Component)
Extension	Hämtar eller anger ytterligare programdefinierad information som är associerad med meddelandet.
Formatter	Hämtar eller anger den formatering som används för att serialisera ett objekt till eller deserialisera ett objekt från meddelandetexten.
HashAlgorithm	Hämtar eller anger den hash-algoritm som Message Queuing använder när du autentiserar ett meddelande eller skapar en digital signatur för ett meddelande.
Id	Hämtar meddelandets identifierare.
IsFirstInTransaction	Hämtar ett värde som anger om meddelandet var det första meddelandet som skickades i en transaktion.
IsLastInTransaction	Hämtar ett värde som anger om meddelandet var det senaste meddelandet som skickades i en transaktion.
Label	Hämtar eller anger en programdefinierad Unicode-sträng som beskriver meddelandet.
LookupId	Introducerades i MSMQ 3.0. Hämtar meddelandets uppslagsidentifierare.
MessageType	Hämtar meddelandetypen: `Normal`, `Acknowledgment`eller `Report`.
Priority	Hämtar eller anger meddelandeprioritet, vilket avgör var i kön meddelandet placeras.
Recoverable	Hämtar eller anger ett värde som anger om meddelandet garanterat levereras i händelse av ett datorfel eller nätverksproblem.
ResponseQueue	Hämtar eller ställer in kön som tar emot programgenererade svarsmeddelanden.
SecurityContext	Hämtar eller anger säkerhetskontexten för ett meddelande.
SenderCertificate	Hämtar eller anger det säkerhetscertifikat som används för att autentisera meddelanden.
SenderId	Hämtar identifieraren för den sändande användaren.
SenderVersion	Hämtar den version av Message Queuing som används för att skicka meddelandet.
SentTime	Hämtar datum och tid på den avsändardator som meddelandet skickades av källköhanteraren.
Site	Hämtar eller ställer in ISite i Component. (Ärvd från Component)
SourceMachine	Hämtar den dator som meddelandet kommer från.
TimeToBeReceived	Hämtar eller anger den maximala tiden för meddelandet som ska tas emot från målkön.
TimeToReachQueue	Hämtar eller anger den maximala tiden för meddelandet att nå kön.
TransactionId	Hämtar identifieraren för transaktionen som meddelandet var en del av.
TransactionStatusQueue	Hämtar transaktionsstatuskön på källdatorn.
UseAuthentication	Hämtar eller anger ett värde som anger om meddelandet autentiserades (eller måste) autentiseras innan det skickades.
UseDeadLetterQueue	Hämtar eller anger ett värde som anger om en kopia av meddelandet som inte kunde levereras ska skickas till en kö med obeställbara meddelanden.
UseEncryption	Hämtar eller anger ett värde som anger om meddelandet ska vara privat.
UseJournalQueue	Hämtar eller anger ett värde som anger om en kopia av meddelandet ska sparas i en datorjournal på den ursprungliga datorn.
UseTracing	Hämtar eller anger ett värde som anger om ett meddelande ska spåras när det rör sig mot målkön.

Metoder

Name	Description
CreateObjRef(Type)	Skapar ett objekt som innehåller all relevant information som krävs för att generera en proxy som används för att kommunicera med ett fjärrobjekt. (Ärvd från MarshalByRefObject)
Dispose()	Släpper alla resurser som används av Component. (Ärvd från Component)
Dispose(Boolean)	Släpper de ohanterade resurser som används av Component och släpper eventuellt de hanterade resurserna. (Ärvd från Component)
Equals(Object)	Avgör om det angivna objektet är lika med det aktuella objektet. (Ärvd från Object)
GetHashCode()	Fungerar som standard-hash-funktion. (Ärvd från Object)
GetLifetimeService()	Hämtar det aktuella livslängdstjänstobjektet som styr livslängdsprincipen för den här instansen. (Ärvd från MarshalByRefObject)
GetService(Type)	Returnerar ett objekt som representerar en tjänst som tillhandahålls av Component eller av dess Container. (Ärvd från Component)
GetType()	Hämtar den aktuella instansen Type . (Ärvd från Object)
InitializeLifetimeService()	Hämtar ett tjänstobjekt för livslängd för att styra livslängdsprincipen för den här instansen. (Ärvd från MarshalByRefObject)
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
MemberwiseClone(Boolean)	Skapar en ytlig kopia av det aktuella MarshalByRefObject objektet. (Ärvd från MarshalByRefObject)
ToString()	Returnerar ett String som innehåller namnet på Component, om det finns. Den här metoden bör inte åsidosättas. (Ärvd från Component)

Händelser

Name	Description
Disposed	Inträffar när komponenten tas bort av ett anrop till Dispose() metoden. (Ärvd från Component)

Gäller för

Se även

Feedback

Var den här sidan till hjälp?