Class

# EasyUDPSocket

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

## Description

Supports communication via the UDP protocol using unicasting, multicasting, or broadcasting. It provides a simple wrapper around the `UDPSocket</api/networking/udpsocket>` class that makes easier for beginners to get started with UDP networking.

## Properties

<div class="rst-class">

table-centered_columns_3_and_4

</div>

| Name                                                 | Type                                                 | Read-Only | Shared |
|------------------------------------------------------|------------------------------------------------------|-----------|--------|
| `BroadcastAddress<easyudpsocket.broadcastaddress>`   | `String</api/data_types/string>`                     | ✓         |        |
| `Handle<easyudpsocket.handle>`                       | `Integer</api/data_types/integer>`                   | ✓         |        |
| `IsConnected<easyudpsocket.isconnected>`             | `Boolean</api/data_types/boolean>`                   | ✓         |        |
| `LocalAddress<easyudpsocket.localaddress>`           | `String</api/data_types/string>`                     | ✓         |        |
| `NetworkInterface<easyudpsocket.networkinterface>`   | `NetworkInterface</api/networking/networkinterface>` |           |        |
| `PacketsAvailable<easyudpsocket.packetsavailable>`   | `Integer</api/data_types/integer>`                   | ✓         |        |
| `PacketsLeftToSend<easyudpsocket.packetslefttosend>` | `Integer</api/data_types/integer>`                   | ✓         |        |
| `Port<easyudpsocket.port>`                           | `Integer</api/data_types/integer>`                   |           |        |
| `RouterHops<easyudpsocket.routerhops>`               | `Integer</api/data_types/integer>`                   |           |        |
| `SendToSelf<easyudpsocket.sendtoself>`               | `Boolean</api/data_types/boolean>`                   |           |        |

## Methods

<div class="rst-class">

table-centered_column_4

</div>

| Name                                                             | Parameters                                                                                                                                          | Returns                              | Shared |
|------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------|--------|
| `Bind<easyudpsocket.bind>`                                       | Port As `Integer</api/data_types/integer>`                                                                                                          |                                      |        |
| `Close<easyudpsocket.close>`                                     |                                                                                                                                                     |                                      |        |
| `Connect<easyudpsocket.connect>`                                 |                                                                                                                                                     |                                      |        |
| `JoinMulticastGroup<easyudpsocket.joinmulticastgroup>`           | Group As `String</api/data_types/string>`                                                                                                           | `Boolean</api/data_types/boolean>`   |        |
| `LeaveMulticastGroup<easyudpsocket.leavemulticastgroup>`         | Group As `String</api/data_types/string>`                                                                                                           |                                      |        |
| `Poll<easyudpsocket.poll>`                                       |                                                                                                                                                     |                                      |        |
| `Purge<easyudpsocket.purge>`                                     |                                                                                                                                                     |                                      |        |
| `Read<easyudpsocket.read>`                                       | enc As `TextEncoding</api/text/encoding_text/textencoding>` = `Nil</api/language/nil>`                                                              | `Datagram</api/networking/datagram>` |        |
| `Register<easyudpsocket.register>`                               | GroupName As `String</api/data_types/string>`                                                                                                       |                                      |        |
| `SendMessageToGroup<easyudpsocket.sendmessagetogroup>`           | GroupName As `String</api/data_types/string>`, Command As `Int32</api/data_types/additional_types/int32>`, Data As `String</api/data_types/string>` |                                      |        |
| `SendMessageToIndividual<easyudpsocket.sendmessagetoindividual>` | IPAddress As `String</api/data_types/string>`, Command As `Int32</api/data_types/additional_types/int32>`, Data As `String</api/data_types/string>` |                                      |        |
| `Unregister<easyudpsocket.unregister>`                           | GroupName As `String</api/data_types/string>`                                                                                                       |                                      |        |
| `WaitForMessage<easyudpsocket.waitformessage>`                   | command As `Int32</api/data_types/additional_types/int32>`, fromIP As `String</api/data_types/string>`                                              | `String</api/data_types/string>`     |        |
| `Write<easyudpsocket.write>`                                     | data As `Datagram</api/networking/datagram>`                                                                                                        |                                      |        |
|                                                                  | ip As `String</api/data_types/string>`, data As `String</api/data_types/string>`                                                                    |                                      |        |

