C#

using System;
using System.Text;
using System.Net;
using System.IO;

namespace TEST
{
    public delegate void delReceiveWebRequest(HttpListenerContext Context);

    public class ProxyServer
    {
        private int m_port = 47809;//Starts with this port, which according to IANA is for private use!
        private static string localhost = "127.0.0.1";
        const int BUFFER_SIZE = 1024;
        public string m_server;
        protected HttpListener m_listener;
        private CredentialCache m_credCache;
        public event delReceiveWebRequest ReceiveWebRequest;

        public ProxyServer(string server, CredentialCache credCache)
        {
            this.m_server = server;
            this.m_credCache = credCache;
        }

        public string Address()
        {
            return "http://" + localhost + ":" + m_port.ToString() + "/";
        }

        /// <summary>
        /// Starts the Web Service
        /// </summary>
        /// <param name="UrlBase">
        /// A Uri that acts as the base that the server is listening on.
        /// Format should be: http://127.0.0.1:8080/ or http://127.0.0.1:8080/somevirtual/
        /// Note: the trailing backslash is required! For more info see the
        /// HttpListener.Prefixes property on MSDN.
        /// </param>

        public bool Start()
        {
            try
            {
                this.m_listener = new HttpListener();
                this.m_listener.Prefixes.Add(Address());
                this.m_listener.Start();

                IAsyncResult result = this.m_listener.BeginGetContext(new AsyncCallback(WebRequestCallback), this.m_listener);
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine(e.ToString());
                System.Diagnostics.Debug.WriteLine("Could not connect on port " + m_port.ToString() + "!");
                m_port++;
                return false;
            }

            System.Diagnostics.Debug.WriteLine("Listening socket on port " + m_port);
            return true;
        }

        /// <summary>
        /// Shut down the Web Service
        /// </summary>

        public void Stop()
        {
            if (m_listener != null)
            {
                this.m_listener.Close();
                this.m_listener = null;
                System.Diagnostics.Debug.WriteLine("Proxy stopped on port " + m_port.ToString() + "!");
            }
        }

        protected void WebRequestCallback(IAsyncResult result)
        {
            if (this.m_listener == null)
                return;

            // Get out the context object
            HttpListenerContext context = this.m_listener.EndGetContext(result);

            // *** Immediately set up the next context
            this.m_listener.BeginGetContext(new AsyncCallback(WebRequestCallback), this.m_listener);

            if (this.ReceiveWebRequest != null)
                this.ReceiveWebRequest(context);

            this.ProcessRequest(context);
        }

        protected virtual void ProcessRequest(HttpListenerContext Context)
        {
            string uri=Context.Request.RawUrl;

            this.m_server = this.m_server.Remove(this.m_server.Length - 1);
            string address = this.m_server + uri;
            WebRequest request = (HttpWebRequest)WebRequest.Create(address);
            request.Credentials = m_credCache;//CredentialCache.DefaultCredentials;
            StringBuilder RequestData = new StringBuilder(String.Empty);

            WebResponse myWebResponse = request.GetResponse();
            Stream ReceiveStream = myWebResponse.GetResponseStream();

            Encoding encode = System.Text.Encoding.GetEncoding("utf-8");

            // Pipe the stream to a higher level stream reader with the required encoding format. 
            StreamReader readStream = new StreamReader(ReceiveStream, encode);
            Char[] read = new Char[BUFFER_SIZE];

            // Read 1024 characters at a time.    
            int count = readStream.Read(read, 0, BUFFER_SIZE);

            HttpListenerResponse response = Context.Response;
            System.IO.Stream output = response.OutputStream;

            while (count > 0)
            {
                // Dump the 1024 characters on a string and display the string onto the console.
                String str = new String(read, 0, count);

                output.Write(encode.GetBytes(str), 0, encode.GetBytes(str).Length);
                count = readStream.Read(read, 0, BUFFER_SIZE);
            }

            output.Close();
        }
    }

}

joana.simoes wrote:

the callback (finish) terminates without actualy sending all the information

reza assar wrote:

i want to lock some text file in the specified directory
just two applications can access these files

reza assar wrote:

what should i do?

I are Troll

reza assar wrote:

is there any other way?

I are Troll

Hristo Bojilov wrote:

You need to be very careful when you are using globally available mutexes running on limited OS accounts

using (stream = new StreamWriter("C:/abc.xls", false, Encoding.UTF8))