public LoggerConfig()
{
outputFolder = Path.Combine(Path.Combine(Path.GetFullPath("."), "Assets"));
bufferLength = 50;
timeStampType = TimeStampType.realtimeSinceStartup;
dataBuffer = new DataBuffer();
}
/// <summary>
/// 时间戳转DateTime
/// </summary>
/// <param name="timeStamp">时间戳</param>
/// <param name="type">类型：秒，毫秒</param>
/// <returns></returns>
public static DateTime TimeStampToDateTime(string timeStamp, TimeStampType type = TimeStampType.秒)
{
var startTime = TimeZoneInfo.ConvertTimeFromUtc(new DateTime(1970, 1, 1), TimeZoneInfo.Local).ToLocalTime();
var time = long.Parse(timeStamp);
return(type switch
{
TimeStampType.秒 => startTime.AddSeconds(time),
TimeStampType.毫秒 => startTime.AddMilliseconds(time),
_ => startTime.AddSeconds(time)
});
/// <summary>
/// 获取指定时间戳所对应的时间
/// </summary>
/// <param name="timestamp">时间戳</param>
/// <param name="timeStampType">时间戳类型</param>
/// <returns>实际时间</returns>
public static DateTime GetDateTime(long timestamp, TimeStampType timeStampType = TimeStampType.Seconds)
{
if (timeStampType == TimeStampType.Seconds)
{
return(new DateTime(1970, 1, 1).AddHours(8).AddSeconds(timestamp));
}
else
{
return(new DateTime(1970, 1, 1).AddHours(8).AddMilliseconds(timestamp));
}
}
public DateTime GetTimeStampByType(TimeStampType timeStampType = TimeStampType.Start)
{
if (timeStampType == TimeStampType.Start) return Start;
if (timeStampType == TimeStampType.End)
{
return End;
}
if (timeStampType == TimeStampType.Middle)
{
return Start + TimeSpan.FromMinutes((End - Start).TotalMinutes/2);
}
return Start;
}
/// <summary>
/// 获取指定时间的时间戳
/// </summary>
/// <param name="datetime">指定时间</param>
/// <param name="timeStampType">所需时间戳类型</param>
/// <returns>时间戳</returns>
public static long GetTime(DateTime datetime, TimeStampType timeStampType = TimeStampType.Seconds)
{
TimeSpan timeSpan = datetime - new DateTime(1970, 1, 1).AddHours(8);
if (timeStampType == TimeStampType.Seconds)
{
return(Convert.ToInt64(timeSpan.TotalSeconds));
}
else
{
return(Convert.ToInt64(timeSpan.TotalMilliseconds));
}
}
public Log(string fileName, LocationLog locationLog = LocationLog.LogFolder, TimeStampType timestampType = TimeStampType.JustTime, FileNameSuffixLog suffixLog = FileNameSuffixLog.Date, int maxLogs = 10)
{
TimeStampType = timestampType;
LocationLog = locationLog;
FileNameSuffix = suffixLog;
_maxLogs = maxLogs;
if (!string.IsNullOrEmpty(Path.GetDirectoryName(fileName)))
{
LocationLog = LocationLog.Custom;
_folder = Path.GetDirectoryName(fileName);
_filename = Path.GetFileNameWithoutExtension(fileName);
}
else
{
_filename = Path.GetFileNameWithoutExtension(fileName);
switch (locationLog)
{
case LocationLog.Custom:
case LocationLog.SameFolder:
_folder = ".";
break;
case LocationLog.LogFolder:
_folder = "./log";
break;
case LocationLog.ProgramDataFolder:
_folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), _vendor, _system);
break;
}
_folder = Path.GetFullPath(_folder);
}
LastException = "";
if (!Directory.Exists(_folder))
{
try
{
Directory.CreateDirectory(_folder);
}
catch (Exception e)
{
LastException = e.Message;
throw new LogException("Erro ao criar diretório " + _folder, e);
}
if (!Directory.Exists(_folder))
{
throw new LogException("Diretório " + _folder + " não foi encontrado");
}
}
}
public TimeType convertTime(TimeStampType origType)
{
TimeType newType;
newType.c_seconds = origType.time.c_seconds;
newType.seconds = origType.time.seconds;
newType.minutes = origType.time.minutes;
newType.hours = origType.time.hours;
newType.day = origType.date.day;
newType.month = origType.date.month;
newType.year = origType.date.year;
return(newType);
}
/// <summary>
/// 将时间戳转换为datetime
/// </summary>
/// <param name="stamp"></param>
/// <param name="timeStampType"></param>
/// <returns></returns>
public static DateTime ConvertStampToDateTime(long stamp, TimeStampType timeStampType = TimeStampType.TenLength)
{
TimeSpan ts = default;
if (timeStampType == TimeStampType.TenLength)
{
ts = new TimeSpan((stamp * 1000 * 10000) + 621355968000000000);
}
else if (timeStampType == TimeStampType.ThirteenLength)
{
ts = new TimeSpan((stamp * 10000) + 621355968000000000);
}
return(new DateTime(ts.Ticks));
}
public DateTime GetTimeStampByType(TimeStampType timeStampType = TimeStampType.Start)
{
if (timeStampType == TimeStampType.Start)
{
return(Start);
}
if (timeStampType == TimeStampType.End)
{
return(End);
}
if (timeStampType == TimeStampType.Middle)
{
return(Start + TimeSpan.FromMinutes((End - Start).TotalMinutes / 2));
}
return(Start);
}
/// <summary>
/// 获取对应时间的时间戳
/// </summary>
/// <param name="timeStampType"></param>
/// <returns></returns>
public static long GetTimeStamp(DateTime date, TimeStampType timeStampType = TimeStampType.TenLength)
{
//1970-01-01的Ticks值
long tStart = 621355968000000000;
TimeSpan ts = new TimeSpan(new DateTimeOffset(date).Ticks - tStart);
if (timeStampType == TimeStampType.TenLength)
{
return(Convert.ToInt64(ts.TotalSeconds));
}
if (timeStampType == TimeStampType.TenLength)
{
return(Convert.ToInt64(ts.TotalMilliseconds));
}
return(0);
}
public string ToUnixTime(string str)
{
if (str.IsNullOrWhiteSpace())
{
return(null);
}
if (str.Equals("now", StringComparison.OrdinalIgnoreCase))
{
return(DateTime.Now.ToTimeStamp().ToString());
}
TimeStampType timeStampType = TimeStampType.Unix;
if (!Type.IsNullOrWhiteSpace())
{
if (str.Equals("js", StringComparison.OrdinalIgnoreCase) || str.Equals("javascript", StringComparison.OrdinalIgnoreCase))
{
timeStampType = TimeStampType.Javascript;
}
}
return(str.ToUnixTimeStamp(timeStampType).ToString());
}
/// <summary>
/// Input default direction, date data constructor with ability to specify first value
/// </summary>
/// <param name="pName"></param>
/// <param name="val"></param>
/// <param name="tType"></param>
public OracleProcParam(string pName, DateTime val, TimeStampType tType)
{
this.paramIsClob = false;
this.Direction = ParameterDirection.Input;
this.dataTypeName = DataTypeConstants.PawnDataType.DATE;
this.Name = pName;
this.parameterValues = new List <object>(1);
this.arraySize = 1;
string tZVal = string.Empty;
switch (tType)
{
case TimeStampType.TIMESTAMP:
this.OracleType = OracleDbType.TimeStamp;
tZVal = OracleDataAccessor.GenerateOracleTimestampString(val);
break;
case TimeStampType.TIMESTAMP_TZ:
this.OracleType = OracleDbType.TimeStampTZ;
tZVal = OracleDataAccessor.GenerateOracleTimestampTZString(val);
break;
case TimeStampType.TIMESTAMP_LTZ:
this.OracleType = OracleDbType.TimeStampLTZ;
tZVal = OracleDataAccessor.GenerateOracleTimestampLTZString(val);
break;
}
//Add value
if (val != DateTime.MaxValue)
{
this.AddValue(tZVal);
}
else
{
this.dataTypeName = DataTypeConstants.PawnDataType.NULLDATE;
this.ComputeDataType();
this.AddValue(string.Empty);
}
}
/// <summary>
/// 时间戳转DateTime
/// </summary>
/// <param name="timestr"></param>
/// <returns></returns>
public static DateTime GetTimeFromTimeStampInt(this string timestr, TimeStampType type)
{
DateTime dtStart;
long lTime;
TimeSpan toNow;
switch (type)
{
case TimeStampType.Ten:
dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
lTime = long.Parse(timestr + "0000000");
toNow = new TimeSpan(lTime);
return(dtStart.Add(toNow));
case TimeStampType.Thirteen:
dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
lTime = long.Parse(timestr + "0000");
toNow = new TimeSpan(lTime);
return(dtStart.Add(toNow));;
default:
return(DateTime.Now);
}
}
public TimeStamp(TimeStampType type, int time)
{
z_type = type;
z_time = time;
}
public TimeStamp(TimeStampType type, uint time)
{
Type = type;
Time = time;
}
/// <summary>
/// Creates a new instance of a <see cref="TimeStampConfiguration" />.
/// </summary>
/// <param name="url">The URL to the timestamp authority.</param>
/// <param name="digestAlgorithm">The digest algorithm the timestamp service authority should use on timestamp signatures.</param>
/// <param name="type">The type of timestamp to use. See <see cref="TimeStampType" /> for details.</param>
public TimeStampConfiguration(string url, HashAlgorithmName digestAlgorithm, TimeStampType type)
{
Url = url;
DigestAlgorithm = digestAlgorithm;
Type = type;
}
/// <summary>
/// Input default direction, date data constructor with ability to specify first value
/// </summary>
/// <param name="pName"></param>
/// <param name="val"></param>
/// <param name="tType"></param>
public OracleProcParam(string pName, DateTime val, TimeStampType tType)
{
this.paramIsClob = false;
this.Direction = ParameterDirection.Input;
this.dataTypeName = DataTypeConstants.PawnDataType.DATE;
this.Name = pName;
this.parameterValues = new List<object>(1);
this.arraySize = 1;
string tZVal = string.Empty;
switch (tType)
{
case TimeStampType.TIMESTAMP:
this.OracleType = OracleDbType.TimeStamp;
tZVal = OracleDataAccessor.GenerateOracleTimestampString(val);
break;
case TimeStampType.TIMESTAMP_TZ:
this.OracleType = OracleDbType.TimeStampTZ;
tZVal = OracleDataAccessor.GenerateOracleTimestampTZString(val);
break;
case TimeStampType.TIMESTAMP_LTZ:
this.OracleType = OracleDbType.TimeStampLTZ;
tZVal = OracleDataAccessor.GenerateOracleTimestampLTZString(val);
break;
}
//Add value
if (val != DateTime.MaxValue)
{
this.AddValue(tZVal);
}
else
{
this.dataTypeName = DataTypeConstants.PawnDataType.NULLDATE;
this.ComputeDataType();
this.AddValue(string.Empty);
}
}
public void updatePresence(string details = DefaultStatusString, string state = DefaultStatusString, TimeStampType startTimeStamp = TimeStampType.Keep)
{
if (!gameObject.activeInHierarchy)
{
return;
}
if (details.Equals(DefaultStatusString))
{
details = presence.details;
}
if (state.Equals(DefaultStatusString))
{
state = presence.state;
}
StopCoroutine(updatePresenceCoroutine());
presence.details = details;
presence.state = state;
presence.largeImageKey = largeImageKey;
switch (startTimeStamp)
{
case (TimeStampType.Keep):
break;
case (TimeStampType.CurrentTime):
presence.startTimestamp = getTimeSinceEpoch();
break;
case (TimeStampType.Clear):
presence.startTimestamp = 0;
break;
}
StartCoroutine(updatePresenceCoroutine());
}
/// <summary>
/// 字符串形式时间戳转DateTime
/// </summary>
/// <returns>转换失败返回<see cref="DateTime"/>的default</returns>
public static DateTime ToDateTime(this string timestampStr, TimeStampType timeStampType = TimeStampType.Unix)
{
return(long.TryParse(timestampStr, out long timestamp) ? ToDateTime(timestamp, timeStampType) : default);
public TimeStamp(BinaryReader br)
{
z_type = (TimeStampType)br.ReadInt32();
z_time = br.ReadInt32();
}
