C#

NarVish wrote:

I need to write a c# program which tracks the changes in excel spreadsheet cells, without saving the file in hard disk.
Without using excel functions, need to detect the changes.

Please guide me to achieve this functionality.

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);
}