## Events

<div class="rst-class">

table-centered_column_4

</div>

| Name                                             | Parameters                                                                                                                          | Returns |
|--------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------|---------|
| `DataAvailable<easyudpsocket.dataavailable>`     |                                                                                                                                     |         |
| `Error<easyudpsocket.error>`                     | e As `RuntimeException</api/exceptions/runtimeexception>`                                                                           |         |
| `ReceivedMessage<easyudpsocket.receivedmessage>` | FromIP As `String</api/data_types/string>`, Command As `Integer</api/data_types/integer>`, Data As `String</api/data_types/string>` |         |
| `SendComplete<easyudpsocket.sendcomplete>`       | UserAborted As `Boolean</api/data_types/boolean>`                                                                                   |         |

## Property descriptions

<div id="easyudpsocket.broadcastaddress">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.BroadcastAddress

**BroadcastAddress** As `String</api/data_types/string>`

> The machine's broadcast address.
>
> This property is read-only.
>
> You can specify this address when you call the `Write<udpsocket.write>` method and the data will be broadcast across the network, but you will not receive the data you sent back.
>
> This example uses the BroadcastAddress to get the address of the group.
>
> ``` xojo
> EasyUDPSocket1.Write(EasyUDPSocket1.BroadcastAddress, "Hello World")
> ```

<div id="easyudpsocket.handle">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Handle

**Handle** As `Integer</api/data_types/integer>`

> This is the socket's internal descriptor and it can be used with `Declare</api/language/declare>` statements.
>
> This property is read-only.
>
> - On Windows, Handle is a Socket, suitable for use in `Declares</api/language/declare>` on Windows.
> - On macOS and Linux, Handle is a UNIX socket descriptor.
>
> The descriptor is platform-specific. If *Handle* is less than zero, the descriptor is not available.

<div id="easyudpsocket.isconnected">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.IsConnected

**IsConnected** As `Boolean</api/data_types/boolean>`

> Indicates whether the socket is currently connected.
>
> This property is read-only.
>
> For `TCPSockets</api/networking/tcpsocket>`, a connection means you can send and receive data and are connected to a remote machine. For `UDPSockets</api/networking/udpsocket>`, this means that you are bound to the port and are able to send, receive, join or leave multicast groups, or set socket options.
>
> ``` xojo
> If EasyUDPSocket1.IsConnected Then
>   ' proceed using the connection
> Else
>   MessageBox("Connection failed!")
> End If
> ```

<div id="easyudpsocket.localaddress">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.LocalAddress

**LocalAddress** As `String</api/data_types/string>`

> The local IP address of the computer.
>
> This property is read-only.
>
> ``` xojo
> Var localIP As String = EasyUDPSocket1.LocalAddress
> ```

<div id="easyudpsocket.networkinterface">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.NetworkInterface

**NetworkInterface** As `NetworkInterface</api/networking/networkinterface>`

> Specifies which network interface the socket should use when binding.
>
> You can get the network interface(s) of the user's computer by calling the `GetNetworkInterface<system.networkinterface>` method of the `System</api/os/system>` module.
>
> Leaving this property set to `Nil</api/language/nil>` will use the currently selected interface. In the case of `UDPSockets</api/networking/udpsocket>`, if you assign a non-`Nil</api/language/nil>` value, the socket may not be able to receive broadcast messages. The behavior is OS-dependent; it appears to work on Windows but not on other supported operating systems. If you wish to send broadcast packets out, then you should not bind to a specific interface because the behavior is undefined.
>
> This example specifies that the <span class="title-ref">EasyUDPSocket</span> will use the first Network Interface on the user's computer.
>
> ``` xojo
> EasyUDPSocket1.NetworkInterface = System.NetworkInterface(0)
> ```

<div id="easyudpsocket.packetsavailable">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.PacketsAvailable

**PacketsAvailable** As `Integer</api/data_types/integer>`

> The number of packets available in the internal receive buffer.
>
> This property is read-only.

<div id="easyudpsocket.packetslefttosend">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.PacketsLeftToSend

**PacketsLeftToSend** As `Integer</api/data_types/integer>`

