0

感谢大家对这个问题感兴趣。你们中的一些人要求更清楚地了解所涉及的代码，因此为了提供更多信息，我将对其进行编辑以提供更多细节。

关于我之前的问题，我正在尝试在 WPF 窗口中模拟基本控制台（仅限文本输出）。它适用于在后台运行大量代码并在单独线程上运行的程序。这段代码也严重依赖 while 循环，因此我的计划是将 WPF 控制台窗口保留在主线程上（以及可能需要的任何其他 GUI 窗口）并在单独的线程上执行所有代码。

该窗口有一个 WriteLine 方法，使用如下：

mainConsole.WriteLine("This is a message for the user.", SomeSender);

其余代码将需要定期调用此方法。

附加信息：

窗口本身由包裹在 Scroller 中的 Textblock 组成。窗口的 WriteLine 方法将消息和格式（字体、字体大小和颜色 - 取决于消息的发送者）添加到包含此信息的对象列表中，然后显示这些消息的列表，包括它们的格式）作为文本块的内容。该方法完全按照预期工作，因此不需要重写，只需要可访问即可。

我试图使这个描述尽可能简洁。有关更多信息，请参阅我之前的问题。

所以我现在的问题是：是否有一种有效的方法可以使窗口的 WriteLine 方法可用于任何类的所有线程，从而使我能够像 Console.WriteLine() 一样使用它？

4

4 回答 4

1

虽然您有多种选择，但听起来，就您而言，任何人在任何地方都能够写入您的控制台确实很有意义。鉴于此，我会创建这样的东西：

public class MyConsole
{
    public static event Action<string> TextWritten;
    public static void Write(object obj)
    {
        string text = (obj ?? "").ToString();
        if (TextWritten != null)
            TextWritten(text);
    }

    public static void WriteLine(object obj)
    {
        Write(obj + "\n");
    }
}

然后让您的控制台表单订阅该TextWritten事件，并在写入文本时将该文本写入控制台。（确保首先编组到 UI 线程。）

与让此类直接处理您的表单相比，在这里使用和事件的主要优点是您可以轻松添加额外的事件处理程序，允许您与标准输入/输出交互，向文件添加额外的日志记录，拥有多个控制台表单立即打开，等等。这种灵活性对于调试（即向平面文件的附加写入）和生产（允许通过标准输入/输出更轻松地重定向）都很有用。

于 2013-01-21T17:58:30.853 回答
1

您似乎正在尝试编写一个日志服务，该服务允许您从代码中的任何位置访问日志。您提到了线程，因此您必须注意并相应地处理该同步。

我会首先创建一个ILogger这样的界面：

public interface ILogger
{
  void Log(string line);
  void Log(string format, params object[] args);
}

然后是一个适当的Logger基类：

public abstract class Logger : ILogger
{
  public abstract void Log(string line);

  public virtual void Log(string format, params object[] args)
  {
    Log(string.Format(format, args));
  }
}

当然，您将需要一个实际的实现：

using System.Collections.Concurrent;
using System.Threading.Tasks;

public class ConcurrentLogger : Logger, ILogger, IDisposable
{
  bool isDisposed;
  BlockingCollection<string> loggedLines;
  Action<string> callback;

  public ConcurrentLogger(Action<string> callback)
  {
    if (callback == null)
      throw new ArgumentNullException("callback");

    var queue = new ConcurrentQueue<string>();
    this.loggedLines = new BlockingCollection<string>(queue);

    this.callback = callback;

    StartMonitoring();
  }

  public void Dispose()
  {
    Dispose(true);
    GC.SuppressFinalize(this);
  }

  protected virtual void Dispose(bool isDisposing)
  {
    if (isDisposed) return;

    if (isDisposing)
    {
      if (loggedLines != null)
        loggedLines.CompleteAdding();
    }

    isDisposed = true;
  }

  public override void Log(string line)
  {
    if (!loggedLines.IsAddingCompleted)
      loggedLines.Add(line);
  }

  protected virtual void StartMonitoring()
  {
    Task.Factory.StartNew(() =>
      {
        foreach (var line in loggedLines.GetConsumingEnumerable())
        {
          if (callback != null)
            callback(line);
        }

        loggedLines.Dispose();

      }, TaskCreationOptions.LongRunning);
  }
}

对于全局访问，您将需要一个Singleton类，所以我会创建这个LogManager类：

public sealed class LogManager : ILogger
{
  #region Singleton
  static readonly LogManager instance = new LogManager();

  public static LogManager Current { get { return instance; } }

  private LogManager() { } // Disallow creating instances.
  #endregion

  ILogger logger;

  public ILogger Logger { get { return logger; } }

  public void StartLogging(ILogger logger)
  {
    if (logger == null)
      throw new ArgumentNullException("logger");

    this.logger = logger;
  }

  public void StopLogging(bool dispose = true)
  {
    var previousLogger = this.logger as IDisposable;
    this.logger =null;

    if (previousLogger != null && dispose)
      previousLogger.Dispose();
  }

  public void Log(string line)
  {
    if (logger != null) logger.Log(line);
  }

  public void Log(string format, params object[] args)
  {
    if (logger != null) logger.Log(format, args);
  }
}

通过一些快速初始化：

void InitializeLog()
{
  var log = new ConcurrentLogger(LogToTextBox);
  LogManager.Current.StartLogging(log);
}

void LogToTextBox(string line)
{
  if (!CheckAccess())
  {
    this.Dispatcher.BeginInvoke((Action<string>)LogToTextBox,
                                DispatcherPriority.Background, 
                                line);
    return;
  }

  logTextBox.AppendText(line + Environment.NewLine);
}

然后您可以在代码中的任何位置调用：LogManager.Current.Log(...);

于 2013-01-21T18:12:17.023 回答
0

创建一个静态类，该类包含 WriteLine 方法和一个引用窗口、控件或您在 writeline 方法中需要的任何内容的属性。然后将一些代码添加到您的 MainWindow 构造函数或加载的事件中，以将 Reference-Property 设置为所需的项目。之后，您可以在任何地方使用 Writeline。

顺便说一句：使用带有 Instance getter 的静态 MainViewModel 可能会更干净，将 MainWindow 的 DataContext 绑定到此 ViewModel 并使用 MVVM 模式。然后，您只需设置一些 ConsoleOutput 属性或调用 AddLine 方法，甚至从您想要的任何地方调用命令，而不必知道视图如何显示它。您可以使用单元测试来测试您的应用程序，您可以更改视觉表示，......所有这些都无需触及应用程序的逻辑。

于 2013-01-21T18:00:42.957 回答
-1 
namespace {yourrootnamespace}
{
   namespace GlobalMethods
   {
        static class ConsoleMethods
        {
        mainConsole mc;
        public static WriteLine(string msg, object sender)
        {
            lock (this)
            {
                mc.WriteLine(msg, sender)
            }
        }
        static ConsoleMethods()
        {
            mc = new mainConsole();
        }
        //more methods
    }
}

接着：using {yourrootnamespace}.GlobalMethods;

或者，让这些方法接受一个 mainConsole 参数，然后使用它来调用。

于 2013-01-21T17:53:40.033 回答