How to save and open files correctly ( without destroying file )

private void BtnDisplay_Click(object sender, EventArgs e)
        {
            if (GridFile.CurrentCell == null)
            {
                MessageBox.Show("select a row");
                return;
            }
            DataTable dt = new DataTable();
            int SelectedRow = GridFile.CurrentCell.RowIndex;
            string OriginalPath = GridFile.SelectedRows[0].Cells[2].Value.ToString();
            string tempsafefilename = GridFile.SelectedRows[0].Cells[5].Value.ToString();
            saveFileDialog1.FileName = OriginalPath;
            string FileName = saveFileDialog1.FileName;
            //.......
            if (File.Exists(FileName))
            {
                Process.Start(FileName);
            }
            else
            {
 
byte[] FileData = new byte[32768];
               FileData = (byte[])DS.Tables["TeacherFile"].Rows[SelectedRow]["FileData"];
                String newfile = @"D:\Temp";
                DirectoryInfo l_dDirInfo = new DirectoryInfo(newfile);
                if (l_dDirInfo.Exists == false)
                {
                    Directory.CreateDirectory(newfile);
                }
 
                string NewPath = newfile + "\\" + tempsafefilename;
 

                    //FileStream fStream = new FileStream(NewPath, FileMode.Create);
 
                    //while (fStream.Read(FileData, 0, FileData.Length) > 0)
                    //{
                    //    Process.Start(NewPath);
                    //}
                   
                    using (FileStream fStream = new FileStream(NewPath, FileMode.Create))
                    {
                        fStream.Write(FileData, 0, FileData.Length);
                        FileData = ReadToEnd(fStream);
                        fStream.Write(FileData, 0, FileData.Length);
                        Process.Start(NewPath);
                    }
 
 public static byte[] ReadToEnd(System.IO.Stream stream)
        {
            long originalPosition = 0;
 
            if (stream.CanSeek)
            {
                originalPosition = stream.Position;
                stream.Position = 0;
            }
 
            try
            {
                byte[] readBuffer = new byte[4096];
 
                int totalBytesRead = 0;
                int bytesRead;
 
                while ((bytesRead = stream.Read(readBuffer, totalBytesRead, readBuffer.Length - totalBytesRead)) > 0)
                {
                    totalBytesRead += bytesRead;
 
                    if (totalBytesRead == readBuffer.Length)
                    {
                        int nextByte = stream.ReadByte();
                        if (nextByte != -1)
                        {
                            byte[] temp = new byte[readBuffer.Length * 2];
                            Buffer.BlockCopy(readBuffer, 0, temp, 0, readBuffer.Length);
                            Buffer.SetByte(temp, totalBytesRead, (byte)nextByte);
                            readBuffer = temp;
                            totalBytesRead++;
                        }
                    }
                }
 

                byte[] buffer = readBuffer;
                if (readBuffer.Length != totalBytesRead)
                {
                    buffer = new byte[totalBytesRead];
                    Buffer.BlockCopy(readBuffer, 0, buffer, 0, totalBytesRead);
                }
                return buffer;
            }
            finally
            {
                if (stream.CanSeek)
                {
                    stream.Position = originalPosition;
                }
            }
        }
        //....OKKKKKK
        byte[] ReadFile(string sPath)
        {
 

            FileStream fStream = new FileStream(sPath, FileMode.Open, FileAccess.Read);
            byte[] buffer = new byte[32768];
            int read = 0;
            int chunk;
            fStream.Position = 3147483648;
            while ((chunk = fStream.Read(buffer, read, buffer.Length - read)) > 0)
            {
                read += chunk;
 
                // If we've reached the end of our buffer, check to see if there's
                // any more information
                if (read == buffer.Length)
                {
                    int nextByte = fStream.ReadByte();
 
                    // End of stream? If so, we're done
                    if (nextByte == -1)
                    {
                        return buffer;
                    }
 
                    // Nope. Resize the buffer, put in the byte we've just
                    // read, and continue
                    byte[] newBuffer = new byte[buffer.Length * 2];
                    Array.Copy(buffer, newBuffer, buffer.Length);
                    newBuffer[read] = (byte)nextByte;
                    buffer = newBuffer;
                    read++;
                }
            }
            // Buffer is now too big. Shrink it.
            byte[] ret = new byte[read];
            Array.Copy(buffer, ret, read);
            return ret;
        }