C#

Luc Pattyn wrote:

- information on how both PCs are connected

Luc Pattyn wrote:

- information on the data written each time: is it text? binary data? how much? what does it represent?

Luc Pattyn wrote:

- the entire code of the method that writes the data, and its context (which thread, how is it triggered, etc)

public bool Send(object oSend)
        {
            try
            {
                SendString(Serialize(oSend).Length.ToString());
                return SendBytes(Serialize(oSend));
            }
            catch
            {
                return false;
            }
        }

public byte[] Serialize(object oSerialize)
        {
            if (oSerialize != null)
            {
                lock (serializeLock)
                {
                    msMem = new MemoryStream();
                    bf = new BinaryFormatter();

                    try
                    {
                        bf.Serialize(msMem, oSerialize);
                        msMem.Flush();
                        msMem.Position = 0;

                        oSerialize = null;
                        bf = null;
                        return msMem.ToArray();
                    }
                    catch
                    {
                        return null;
                    }
                }
            }
            else
                return null;
        }

public bool SendString(string strSend)
        {
            try
            {
                SendBytes(new System.Text.ASCIIEncoding().GetBytes(strSend));
                return true;
            }
            catch
            {
                return false;
            }
        }

public bool SendBytes(byte[] bUp)
        {
            if (bUp != null && nsStream != null)
            {
                lock (sendLock)
                {
                    try
                    {
                        if (nsStream.CanWrite)
                            nsStream.Write(bUp, 0, bUp.Length);

                        nsStream.Flush();

                        int x = 0;

                        while (nsStream.DataAvailable && x < dataReadWait)
                        {
                            x++;
                            // Wait for data to be read
                        }

                        return true;
                    }
                    catch
                    {
                        return false;
                    }
                }
            }
            else
                return false;
        }

public object Receive()
        {
            return Deserialize(ReceiveBytes());
        }

public byte[] ReceiveBytes()
        {
            bDown = new byte[8];

            try
            {
                int bytesLength = Convert.ToInt32(ReceiveString(8));
                bDown = new byte[bytesLength];

                return ReceiveBytes(bytesLength);
            }
            catch
            {
                return null;
            }
        }

public byte[] ReceiveBytes(int length)
        {
            if (nsStream != null)
            {
                lock (receiveLock)
                {
                    bDown = new byte[length];

                    try
                    {
                        if (nsStream.CanRead)
                            nsStream.Read(bDown, 0, bDown.Length);

                        nsStream.Flush();
                        return bDown;
                    }
                    catch
                    {
                        return null;
                    }
                }
            }
            else
                return null;
        }

public object Deserialize(byte[] oDeserialize)
        {
            if (oDeserialize != null && oDeserialize.Length != 0)
            {
                lock (deserializeLock)
                {
                    msMem = new MemoryStream(oDeserialize);
                    bf = new BinaryFormatter();
                    msMem.Position = 0;

                    try
                    {
                        obj = bf.Deserialize(msMem);
                        bf = null;
                        msMem = null;
                        return obj;
                    }
                    catch
                    {
                        msMem = null;
                        bf = null;
                        obj = null;
                        return null;
                    }
                }
            }
            else
                return null;
        }

try {
    ....
} catch(AVerySpecificExceptionWeWantToReallyIgnore) {
    // empty by design, as this exception is really harmless and does not need logging
} catch(Exception exc) {
    log(exc.ToString());
    ...
}

public void log(string s) {
    listbox1.Items.Add(s);
    listbox1.TopIndex=listbox1.Items.Count-1; // scroll
    File.AppendText(logfileName, s+Environment.NewLine);
}

ramindya wrote:

I am a beginner to ASP.NET.

ramindya wrote:

Assume Server whose health to monitor is GEMINI.
Create two unattended (non UI) Windows Services (or Windows exe) written in C#.
Every specific “duration” the windows services will be invoked.Use app.config file to store this duration value.
Should check the server (GEMINI) if it is up or down.
Check the following various applications under following broad classifications in the server.
Server
IIS
SQL Server
Windows Service ( control panel --> under services u see services running)
Windows Exe
Web Service

If the application is down and the server is down it has to log data into the sql server database.

for(;;) {
    // do whatever you want to do periodically
    ...
    // now pause
    Thread.Sleep(5*60*1000);
}