Condividi tramite

SerialPort Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.IO.Ports
Assembly:
System.IO.Ports.dll
Assembly:
System.dll
Pacchetto:
System.IO.Ports v6.0.0
Pacchetto:
System.IO.Ports v7.0.0
Pacchetto:
System.IO.Ports v8.0.0
Pacchetto:
System.IO.Ports v9.0.0-preview.2.24128.5
Origine:
SerialPort.cs
Origine:
SerialPort.cs
Origine:
SerialPort.cs

Rappresenta una risorsa di porta seriale.

public ref class SerialPort : System::ComponentModel::Component
public class SerialPort : System.ComponentModel.Component
type SerialPort = class
    inherit Component
Public Class SerialPort
Inherits Component
Ereditarietà
Object
MarshalByRefObject
Component
SerialPort

Esempio

Nell'esempio di codice seguente viene illustrato l'uso della SerialPort classe per consentire a due utenti di chattare da due computer separati connessi da un cavo modem Null. In questo esempio, agli utenti vengono richieste le impostazioni della porta e un nome utente prima della chat. Entrambi i computer devono eseguire il programma per ottenere tutte le funzionalità di questo esempio.

#using <System.dll>

using namespace System;
using namespace System::IO::Ports;
using namespace System::Threading;

public ref class PortChat
{
private:
    static bool _continue;
    static SerialPort^ _serialPort;

public:
    static void Main()
    {
        String^ name;
        String^ message;
        StringComparer^ stringComparer = StringComparer::OrdinalIgnoreCase;
        Thread^ readThread = gcnew Thread(gcnew ThreadStart(PortChat::Read));

        // Create a new SerialPort object with default settings.
        _serialPort = gcnew SerialPort();

        // Allow the user to set the appropriate properties.
        _serialPort->PortName = SetPortName(_serialPort->PortName);
        _serialPort->BaudRate = SetPortBaudRate(_serialPort->BaudRate);
        _serialPort->Parity = SetPortParity(_serialPort->Parity);
        _serialPort->DataBits = SetPortDataBits(_serialPort->DataBits);
        _serialPort->StopBits = SetPortStopBits(_serialPort->StopBits);
        _serialPort->Handshake = SetPortHandshake(_serialPort->Handshake);

        // Set the read/write timeouts
        _serialPort->ReadTimeout = 500;
        _serialPort->WriteTimeout = 500;

        _serialPort->Open();
        _continue = true;
        readThread->Start();

        Console::Write("Name: ");
        name = Console::ReadLine();

        Console::WriteLine("Type QUIT to exit");

        while (_continue)
        {
            message = Console::ReadLine();

            if (stringComparer->Equals("quit", message))
            {
                _continue = false;
            }
            else
            {
                _serialPort->WriteLine(
                    String::Format("<{0}>: {1}", name, message) );
            }
        }

        readThread->Join();
        _serialPort->Close();
    }

    static void Read()
    {
        while (_continue)
        {
            try
            {
                String^ message = _serialPort->ReadLine();
                Console::WriteLine(message);
            }
            catch (TimeoutException ^) { }
        }
    }

    static String^ SetPortName(String^ defaultPortName)
    {
        String^ portName;

        Console::WriteLine("Available Ports:");
        for each (String^ s in SerialPort::GetPortNames())
        {
            Console::WriteLine("   {0}", s);
        }

        Console::Write("Enter COM port value (Default: {0}): ", defaultPortName);
        portName = Console::ReadLine();

        if (portName == "")
        {
            portName = defaultPortName;
        }
        return portName;
    }

    static Int32 SetPortBaudRate(Int32 defaultPortBaudRate)
    {
        String^ baudRate;

        Console::Write("Baud Rate(default:{0}): ", defaultPortBaudRate);
        baudRate = Console::ReadLine();

        if (baudRate == "")
        {
            baudRate = defaultPortBaudRate.ToString();
        }

        return Int32::Parse(baudRate);
    }

    static Parity SetPortParity(Parity defaultPortParity)
    {
        String^ parity;

        Console::WriteLine("Available Parity options:");
        for each (String^ s in Enum::GetNames(Parity::typeid))
        {
            Console::WriteLine("   {0}", s);
        }
        
        Console::Write("Enter Parity value (Default: {0}):", defaultPortParity.ToString());
        parity = Console::ReadLine();

        if (parity == "")
        {
            parity = defaultPortParity.ToString();
        }

        return (Parity)Enum::Parse(Parity::typeid, parity);
    }

    static Int32 SetPortDataBits(Int32 defaultPortDataBits)
    {
        String^ dataBits;

        Console::Write("Enter DataBits value (Default: {0}): ", defaultPortDataBits);
        dataBits = Console::ReadLine();

        if (dataBits == "")
        {
            dataBits = defaultPortDataBits.ToString();
        }

        return Int32::Parse(dataBits);
    }

    static StopBits SetPortStopBits(StopBits defaultPortStopBits)
    {
        String^ stopBits;

        Console::WriteLine("Available Stop Bits options:");
        for each (String^ s in Enum::GetNames(StopBits::typeid))
        {
            Console::WriteLine("   {0}", s);
        }

        Console::Write("Enter StopBits value (None is not supported and \n" +
            "raises an ArgumentOutOfRangeException. \n (Default: {0}):", defaultPortStopBits.ToString());
        stopBits = Console::ReadLine();

        if (stopBits == "")
        {
            stopBits = defaultPortStopBits.ToString();
        }

        return (StopBits)Enum::Parse(StopBits::typeid, stopBits);
    }

    static Handshake SetPortHandshake(Handshake defaultPortHandshake)
    {
        String^ handshake;

        Console::WriteLine("Available Handshake options:");
        for each (String^ s in Enum::GetNames(Handshake::typeid))
        {
            Console::WriteLine("   {0}", s);
        }

        Console::Write("Enter Handshake value (Default: {0}):", defaultPortHandshake.ToString());
        handshake = Console::ReadLine();

        if (handshake == "")
        {
            handshake = defaultPortHandshake.ToString();
        }

        return (Handshake)Enum::Parse(Handshake::typeid, handshake);
    }
};

