public LogMessage(string text, DateTime timestamp, string sourceInfo, LogMessageType type) { this.text = text; this.timestamp = timestamp; this.sourceInfo = sourceInfo; this.type = type; }
/// <summary> /// Write Log By MessageType /// </summary> /// <param name="message">Message</param> /// <param name="messageType">MessageType</param> /// <param name="ex">Exception Object</param> /// <param name="type">Log Source Type</param> private static void DoLog(string message, LogMessageType messageType, Exception ex, Type type) { string stackTrace = string.Empty; if (ex != null) { stackTrace = ex.StackTrace; } _mLog = LogManager.GetLogger(type); switch (messageType) { case LogMessageType.Debug: //AppLog._mLog.Debug(message + " ExceptionStackTrace:" + stackTrace, ex);//Edit by Gerry AppLog._mLog.Debug(message + stackTrace, ex); break; case LogMessageType.Info: AppLog._mLog.Info(message + stackTrace, ex); break; case LogMessageType.Warn: AppLog._mLog.Warn(message + stackTrace, ex); break; case LogMessageType.Error: AppLog._mLog.Error(message + stackTrace, ex); break; case LogMessageType.Fatal: AppLog._mLog.Fatal(message + stackTrace, ex); break; } }
/// <summary> /// Initializes a new instance of the <see cref="LogMessage"/> class. /// </summary> /// <param name="content"> /// The content. /// </param> /// <param name="messageType"> /// The message type. /// </param> /// <param name="logLevel"> /// The log level. /// </param> /// <param name="messageIndex"> /// The message Index. /// </param> public LogMessage(string content, LogMessageType messageType, LogLevel logLevel, long messageIndex) { this.Content = content; this.MessageType = messageType; this.LogLevel = logLevel; this.MessageIndex = messageIndex; }
public LogMessage(String message, LogMessageType type, LogMessageSeverity severity, Exception exception) { Message = message; Type = type; Severity = severity; Exception = exception; }
/// <summary> /// Writes a single message to the output. /// </summary> /// <param name="source">The <see cref="Log"/> from which the message originates.</param> /// <param name="type">The type of the log message.</param> /// <param name="msg">The message to write.</param> /// <param name="context">The context in which this log was written. Usually the primary object the log entry is associated with.</param> public virtual void Write(Log source, LogMessageType type, string msg, object context) { int indent = source.Indent; string prefix = source.Prefix ?? ""; string[] lines = msg.Split(new[] { '\n', '\r', '\0' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < lines.Length; i++) { if (i == 0) { switch (type) { case LogMessageType.Message: lines[i] = prefix + "Msg: " + new string(' ', indent * 2) + lines[i]; break; case LogMessageType.Warning: lines[i] = prefix + "Wrn: " + new string(' ', indent * 2) + lines[i]; break; case LogMessageType.Error: lines[i] = prefix + "ERR: " + new string(' ', indent * 2) + lines[i]; break; } } else { lines[i] = new string(' ', prefix.Length + 5 + indent * 2) + lines[i]; } this.WriteLine(source, type, lines[i], context); } }
// Help methods that use our FileSystem abstraction public override void AppendLog(String message, LogMessageType messageType) { string textEntry = string.Format("{0:MM-dd-yyyy HH:mm:ss:ffff} :{1}: [{2}] {3}", DateTime.Now, System.Threading.Thread.CurrentThread.ManagedThreadId, messageType.ToString(), message); switch (messageType) { case LogMessageType.Info: Android.Util.Log.Info(TAG, message); break; case LogMessageType.Warn: Android.Util.Log.Debug(TAG, message); break; case LogMessageType.Debug: Android.Util.Log.Debug(TAG, message); break; case LogMessageType.Error: Android.Util.Log.Error(TAG, message); break; case LogMessageType.Fatal: Android.Util.Log.Wtf(TAG, message); break; case LogMessageType.Metric: Android.Util.Log.Debug( TAG_METRIC, message ); break; default: break; } AppendText(LogFileName, textEntry); }
void Colorize ( LogMessageType eventType ) { switch (eventType) { case LogMessageType.Debug : Console.ForegroundColor = ConsoleColor.DarkGreen; Console.BackgroundColor = ConsoleColor.Black; break; case LogMessageType.Verbose : Console.ForegroundColor = ConsoleColor.DarkGray; Console.BackgroundColor = ConsoleColor.Black; break; case LogMessageType.Information : Console.ForegroundColor = ConsoleColor.Gray; Console.BackgroundColor = ConsoleColor.Black; break; case LogMessageType.Warning : Console.ForegroundColor = ConsoleColor.Yellow; Console.BackgroundColor = ConsoleColor.Black; break; case LogMessageType.Error : Console.ForegroundColor = ConsoleColor.Red; Console.BackgroundColor = ConsoleColor.Black; break; case LogMessageType.Fatal : Console.ForegroundColor = ConsoleColor.Yellow; Console.BackgroundColor = ConsoleColor.Red; break; } }
/// <summary> /// Writes a single message to the output. /// </summary> /// <param name="source">The <see cref="Log"/> from which the message originates.</param> /// <param name="type">The type of the log message.</param> /// <param name="msg">The message to write.</param> /// <param name="context">The context in which this log was written. Usually the primary object the log entry is associated with.</param> public virtual void Write(Log source, LogMessageType type, string msg, object context) { int indent = source.Indent; string[] lines = msg.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < lines.Length; i++) { if (i == 0) { switch (type) { case LogMessageType.Message: lines[i] = source.Prefix + "Info: " + new string(' ', indent * 4) + lines[i]; break; case LogMessageType.Warning: lines[i] = source.Prefix + "Warning: " + new string(' ', indent * 4) + lines[i]; break; case LogMessageType.Error: lines[i] = source.Prefix + "ERROR: " + new string(' ', indent * 4) + lines[i]; break; } } else { lines[i] = source.Prefix + " " + new string(' ', indent * 4) + lines[i]; } this.writer.WriteLine(lines[i]); } }
public void WriteLineTest1() { LogMessageType messageFlag = new LogMessageType(); // TODO: 初始化为适当的值 string strFormat = string.Empty; // TODO: 初始化为适当的值 object[] arg = null; // TODO: 初始化为适当的值 LOGs.WriteLine( messageFlag, strFormat, arg ); Assert.Inconclusive( "无法验证不返回值的方法。" ); }
public override void WriteMessage(string message, LogMessageType type, Exception exception) { if (type == LogMessageType.Error) System.Threading.Interlocked.Increment(ref ErrorCount); else if (type == LogMessageType.Warning) System.Threading.Interlocked.Increment(ref WarningCount); base.WriteMessage(this.Backupset + ", " + message, type, exception); }
/// <summary> /// Initializes a new instance of the <see cref="AssetLogMessage" /> class. /// </summary> /// <param name="package">The package.</param> /// <param name="assetReference">The asset reference.</param> /// <param name="type">The type.</param> /// <param name="messageCode">The message code.</param> /// <param name="arguments">The arguments.</param> /// <exception cref="System.ArgumentNullException">asset</exception> public AssetLogMessage(Package package, IReference assetReference, LogMessageType type, string text) { this.package = package; AssetReference = assetReference; Type = type; Related = new List<IReference>(); Text = text; }
TextWriter GetWriter ( LogMessageType eventType ) { if ( eventType==LogMessageType.Error || eventType==LogMessageType.Warning || eventType==LogMessageType.Fatal ) { return Console.Error; } else { return Console.Out; } }
/// <summary> /// Initializes a new instance of the <see cref="LogMessage" /> class. /// </summary> /// <param name="module">The module.</param> /// <param name="type">The type.</param> /// <param name="text">The text.</param> /// <param name="exception">The exception.</param> /// <param name="callerInfo">The caller info.</param> public LogMessage(string module, LogMessageType type, string text, Exception exception, CallerInfo callerInfo) { Module = module; Type = type; Text = text; Exception = exception; CallerInfo = callerInfo; }
// Help methods that use our FileSystem abstraction public override void AppendLog(String message, LogMessageType messageType) { string textEntry = string.Format("{0:MM-dd-yyyy HH:mm:ss:ffff} :{1}: [{2}] {3}", DateTime.Now, System.Threading.Thread.CurrentThread.ManagedThreadId, messageType.ToString(), message); Console.WriteLine(textEntry); AppendText(LogFileName, textEntry); }
/// <summary> /// Activates the log for loggers that match a regex pattern on the module name. /// </summary> /// <param name="regexPatternModule">The regex pattern to match a module name.</param> /// <param name="minimumLevel">The minimum level.</param> /// <param name="maximumLevel">The maximum level.</param> /// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param> /// <exception cref="ArgumentNullException">If regexPatternModule is null</exception> public static void ActivateLog(string regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true) { if (regexPatternModule == null) throw new ArgumentNullException("regexPatternModule"); var regex = new Regex(regexPatternModule); ActivateLog(regex, minimumLevel, maximumLevel); }
public LogMessageEventArgs(LogMessageType logMessageType, string message) { if (message == null) throw new ArgumentNullException("message"); LogMessageType = logMessageType; Message = message; }
/// <summary> /// /// </summary> /// <param name="messageFlag"></param> /// <param name="strFormat"></param> /// <param name="parameter"></param> public LogInfo(LogMessageType messageFlag, string strFormat, object[] parameter = null) { m_messageFlag = messageFlag; format = strFormat; _parameter = parameter; outStr = null; time = DateTime.Now; }
/// <summary> /// The function called when a message is logged /// </summary> /// <param name="message">The message logged</param> /// <param name="type">The type of message logged</param> /// <param name="exception">An exception, may be null</param> public virtual void WriteMessage(string message, LogMessageType type, Exception exception) { m_stream.WriteLine("{0:u} - {1}: {2}", DateTime.Now, type, message); if (exception != null) { m_stream.WriteLine(exception.ToString()); m_stream.WriteLine(); } }
/// <summary> /// Initializes a new instance of the <see cref="SerializableLogMessage"/> class using the given parameters to set its properties. /// </summary> /// <param name="module">The module name.</param> /// <param name="type">The type.</param> /// <param name="text">The text.</param> /// <param name="exceptionInfo">The exception information. This parameter can be null.</param> public SerializableLogMessage(string module, LogMessageType type, string text, ExceptionInfo exceptionInfo = null) { if (module == null) throw new ArgumentNullException("module"); if (text == null) throw new ArgumentNullException("text"); Module = module; Type = type; Text = text; ExceptionInfo = exceptionInfo; }
/// <summary> /// Initializes a new instance of the <see cref="AssetLogMessage" /> class. /// </summary> /// <param name="package">The package.</param> /// <param name="assetReference">The asset reference.</param> /// <param name="type">The type.</param> /// <param name="messageCode">The message code.</param> /// <exception cref="System.ArgumentNullException">asset</exception> public AssetLogMessage(Package package, IReference assetReference, LogMessageType type, AssetMessageCode messageCode) { this.package = package; AssetReference = assetReference; Type = type; MessageCode = messageCode; Related = new List<IReference>(); Text = AssetMessageStrings.ResourceManager.GetString(messageCode.ToString()) ?? messageCode.ToString(); }
public LogEntry(Log source, LogMessageType type, string msg) { this.source = source; this.type = type; this.msg = msg; this.indent = source.Indent; this.timestamp = DateTime.Now; this.frameIndex = Time.FrameCount; }
private void SetDarkConsoleColor(LogMessageType type) { switch (type) { default: case LogMessageType.Message: Console.ForegroundColor = ConsoleColor.DarkGray; break; case LogMessageType.Warning: Console.ForegroundColor = ConsoleColor.DarkYellow; break; case LogMessageType.Error: Console.ForegroundColor = ConsoleColor.DarkRed; break; } }
public LogEntry(Log source, LogMessageType type, string msg, object context) { this.source = source; this.type = type; this.message = msg; this.context = context; this.indent = source.Indent; this.timeStamp = DateTime.Now; this.frameStamp = Time.FrameCount; }
public override void Log(LogMessageType type, bool logToConsole, string message) { if (_entries != null) { LogEntry entry = new LogEntry(message, type, logToConsole); _entriesLock.WaitOne(); _entries.Add(entry); _entriesLock.ReleaseMutex(); } }
/// <summary> /// Initializes a new instance of the <see cref="AssetLogMessage" /> class. /// </summary> /// <param name="package">The package.</param> /// <param name="assetReference">The asset reference.</param> /// <param name="type">The type.</param> /// <param name="messageCode">The message code.</param> /// <param name="arguments">The arguments.</param> /// <exception cref="System.ArgumentNullException">asset</exception> public AssetLogMessage(Package package, IReference assetReference, LogMessageType type, AssetMessageCode messageCode, params object[] arguments) { this.package = package; AssetReference = assetReference; Type = type; MessageCode = messageCode; Related = new List<IReference>(); var message = AssetMessageStrings.ResourceManager.GetString(messageCode.ToString()) ?? messageCode.ToString(); Text = string.Format(message, arguments); }
public bool Log(string userID, string userName, string messageString, LogMessageType messageType) { var log = new Log(); log.UserID = userID; log.UserName = userName; log.Message = messageString; logRepository.Create(log); return true; }
public void OutputLog(string message, LogMessageType logType) { if (!supportedLogTypes.Contains(logType)) { return; } foreach (var logger in innerLoggers) { logger.Process(message, logType); } }
private void SetBrightConsoleColor(LogMessageType type, bool highlight) { switch (type) { default: case LogMessageType.Message: Console.ForegroundColor = highlight ? ConsoleColor.White : ConsoleColor.Gray; break; case LogMessageType.Warning: Console.ForegroundColor = ConsoleColor.Yellow; break; case LogMessageType.Error: Console.ForegroundColor = ConsoleColor.Red; break; } }
public LogItem() { LogItemId = LogHolder.Singleton.NextId; ClientId = 0; EntityId = 0; EntityMessageType = EntityMessage.Null; ComponentFamily = ComponentFamily.Generic; SenderType = ""; MessageType = ComponentMessageType.Null; Parameters = null; MessageSource = LogMessageType.None; }
///// <summary> ///// Indicates that debug messages are allowed. ///// </summary> //public static bool IsDebugMessageEnabled { get { return VerbosityLevel == LogMessageType.Debug; } } /// <summary> /// /// </summary> /// <param name="type"></param> /// <param name="message"></param> static void AddMessage ( LogMessageType type, string text ) { if (type>=VerbosityLevel) { lock (lockObj) { var threadId = Thread.CurrentThread.ManagedThreadId; var message = new LogMessage( threadId, type, text ); foreach (var listener in listeners) { listener.Log( message ); } } } }
/// <summary> /// Writes a log message in the log /// </summary> /// <param name="message">The message to write to log</param> /// <param name="messageType">The type of the log message to write</param> /// <param name="type">The object type for which to get the logger for writing the log</param> public static void Write(string message, LogMessageType messageType, Type type) { DoLog(message, messageType, null, type); }
/// <summary> /// Writes a log message in the log /// </summary> /// <param name="message">The message to write to log</param> /// <param name="messageType">The type of the log message to write</param> public static void Write(string message, LogMessageType messageType) { DoLog(message, messageType, null, Type.GetType("System.Object")); }
/// <summary> /// Activates the log for loggers that match a regex pattern on the module name. /// </summary> /// <param name="regexPatternModule">The regex pattern to match a module name.</param> /// <param name="minimumLevel">The minimum level.</param> /// <param name="maximumLevel">The maximum level.</param> /// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param> /// <exception cref="ArgumentNullException">If regexPatternModule is null</exception> public static void ActivateLog(string regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true) { if (regexPatternModule == null) { throw new ArgumentNullException("regexPatternModule"); } var regex = new Regex(regexPatternModule); ActivateLog(regex, minimumLevel, maximumLevel); }
public void Log(string loggerName, object message, Exception exception, LogMessageType logMessageType) { Debug.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} {message}: {exception}"); }
public void Log(Type senderType, object message, LogMessageType logMessageType) { }
/// <summary> /// Determines whether the <see cref="LogMessageType"/> is enabled (see <see cref="EnabledLogMessageTypes"/>). /// </summary> /// <param name="type">The <see cref="LogMessageType"/>.</param> /// <returns><c>true</c> if enabled; otherwise, <c>false</c>.</returns> public static bool IsEnabled(LogMessageType type) { return((EnabledLogMessageTypes & type) == type); }
private HightligtedTextPart[] GetHightlightedTextParts(string message, LogMessageType type) { HightligtedTextPart currentPart = null; var parts = new List <HightligtedTextPart>(); var lastColor = ConsoleColor.White; var isInsideString = false; var isInsideQuoute = false; var isInsideParanthesis = false; for (var i = 0; i < message.Length; i++) { var token = GetToken(message, i, isInsideString, isInsideParanthesis, isInsideQuoute); if (token == null) { continue; } var color = token.Color; if (token.IsQuouteStart) { isInsideQuoute = true; } if (token.IsQuouteEnd) { isInsideQuoute = false; } if (token.IsStringStart) { isInsideString = true; } if (token.IsStringEnd) { isInsideString = false; } if (token.IsParanthesisStart) { isInsideParanthesis = true; } if (token.IsParanthesisEnd) { isInsideParanthesis = false; } if (token.IsLineBreak) { if (currentPart != null) { parts.Add(currentPart); parts.Add(new HightligtedTextPart { IsLineBreak = true }); currentPart = null; lastColor = color; continue; } } if (currentPart == null) { currentPart = new HightligtedTextPart(); currentPart.Text += token.Text; currentPart.Color = color; lastColor = color; } else if (lastColor == color) { currentPart.Text += token.Text; if (i >= message.Length - 1) { parts.Add(currentPart); break; } } if (lastColor != color) { parts.Add(currentPart); currentPart = new HightligtedTextPart(); currentPart.Text += token.Text; currentPart.Color = color; lastColor = color; } } switch (type) { case LogMessageType.Error: for (var i = 3; i < parts.Count; i++) { parts[i].Color = ErrorColor; } break; case LogMessageType.Warning: for (var i = 3; i < parts.Count; i++) { parts[i].Color = WarningColor; } break; case LogMessageType.Debug: for (var i = 3; i < parts.Count; i++) { parts[i].Color = DebugColor; } break; } return(parts.ToArray()); }
public AssetSerializableLogMessage(AssetId assetId, UFile assetUrl, LogMessageType type, string text, ExceptionInfo exceptionInfo = null) : base("", type, text, exceptionInfo) { AssetId = assetId; AssetUrl = assetUrl; }
/// <summary> /// Logs messages to a database. /// </summary> /// <param name="authenticatedTicket">The ticket which has the ticket string. The ticket could also be not authenticated if an error happened.</param> /// <param name="messageType">Type of message.</param> /// <param name="direction">Direction of the message (In the WebService, or Out the WebService).</param> /// <param name="ticket">The ticket.</param> /// <param name="arguments">Other arguments to save.</param> protected internal virtual void LogMessage(IAuthenticatedTicket authenticatedTicket, LogMessageType messageType, LogDirection direction, string ticket, params string[] arguments) { logger.LogTrace("Ticket: {TICKET}; Type: {TYPE}; Direction: {DIRECTION}; Arguments: {Arguments}", ticket, messageType, direction, arguments); }
/// <summary> /// 防止多线程的问题 /// </summary> /// <param name="messageFlag"></param> /// <param name="strFormat"></param> private static void WriteLine(LogMessageType messageFlag, string strFormat) { WriteLine(messageFlag, strFormat, null); }
// сообщения для лога /// <summary> /// добавить в лог новое сообщение /// </summary> private void SendLogMessage(string message, LogMessageType type) { LogMessageEvent?.Invoke(message, type); }
/// <summary> /// Writes a log message in the log /// </summary> /// <param name="message">The message to write to log</param> /// <param name="messageType">The type of the log message to write</param> /// <param name="ex">Exception to be logged</param> public static void Write(string message, LogMessageType messageType, Exception ex) { DoLog(message, messageType, ex, Type.GetType("System.Object")); }
/// <summary> /// Writes a log message in the log /// </summary> /// <param name="message">The message to write to log</param> /// <param name="messageType">The type of the log message to write</param> /// <param name="ex">Exception to be logged</param> /// <param name="type">The object type for which to get the logger for writing the log</param> public static void Write(string message, LogMessageType messageType, Exception ex, Type type) { DoLog(message, messageType, ex, type); }
/// <summary> /// Logs messages to a database. /// </summary> /// <param name="authenticatedTicket">The ticket which has the ticket string. The ticket could also be not authenticated if an error happened.</param> /// <param name="messageType">Type of message.</param> /// <param name="direction">Direction of the message (In the WebService, or Out the WebService).</param> /// <param name="arguments">Other arguments to save.</param> protected internal virtual void LogMessage(AuthenticatedTicket authenticatedTicket, LogMessageType messageType, LogDirection direction, string ticket, params string[] arguments) { }
/// <summary> /// Writes message line to text log file. Type of message is also specified. /// </summary> /// <param name="message"></param> /// <param name="logMessageType"></param> public void WriteLine(string message, LogMessageType logMessageType) { string messageDateAndType = ""; string formattedMessage = ""; string messagePrefix = ""; string machineName = ""; try { if (this._showDatetime) { messageDateAndType = DateTime.Now.ToString(this._dateTimeFormat); } else { messageDateAndType = ""; } if (this._showMessageType) { if (messageDateAndType.Length > 0) { messageDateAndType += " "; } messageDateAndType += logMessageType.ToString().ToUpper() + ": "; } if (this.ShowErrorWarningTypes == true && this.ShowMessageType == false) { if (logMessageType == LogMessageType.Warning || logMessageType == LogMessageType.Error) { if (messageDateAndType.Length > 0) { messageDateAndType += " "; } messageDateAndType += logMessageType.ToString().ToUpper() + ": "; } } if (this._machineName.Length > 0) { if (this._applicationName.Length > 0) { machineName = " on " + this._machineName; } else { machineName = this._machineName; } } else { machineName = ""; } if ((this._applicationName.Length > 0) | (machineName.Length > 0)) { messagePrefix = (messageDateAndType + " <" + (this._applicationName + machineName).Trim() + "> ").Trim(); } else { messagePrefix = messageDateAndType.Trim(); } if (messagePrefix.Length > 0) { formattedMessage = messagePrefix + " " + message; } else { formattedMessage = message; } StreamWriter writer = File.AppendText(this._fileName); writer.WriteLine(formattedMessage); writer.Flush(); writer.Close(); } catch (Exception ex) { throw ex; } }
public MutationRunProgress(string message, int progress, LogMessageType logMessageType) { Progress = progress; LogMessageType = logMessageType; Message = message; }
/// <summary> /// Writes a message to the current log destination /// </summary> /// <param name="message">The message to write</param> /// <param name="type">The type of the message</param> public static void WriteMessage(string message, LogMessageType type) { WriteMessage(message, type, null); }
/// <summary> /// Конструктор с выбором типа сообщения. /// </summary> /// <param name="message">Текст сообщения</param> /// <param name="type">Тип сообщения</param> public LogMessage(string message, LogMessageType type = LogMessageType.Notification) { Message = message; Type = type; }
public void Log(Type senderType, object message, Exception exception, LogMessageType logMessageType) { }
public void Write <T>(T entity, LogMessageType messageType) { Write(entity, messageType, null, null); }
public override void DoWindowContents(Rect rect) { int btnWidth = 200; Rect chkEnabledRect = new Rect(x: 0, y: 20f, width: rect.width, height: controlHeight); Rect teSearchRect = new Rect(x: 0, y: chkEnabledRect.yMax, width: rect.width, height: controlHeight); Rect btnErrorsRect = new Rect(x: 10f, y: teSearchRect.yMax, width: btnWidth, height: controlHeight); Rect btnWarningsRect = new Rect(x: btnErrorsRect.xMax, y: btnErrorsRect.y, width: btnWidth, height: controlHeight); Rect btnMessagesRect = new Rect(x: btnWarningsRect.xMax, y: btnErrorsRect.y, width: btnWidth, height: controlHeight); Rect teContainFilterRect = new Rect(x: 0, y: btnMessagesRect.yMax, width: rect.width, height: controlHeight); bool enabled = Settings.Get().LogFilter.enabled; Widgets.CheckboxLabeled(chkEnabledRect, "AnotherTweaks.LogFilter.Enabled".Translate(), ref enabled); Settings.Get().LogFilter.enabled = enabled; _searchBuf = Widgets.TextEntryLabeled(teSearchRect, "AnotherTweaks.LogFilter.Search".Translate(), _searchBuf); Color color = GUI.color; if (_logMessageType == LogMessageType.Error) { GUI.color = SelectedColor; } if (Widgets.ButtonText(btnErrorsRect, "AnotherTweaks.LogFilter.ErrorsTab".Translate())) { _logMessageType = LogMessageType.Error; } GUI.color = color; if (_logMessageType == LogMessageType.Warning) { GUI.color = SelectedColor; } if (Widgets.ButtonText(btnWarningsRect, "AnotherTweaks.LogFilter.WarningsTab".Translate())) { _logMessageType = LogMessageType.Warning; } GUI.color = color; if (_logMessageType == LogMessageType.Message) { GUI.color = SelectedColor; } if (Widgets.ButtonText(btnMessagesRect, "AnotherTweaks.LogFilter.MessagesTab".Translate())) { _logMessageType = LogMessageType.Message; } GUI.color = color; var cfg = Settings.Get().LogFilter; IEnumerable <LogMessageHided> containFilteredItems = null; switch (_logMessageType) { case LogMessageType.Error: cfg.errorContain = Widgets.TextEntryLabeled(teContainFilterRect, "AnotherTweaks.LogFilter.ErrorContain".Translate(), cfg.errorContain); containFilteredItems = _logMessages.Where(x => x.type == _logMessageType && !cfg.errorContain.ContainFilter(x.text)); break; case LogMessageType.Warning: cfg.warningContain = Widgets.TextEntryLabeled(teContainFilterRect, "AnotherTweaks.LogFilter.WarningContain".Translate(), cfg.warningContain); containFilteredItems = _logMessages.Where(x => x.type == _logMessageType && !cfg.warningContain.ContainFilter(x.text)); break; case LogMessageType.Message: cfg.messageContain = Widgets.TextEntryLabeled(teContainFilterRect, "AnotherTweaks.LogFilter.MessageContain".Translate(), cfg.messageContain); containFilteredItems = _logMessages.Where(x => x.type == _logMessageType && !cfg.messageContain.ContainFilter(x.text)); break; } List <LogMessageHided> drawItems; if (String.IsNullOrWhiteSpace(_searchBuf)) { drawItems = containFilteredItems.ToList(); } else { drawItems = containFilteredItems.Where(x => x.text.ToLower().Contains(_searchBuf.ToLower())).ToList(); } float y = teContainFilterRect.yMax; Rect outRect = new Rect(x: 0f, y: y, width: rect.width, height: rect.height - y); Rect viewRect = new Rect(x: 0f, y: y, width: rect.width - 30f, height: drawItems.Count * controlHeight); Widgets.BeginScrollView(outRect: outRect, scrollPosition: ref _scrollPosition, viewRect: viewRect); foreach (var item in drawItems) { Rect chkItemRect = new Rect(x: 0, y: y, width: viewRect.width, height: controlHeight); Widgets.CheckboxLabeled(chkItemRect, item.text, ref item.show); TooltipHandler.TipRegion(chkItemRect, item.text); Widgets.DrawHighlightIfMouseover(chkItemRect); y += controlHeight /*chkItemRect.yMax*/; } Widgets.EndScrollView(); }
public void Log(string Message, int MessageId, LogMessageType MessageType = LogMessageType.Information, LogReceiver Receiver = LogReceiver.MessageBox | LogReceiver.Console, string Details = null) { string timeStamp = DateTime.Now.ToString(); if (Receiver.HasFlag(LogReceiver.Console)) { ListViewItem logItem = new ListViewItem(); string iconName = null; string levelName = null; _detailsList.Add(Details); switch (MessageType) { case LogMessageType.Exclamation: iconName = "exclamation"; levelName = Resources.Messages.Exclamation; break; case LogMessageType.Warning: iconName = "warning"; levelName = Resources.Messages.Warning; break; case LogMessageType.Success: iconName = "success"; levelName = Resources.Messages.Success; break; case LogMessageType.Failure: iconName = "failure"; levelName = Resources.Messages.Failure; break; default: iconName = "information"; levelName = Resources.Messages.Information; break; } logItem.Name = (_detailsList.Count - 1).ToString(); logItem.ImageKey = iconName; logItem.Text = levelName; logItem.SubItems.Add(Message); logItem.SubItems.Add(MessageId != 0 ? MessageId.ToString() : ""); logItem.SubItems.Add(timeStamp); LogList.BeginInvoke(new Action(() => { try { LogList.Items.Add(logItem); if (LogList.Items.Count > 1) { LogList.EnsureVisible(LogList.Items.Count - 1); } } catch (Exception) { } })); } if (Receiver.HasFlag(LogReceiver.StatusBar)) { Color foreColor = Color.Black; switch (MessageType) { case LogMessageType.Warning: foreColor = Color.Orange; break; case LogMessageType.Failure: case LogMessageType.Exclamation: foreColor = Color.Red; break; default: foreColor = Color.Black; break; } LogList.BeginInvoke(new Action(() => { StatusBarLabel.Text = Message; StatusBarLabel.ForeColor = foreColor; })); if (MessageType == LogMessageType.Information || MessageType == LogMessageType.Success) { } } if (Receiver.HasFlag(LogReceiver.MessageBox)) { MessageBoxIcon icon; string title; switch (MessageType) { case LogMessageType.Failure: icon = MessageBoxIcon.Error; title = Resources.Messages.Failure; break; case LogMessageType.Warning: icon = MessageBoxIcon.Warning; title = Resources.Messages.Warning; break; default: icon = MessageBoxIcon.Information; title = Resources.Messages.Information; break; } AlertBox.Show(Message, title, icon, Details); } }
/// <summary> /// Activates the log for loggers that match a regex pattern on the module name. /// </summary> /// <param name="regexPatternModule">The regex pattern to match a module name.</param> /// <param name="minimumLevel">The minimum level.</param> /// <param name="maximumLevel">The maximum level.</param> /// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param> /// <exception cref="ArgumentNullException">If regexPatternModule is null</exception> public static void ActivateLog(Regex regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true) { if (regexPatternModule == null) { throw new ArgumentNullException("regexPatternModule"); } ActivateLog( logger => { if (regexPatternModule.Match(logger.Module).Success) { logger.ActivateLog(minimumLevel, maximumLevel, enabledFlag); } }); }
// Help methods that use our FileSystem abstraction public virtual void AppendLog(String message, LogMessageType messageType) { string textEntry = string.Format("{0:MM-dd-yyyy HH:mm:ss:ffff} :{1}: [{2}] {3}", DateTime.Now, System.Threading.Thread.CurrentThread.ManagedThreadId, messageType.ToString(), message); AppendText(LogFileName, textEntry); }
/// <summary> /// Internal wrapper to log a message. /// </summary> /// <param name="msg"></param> /// <param name="type"></param> private void Log(string msg, LogMessageType type) { this.m_LoggingService.OnAddLogMessage(this, new LogMessageEventArgs(msg, type)); }
public virtual void AppendLog(Exception ex, LogMessageType messageType) { AppendLog(LogHelper.BuildExceptionMessage(ex, messageType), messageType); }
public abstract void Log(LogMessageType type, bool logToConsole, string message);
/// <summary> /// Writes a message to the console output if an output is available /// </summary> /// <param name="type">Error log type</param> /// <param name="message">Formatted string, e.g. Starting proxy on port {0}</param> /// <param name="args">List of arguments</param> public void WriteLine(LogMessageType type, string message, params object[] args) { this.WriteLine(type, String.Format(message, args)); }
public static void Run(TestHelper helper) { Communicator?communicator = helper.Communicator(); TestHelper.Assert(communicator != null); TextWriter output = helper.GetWriter(); bool ice1 = communicator.DefaultProtocol == Protocol.Ice1; output.Write("testing communicator operations... "); output.Flush(); { // Test: Exercise AddAdminFacet, FindAdminFacet, RemoveAdminFacet with a typical configuration. var properties = new Dictionary <string, string> { ["Ice.Admin.Endpoints"] = ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0", ["Ice.Admin.InstanceName"] = "Test" }; using var com = new Communicator(properties); TestFacets(com, true, false); } { // Test: Verify that the operations work correctly in the presence of facet filters. var properties = new Dictionary <string, string> { ["Ice.Admin.Endpoints"] = ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0", ["Ice.Admin.InstanceName"] = "Test", ["Ice.Admin.Facets"] = "Properties" }; using var com = new Communicator(properties); TestFacets(com, false, true); } { // Test: Verify that the operations work correctly with the Admin object disabled. using var com = new Communicator(); TestFacets(com, false, false); } { // Test: Verify that the operations work correctly with Ice.Admin.Enabled=1 var properties = new Dictionary <string, string>() { { "Ice.Admin.Enabled", "1" } }; using var com = new Communicator(properties); TestHelper.Assert(com.GetAdmin() == null); var id = Identity.Parse("test-admin"); try { com.CreateAdmin(null, id); TestHelper.Assert(false); } catch (InvalidConfigurationException) { } ObjectAdapter adapter = com.CreateObjectAdapter(); TestHelper.Assert(com.CreateAdmin(adapter, id) != null); TestHelper.Assert(com.GetAdmin() != null); TestFacets(com, true, false); } { // Test: Verify that the operations work correctly when creation of the Admin object is delayed. var properties = new Dictionary <string, string>() { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.DelayCreation", "1" } }; using var com = new Communicator(properties); TestFacets(com, true, false); com.GetAdmin(); TestFacets(com, true, false); } output.WriteLine("ok"); var factory = IRemoteCommunicatorFactoryPrx.Parse(helper.GetTestProxy("factory", 0), communicator); output.Write("testing process facet... "); output.Flush(); { // Test: Verify that Process.Shutdown() operation shuts down the communicator. var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); IProcessPrx proc = obj.Clone("Process", IProcessPrx.Factory); proc.Shutdown(); com.WaitForShutdown(); com.Destroy(); } output.WriteLine("ok"); output.Write("testing properties facet... "); output.Flush(); { var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" }, { "Prop1", "1" }, { "Prop2", "2" }, { "Prop3", "3" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); IPropertiesAdminPrx pa = obj.Clone("Properties", IPropertiesAdminPrx.Factory); // Test: PropertiesAdmin.GetProperty() TestHelper.Assert(pa.GetProperty("Prop2") == "2"); TestHelper.Assert(pa.GetProperty("Bogus").Length == 0); // Test: PropertiesAdmin.GetProperties() Dictionary <string, string> pd = pa.GetPropertiesForPrefix(""); TestHelper.Assert(pd.Count == 7); TestHelper.Assert(pd["Ice.ProgramName"] == "server"); TestHelper.Assert(pd["Ice.Admin.Endpoints"] == (ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0")); TestHelper.Assert(pd["Ice.Admin.InstanceName"] == "Test"); TestHelper.Assert(pd["Prop1"] == "1"); TestHelper.Assert(pd["Prop2"] == "2"); TestHelper.Assert(pd["Prop3"] == "3"); TestHelper.Assert(pd["Ice.Default.Protocol"] == communicator.DefaultProtocol.GetName()); Dictionary <string, string> changes; // Test: PropertiesAdmin.SetProperties() var setProps = new Dictionary <string, string> { { "Prop1", "10" }, // Changed { "Prop2", "20" }, // Changed { "Prop3", "" }, // Removed { "Prop4", "4" }, // Added { "Prop5", "5" } // Added }; pa.SetProperties(setProps); TestHelper.Assert(pa.GetProperty("Prop1").Equals("10")); TestHelper.Assert(pa.GetProperty("Prop2").Equals("20")); TestHelper.Assert(pa.GetProperty("Prop3").Length == 0); TestHelper.Assert(pa.GetProperty("Prop4").Equals("4")); TestHelper.Assert(pa.GetProperty("Prop5").Equals("5")); changes = com.GetChanges(); TestHelper.Assert(changes.Count == 5); TestHelper.Assert(changes["Prop1"].Equals("10")); TestHelper.Assert(changes["Prop2"].Equals("20")); TestHelper.Assert(changes["Prop3"].Length == 0); TestHelper.Assert(changes["Prop4"].Equals("4")); TestHelper.Assert(changes["Prop5"].Equals("5")); pa.SetProperties(setProps); changes = com.GetChanges(); TestHelper.Assert(changes.Count == 0); com.Destroy(); } output.WriteLine("ok"); output.Write("testing logger facet... "); output.Flush(); { var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" }, { "NullLogger", "1" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); com.Trace("testCat", "trace"); com.Warning("warning"); com.Error("error"); com.Print("print"); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); ILoggerAdminPrx logger = obj.Clone("Logger", ILoggerAdminPrx.Factory); // Get all (LogMessage[] logMessages, string prefix) = logger.GetLog(Array.Empty <LogMessageType>(), Array.Empty <string>(), -1); TestHelper.Assert(logMessages.Length == 4); TestHelper.Assert(prefix.Equals("NullLogger")); TestHelper.Assert(logMessages[0].TraceCategory.Equals("testCat") && logMessages[0].Message.Equals("trace")); TestHelper.Assert(logMessages[1].Message.Equals("warning")); TestHelper.Assert(logMessages[2].Message.Equals("error")); TestHelper.Assert(logMessages[3].Message.Equals("print")); // Get only errors and warnings com.Error("error2"); com.Print("print2"); com.Trace("testCat", "trace2"); com.Warning("warning2"); LogMessageType[] messageTypes = { LogMessageType.ErrorMessage, LogMessageType.WarningMessage }; (logMessages, prefix) = logger.GetLog(messageTypes, Array.Empty <string>(), -1); TestHelper.Assert(logMessages.Length == 4); TestHelper.Assert(prefix.Equals("NullLogger")); foreach (LogMessage msg in logMessages) { TestHelper.Assert(msg.Type == LogMessageType.ErrorMessage || msg.Type == LogMessageType.WarningMessage); } // Get only errors and traces with Cat = "testCat" com.Trace("testCat2", "A"); com.Trace("testCat", "trace3"); com.Trace("testCat2", "B"); messageTypes = new LogMessageType[] { LogMessageType.ErrorMessage, LogMessageType.TraceMessage }; string[] categories = { "testCat" }; (logMessages, prefix) = logger.GetLog(messageTypes, categories, -1); TestHelper.Assert(logMessages.Length == 5); TestHelper.Assert(prefix.Equals("NullLogger")); foreach (LogMessage msg in logMessages) { TestHelper.Assert(msg.Type == LogMessageType.ErrorMessage || (msg.Type == LogMessageType.TraceMessage && msg.TraceCategory.Equals("testCat"))); } // Same, but limited to last 2 messages(trace3 + error3) com.Error("error3"); (logMessages, prefix) = logger.GetLog(messageTypes, categories, 2); TestHelper.Assert(logMessages.Length == 2); TestHelper.Assert(prefix.Equals("NullLogger")); TestHelper.Assert(logMessages[0].Message.Equals("trace3")); TestHelper.Assert(logMessages[1].Message.Equals("error3")); // Now, test RemoteLogger ObjectAdapter adapter = communicator.CreateObjectAdapterWithEndpoints("RemoteLoggerAdapter", ice1 ? "tcp -h localhost" : "ice+tcp://localhost:0", serializeDispatch: true); var remoteLogger = new RemoteLogger(); IRemoteLoggerPrx myProxy = adapter.AddWithUUID(remoteLogger, IRemoteLoggerPrx.Factory); adapter.Activate(); // No filtering (logMessages, prefix) = logger.GetLog(Array.Empty <LogMessageType>(), Array.Empty <string>(), -1); logger.AttachRemoteLogger(myProxy, Array.Empty <LogMessageType>(), Array.Empty <string>(), -1); remoteLogger.Wait(1); foreach (LogMessage m in logMessages) { remoteLogger.CheckNextInit(prefix, m.Type, m.Message, m.TraceCategory); } com.Trace("testCat", "rtrace"); com.Warning("rwarning"); com.Error("rerror"); com.Print("rprint"); remoteLogger.Wait(4); remoteLogger.CheckNextLog(LogMessageType.TraceMessage, "rtrace", "testCat"); remoteLogger.CheckNextLog(LogMessageType.WarningMessage, "rwarning", ""); remoteLogger.CheckNextLog(LogMessageType.ErrorMessage, "rerror", ""); remoteLogger.CheckNextLog(LogMessageType.PrintMessage, "rprint", ""); TestHelper.Assert(logger.DetachRemoteLogger(myProxy)); TestHelper.Assert(!logger.DetachRemoteLogger(myProxy)); // Use Error + Trace with "traceCat" filter with 4 limit (logMessages, prefix) = logger.GetLog(messageTypes, categories, 4); TestHelper.Assert(logMessages.Length == 4); logger.AttachRemoteLogger(myProxy, messageTypes, categories, 4); remoteLogger.Wait(1); foreach (LogMessage m in logMessages) { remoteLogger.CheckNextInit(prefix, m.Type, m.Message, m.TraceCategory); } com.Warning("rwarning2"); com.Trace("testCat", "rtrace2"); com.Warning("rwarning3"); com.Error("rerror2"); com.Print("rprint2"); remoteLogger.Wait(2); remoteLogger.CheckNextLog(LogMessageType.TraceMessage, "rtrace2", "testCat"); remoteLogger.CheckNextLog(LogMessageType.ErrorMessage, "rerror2", ""); // Attempt reconnection with slightly different proxy try { logger.AttachRemoteLogger(myProxy.Clone(oneway: true), messageTypes, categories, 4); TestHelper.Assert(false); } catch (RemoteLoggerAlreadyAttachedException) { // expected } com.Destroy(); } output.WriteLine("ok"); output.Write("testing custom facet... "); output.Flush(); { // Test: Verify that the custom facet is present. var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); ITestFacetPrx tf = obj.Clone("TestFacet", ITestFacetPrx.Factory); tf.Op(); com.Destroy(); } output.WriteLine("ok"); output.Write("testing facet filtering... "); output.Flush(); { // Test: Set Ice.Admin.Facets to expose only the Properties facet, meaning no other facet is available. var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "Properties" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); try { IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } try { ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } com.Destroy(); } { // Test: Set Ice.Admin.Facets to expose only the Process facet, meaning no other facet is available. var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "Process" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); try { IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } try { ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } com.Destroy(); } { // Test: Set Ice.Admin.Facets to expose only the TestFacet facet, meaning no other facet is available. var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "TestFacet" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); try { IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } try { IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } com.Destroy(); } { // Test: Set Ice.Admin.Facets to expose two facets. Use whitespace to separate the facet names. var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "Properties TestFacet" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); IPropertiesAdminPrx pa = obj.Clone("Properties", IPropertiesAdminPrx.Factory); TestHelper.Assert(pa.GetProperty("Ice.Admin.InstanceName").Equals("Test")); var tf = ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory)); tf !.Op(); try { IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } com.Destroy(); } { // Test: Set Ice.Admin.Facets to expose two facets. Use a comma to separate the facet names. var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "TestFacet, Process" } }; IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.GetAdmin(); TestHelper.Assert(obj != null); try { IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } var tf = ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory)); TestHelper.Assert(tf != null); tf.Op(); var proc = IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory)); TestHelper.Assert(proc != null); proc.Shutdown(); com.WaitForShutdown(); com.Destroy(); } output.WriteLine("ok"); factory.Shutdown(); }
private void AppLog_OnTraceMessage(LogMessageType type, string traceMessage) { Console.WriteLine($"{traceMessage}"); }