/// Similar to ReceiveSomePackets() except it keeps reading packets until conut packets are processed or an error occurs. It does not return when live read timeouts occur.
/// Similar to ReceiveSomePackets() except it keeps reading packets until conut packets are processed or an error occurs. It does not return when live read timeouts occur.
/// <seealso cref="ReceivePacket"/>
/// <seealso cref="ReceivePacket"/>
/// <seealso cref="ReceiveSomePackets"/>
/// <seealso cref="ReceiveSomePackets"/>
/// <seealso cref="Break"/>
/// </summary>
/// </summary>
/// <param name="count">Number of packets to process. A negative count causes ReceivePackets() to loop forever (or at least until an error occurs).</param>
/// <param name="count">Number of packets to process. A negative count causes ReceivePackets() to loop forever (or at least until an error occurs).</param>
/// <param name="callback">Specifies a routine to be called with one argument: the packet received.</param>
/// <param name="callback">Specifies a routine to be called with one argument: the packet received.</param>
/// Collect a group of statistics every readTimeout given in LivePacketDevice.Open().
/// Collect a group of statistics every readTimeout given in LivePacketDevice.Open().
/// <seealso cref="Break"/>
/// </summary>
/// </summary>
/// <param name="count">Number of statistics to process. A negative count causes ReceiveStatistics() to loop forever (or at least until an error occurs).</param>
/// <param name="count">Number of statistics to process. A negative count causes ReceiveStatistics() to loop forever (or at least until an error occurs).</param>
/// <param name="callback">Specifies a routine to be called with one argument: the statistics received.</param>
/// <param name="callback">Specifies a routine to be called with one argument: the statistics received.</param>
/// <item>This routine is safe to use inside a signal handler on UNIX or a console control handler on Windows, as it merely sets a flag that is checked within the loop.</item>
/// <item>The flag is checked in loops reading packets from the OS - a signal by itself will not necessarily terminate those loops - as well as in loops processing a set of packets/statistics returned by the OS.</item>
/// <item>Note that if you are catching signals on UNIX systems that support restarting system calls after a signal, and calling Break() in the signal handler, you must specify, when catching those signals, that system calls should NOT be restarted by that signal. Otherwise, if the signal interrupted a call reading packets in a live capture, when your signal handler returns after calling Break(), the call will be restarted, and the loop will not terminate until more packets arrive and the call completes.</item>
/// <item>ReceivePacket() will, on some platforms, loop reading packets from the OS; that loop will not necessarily be terminated by a signal, so Break() should be used to terminate packet processing even if ReceivePacket() is being used.</item>
/// <item>Break() does not guarantee that no further packets/statistics will be processed by ReceiveSomePackets(), ReceivePackets() or ReceiveStatistics() after it is called; at most one more packet might be processed.</item>
/// <item>If BreakLoop is returned from ReceiveSomePackets(), ReceivePackets() or ReceiveStatistics(), the flag is cleared, so a subsequent call will resume reading packets. If a different return value is returned, the flag is not cleared, so a subsequent call will return BreakLoop and clear the flag.</item>
/// </list>
/// </remarks>
voidBreak();
voidBreak();
/// <summary>
/// Send a raw packet.
/// This function allows to send a raw packet to the network.
/// <seealso cref="Transmit"/>
/// </summary>
/// <param name="packet">The packet to send (including the various protocol headers). The MAC CRC doesn't need to be included, because it is transparently calculated and added by the network interface driver.</param>
/// This function transmits the content of a queue to the wire.
/// <seealso cref="SendPacket"/>
/// <seealso cref="PacketSendBuffer"/>
/// </summary>
/// <param name="sendBuffer">Contains the packets to send.</param>
/// <param name="isSync">Determines if the send operation must be synchronized: if it is true, the packets are sent respecting the timestamps, otherwise they are sent as fast as possible.</param>
/// <exception cref="System::InvalidOperationException">An error occurred during the send. The error can be caused by a driver/adapter problem or by an inconsistent/bogus send buffer..</exception>
/// <remarks>
/// <list type="bullet">
/// <item>Using this function is more efficient than issuing a series of SendPacket(), because the packets are buffered in the kernel driver, so the number of context switches is reduced. Therefore, expect a better throughput when using Transmit().</item>
/// <item>When isSync is true, the packets are synchronized in the kernel with a high precision timestamp. This requires a non-negligible amount of CPU, but allows normally to send the packets with a precision of some microseconds (depending on the accuracy of the performance counter of the machine). Such a precision cannot be reached sending the packets with SendPacket().</item>