int main()
{
    PortChat::Main();
}

// Use this code inside a project created with the Visual C# > Windows Desktop > Console Application template.
// Replace the code in Program.cs with this code.

using System;
using System.IO.Ports;
using System.Threading;

public class PortChat
{
    static bool _continue;
    static SerialPort _serialPort;

    public static void Main()
    {
        string name;
        string message;
        StringComparer stringComparer = StringComparer.OrdinalIgnoreCase;
        Thread readThread = new Thread(Read);

        // Create a new SerialPort object with default settings.
        _serialPort = new SerialPort();

        // Allow the user to set the appropriate properties.
        _serialPort.PortName = SetPortName(_serialPort.PortName);
        _serialPort.BaudRate = SetPortBaudRate(_serialPort.BaudRate);
        _serialPort.Parity = SetPortParity(_serialPort.Parity);
        _serialPort.DataBits = SetPortDataBits(_serialPort.DataBits);
        _serialPort.StopBits = SetPortStopBits(_serialPort.StopBits);
        _serialPort.Handshake = SetPortHandshake(_serialPort.Handshake);

        // Set the read/write timeouts
        _serialPort.ReadTimeout = 500;
        _serialPort.WriteTimeout = 500;

        _serialPort.Open();
        _continue = true;
        readThread.Start();

        Console.Write("Name: ");
        name = Console.ReadLine();

        Console.WriteLine("Type QUIT to exit");

        while (_continue)
        {
            message = Console.ReadLine();

            if (stringComparer.Equals("quit", message))
            {
                _continue = false;
            }
            else
            {
                _serialPort.WriteLine(
                    String.Format("<{0}>: {1}", name, message));
            }
        }

        readThread.Join();
        _serialPort.Close();
    }

    public static void Read()
    {
        while (_continue)
        {
            try
            {
                string message = _serialPort.ReadLine();
                Console.WriteLine(message);
            }
            catch (TimeoutException) { }
        }
    }

