Gurux.Net

GXNet cl = new GXNet();
cl.setHostName("localhost");
cl.setPort(1000);
cl.setProtocol(NetworkType.TCP);
cl.open();

GXNet cl = new GXNet();
cl.HostName = "localhost";
cl.Port = 1000;
cl.Protocol = NetworkType.Tcp;
cl.Open();

CGXNet cl;
cl.SetProtocol(GX_NW_TCPIP);
cl.SetPort(port);
cl.SetTrace(GX_TRACE_LEVEL_VERBOSE);
cl.IsServer(true);
cl.AddListener(this);
int ret;
if ((ret = m_Media.Open()) != 0)
{
	printf("Media open failed %d", ret);
	return ret;
}	

cl.send("Hello World!", null);

cl.Send("Hello World!");

const char* pData = "Hello World";
vector data;
data.insert(data.end(), pData, reinterpret_cast(pData) + strlen(pData));			
cl.Send(data, NULL);

//1. Add class that you want to use to listen media events and derive class from IGXMediaListener
*/
 Media listener.
*/
class GXMediaListener implements IGXMediaListener, gurux.net.IGXNetListener
{
    /** 
    Represents the method that will handle the error event of a Gurux component.
    @param sender The source of the event.
    @param ex An Exception object that contains the event data.
    */
    @Override
    void onError(Object sender, RuntimeException ex)
    {
    }

    /** 
     Media component sends received data through this method.

     @param sender The source of the event.
     @param e Event arguments.
    */
    @Override
    void onReceived(Object sender, ReceiveEventArgs e)
    {

    }

    /** 
     Media component sends notification, when its state changes.
     @param sender The source of the event.    
     @param e Event arguments.
    */
    @Override
    void onMediaStateChange(Object sender, MediaStateEventArgs e)
    {

    }

    /** 
     Called when the Media is sending or receiving data.
     @param sender
     @param e
     @see IGXMedia.Trace Traceseealso>
    */
    @Override
    void onTrace(Object sender, TraceEventArgs e)
    {

    }

    // Summary:
    //     Represents the method that will handle the System.ComponentModel.INotifyPropertyChanged.PropertyChanged
    //     event raised when a property is changed on a component.
    //
    // Parameters:
    //   sender:
    //     The source of the event.
    //
    //   e:
    //     A System.ComponentModel.PropertyChangedEventArgs that contains the event
    //     data.
    @Override
    void onPropertyChanged(Object sender, PropertyChangedEventArgs e)
    {

    }

    /*
     * Client is made connection.
     */
    @Override
    public void onClientConnected(Object sender, gurux.net.ConnectionEventArgs e) 
    {
        System.out.println("Client Connected.");
    }

    /*
     * Client is closed connection.
     */
    @Override
    public void onClientDisconnected(Object sender, gurux.net.ConnectionEventArgs e) 
    {
        System.out.println("Client Disconnected.");
    }
}

//2. Listener is registered calling addListener method.
cl.addListener(this);

cl.OnReceived += new ReceivedEventHandler(this.OnReceived);

//1. Add class that you want to use to listen media events and derive class from IGXMediaListener
class CGXMediaListener : IGXMediaListener, IGXNetListener
{
    void OnClientConnected(IGXMedia* pSender, CConnectionEventArgs& e)
	{
		printf("Client Connected : %s\r\n", e.GetInfo().c_str());
	}

    /** 
     Called when the client has been disconnected from the GXNet server.

     @param sender The source of the event.    
     @param e Event arguments.
    */
    void OnClientDisconnected(IGXMedia* pSender, CConnectionEventArgs& e)
	{
    	printf("Client Disonnected : %s\r\n", e.GetInfo().c_str());
	}
    
    void OnError(IGXMedia* pSender, basic_string& ex)
	{
		printf("Error has occurred : %s\r\n", ex.c_str());
	}

    /** 
     Media component sends received data through this method.

     @param sender The source of the event.
     @param e Event arguments.
    */
    void OnReceived(IGXMedia* pSender, CReceiveEventArgs& e)
	{		
	}

    /** 
     Media component sends notification, when its state changes.

     @param sender The source of the event.    
     @param e Event arguments.
    */
    void OnMediaStateChange(IGXMedia* pSender, CMediaStateEventArgs& e)
	{
	}

    /** 
     Called when the Media is sending or receiving data.

     @param sender
     @param e
     @see IGXMedia.Trace Trace
    */
    void OnTrace(IGXMedia* pSender, CTraceEventArgs& e)
	{
    	printf("%s\r\n", e.ToString().c_str());
	}
    
    // Summary:
    //  Event raised when a property is changed on a component.
    //
    // Parameters:
    //   sender:
    //     The source of the event.
    //
    //   e:
    //     A System.ComponentModel.PropertyChangedEventArgs that contains the event
    //     data.
    void OnPropertyChanged(IGXMedia* pSender, CPropertyChangedEventArgs& e)
	{

	}
}

//2. Listener is registered calling addListener method.
cl.AddListener(this);

synchronized (cl.getSynchronous())
{
    String reply = "";    
    ReceiveParameters<byte[]> p = new ReceiveParameters<byte[]>(byte[].class);    
    //End of Packet.
    p.setEop('\n'); 
    //How long reply is waited.   
    p.setWaitTime(1000);          
    cl.send("Hello World!", null);
    if (!cl.receive(p))
    {
        throw new RuntimeException("Failed to receive response..");
    }
}

lock (cl.Synchronous)
{
    string reply = "";
    ReceiveParameters<string> p = new ReceiveParameters<string>()
    //ReceiveParameters<byte[]> p = new ReceiveParameters<byte[]>()
    {
       //Wait time tells how long data is waited.
       WaitTime = 1000,
       //Eop tells End Of Packet charachter.
       Eop = '\r'
    };
    cl.Send("Hello World!", null);
    if (cl.Receive(p))
    {
        reply = Convert.ToString(p.Reply);
    }
}

//ANSI C++ do not support syncronous mode at the moment.

lock (gxNet1.SyncRoot)
{
    gxNet1.Open();
    ...
    gxNet1.Close();
}