> The number of packets left in the queue to send.
>
> This property is read-only.
>
> This enables you to create a synchronous socket without needing to subclass the <span class="title-ref">EasyUDPSocket</span>.

<div id="easyudpsocket.port">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Port

**Port** As `Integer</api/data_types/integer>`

> The port to bind on or connect to.
>
> On most operating systems, attempting to bind to a port less than 1024 causes a `Error<socketcore.error>` event to fire with an error number 107 unless the application is running with administrative permissions. This is due to security features built into the underlying OS.
>
> You need to set the port property explicitly before any call to Listen or Connect as the Port property will be modified to reflect what the actual bound port is during the various stages of operation.
>
> For instance, if you listen on port 8080 and a connection comes in, you can check the Port property to ensure that you're still listening on port 8080 (that the port hasn't been hijacked). Or, if you connect to a socket on port 8080, once the connection occurs, you can check to see what port the OS has bound you to. This will be a random-seeming port number.
>
> This trick can be very useful when you do things like Listen on port 0. In that case, the OS will pick a port for you and listen on it. Then you can check the Port property to see which port the OS picked. This functionality is used for various protocols, such as FTP.
>
> This example sets the Port to 8080.
>
> ``` xojo
> EasyUDPSocket1.Port = 8080
> ```

<div id="easyudpsocket.routerhops">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.RouterHops

**RouterHops** As `Integer</api/data_types/integer>`