    // Display Port values and prompt user to enter a port.
    public static string SetPortName(string defaultPortName)
    {
        string portName;

        Console.WriteLine("Available Ports:");
        foreach (string s in SerialPort.GetPortNames())
        {
            Console.WriteLine("   {0}", s);
        }

        Console.Write("Enter COM port value (Default: {0}): ", defaultPortName);
        portName = Console.ReadLine();

        if (portName == "" || !(portName.ToLower()).StartsWith("com"))
        {
            portName = defaultPortName;
        }
        return portName;
    }
    // Display BaudRate values and prompt user to enter a value.
    public static int SetPortBaudRate(int defaultPortBaudRate)
    {
        string baudRate;

        Console.Write("Baud Rate(default:{0}): ", defaultPortBaudRate);
        baudRate = Console.ReadLine();

        if (baudRate == "")
        {
            baudRate = defaultPortBaudRate.ToString();
        }

        return int.Parse(baudRate);
    }

    // Display PortParity values and prompt user to enter a value.
    public static Parity SetPortParity(Parity defaultPortParity)
    {
        string parity;

        Console.WriteLine("Available Parity options:");
        foreach (string s in Enum.GetNames(typeof(Parity)))
        {
            Console.WriteLine("   {0}", s);
        }

        Console.Write("Enter Parity value (Default: {0}):", defaultPortParity.ToString(), true);
        parity = Console.ReadLine();

        if (parity == "")
        {
            parity = defaultPortParity.ToString();
        }

        return (Parity)Enum.Parse(typeof(Parity), parity, true);
    }
    // Display DataBits values and prompt user to enter a value.
    public static int SetPortDataBits(int defaultPortDataBits)
    {
        string dataBits;

        Console.Write("Enter DataBits value (Default: {0}): ", defaultPortDataBits);
        dataBits = Console.ReadLine();

        if (dataBits == "")
        {
            dataBits = defaultPortDataBits.ToString();
        }

        return int.Parse(dataBits.ToUpperInvariant());
    }

    // Display StopBits values and prompt user to enter a value.
    public static StopBits SetPortStopBits(StopBits defaultPortStopBits)
    {
        string stopBits;

        Console.WriteLine("Available StopBits options:");
        foreach (string s in Enum.GetNames(typeof(StopBits)))
        {
            Console.WriteLine("   {0}", s);
        }

        Console.Write("Enter StopBits value (None is not supported and \n" +
         "raises an ArgumentOutOfRangeException. \n (Default: {0}):", defaultPortStopBits.ToString());
        stopBits = Console.ReadLine();

        if (stopBits == "" )
        {
            stopBits = defaultPortStopBits.ToString();
        }

        return (StopBits)Enum.Parse(typeof(StopBits), stopBits, true);
    }
    public static Handshake SetPortHandshake(Handshake defaultPortHandshake)
    {
        string handshake;

        Console.WriteLine("Available Handshake options:");
        foreach (string s in Enum.GetNames(typeof(Handshake)))
        {
            Console.WriteLine("   {0}", s);
        }

        Console.Write("Enter Handshake value (Default: {0}):", defaultPortHandshake.ToString());
        handshake = Console.ReadLine();

        if (handshake == "")
        {
            handshake = defaultPortHandshake.ToString();
        }

        return (Handshake)Enum.Parse(typeof(Handshake), handshake, true);
    }
}

' Use this code inside a project created with the Visual Basic > Windows Desktop > Console Application template.
' Replace the default code in Module1.vb with this code. Then right click the project in Solution Explorer,
' select Properties, and set the Startup Object to PortChat.

Imports System.IO.Ports
Imports System.Threading

