C#

public bool MyFunc(string username)
{
  try
  {
    ...
    return true;
  }
  catch(Exception)
  {
    return false;
  }
}

netJP12L wrote:

Is this way big applications deal with complicated applications issues?

public enum ReturnStatus{
   True,
   False,
   Maybe,
   CriticalError,
   AcceptableError
}

public ReturnStatus Func1(string s)
{
    if(s == null)
       return ReturnStatus.False;
    if(s == "?")
       return ReturnStatus.Maybe;
    return ReturnStatus.True;
}

public Object AddUser(string username)
{
   CustomObject obj = null;
 
   try
   {
     obj = CustomObject(false,"",,"")
   }
   catch(Exception ex)
   {
      obj = CustomObject(true,"101",ex,"Database couldn't be started.")
 
   }
 
   return obj;
}
 

public class CustomObject
{
  public CustomObject(bool errorFound, string ErrorID, Exception exception, string CustomErrorMessage)
  {
  }
}

                m_prx = new ProxyServer(this);
                System.Threading.Thread proxythread = new System.Threading.Thread(new ThreadStart(m_prx.Start));
                proxythread.Start();

                 m_listener.Start();
                System.Diagnostics.Debug.WriteLine("Listening socket on port " + m_port);
                
                while (true)
                {
                    HttpListenerContext request = m_listener.GetContext();
                    ThreadPool.QueueUserWorkItem(ProcessRequest, request);

                        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(address);
                        //create cache object
                        request.Credentials = AddCache(uri);
                        request.ClientCertificates.Add(SisService.GetClientCertificate());
 

                        buffer = new byte[BUFFER_SIZE];
                        Stream instream = context.Request.InputStream;
                        int incount = instream.Read(buffer, 0, buffer.Length);
                        while (incount > 0)
                        {
                            request.GetRequestStream().Write(buffer, 0, incount);
                            incount = instream.Read(buffer, 0, buffer.Length);
                        }
                        // Wait for Response
                        WebResponse response = request.GetResponse();

                        // Transfer the body data from the WebResponse
                        buffer = new byte[BUFFER_SIZE];
                        Stream outstream = response.GetResponseStream();
                        int outcount = outstream.Read(buffer, 0, buffer.Length);
                        while (outcount > 0)
                        {
                            context.Response.OutputStream.Write(buffer, 0, outcount);
                            outcount = outstream.Read(buffer, 0, buffer.Length);
                        }
                        // Close streams
                        instream.Close();
                        outstream.Close();
                        context.Response.OutputStream.Close();

A first chance exception of type 'System.Net.HttpListenerException' occurred in System.dll
An operation was attempted on a nonexistent network connection

                TcpListener listener = new TcpListener(IPAddress.Any, m_port);
                listener.Start();
 
                DoBeginAcceptSocket(listener);

    public static void DoBeginAcceptSocket(TcpListener listener)
    {
        // Set the event to nonsignaled state.
        tcpClientConnected.Reset();
 
        // Start to listen for connections from a client.
        //Console.WriteLine("Waiting for a connection...");

        // Accept the connection. 
        // BeginAcceptSocket() creates the accepted socket.
        listener.BeginAcceptSocket(
            new AsyncCallback(ProcessSocket), listener);
        // Wait until a connection is made and processed before 
        // continuing.
        tcpClientConnected.WaitOne();
    }

A first chance exception of type 'System.Net.Sockets.SocketException' occurred in System.dll
An existing connection was forcibly closed by the remote host.

buffer = new byte[BUFFER_SIZE];
                        Stream outstream = response.GetResponseStream();
                        int outcount = outstream.Read(buffer, 0, buffer.Length);
                        while (outcount > 0)
                        {
                            context.Response.OutputStream.Write(buffer, 0, outcount);
                            outcount = outstream.Read(buffer, 0, buffer.Length);
                        }

Paulo Zemek wrote:

I think you should read from instream and write to outstream.
Maybe that's the problem (I am not sure, as I don't have the full source).
 

                        Stream instream = response.GetResponseStream();
                        Stream outstream = context.Response.OutputStream;
 
                        int outcount = instream.Read(buffer, 0, buffer.Length);
                        while (outcount > 0)
                        {
                            outstream.Write(buffer, 0, outcount);
                            outcount = instream.Read(buffer, 0, buffer.Length);
                        }
                        // Close streams
                        instream.Close();
                        outstream.Close();

