mirror of
https://github.com/runuo/runuo
synced 2026-08-11 22:26:04 -04:00
827 lines
No EOL
20 KiB
C#
827 lines
No EOL
20 KiB
C#
/***************************************************************************
|
|
* Main.cs
|
|
* -------------------
|
|
* begin : May 1, 2002
|
|
* copyright : (C) The RunUO Software Team
|
|
* email : info@runuo.com
|
|
*
|
|
* $Id$
|
|
*
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
***************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Server.Network;
|
|
using System.Runtime;
|
|
|
|
namespace Server
|
|
{
|
|
public delegate void Slice();
|
|
|
|
public static class Core
|
|
{
|
|
private static bool m_Crashed;
|
|
private static Thread timerThread;
|
|
private static string m_BaseDirectory;
|
|
private static string m_ExePath;
|
|
|
|
private static readonly List<string> m_DataDirectories = new List<string>();
|
|
|
|
private static Assembly m_Assembly;
|
|
private static Process m_Process;
|
|
private static Thread m_Thread;
|
|
private static bool m_Service;
|
|
private static bool m_Debug;
|
|
private static bool m_Cache = true;
|
|
private static bool m_HaltOnWarning;
|
|
private static bool m_VBdotNET;
|
|
private static MultiTextWriter m_MultiConOut;
|
|
|
|
private static bool m_Profiling;
|
|
private static DateTime m_ProfileStart;
|
|
private static TimeSpan m_ProfileTime;
|
|
|
|
private static MessagePump m_MessagePump;
|
|
|
|
public static MessagePump MessagePump
|
|
{
|
|
get { return m_MessagePump; }
|
|
set { m_MessagePump = value; }
|
|
}
|
|
|
|
public static Slice Slice;
|
|
|
|
public static bool Profiling
|
|
{
|
|
get { return m_Profiling; }
|
|
set
|
|
{
|
|
if( m_Profiling == value )
|
|
return;
|
|
|
|
m_Profiling = value;
|
|
|
|
if( m_ProfileStart > DateTime.MinValue )
|
|
m_ProfileTime += DateTime.UtcNow - m_ProfileStart;
|
|
|
|
m_ProfileStart = (m_Profiling ? DateTime.UtcNow : DateTime.MinValue);
|
|
}
|
|
}
|
|
|
|
public static TimeSpan ProfileTime
|
|
{
|
|
get
|
|
{
|
|
if( m_ProfileStart > DateTime.MinValue )
|
|
return m_ProfileTime + (DateTime.UtcNow - m_ProfileStart);
|
|
|
|
return m_ProfileTime;
|
|
}
|
|
}
|
|
|
|
public static bool Service { get { return m_Service; } }
|
|
public static bool Debug { get { return m_Debug; } }
|
|
internal static bool HaltOnWarning { get { return m_HaltOnWarning; } }
|
|
internal static bool VBdotNet { get { return m_VBdotNET; } }
|
|
public static List<string> DataDirectories { get { return m_DataDirectories; } }
|
|
public static Assembly Assembly { get { return m_Assembly; } set { m_Assembly = value; } }
|
|
public static Version Version { get { return m_Assembly.GetName().Version; } }
|
|
public static Process Process { get { return m_Process; } }
|
|
public static Thread Thread { get { return m_Thread; } }
|
|
public static MultiTextWriter MultiConsoleOut { get { return m_MultiConOut; } }
|
|
|
|
/*
|
|
* DateTime.Now and DateTime.UtcNow are based on actual system clock time.
|
|
* The resolution is acceptable but large clock jumps are possible and cause issues.
|
|
* GetTickCount and GetTickCount64 have poor resolution.
|
|
* GetTickCount64 is unavailable on Windows XP and Windows Server 2003.
|
|
* Stopwatch.GetTimestamp() (QueryPerformanceCounter) is high resolution, but
|
|
* somewhat expensive to call because of its defference to DateTime.Now,
|
|
* which is why Stopwatch has been used to verify HRT before calling GetTimestamp(),
|
|
* enabling the usage of DateTime.UtcNow instead.
|
|
*/
|
|
|
|
private static readonly bool _HighRes = Stopwatch.IsHighResolution;
|
|
|
|
private static readonly double _HighFrequency = 1000.0 / Stopwatch.Frequency;
|
|
private static readonly double _LowFrequency = 1000.0 / TimeSpan.TicksPerSecond;
|
|
|
|
private static bool _UseHRT;
|
|
|
|
public static bool UsingHighResolutionTiming { get { return _UseHRT && _HighRes && !Unix; } }
|
|
|
|
public static long TickCount { get { return (long)Ticks; } }
|
|
|
|
public static double Ticks
|
|
{
|
|
get
|
|
{
|
|
if (_UseHRT && _HighRes && !Unix)
|
|
{
|
|
return Stopwatch.GetTimestamp() * _HighFrequency;
|
|
}
|
|
|
|
return DateTime.UtcNow.Ticks * _LowFrequency;
|
|
}
|
|
}
|
|
|
|
public static readonly bool Is64Bit = Environment.Is64BitProcess;
|
|
|
|
private static bool m_MultiProcessor;
|
|
private static int m_ProcessorCount;
|
|
|
|
public static bool MultiProcessor { get { return m_MultiProcessor; } }
|
|
public static int ProcessorCount { get { return m_ProcessorCount; } }
|
|
|
|
private static bool m_Unix;
|
|
|
|
public static bool Unix { get { return m_Unix; } }
|
|
|
|
public static string FindDataFile( string path )
|
|
{
|
|
if( m_DataDirectories.Count == 0 )
|
|
throw new InvalidOperationException( "Attempted to FindDataFile before DataDirectories list has been filled." );
|
|
|
|
string fullPath = null;
|
|
|
|
foreach (string p in m_DataDirectories)
|
|
{
|
|
fullPath = Path.Combine( p, path );
|
|
|
|
if( File.Exists( fullPath ) )
|
|
break;
|
|
|
|
fullPath = null;
|
|
}
|
|
|
|
return fullPath;
|
|
}
|
|
|
|
public static string FindDataFile( string format, params object[] args )
|
|
{
|
|
return FindDataFile( String.Format( format, args ) );
|
|
}
|
|
|
|
#region Expansions
|
|
|
|
private static Expansion m_Expansion;
|
|
public static Expansion Expansion
|
|
{
|
|
get { return m_Expansion; }
|
|
set { m_Expansion = value; }
|
|
}
|
|
|
|
public static bool T2A
|
|
{
|
|
get { return m_Expansion >= Expansion.T2A; }
|
|
}
|
|
|
|
public static bool UOR
|
|
{
|
|
get { return m_Expansion >= Expansion.UOR; }
|
|
}
|
|
|
|
public static bool UOTD
|
|
{
|
|
get { return m_Expansion >= Expansion.UOTD; }
|
|
}
|
|
|
|
public static bool LBR
|
|
{
|
|
get { return m_Expansion >= Expansion.LBR; }
|
|
}
|
|
|
|
public static bool AOS
|
|
{
|
|
get { return m_Expansion >= Expansion.AOS; }
|
|
}
|
|
|
|
public static bool SE
|
|
{
|
|
get { return m_Expansion >= Expansion.SE; }
|
|
}
|
|
|
|
public static bool ML
|
|
{
|
|
get { return m_Expansion >= Expansion.ML; }
|
|
}
|
|
|
|
public static bool SA
|
|
{
|
|
get { return m_Expansion >= Expansion.SA; }
|
|
}
|
|
|
|
public static bool HS
|
|
{
|
|
get { return m_Expansion >= Expansion.HS; }
|
|
}
|
|
|
|
public static bool TOL
|
|
{
|
|
get { return m_Expansion >= Expansion.TOL; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
public static string ExePath
|
|
{
|
|
get { return m_ExePath ?? (m_ExePath = Assembly.Location); }
|
|
}
|
|
|
|
public static string BaseDirectory
|
|
{
|
|
get
|
|
{
|
|
if( m_BaseDirectory == null )
|
|
{
|
|
try
|
|
{
|
|
m_BaseDirectory = ExePath;
|
|
|
|
if( m_BaseDirectory.Length > 0 )
|
|
m_BaseDirectory = Path.GetDirectoryName( m_BaseDirectory );
|
|
}
|
|
catch
|
|
{
|
|
m_BaseDirectory = "";
|
|
}
|
|
}
|
|
|
|
return m_BaseDirectory;
|
|
}
|
|
}
|
|
|
|
private static void CurrentDomain_UnhandledException( object sender, UnhandledExceptionEventArgs e )
|
|
{
|
|
Console.WriteLine( e.IsTerminating ? "Error:" : "Warning:" );
|
|
Console.WriteLine( e.ExceptionObject );
|
|
|
|
if( e.IsTerminating )
|
|
{
|
|
m_Crashed = true;
|
|
|
|
bool close = false;
|
|
|
|
try
|
|
{
|
|
CrashedEventArgs args = new CrashedEventArgs( e.ExceptionObject as Exception );
|
|
|
|
EventSink.InvokeCrashed( args );
|
|
|
|
close = args.Close;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
if( !close && !m_Service )
|
|
{
|
|
try
|
|
{
|
|
foreach (Listener l in m_MessagePump.Listeners)
|
|
{
|
|
l.Dispose();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
Console.WriteLine( "This exception is fatal, press return to exit" );
|
|
Console.ReadLine();
|
|
}
|
|
|
|
Kill();
|
|
}
|
|
}
|
|
|
|
internal enum ConsoleEventType
|
|
{
|
|
CTRL_C_EVENT,
|
|
CTRL_BREAK_EVENT,
|
|
CTRL_CLOSE_EVENT,
|
|
CTRL_LOGOFF_EVENT=5,
|
|
CTRL_SHUTDOWN_EVENT
|
|
}
|
|
|
|
internal delegate bool ConsoleEventHandler( ConsoleEventType type );
|
|
internal static ConsoleEventHandler m_ConsoleEventHandler;
|
|
|
|
internal class UnsafeNativeMethods {
|
|
[DllImport("Kernel32")]
|
|
internal static extern bool SetConsoleCtrlHandler(ConsoleEventHandler callback, bool add);
|
|
}
|
|
|
|
private static bool OnConsoleEvent( ConsoleEventType type )
|
|
{
|
|
if( World.Saving || ( m_Service && type == ConsoleEventType.CTRL_LOGOFF_EVENT ) )
|
|
return true;
|
|
|
|
Kill(); //Kill -> HandleClosed will handle waiting for the completion of flushing to disk
|
|
|
|
return true;
|
|
}
|
|
|
|
private static void CurrentDomain_ProcessExit( object sender, EventArgs e )
|
|
{
|
|
HandleClosed();
|
|
}
|
|
|
|
private static bool m_Closing;
|
|
public static bool Closing { get { return m_Closing; } }
|
|
|
|
private static int m_CycleIndex = 1;
|
|
private static readonly float[] m_CyclesPerSecond = new float[100];
|
|
|
|
public static float CyclesPerSecond { get { return m_CyclesPerSecond[(m_CycleIndex - 1) % m_CyclesPerSecond.Length]; } }
|
|
|
|
public static float AverageCPS { get { return m_CyclesPerSecond.Take(m_CycleIndex).Average(); } }
|
|
|
|
public static void Kill()
|
|
{
|
|
Kill( false );
|
|
}
|
|
|
|
public static void Kill( bool restart )
|
|
{
|
|
HandleClosed();
|
|
|
|
if ( restart )
|
|
Process.Start( ExePath, Arguments );
|
|
|
|
m_Process.Kill();
|
|
}
|
|
|
|
private static void HandleClosed()
|
|
{
|
|
if( m_Closing )
|
|
return;
|
|
|
|
m_Closing = true;
|
|
|
|
Console.Write( "Exiting..." );
|
|
|
|
World.WaitForWriteCompletion();
|
|
|
|
if( !m_Crashed )
|
|
EventSink.InvokeShutdown( new ShutdownEventArgs() );
|
|
|
|
Timer.TimerThread.Set();
|
|
|
|
Console.WriteLine( "done" );
|
|
}
|
|
|
|
private static readonly AutoResetEvent m_Signal = new AutoResetEvent( true );
|
|
|
|
public static void Set() { m_Signal.Set(); }
|
|
|
|
public static void Main( string[] args )
|
|
{
|
|
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
|
|
AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
|
|
|
|
foreach (string a in args)
|
|
{
|
|
if ( Insensitive.Equals( a, "-debug" ) )
|
|
m_Debug = true;
|
|
else if ( Insensitive.Equals( a, "-service" ) )
|
|
m_Service = true;
|
|
else if ( Insensitive.Equals( a, "-profile" ) )
|
|
Profiling = true;
|
|
else if ( Insensitive.Equals( a, "-nocache" ) )
|
|
m_Cache = false;
|
|
else if ( Insensitive.Equals( a, "-haltonwarning" ) )
|
|
m_HaltOnWarning = true;
|
|
else if ( Insensitive.Equals( a, "-vb" ) )
|
|
m_VBdotNET = true;
|
|
else if ( Insensitive.Equals( a, "-usehrt" ) )
|
|
_UseHRT = true;
|
|
}
|
|
|
|
try
|
|
{
|
|
if( m_Service )
|
|
{
|
|
if( !Directory.Exists( "Logs" ) )
|
|
Directory.CreateDirectory( "Logs" );
|
|
|
|
Console.SetOut( m_MultiConOut = new MultiTextWriter( new FileLogger( "Logs/Console.log" ) ) );
|
|
}
|
|
else
|
|
{
|
|
Console.SetOut( m_MultiConOut = new MultiTextWriter( Console.Out ) );
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
m_Thread = Thread.CurrentThread;
|
|
m_Process = Process.GetCurrentProcess();
|
|
m_Assembly = Assembly.GetEntryAssembly();
|
|
|
|
if( m_Thread != null )
|
|
m_Thread.Name = "Core Thread";
|
|
|
|
if( BaseDirectory.Length > 0 )
|
|
Directory.SetCurrentDirectory( BaseDirectory );
|
|
|
|
Timer.TimerThread ttObj = new Timer.TimerThread();
|
|
timerThread = new Thread(ttObj.TimerMain)
|
|
{
|
|
Name = "Timer Thread"
|
|
};
|
|
|
|
Version ver = m_Assembly.GetName().Version;
|
|
|
|
// Added to help future code support on forums, as a 'check' people can ask for to it see if they recompiled core or not
|
|
Console.WriteLine("RunUO - [https://github.com/runuo/] Version {0}.{1}.{2}.{3}", ver.Major, ver.Minor, ver.Build, ver.Revision);
|
|
Console.WriteLine("Core: Running on .NET Framework Version {0}.{1}.{2}", Environment.Version.Major, Environment.Version.Minor, Environment.Version.Build);
|
|
|
|
string s = Arguments;
|
|
|
|
if( s.Length > 0 )
|
|
Console.WriteLine( "Core: Running with arguments: {0}", s );
|
|
|
|
m_ProcessorCount = Environment.ProcessorCount;
|
|
|
|
if( m_ProcessorCount > 1 )
|
|
m_MultiProcessor = true;
|
|
|
|
if( m_MultiProcessor || Is64Bit )
|
|
Console.WriteLine( "Core: Optimizing for {0} {2}processor{1}", m_ProcessorCount, m_ProcessorCount == 1 ? "" : "s", Is64Bit ? "64-bit " : "" );
|
|
|
|
int platform = (int)Environment.OSVersion.Platform;
|
|
if( platform == 4 || platform == 128 ) { // MS 4, MONO 128
|
|
m_Unix = true;
|
|
Console.WriteLine( "Core: Unix environment detected" );
|
|
}
|
|
else {
|
|
m_ConsoleEventHandler = OnConsoleEvent;
|
|
UnsafeNativeMethods.SetConsoleCtrlHandler( m_ConsoleEventHandler, true );
|
|
}
|
|
|
|
if ( GCSettings.IsServerGC )
|
|
Console.WriteLine("Core: Server garbage collection mode enabled");
|
|
|
|
if (_UseHRT)
|
|
Console.WriteLine("Core: Requested high resolution timing ({0})", UsingHighResolutionTiming ? "Supported" : "Unsupported");
|
|
|
|
Console.WriteLine("RandomImpl: {0} ({1})", RandomImpl.Type.Name, RandomImpl.IsHardwareRNG ? "Hardware" : "Software");
|
|
|
|
while( !ScriptCompiler.Compile( m_Debug, m_Cache ) )
|
|
{
|
|
Console.WriteLine( "Scripts: One or more scripts failed to compile or no script files were found." );
|
|
|
|
if( m_Service )
|
|
return;
|
|
|
|
Console.WriteLine( " - Press return to exit, or R to try again." );
|
|
|
|
if( Console.ReadKey( true ).Key != ConsoleKey.R )
|
|
return;
|
|
}
|
|
|
|
ScriptCompiler.Invoke( "Configure" );
|
|
|
|
Region.Load();
|
|
World.Load();
|
|
|
|
ScriptCompiler.Invoke( "Initialize" );
|
|
|
|
MessagePump messagePump = m_MessagePump = new MessagePump();
|
|
|
|
timerThread.Start();
|
|
|
|
foreach (Map m in Map.AllMaps)
|
|
m.Tiles.Force();
|
|
|
|
NetState.Initialize();
|
|
|
|
EventSink.InvokeServerStarted();
|
|
|
|
try
|
|
{
|
|
long now, last = TickCount;
|
|
|
|
const int sampleInterval = 100;
|
|
const float ticksPerSecond = 1000.0f * sampleInterval;
|
|
|
|
long sample = 0;
|
|
|
|
while( !m_Closing )
|
|
{
|
|
m_Signal.WaitOne();
|
|
|
|
Mobile.ProcessDeltaQueue();
|
|
Item.ProcessDeltaQueue();
|
|
|
|
Timer.Slice();
|
|
messagePump.Slice();
|
|
|
|
NetState.FlushAll();
|
|
NetState.ProcessDisposedQueue();
|
|
|
|
if( Slice != null )
|
|
Slice();
|
|
|
|
if (sample++ % sampleInterval != 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
now = TickCount;
|
|
m_CyclesPerSecond[m_CycleIndex++ % m_CyclesPerSecond.Length] = ticksPerSecond / (now - last);
|
|
last = now;
|
|
}
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
CurrentDomain_UnhandledException( null, new UnhandledExceptionEventArgs( e, true ) );
|
|
}
|
|
}
|
|
|
|
public static string Arguments
|
|
{
|
|
get
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
if( m_Debug )
|
|
Utility.Separate( sb, "-debug", " " );
|
|
|
|
if( m_Service )
|
|
Utility.Separate( sb, "-service", " " );
|
|
|
|
if( m_Profiling )
|
|
Utility.Separate( sb, "-profile", " " );
|
|
|
|
if( !m_Cache )
|
|
Utility.Separate( sb, "-nocache", " " );
|
|
|
|
if( m_HaltOnWarning )
|
|
Utility.Separate( sb, "-haltonwarning", " " );
|
|
|
|
if ( m_VBdotNET )
|
|
Utility.Separate( sb, "-vb", " " );
|
|
|
|
if ( _UseHRT )
|
|
Utility.Separate( sb, "-usehrt", " " );
|
|
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
|
|
private static int m_GlobalUpdateRange = 18;
|
|
|
|
public static int GlobalUpdateRange
|
|
{
|
|
get { return m_GlobalUpdateRange; }
|
|
set { m_GlobalUpdateRange = value; }
|
|
}
|
|
|
|
private static int m_GlobalMaxUpdateRange = 24;
|
|
|
|
public static int GlobalMaxUpdateRange
|
|
{
|
|
get { return m_GlobalMaxUpdateRange; }
|
|
set { m_GlobalMaxUpdateRange = value; }
|
|
}
|
|
|
|
private static int m_ItemCount, m_MobileCount;
|
|
|
|
public static int ScriptItems { get { return m_ItemCount; } }
|
|
public static int ScriptMobiles { get { return m_MobileCount; } }
|
|
|
|
public static void VerifySerialization()
|
|
{
|
|
m_ItemCount = 0;
|
|
m_MobileCount = 0;
|
|
|
|
var ca = Assembly.GetCallingAssembly();
|
|
|
|
VerifySerialization(ca);
|
|
|
|
foreach (var a in ScriptCompiler.Assemblies.Where(a => a != ca))
|
|
{
|
|
VerifySerialization(a);
|
|
}
|
|
}
|
|
|
|
private static readonly Type[] m_SerialTypeArray = { typeof(Serial) };
|
|
|
|
private static void VerifyType(Type t)
|
|
{
|
|
var isItem = t.IsSubclassOf(typeof(Item));
|
|
|
|
if (!isItem && !t.IsSubclassOf(typeof(Mobile)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (isItem)
|
|
{
|
|
//++_ItemCount;
|
|
Interlocked.Increment(ref m_ItemCount);
|
|
}
|
|
else
|
|
{
|
|
//++_MobileCount;
|
|
Interlocked.Increment(ref m_MobileCount);
|
|
}
|
|
|
|
StringBuilder warningSb = null;
|
|
|
|
try
|
|
{
|
|
if (t.GetConstructor(m_SerialTypeArray) == null)
|
|
{
|
|
warningSb = new StringBuilder();
|
|
|
|
warningSb.AppendLine(" - No serialization constructor");
|
|
}
|
|
|
|
if (
|
|
t.GetMethod(
|
|
"Serialize",
|
|
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly) == null)
|
|
{
|
|
if (warningSb == null)
|
|
{
|
|
warningSb = new StringBuilder();
|
|
}
|
|
|
|
warningSb.AppendLine(" - No Serialize() method");
|
|
}
|
|
|
|
if (
|
|
t.GetMethod(
|
|
"Deserialize",
|
|
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly) == null)
|
|
{
|
|
if (warningSb == null)
|
|
{
|
|
warningSb = new StringBuilder();
|
|
}
|
|
|
|
warningSb.AppendLine(" - No Deserialize() method");
|
|
}
|
|
|
|
if (warningSb != null && warningSb.Length > 0)
|
|
{
|
|
Console.WriteLine("Warning: {0}\n{1}", t, warningSb);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Warning: Exception in serialization verification of type {0}", t);
|
|
}
|
|
}
|
|
|
|
private static void VerifySerialization(Assembly a)
|
|
{
|
|
if (a != null)
|
|
{
|
|
Parallel.ForEach(a.GetTypes(), VerifyType);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class FileLogger : TextWriter
|
|
{
|
|
public const string DateFormat = "[MMMM dd hh:mm:ss.f tt]: ";
|
|
|
|
private bool _NewLine;
|
|
|
|
public string FileName { get; private set; }
|
|
|
|
public FileLogger(string file)
|
|
: this(file, false)
|
|
{ }
|
|
|
|
public FileLogger(string file, bool append)
|
|
{
|
|
FileName = file;
|
|
|
|
using (
|
|
var writer =
|
|
new StreamWriter(
|
|
new FileStream(FileName, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
writer.WriteLine(">>>Logging started on {0}.", DateTime.UtcNow.ToString("f"));
|
|
//f = Tuesday, April 10, 2001 3:51 PM
|
|
}
|
|
|
|
_NewLine = true;
|
|
}
|
|
|
|
public override void Write(char ch)
|
|
{
|
|
using (var writer = new StreamWriter(new FileStream(FileName, FileMode.Append, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
if (_NewLine)
|
|
{
|
|
writer.Write(DateTime.UtcNow.ToString(DateFormat));
|
|
_NewLine = false;
|
|
}
|
|
|
|
writer.Write(ch);
|
|
}
|
|
}
|
|
|
|
public override void Write(string str)
|
|
{
|
|
using (var writer = new StreamWriter(new FileStream(FileName, FileMode.Append, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
if (_NewLine)
|
|
{
|
|
writer.Write(DateTime.UtcNow.ToString(DateFormat));
|
|
_NewLine = false;
|
|
}
|
|
|
|
writer.Write(str);
|
|
}
|
|
}
|
|
|
|
public override void WriteLine(string line)
|
|
{
|
|
using (var writer = new StreamWriter(new FileStream(FileName, FileMode.Append, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
if (_NewLine)
|
|
{
|
|
writer.Write(DateTime.UtcNow.ToString(DateFormat));
|
|
}
|
|
|
|
writer.WriteLine(line);
|
|
_NewLine = true;
|
|
}
|
|
}
|
|
|
|
public override Encoding Encoding { get { return Encoding.Default; } }
|
|
}
|
|
|
|
public class MultiTextWriter : TextWriter
|
|
{
|
|
private readonly List<TextWriter> _Streams;
|
|
|
|
public MultiTextWriter(params TextWriter[] streams)
|
|
{
|
|
_Streams = new List<TextWriter>(streams);
|
|
|
|
if (_Streams.Count < 0)
|
|
{
|
|
throw new ArgumentException("You must specify at least one stream.");
|
|
}
|
|
}
|
|
|
|
public void Add(TextWriter tw)
|
|
{
|
|
_Streams.Add(tw);
|
|
}
|
|
|
|
public void Remove(TextWriter tw)
|
|
{
|
|
_Streams.Remove(tw);
|
|
}
|
|
|
|
public override void Write(char ch)
|
|
{
|
|
foreach (var t in _Streams)
|
|
{
|
|
t.Write(ch);
|
|
}
|
|
}
|
|
|
|
public override void WriteLine(string line)
|
|
{
|
|
foreach (var t in _Streams)
|
|
{
|
|
t.WriteLine(line);
|
|
}
|
|
}
|
|
|
|
public override void WriteLine(string line, params object[] args)
|
|
{
|
|
WriteLine(String.Format(line, args));
|
|
}
|
|
|
|
public override Encoding Encoding { get { return Encoding.Default; } }
|
|
}
|
|
} |