Public Class PortChat
    Shared _continue As Boolean
    Shared _serialPort As SerialPort

    Public Shared Sub Main()
        Dim name As String
        Dim message As String
        Dim stringComparer__1 As StringComparer = StringComparer.OrdinalIgnoreCase
        Dim readThread As New Thread(AddressOf Read)

        ' Create a new SerialPort object with default settings.
        _serialPort = New SerialPort()

        ' Allow the user to set the appropriate properties.
        _serialPort.PortName = SetPortName(_serialPort.PortName)
        _serialPort.BaudRate = SetPortBaudRate(_serialPort.BaudRate)
        _serialPort.Parity = SetPortParity(_serialPort.Parity)
        _serialPort.DataBits = SetPortDataBits(_serialPort.DataBits)
        _serialPort.StopBits = SetPortStopBits(_serialPort.StopBits)
        _serialPort.Handshake = SetPortHandshake(_serialPort.Handshake)

        ' Set the read/write timeouts
        _serialPort.ReadTimeout = 500
        _serialPort.WriteTimeout = 500

        _serialPort.Open()
        _continue = True
        readThread.Start()

        Console.Write("Name: ")
        name = Console.ReadLine()

        Console.WriteLine("Type QUIT to exit")

        While _continue
            message = Console.ReadLine()

            If stringComparer__1.Equals("quit", message) Then
                _continue = False
            Else
                _serialPort.WriteLine([String].Format("<{0}>: {1}", name, message))
            End If
        End While

        readThread.Join()
        _serialPort.Close()
    End Sub

    Public Shared Sub Read()
        While _continue
            Try
                Dim message As String = _serialPort.ReadLine()
                Console.WriteLine(message)
            Catch generatedExceptionName As TimeoutException
            End Try
        End While
    End Sub

    ' Display Port values and prompt user to enter a port.
    Public Shared Function SetPortName(defaultPortName As String) As String
        Dim portName As String

        Console.WriteLine("Available Ports:")
        For Each s As String In SerialPort.GetPortNames()
            Console.WriteLine("   {0}", s)
        Next

        Console.Write("Enter COM port value (Default: {0}): ", defaultPortName)
        portName = Console.ReadLine()

        If portName = "" OrElse Not (portName.ToLower()).StartsWith("com") Then
            portName = defaultPortName
        End If
        Return portName
    End Function
    ' Display BaudRate values and prompt user to enter a value.
    Public Shared Function SetPortBaudRate(defaultPortBaudRate As Integer) As Integer
        Dim baudRate As String

        Console.Write("Baud Rate(default:{0}): ", defaultPortBaudRate)
        baudRate = Console.ReadLine()

        If baudRate = "" Then
            baudRate = defaultPortBaudRate.ToString()
        End If

        Return Integer.Parse(baudRate)
    End Function

    ' Display PortParity values and prompt user to enter a value.
    Public Shared Function SetPortParity(defaultPortParity As Parity) As Parity
        Dim parity As String

        Console.WriteLine("Available Parity options:")
        For Each s As String In [Enum].GetNames(GetType(Parity))
            Console.WriteLine("   {0}", s)
        Next

        Console.Write("Enter Parity value (Default: {0}):", defaultPortParity.ToString(), True)
        parity = Console.ReadLine()

        If parity = "" Then
            parity = defaultPortParity.ToString()
        End If

        Return CType([Enum].Parse(GetType(Parity), parity, True), Parity)
    End Function
    ' Display DataBits values and prompt user to enter a value.
    Public Shared Function SetPortDataBits(defaultPortDataBits As Integer) As Integer
        Dim dataBits As String

        Console.Write("Enter DataBits value (Default: {0}): ", defaultPortDataBits)
        dataBits = Console.ReadLine()

        If dataBits = "" Then
            dataBits = defaultPortDataBits.ToString()
        End If

        Return Integer.Parse(dataBits.ToUpperInvariant())
    End Function
    ' Display StopBits values and prompt user to enter a value.

    Public Shared Function SetPortStopBits(defaultPortStopBits As StopBits) As StopBits
        Dim stopBits As String

        Console.WriteLine("Available StopBits options:")
        For Each s As String In [Enum].GetNames(GetType(StopBits))
            Console.WriteLine("   {0}", s)
        Next

        Console.Write("Enter StopBits value (None is not supported and " &
                      vbLf & "raises an ArgumentOutOfRangeException. " &
                      vbLf & " (Default: {0}):", defaultPortStopBits.ToString())
        stopBits = Console.ReadLine()

        If stopBits = "" Then
            stopBits = defaultPortStopBits.ToString()
        End If

        Return CType([Enum].Parse(GetType(StopBits), stopBits, True), StopBits)
    End Function
    Public Shared Function SetPortHandshake(defaultPortHandshake As Handshake) As Handshake
        Dim handshake As String

        Console.WriteLine("Available Handshake options:")
        For Each s As String In [Enum].GetNames(GetType(Handshake))
            Console.WriteLine("   {0}", s)
        Next

        Console.Write("Enter Handshake value (Default: {0}):", defaultPortHandshake.ToString())
        handshake = Console.ReadLine()

        If handshake = "" Then
            handshake = defaultPortHandshake.ToString()
        End If

        Return CType([Enum].Parse(GetType(Handshake), handshake, True), Handshake)
    End Function
