c# - 第三方应用程序无法读取新创建的 .text 文件中的数据

Question

我开发了一个 Windows 应用程序，它将从 .jrn 文件(在 ATM 机中)读取更新的数据，并将文本复制到一个临时文本文件“tempfile.txt”。

还有另一个名为“POS Text Sender”的第三方应用程序，它读取“tempfile.txt”并将其内容显示在闭路电视摄像机中。

问题是，如果我直接在临时文件中键入内容，POS 应用程序将读取它，但如果我的应用程序将文本写入“tempfile”，我可以在临时文件中看到与 .jrn 文件中相同的内容，但是当数据从新生成的文件复制到临时文件时，它不会反射(reflect)在 POS 应用程序中。如果在第一个数据从新生成的文件复制到临时文件后重新启动 POS 文本发送器，POS 文本发送器将显示内容直到新创建的内容文件被写入临时文件

我的应用程序代码正在使用 StreamReader 读取 .jrn 文件并将其分配给字符串变量，然后使用 StreamWriter 将其写入临时文件。在文件上手动键入文本与 .NET StreamWriter 将文本写入文件有什么区别？

代码:

 DateTime LastChecked = DateTime.Now;
 try
 {
     string[] files = System.IO.Directory.GetFiles(@"C:\Test", "*.jrn", System.IO.SearchOption.AllDirectories);

     foreach (string file in files)
     {
         if (!fileList.Contains(file))
         {
             currentfilename = file;
             fileList.Add(file);
             copywarehouse(file);
             //do_some_processing();
             try
             {
                 // Create an instance of StreamReader to read from a file.
                 // The using statement also closes the StreamReader.
                 using (StreamReader sr = new StreamReader(file))
                 {
                     currentcontent=sr.ReadToEnd();
                     // Read and display lines from the file until the end of
                     //// the file is reached.
                     //while ((currentcontent = sr.ReadLine()) != null)
                     //{

                     //}
                     sr.Close();
                     //sr.Dispose();
                 }
             }
             catch (Exception)
             {
                 // Let the user know what went wrong.

             }
         }
     }

     //checking
     try
     {
         using (StreamReader sr = new StreamReader(currentfilename))
         {
             string currentfilecontent = sr.ReadToEnd();
             sr.Close();
             //sr.Dispose();
             if (currentfilecontent!=currentcontent)
             {
                 if (currentfilecontent.Contains(currentcontent))
                 {
                     string originalcontent = currentfilecontent.Substring(currentcontent.Length);
                     System.IO.StreamWriter filenew = new System.IO.StreamWriter(@"C:\Test\tempfile.txt");

                     filenew.WriteLine(originalcontent);
                     filenew.Close();
                     currentcontent = currentfilecontent;
                 }
             }
         }
     }
     catch (Exception)
     {
         // Let the user know what went wrong.
     }

copywarehouse方法:

 private void copywarehouse(string filename)
 {
    string sourcePath = @"C:\Test";
    string targetPath = @"C:\Test";
    try
    {
       string sourceFile = System.IO.Path.Combine(sourcePath, filename);
       string destFile = System.IO.Path.Combine(targetPath, "tempfile.txt");
       System.IO.File.Copy(sourceFile, destFile, true);
    }
    catch (Exception)
    {

    }
}

Answer 1

你能检查以下内容吗:

1. 生成的文件编码是否与手动创建的文件相同？ (即 UTF-8/ANSI)。
2. 您是否经常刷新 streamWriter 的缓冲区？或者将 StreamWriter 的 AutoFlush 属性设置为 true。
3. 是否使用不允许读取的 WriteLock 打开 StreamWriter？在这种情况下，其他应用程序可能无法打开您的临时文件进行读取访问。

编辑:

此外，在您发布的代码中，您将 tempFile 数据与当前数据进行比较，如果 tempFile 数据比当前数据更新，您将附加临时文件，我认为 应该相反。

主要变化:

using (StreamWriter filenew = new StreamWriter(fileDetail.TempFileName, true, Encoding.ASCII))
                                {
                                    filenew.WriteLine(newContent);
                                }

要知道正确的编码，只需创建一个新的临时文件，在编辑器中写入一些内容并保存即可。在记事本中打开文件并执行“另存为”。这将在底部显示当前编码。在 .NET 代码中设置该编码。

如果这不起作用，请尝试(按照 shr 的建议):

using (StreamWriter filenew = new StreamWriter(fileDetail.TempFileName, true, Encoding.ASCII))
                                {
                                    filenew.Write(newContent + "\r\n");
                                }

长版:(可能与您的代码略有不同):

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime LastChecked = DateTime.Now;

            IDictionary<string, FileDetails> fileDetails = new Dictionary<string, FileDetails>(StringComparer.OrdinalIgnoreCase);
            IList<string> tempFileList = new List<string>();

            try
            {
                string[] files = System.IO.Directory.GetFiles(@"C:\Test", "*.jrn", System.IO.SearchOption.AllDirectories);

                foreach (string file in files)
                {
                    string currentfilename = file;
                    string currentcontent = string.Empty;

                    if (!fileDetails.Keys.Contains(file))
                    {
                        fileDetails[file] = new FileDetails(copywarehouse(file));
                        //do_some_processing();
                    }

                    try
                    {
                        using (StreamReader sr = new StreamReader(file))
                        {
                            currentcontent = sr.ReadToEnd();
                        }
                    }
                    catch (Exception)
                    {
                        // Let the user know what went wrong.
                    }

                    fileDetails[file].AddContent(currentcontent);
                }

                //TODO: Check using the file modified time. Avoids unnecessary reading of file.
                foreach (var fileDetail in fileDetails.Values)
                {
                    //checking
                    try
                    {
                        string tempFileContent = string.Empty;
                        string currentcontent = fileDetail.GetContent();

                        using (StreamReader sr = new StreamReader(fileDetail.TempFileName))
                        {
                            tempFileContent = sr.ReadToEnd();
                            sr.Close();
                        }

                        if (!(0 == string.Compare(tempFileContent, currentcontent)))
                        {
                            if (currentcontent.Contains(tempFileContent))
                            {
                                string newContent = tempFileContent.Substring(currentcontent.Length);

                                using (StreamWriter filenew = new StreamWriter(fileDetail.TempFileName, true, Encoding.ASCII))
                                {
                                    filenew.WriteLine(newContent);
                                }
                            }
                        }
                    }
                    catch (Exception)
                    {
                        // Let the user know what went wrong.
                    }

                }
            }
            catch (Exception)
            {
            }
        }

        private static string copywarehouse(string filename)
        {
            string sourcePath = @"C:\Test";
            string targetPath = @"C:\Test";

            string sourceFile = System.IO.Path.Combine(sourcePath, filename);
            string destFile = System.IO.Path.Combine(targetPath, filename+ "tempfile.txt");

            try
            {
                System.IO.File.Copy(sourceFile, destFile, true);
            }
            catch (Exception)
            {
            }

            return destFile;
        }

        internal class FileDetails
        {
            public string TempFileName { get; private set; }
            private StringBuilder _content;

            public FileDetails(string tempFileName)
            {
                TempFileName = tempFileName;
                _content = new StringBuilder();
            }

            public void AddContent(string content)
            {
                _content.Append(content);
            }

            public string GetContent()
            {
                return _content.ToString();
            }
        }
    }
}

编辑 2:您能否将 copywarehouse 更改为此并看到问题仍然存在:

         private void copywarehouse(string filename)
        {
            const string sourcePath = @"C:\Test";
            const string targetPath = @"C:\Test";
            try
            {
                string sourceFile = Path.Combine(sourcePath, filename);
                string destFile = Path.Combine(targetPath, "tempfile.txt");


                string currentcontent;
                using (var sr = new StreamReader(sourceFile))
                {
                    currentcontent = sr.ReadToEnd();
                }

                using (var wr = new StreamWriter(destFile, false, Encoding.ASCII))
                {
                    wr.WriteLine(currentcontent);
                }
            }
            catch (Exception)
            {

            }
        }