Paulo Zemek wrote:

Also, I think the best pattern is:
Create a TcpListener.
Start it.
In a loop, you accept a TcpClient, start a thread to process the client and continues in the loop accepting new requests.

                TcpListener listener = new TcpListener(IPAddress.Any, m_port);
                listener.Start();
                
                while (true)
                {
                    Socket client = listener.AcceptSocket();
                    ThreadPool.QueueUserWorkItem(ProcessSocket, client);
                }

Paulo Zemek wrote:

And, finally, maybe the connection is lost in the middle. This can happen (think about the stop button, for example). So, if the connection is closed, it's ok. Ignore this exception.

                m_listener.Start();
                System.Diagnostics.Debug.WriteLine("Listening socket on port " + m_port);
 
                ThreadedListener tl=new ThreadedListener(m_listener, m_service);
                Thread newThread = new Thread(new ThreadStart(tl.Process));
                newThread.Start();
 
                Console.WriteLine("(0): Creathed Thread (ID {1})",
                    Thread.CurrentThread.ManagedThreadId, newThread.ManagedThreadId);

    internal class ThreadedListener
    {
        private HttpListener m_listener;
        private SisService m_service;
        const int BUFFER_SIZE = 1024;
 
        public ThreadedListener(HttpListener listener, SisService service) { m_listener = listener; m_service = service; }
 
        public void Process()
        {
            HttpListenerContext request=m_listener.GetContext();
            IAsyncResult result = m_listener.BeginGetContext(new AsyncCallback(RequestHandler), m_listener);
        }
 
        private void RequestHandler(IAsyncResult ar)
        {
            HttpListenerContext httpContext = null;
            try
            {
                HttpListener listener = (HttpListener)ar.AsyncState;
                httpContext = listener.EndGetContext(ar);
 
                // start listening for next request
                listener.BeginGetContext(RequestHandler, listener);
 
                // invoke response handler
                ResponseHandler(httpContext);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                if (httpContext != null)
                {
                    httpContext.Response.Close();
                }
            }
        }
 
        private void ResponseHandler(HttpListenerContext context) 
        {
             //do Stuff;
        }
     }

A first chance exception of type 'System.Net.HttpListenerException' occurred in System.dll
An operation was attempted on a nonexistent network connection

                System.Threading.Thread proxythread = new System.Threading.Thread(new ThreadStart(m_prx.Start));
                proxythread.Start();

                m_prx = new ProxyServer(this);
                m_prx.Start();

ThreadedListener tl=new ThreadedListener(m_listener, m_service);
Thread newThread = new Thread(new ThreadStart(tl.Process));
newThread.Start();

HttpListenerContext request=m_listener.GetContext();
IAsyncResult result = m_listener.BeginGetContext(new AsyncCallback(RequestHandler), m_listener);

                m_listener.Start();
                System.Diagnostics.Debug.WriteLine("Listening socket on port " + m_port);
 
                ThreadedListener tl = new ThreadedListener(m_listener, m_service);
                Thread newThread = new Thread(new ThreadStart(tl.Process));
                newThread.Start();

            while (true)
            {
                HttpListenerContext request = m_listener.GetContext();
                req myReq=new req(m_service);
                Thread newThread = new Thread(myReq.ProcessRequest);
                newThread.Start(request);
            }

ERROR_CONNECTION_ACTIVE
1230 (0x4CE)

An invalid operation was attempted on an active network connection.

                            outstream.Write(buffer, 0, outcount);

A first chance exception of type 'System.Net.HttpListenerException' occurred in System.dll
System.Net.HttpListenerException: An operation was attempted on a nonexistent network connection
   at System.Net.HttpResponseStream.Write(Byte[] buffer, Int32 offset, Int32 size)