End Class

Commenti

Usare questa classe per controllare una risorsa file di porta seriale. Questa classe fornisce le I/O sincrone e guidate dagli eventi, l'accesso agli stati di aggiunta e interruzione e l'accesso alle proprietà del driver seriale. Inoltre, la funzionalità di questa classe può essere sottoposta a wrapping in un oggetto interno Stream , accessibile tramite la BaseStream proprietà e passata alle classi che esezionare o usare flussi.

La SerialPort classe supporta le codifiche seguenti: ASCIIEncoding, UTF8Encoding, UnicodeEncoding, UTF32Encodinge qualsiasi codifica definita in mscorlib.dll in cui la tabella codici è minore di 50000 o la tabella codici è 54936. È possibile usare codifiche alternative, ma è necessario usare il ReadByte metodo o Write ed eseguire manualmente la codifica.

Utilizzare il GetPortNames metodo per recuperare le porte valide per il computer corrente.

Se un SerialPort oggetto viene bloccato durante un'operazione di lettura, non interrompere il thread. Chiudere invece il flusso di base o eliminare l'oggetto SerialPort .

Costruttori

SerialPort()

Inizializza una nuova istanza della classe SerialPort.
SerialPort(IContainer)

Inizializza una nuova istanza della classe SerialPort usando l'oggetto IContainer specificato.
SerialPort(String)

Inizializza una nuova istanza della classe SerialPort usando il nome della porta specificato.
SerialPort(String, Int32)

Inizializza una nuova istanza della classe SerialPort usando il nome della porta e la velocità in baud specificati.
SerialPort(String, Int32, Parity)

Inizializza una nuova istanza della classe SerialPort usando il nome della porta, la velocità in baud e il bit di parità specificati.
SerialPort(String, Int32, Parity, Int32)

Inizializza una nuova istanza della classe SerialPort usando il nome della porta, la velocità in baud, il bit di parità e i bit di dati specificati.
SerialPort(String, Int32, Parity, Int32, StopBits)

Inizializza una nuova istanza della classe SerialPort usando il nome della porta, la velocità in baud, il bit di parità, i bit di dati e il bit di stop specificati.

Campi

InfiniteTimeout

Indica che non deve verificarsi alcun timeout.

Proprietà

BaseStream

Ottiene l'oggetto Stream sottostante per un oggetto SerialPort.
BaudRate

Ottiene o imposta la velocità in baud della porta seriale.
BreakState

Ottiene o imposta lo stato del segnale di interruzione.
BytesToRead

Ottiene il numero di byte di dati nel buffer di ricezione.
BytesToWrite

Ottiene il numero di byte di dati nel buffer di invio.
CanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.

(Ereditato da Component)
CDHolding

Ottiene lo stato della linea di rilevamento portante (CD, Carrier Detect).
Container

Ottiene l'oggetto IContainer che contiene Component.

(Ereditato da Component)
CtsHolding

Ottiene lo stato della linea CTS (Clear-to-Send).
DataBits

Ottiene o imposta la lunghezza standard dei bit di dati per byte.
DesignMode

Ottiene un valore che indica se il Component si trova in modalità progettazione.

(Ereditato da Component)
DiscardNull

Ottiene o imposta un valore che indica se i byte null vengono ignorati quando vengono trasmessi tra la porta e il buffer di ricezione.
DsrHolding

Ottiene lo stato del segnale DSR (Data Set Ready).
DtrEnable

Ottiene o imposta un valore che abilita il segnale DTR (Data Terminal Ready) durante una comunicazione seriale.
Encoding

Ottiene o imposta la codifica dei byte per la conversione del testo prima e dopo la trasmissione.
Events

Ottiene l'elenco dei gestori eventi allegati a questo Component.

(Ereditato da Component)
Handshake

Ottiene o imposta il protocollo di sincronizzazione per la trasmissione dei dati tramite la porta seriale usando un valore di Handshake.
IsOpen