> Specifies how many router hops the data sent out can make.
>
> Multicasting has some extra features that make it an even more powerful utility for network applications. If you wish to receive the data you sent out with a multicast send, you can set the `SendToSelf<udpsocket.sendtoself>` property (also known as *loopback*) of the `UDPSocket</api/networking/udpsocket>`. If it is set to `True</api/language/true>`, then when you do a send (to a multicast group) you will get that data back. You can also set the number of router hops a multicast datagram will take (This is also known as the Time To Live (or TTL). When your `Datagram</api/networking/datagram>` gets sent out, it runs through a series of routers on the way to its destinations. Every time the `Datagram</api/networking/datagram>` hits a router, its `RouterHops<udpsocket.routerhops>` property gets decremented. When that number reaches zero, the `Datagram</api/networking/datagram>` is destroyed. This means you can control who gets your datagrams with a lot more precision. There are some “best guesses” as to what the value of `RouterHops<udpsocket.routerhops>` should be.
>
> | Value | Description    |
> |-------|----------------|
> | 0     | Same host      |
> | 1     | Same subnet    |
> | 32    | Same site      |
> | 64    | Same region    |
> | 128   | Same continent |
> | 255   | Unrestricted   |
>
> Note that if your `Datagram</api/networking/datagram>` runs through a router that does not support multicasting, it is killed immediately.
>
> ``` xojo
> EasyUDPSocket1.RouterHops = 32
> ```

<div id="easyudpsocket.sendtoself">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.SendToSelf

**SendToSelf** As `Boolean</api/data_types/boolean>`

> Specifies whether the data you send out will be sent to yourself as well.
>
> This is also known as loopback. This property applies only to multicast sends.
>
> Setting the SendToSelf property to `True</api/language/true>` may not work on all versions of Windows. MSDN states that the SendToSelf property on NT 4 cannot be turned off. A multicasting socket will always receive the data it sends out.
>
> ``` xojo
> EasyUDPSocket1.SendToSelf = True
> ```

## Method descriptions

<div id="easyudpsocket.bind">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Bind

**Bind**(Port As `Integer</api/data_types/integer>`)

> Binds the socket to the specified port.
>
> This example binds the socket to any available port between 8192 and 65535 (Note: the other member of the group must then use the same port, so you need to find a way to communicate this port to the others):
>
> ``` xojo
> Var success As Boolean
>
> Do
>   success = True
>   Try
>     Me.Bind (Rnd * (65536 - 8192) + 8192)
>   Catch error As RuntimeException
>     success = False
>   End Try
> Loop Until success
> ```

<div id="easyudpsocket.close">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Close

**Close**

> Closes the socket's connection, closes any connections the socket may have, and resets the socket.
>
> The only information that is retained after calling Close is the socket, and data left in the socket's receive buffer. All other information is discarded.
>
> This example closes the `EasyTCPSockets</api/networking/easytcpsocket>` that were open. The sockets were added to the main window.
>
> ``` xojo
> Connector.Close
> Listener.Close
> ```

<div id="easyudpsocket.connect">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Connect

**Connect**

> Attempts to connect.
>
> For `TCPSockets</api/networking/tcpsocket>`, the address and port properties must be set. For `UDPSockets</api/networking/udpsocket>`, the port property must be set. The Connect method binds a socket to a port. After calling Connect, the Port property will report the actual port you are bound to.

<div id="easyudpsocket.joinmulticastgroup">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.JoinMulticastGroup

**JoinMulticastGroup**(Group As `String</api/data_types/string>`) As `Boolean</api/data_types/boolean>`

> Joins the specified multicast group. Returns `True</api/language/true>` if the group was successfully joined, `False</api/language/false>` if not.
>
> ``` xojo
> If EasyUDPSocket1.JoinMulticastGroup(TextField5.Text) Then
>   MessageBox("Joined!")
> End If
> ```

<div id="easyudpsocket.leavemulticastgroup">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.LeaveMulticastGroup

**LeaveMulticastGroup**(Group As `String</api/data_types/string>`)

> Leaves the specified multicast group. The `TextField</api/user_interface/desktop/desktoptextfield>` contains the name of the group.
>
> ``` xojo
> EasyUDPSocket1.LeaveMulticastGroup(TextField5.Text)
> ```

<div id="easyudpsocket.poll">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Poll

**Poll**

> Polls the socket manually, which allows a socket to be used synchronously.
>
> The following example polls the <span class="title-ref">EasyUDPSocket</span>.
>
> ``` xojo
> Listener.Poll
> ```

<div id="easyudpsocket.purge">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Purge

**Purge**

> Removes all data from the socket's internal receive buffer. It does not affect the socket's internal send buffer.
>
> ``` xojo
> Listener.Purge
> ```

<div id="easyudpsocket.read">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Read

**Read**(enc As `TextEncoding</api/text/encoding_text/textencoding>` = `Nil</api/language/nil>`) As `Datagram</api/networking/datagram>`

> Returns a `Datagram</api/networking/datagram>` from the internal receive buffer.
>
> The address property of the `Datagram</api/networking/datagram>` is the remote address from which the data was sent. The optional *enc* parameter enables you to specify the text encoding of the data to be returned. Use the `Encodings</api/text/encoding_text/encodings>` module to specify a text encoding.

<div id="easyudpsocket.register">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Register

**Register**(GroupName As `String</api/data_types/string>`)

> Registers *GroupName* as an identifier for messages sent by SendMessageToGroup.
>
> *GroupName* can be any string, which will be mapped it to a valid Class D IP address. Class D IP addresses are in the range: \[224.0.0.0 to 239.255.255.255\]. For example, you can call Register("My Cool App"), and it will be hashed to a valid Class D IP address. However, if you use a valid Class D IP address, it will use that without modifications.
>
> Before calling Register, please set the port and call `Connect<socketcore.connect>`.
>
> This example registers the user as a group member and updates the list. Everyone on the network who wants to join the group needs to use the same group name:
>
> ``` xojo
> EasyUDPSocket1.Register("MyGroup")
> EasyUDPSocket1.UpdateMemberList
> ```

<div id="easyudpsocket.sendmessagetogroup">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.SendMessageToGroup

**SendMessageToGroup**(GroupName As `String</api/data_types/string>`, Command As `Int32</api/data_types/additional_types/int32>`, Data As `String</api/data_types/string>`)

> Sends a message consisting of *command* and *data* to the group specified by *groupName*.
>
> Effective with 2017r3, the *command* parameter is Int32 instead of Integer to prevent incorrect behavior in 64-bit apps.
>
> The text encoding is not sent to the other application. So if you want to preserve text encoding, you should use `ConvertEncoding</api/text/encoding_text/convertencoding>` to e.g. UTF-8 before sending the string and use `DefineEncoding</api/text/encoding_text/defineencoding>` when you receive a message to restore the text encoding.

<div id="easyudpsocket.sendmessagetoindividual">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.SendMessageToIndividual

**SendMessageToIndividual**(IPAddress As `String</api/data_types/string>`, Command As `Int32</api/data_types/additional_types/int32>`, Data As `String</api/data_types/string>`)

> Sends a message consisting of *command* and *data* to the machine having the IP address specified by *IPAddress*.
>
> Effective with 2017r3, the *command* parameter is Int32 instead of Integer to prevent incorrect behavior in 64-bit apps.
>
> The text encoding is not sent to the other application. So if you want to preserve text encoding, you should use `ConvertEncoding</api/text/encoding_text/convertencoding>` to e.g. UTF-8 before sending the string and use `DefineEncoding</api/text/encoding_text/defineencoding>` when you receive a message to restore the text encoding.

<div id="easyudpsocket.unregister">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Unregister

**Unregister**(GroupName As `String</api/data_types/string>`)

> Unregisters the *GroupName* passed.

<div id="easyudpsocket.waitformessage">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.WaitForMessage

**WaitForMessage**(command As `Int32</api/data_types/additional_types/int32>`, fromIP As `String</api/data_types/string>`) As `String</api/data_types/string>`

> Waits for a message from the *fromIP* addresss identified by the value of *command*.
>
> Returns a `String</api/data_types/string>`, containing the message text.
>
> The *command* parameter can be used as a code to identify the type of data that is sent. For example, you could send a command ID of 100 to mean that the string data is actually a memory block containing a `FolderItem</api/files/folderitem>`. Or, you could define ID 101 as the username of a remote application. This message mode is enforced on you in that you cannot use an arbitrary Write command. If you'd like to send arbitrary data, then you can make up a miscellaneous command ID and send your arbitrary data.
>
> Command IDs less than 0 are reserved for internal use. When you are sending messages, you should not use a command ID less than 0, as it may very well cause issues with other classes.

<div id="easyudpsocket.write">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Write

**Write**(data As `Datagram</api/networking/datagram>`)

> Constructs a `Datagram</api/networking/datagram>` and sends the data to the specified address.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Write

**Write**(ip As `String</api/data_types/string>`, data As `String</api/data_types/string>`)

> Constructs a `Datagram</api/networking/datagram>` and sends the *data* to the specified IP address *ip*.
>
> This example uses `BroadcastAddress<udpsocket.broadcastaddress>` to get the address of the group.
>
> ``` xojo
> EasyUDPSocket1.Write(EasyUDPSocket1.BroadcastAddress, "Hello World")
> ```

## Event descriptions

<div id="easyudpsocket.dataavailable">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.DataAvailable

**DataAvailable**

> Occurs when additional data has come into the internal receive buffer.

<div id="easyudpsocket.error">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.Error

**Error**(e As `RuntimeException</api/exceptions/runtimeexception>`)

> Occurs when an error occurs with the socket.
>
> These error codes provide you with key information about your socket, and it is not advisable to ignore them.
>
> When an error occurs, the `RuntimeException.ErrorNumber<runtimeexception.errornumber>` property will likely contain one of the following error codes:
>
> | Error Code | Description                                                                                                             |
> |------------|-------------------------------------------------------------------------------------------------------------------------|
> | 0          | No error occurred.                                                                                                      |
> | 100        | There was an error opening and initializing the drivers.                                                                |
> | 101        | This error code is no longer used.                                                                                      |
> | 102        | This code means that you lost your connection.                                                                          |
> | 103        | The socket was unable to resolve the address that was specified.                                                        |
> | 104        | This error code is no longer used.                                                                                      |
> | 105        | The address is currently in use.                                                                                        |
> | 106        | This is an invalid state error, which means that the socket is not in the proper state to be doing a certain operation. |
> | 107        | This error means that the port you specified is invalid.                                                                |
> | 108        | This error indicates that your application has run out of memory.                                                       |
>
> These are not the only errors that are returned. For Windows, additional error codes are usually positive numbers in the range \[10004, 11004\]. For Windows error codes, see WinSock.h. MacOS and Linux use POSIX error codes. For a description of macOS and Linux error codes, see <http://www.ioplex.com/~miallen/errcmp.html>.
>
> e.g. error 64 is for "host is down".
>
> The following example in the Error event handler displays the error code.
>
> ``` xojo
> MessageBox(Me.e.ErrorNumber.ToString)
> ```

<div id="easyudpsocket.receivedmessage">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.ReceivedMessage

**ReceivedMessage**(FromIP As `String</api/data_types/string>`, Command As `Integer</api/data_types/integer>`, Data As `String</api/data_types/string>`)

> A new complete message, consisting of an identifying integer, *command*, and the text *data*, has been received from the computer with *FromIP* IP address.
>
> Effective with 2017r3, the *command* parameter is Int32 instead of Integer to prevent incorrect behavior in 64-bit apps.
>
> Both *fromIP* and *data* strings both have no encoding set. If you know the encoding, you should use `DefineEncoding</api/text/encoding_text/defineencoding>` to set it.

<div id="easyudpsocket.sendcomplete">

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

</div>

<div class="rst-class">

forsearch

</div>

EasyUDPSocket.SendComplete

**SendComplete**(UserAborted As `Boolean</api/data_types/boolean>`)

> Occurs when a send has completed.
>
> Use this to determine when all your data has been sent. *UserAborted* will be `True</api/language/true>` if the user aborted the send by returning `True</api/language/true>` from the SendProgress event. You can use this information to update different status variables or to inform user about the success or failure of the transfer. If the send was completed, this value is `False</api/language/false>`. UserAborted will always be `False</api/language/false>` for UDP sockets.

## Notes

Even though you have access to the Write and Read methods of the `UDPSocket</api/networking/udpsocket>` class, you should never call them. Doing so will cause a `RuntimeException</api/exceptions/runtimeexception>` to be raised (with an appropriate message set). This is so the internal protocol is enforced.

If you are subclassing a <span class="title-ref">EasyUDPSocket</span>, you must call the Super class's constructor in your own subclass's constructor. The subclass will not work or exhibit “strange” behavior unless this is done. Use the `Super</api/language/super>` keyword for this.

The DataAvailable event of the `UDPSocket</api/networking/udpsocket>` class is not available.

The <span class="title-ref">EasyUDPSocket</span> class provides a simple “wrapper” around the `UDPSocket</api/networking/udpsocket>` class that makes easier for beginners to get started with UDP networking. With the <span class="title-ref">EasyUDPSocket</span> class, you can send messages either to an individual or to an entire group. One main benefit to the <span class="title-ref">EasyUDPSocket</span> class is the way it handles multicasting. It's a nuisance to look up which IP addresses can be used with multicasting.

The Command parameter can be used as a code to identify the type of data that is sent. For example, you could send a command ID of 100 to mean that the data is actually a memory block containing a `FolderItem</api/files/folderitem>`. Or, you could define ID 101 as the username of a remote application. This message mode is enforced on you in that you cannot use an arbitrary Write command. If you'd like to send arbitrary data, then you can make up a miscellaneous command ID and send your arbitrary data.

Command IDs less than 0 are reserved for internal use. When you are sending messages, you should not use a command ID less than 0, as it may very well cause issues with other classes.

To send a message to a group, you pass the group name that you have previously assigned to the group using the Register method. This means that you can pass "MyLocalGroup" as the parameter to the Register method and use that string for calls to SendMessageToGroup. To send a message to an individual, you need the IP address of the user&&lsquo;s computer in the SendMessageToIndividual method.

You can still pass a valid Class D IP address and it will be used. One other helper function is the Bind function. This sets up the socket for you properly (so you don't have to set RouterHops or SendToSelf up yourself) and does the bind on the port specified.

One thing to keep in mind is that <span class="title-ref">EasyUDPSocket</span> defaults to having SendToSelf on. You are welcome to override this default yourself by setting SendToSelf to `False</api/language/false>` after the making the Bind call. While you can still call \[Join/Leave\]MulticastGroup, we suggest that you only use Register and Unregister for your <span class="title-ref">EasyUDPSocket</span> application.

## Compatibility

|                       |                       |
|-----------------------|-----------------------|
| **Project Types**     | Console, Desktop, Web |
| **Operating Systems** | All                   |

<div class="seealso">

`UDPSocket</api/networking/udpsocket>` parent class; `AutoDiscovery</api/networking/autodiscovery>`, `SocketCore</api/networking/socketcore>` classes.

</div>