Пример #1
0
        private void ForceAutoSave()
        {
            FControlFileStream.Flush();
            FFileStream.Flush();

            Stream textStream      = (FFileStream as StreamWriter).BaseStream;
            String recycleFilePath = FileHelper.RecycleAndGetNextFileName(FFilePath, FAutoSave, FFileHeader);

            using (FileStream recycleStream = FileStreamAccess.OpenFileStreamForWriting(recycleFilePath, FileMode.Create))
            {
                RIUtils.CopyFile(textStream, recycleStream);
            }

            // truncate text file
            textStream.SetLength(0);
            textStream.Seek(0, SeekOrigin.End);
            FFileStream.Flush();

            // trucate control file
            FControlFileStream.SetLength(0);
            FControlFileStream.Seek(0, SeekOrigin.End);
            FControlFileStream.Flush();

            FFileHeader = FileHelper.ReadHeader(FControlFileStream, FControlFilePath, null);
            FControlFileStream.Seek(0, SeekOrigin.End);
        }
        private void OpenFileStream()
        {
            CloseFileStream(false);
            FFileStream = FileStreamAccess.OpenFileStreamForWriting(FFilePath, FileMode.OpenOrCreate);

            try
            {
                Dictionary <Int32, FastSerializerObjectData> onNewExtraData;
                if (FFileHeader != null)
                {
                    onNewExtraData = FFileHeader.CloneExtraData();
                }
                else
                {
                    onNewExtraData = null;
                }

                FFileHeader = FileHelper.ReadHeader(FFileStream, FFilePath, onNewExtraData);
                FFileStream.Seek(0, SeekOrigin.End);
            }
            catch (Exception)
            {
                CloseFileStream(false);
                throw;
            }
        }
Пример #3
0
        private void OpenControlFile()
        {
            CloseFileStream(false);
            FControlFileStream = FileStreamAccess.OpenFileStreamForWriting(FControlFilePath, FileMode.OpenOrCreate);

            Dictionary <Int32, FastSerializerObjectData> onNewExtraData;

            if (FFileHeader != null)
            {
                onNewExtraData = FFileHeader.CloneExtraData();
            }
            else
            {
                onNewExtraData = null;
            }

            FFileHeader = FileHelper.ReadHeader(FControlFileStream, FFilePath, onNewExtraData);
        }
        private void ForceAutoSave()
        {
            // write header and flush all buffers
            FileHelper.WriteHeader(FFileStream, FFileHeader);
            FFileStream.Flush();

            String recycleFilePath = FileHelper.RecycleAndGetNextFileName(FFilePath, FAutoSave, FFileHeader);

            using (FileStream recycleStream = FileStreamAccess.OpenFileStreamForWriting(recycleFilePath, FileMode.Create))
            {
                RIUtils.CopyFile(FFileStream, recycleStream);
            }

            // trucate the file
            FFileStream.SetLength(0);
            FFileStream.Flush();

            FFileHeader = FileHelper.ReadHeader(FFileStream, FFilePath, null);
            FFileStream.Seek(0, SeekOrigin.End);
        }
        private void RewriteFileIgnoreRequestor(RIFileHeader newHeader, FastBinaryFormatter ff, UInt32 sessionID, UInt32 requestID)
        {
            RIFileHeader tmpHeader = null;
            String       tmpFile   = String.Format("{0}.tmp", FFilePath);

            using (FileStream tmpStream = FileStreamAccess.OpenFileStreamForWriting(tmpFile, FileMode.Create))
            {
                // original file: set file pointer to top
                FFileStream.Seek(0, SeekOrigin.Begin);
                ff.Serialize(FFileStream, FFileHeader);

                // original file: move file pointer to the end of the file header
                FFileStream.Seek(0, SeekOrigin.Begin);
                ff.Deserialize <RIFileHeader>(FFileStream);

                // temp file: move file pointer to the end of the file header with new header info
                tmpHeader = newHeader;
                tmpHeader.FInitDateTime   = DateTime.MinValue;
                tmpHeader.FFirstDateTime  = DateTime.MinValue;
                tmpHeader.FLastDateTime   = DateTime.MinValue;
                tmpHeader.FNextSequenceId = FFileHeader.FNextSequenceId;
                tmpHeader.FMessageCount   = 0;
                ff.Serialize(tmpStream, tmpHeader);

                // start copying original messages to temp file
                for (Int32 i = 0; i < FFileHeader.FMessageCount; i++)
                {
                    ReflectInsightPackage message = ff.Deserialize <ReflectInsightPackage>(FFileStream);
                    if (message.FRequestID == requestID && message.FSessionID == sessionID)
                    {
                        continue;
                    }

                    if (tmpHeader.FInitDateTime == DateTime.MinValue)
                    {
                        tmpHeader.FInitDateTime  = message.FDateTime;
                        tmpHeader.FFirstDateTime = message.FDateTime;
                        tmpHeader.FLastDateTime  = message.FDateTime;
                    }

                    tmpHeader.FMessageCount++;
                    tmpHeader.FLastDateTime = message.FDateTime;
                    ff.Serialize(tmpStream, message);
                }

                // update the FileHeader with the temp file header and write it out
                // with latest info.
                FFileHeader = tmpHeader;
                tmpStream.Seek(0, SeekOrigin.Begin);
                ff.Serialize(tmpStream, FFileHeader);
            }

            if (tmpHeader != null)
            {
                // delete the original file first, then copy temp to original
                DeleteFile(false);
                try
                {
                    File.Move(tmpFile, FFilePath);
                }
                finally
                {
                    OpenFileStream();
                }
            }
        }