Ottiene un valore che indica lo stato aperto o chiuso dell'oggetto SerialPort.
NewLine

Ottiene o imposta il valore usato per interpretare la fine di una chiamata ai metodi ReadLine() e WriteLine(String).
Parity

Ottiene o imposta il protocollo di controllo della parità.
ParityReplace

Ottiene o imposta il byte che sostituisce i byte non validi in un flusso di dati quando si verifica un errore di parità.
PortName

Ottiene o imposta la porta per le comunicazioni, incluse, ma non solo, tutte le porte COM disponibili.
ReadBufferSize

Ottiene o imposta la dimensione del buffer di input SerialPort.
ReadTimeout

Ottiene o imposta il numero di millisecondi prima del timeout quando un'operazione di lettura non viene completata.
ReceivedBytesThreshold

Ottiene o imposta il numero di byte nel buffer di input interno prima che si verifichi un evento DataReceived.
RtsEnable

Ottiene o imposta un valore che indica se il segnale RTS (Request to Send) è abilitato durante la comunicazione seriale.
Site

Ottiene o imposta l'oggetto ISite di Component.

(Ereditato da Component)
StopBits

Ottiene o imposta il numero standard dei bit di stop per byte.
WriteBufferSize

Ottiene o imposta la dimensione del buffer di output della porta seriale.
WriteTimeout

Ottiene o imposta il numero di millisecondi prima del timeout quando un'operazione di scrittura non viene completata.

Metodi

Close()

Chiude la connessione alla porta, imposta la proprietà IsOpen su false ed elimina l'oggetto interno Stream.
CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.

(Ereditato da MarshalByRefObject)
DiscardInBuffer()

Elimina i dati dal buffer di ricezione del driver seriale.
DiscardOutBuffer()

Elimina i dati dal buffer di trasmissione del driver seriale.
Dispose()

Rilascia tutte le risorse usate da Component.

(Ereditato da Component)
Dispose(Boolean)

Rilascia le risorse non gestite usate da SerialPort e, facoltativamente, le risorse gestite.
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetLifetimeService()
Obsoleti.

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.

(Ereditato da MarshalByRefObject)
GetPortNames()

Ottiene una matrice di nomi di porta seriale per il computer corrente.
GetService(Type)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.

(Ereditato da Component)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
InitializeLifetimeService()
Obsoleti.

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.

(Ereditato da MarshalByRefObject)
Open()

Apre una nuova connessione su porta seriale.
Read(Byte[], Int32, Int32)

Legge un numero di byte dal buffer di input SerialPort e li scrive in una matrice di byte con l'offset specificato.
Read(Char[], Int32, Int32)

Legge un numero di caratteri dal buffer di input SerialPort e li scrive in una matrice di caratteri in corrispondenza di un offset specificato.
ReadByte()

Legge in modo sincrono un byte dal buffer di input SerialPort.
ReadChar()

Legge in modo sincrono un carattere dal buffer di input SerialPort.
ReadExisting()

Legge tutti i byte disponibili immediatamente, in base alla codifica, sia nel flusso che nel buffer di input dell'oggetto SerialPort.
ReadLine()

Legge fino al valore di NewLine nel buffer di input.
ReadTo(String)

Legge una stringa fino al parametro value specificato nel buffer di input.
ToString()

Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override.

(Ereditato da Component)
Write(Byte[], Int32, Int32)

Scrive sulla porta un numero specificato di byte sulla porta seriale usando i dati di un buffer.
Write(Char[], Int32, Int32)

Scrive sulla porta seriale un numero specificato di caratteri usando i dati di un buffer.
Write(String)

Scrive sulla porta seriale la stringa specificata.
WriteLine(String)

Scrive la stringa specificata e il valore di NewLine nel buffer di output.

Eventi

DataReceived

Indica che i dati sono stati ricevuti tramite una porta rappresentata dall'oggetto SerialPort.
Disposed

Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose().

(Ereditato da Component)
ErrorReceived

Indica che si è verificato un errore con una porta rappresentata dall'oggetto SerialPort.
PinChanged

Indica che si è verificato un evento segnale non di dati sulla porta rappresentata dall'oggetto SerialPort.

Si applica a