private void RenderExceptionData(RendererMap rendererMap, Exception ex, TextWriter writer, int depthLevel) { var dataCount = ex.Data.Count; if (dataCount == 0) { return; } writer.WriteLine(); writer.WriteLine($"Exception data on level {depthLevel} ({dataCount} items):"); var currentElement = 0; foreach (DictionaryEntry entry in ex.Data) { currentElement++; writer.Write("["); ExceptionObjectLogger.RenderValue(rendererMap, writer, entry.Key); writer.Write("]: "); ExceptionObjectLogger.RenderValue(rendererMap, writer, entry.Value); if (currentElement < dataCount) { writer.WriteLine(); } } }
public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (rendererMap == null) { throw new ArgumentNullException("rendererMap"); } if (obj == null) { writer.Write(SystemInfo.NullText); } else { Array array = obj as Array; if (array != null) { this.RenderArray(rendererMap, array, writer); } else { IEnumerable enumerable = obj as IEnumerable; if (enumerable != null) { ICollection is2 = obj as ICollection; if ((is2 != null) && (is2.Count == 0)) { writer.Write("{}"); } else { IDictionary dictionary = obj as IDictionary; if (dictionary != null) { this.RenderEnumerator(rendererMap, dictionary.GetEnumerator(), writer); } else { this.RenderEnumerator(rendererMap, enumerable.GetEnumerator(), writer); } } } else { IEnumerator enumerator = obj as IEnumerator; if (enumerator != null) { this.RenderEnumerator(rendererMap, enumerator, writer); } else if (obj is DictionaryEntry) { this.RenderDictionaryEntry(rendererMap, (DictionaryEntry)obj, writer); } else { string str = obj.ToString(); writer.Write((str != null) ? str : SystemInfo.NullText); } } } } }
/// <summary> /// Render the object <paramref name="obj"/> to a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="obj">The object to render</param> /// <returns>the object rendered as a string</returns> /// <remarks> /// <para>Render the object <paramref name="obj"/> to a /// string.</para> /// /// <para>The <paramref name="rendererMap"/> parameter is /// provided to lookup and render other objects. This is /// very useful where <paramref name="obj"/> contains /// nested objects of unknown type. The <see cref="RendererMap.FindAndRender"/> /// method can be used to render these objects.</para> /// /// <para>The default renderer supports rendering objects to strings as follows:</para> /// /// <list type="table"> /// <listheader> /// <term>Value</term> /// <description>Rendered String</description> /// </listheader> /// <item> /// <term><c>null</c></term> /// <description> /// <para>"(null)"</para> /// </description> /// </item> /// <item> /// <term><see cref="Array"/></term> /// <description> /// <para>For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>int[] {1, 2, 3}</c>.</para> /// <para>If the array is not one dimensional the /// <c>Array.ToString()</c> is returned.</para> /// /// <para>The <see cref="RenderArray"/> method is called /// to do the actual array rendering. This method can be /// overridden in a subclass to provide different array /// rendering.</para> /// </description> /// </item> /// <item> /// <term><see cref="Exception"/></term> /// <description> /// <para>Renders the exception type, message /// and stack trace. Any nested exception is also rendered.</para> /// /// <para>The <see cref="RenderException"/> method is called /// to do the actual exception rendering. This method can be /// overridden in a subclass to provide different exception /// rendering.</para> /// </description> /// </item> /// <item> /// <term>other</term> /// <description> /// <para><c>Object.ToString()</c></para> /// </description> /// </item> /// </list> /// </remarks> virtual public string DoRender(RendererMap rendererMap, object obj) { if (rendererMap == null) { throw new ArgumentNullException("rendererMap"); } if (obj == null) { return("(null)"); } if (obj is Array) { return(RenderArray(rendererMap, (Array)obj)); } else if (obj is Exception) { return(RenderException(rendererMap, (Exception)obj)); } else { return(obj.ToString()); } }
protected virtual string Serialize(object obj, RendererMap map) { var type = GetSerializedType(obj); var settings = GetSettings(obj, type, map); return(JsonConvert.SerializeObject(obj, type, settings)); }
/// <summary></summary> public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (obj == null) { return; } var objAsString = obj as string; if (obj is string) { writer.Write(objAsString); return; } if (obj is LazyString) { writer.Write(obj.ToString()); return; } if (obj.GetType().IsTypeFromLoggingFramework()) { //if we get a log4net object, log4net will expect us to call ToString to get the format writer.Write(obj.ToString()); return; } obj.DumpTo(writer); }
public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (obj is Amazon.CloudWatch.Model.MetricDatum) RenderAWSMetricDatum((Amazon.CloudWatch.Model.MetricDatum)obj, writer); else if (obj is MetricDatum) RenderAppenderMetricDatum((MetricDatum)obj, writer); }
/// <summary> /// Write the object value as Json string into the writer using the serializer /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="obj">Object to be serialized</param> /// <param name="writer">Will receive the serialized data of obj</param> public virtual void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { var serializer = Serializer ?? JsonSerializer.DefaultSerializer; var data = serializer.Serialize(obj, rendererMap); writer.WriteLine(data); }
/// Implementation of the IObjectRenderer interface. Called on when an /// exception is logged. public void RenderObject(RendererMap map, object obj, System.IO.TextWriter writer) { Exception ex = obj as Exception; for (; ex != null; ex = ex.InnerException) { if (ex is COMException && ex.Message.StartsWith("<?xml")) { writer.WriteLine(); writer.Write("HFMException message XML contents:"); writer.Write(YAML.XML.ConvertXML(ex.Message)); } else { writer.Write(ex.GetType().Name); writer.Write(": "); writer.Write(ex.Message); } if (ex.InnerException != null) { writer.WriteLine(); } else if (_logHierarchy.Root.Level.CompareTo(log4net.Core.Level.Fine) < 0) { writer.WriteLine(); writer.WriteLine("Backtrace:"); writer.Write(ex.StackTrace); } } }
/// <summary></summary> public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (obj == null) { return; } var objAsString = obj as string; if (obj is string) { writer.Write(objAsString); return; } if (obj is LazyString) { writer.Write(obj.ToString()); return; } var ns = obj.GetType().Namespace; if (!string.IsNullOrEmpty(ns) && (ns.StartsWith("log4net") || ns.StartsWith("Common.Logging"))) { //if we get a log4net object, log4net will expect us to call ToString to get the format writer.Write(obj.ToString()); return; } obj.DumpTo(writer); }
/// <summary> /// Serialize enumerables into a string builder /// </summary> /// <param name="obj"></param> /// <param name="sb"></param> /// <param name="map">log4net renderer map</param> protected virtual bool SerializeArray(IEnumerable obj, TextWriter sb, RendererMap map) { if (obj == null) { return(false); } sb.Write("["); bool first = true; foreach (var item in obj) { if (first) { first = false; } else { sb.Write(","); } Serialize(item, sb, map, true); } sb.Write("]"); return(true); }
/// <summary> /// Serialize a dictionary into a string builder /// </summary> /// <param name="obj"></param> /// <param name="sb"></param> /// <param name="map">log4net renderer map</param> protected virtual bool SerializeDictionary(IDictionary obj, TextWriter sb, RendererMap map) { if (obj == null) { return(false); } sb.Write("{"); bool first = true; foreach (DictionaryEntry entry in (IDictionary)obj) { if (first) { first = false; } else { sb.Write(","); } sb.WriteFormat(@"""{0}"":", entry.Key); Serialize(entry.Value, sb, map, true); } sb.Write("}"); return(true); }
/// <summary> /// Render the exception into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="ex">the exception to render</param> /// <returns>the string representation of the exception</returns> /// <remarks> /// <para>Renders the exception type, message, and stack trace. Any nested /// exceptions are also rendered.</para> /// /// <para>The <see cref="RenderExceptionMessage(RendererMap,Exception)"/> /// method is called to render the Exception's message into a string. This method /// can be overridden to change the behaviour when rendering /// exceptions. To change or extend only the message that is /// displayed override the <see cref="RenderExceptionMessage(RendererMap,Exception)"/> /// method instead.</para> /// </remarks> virtual protected string RenderException(RendererMap rendererMap, Exception ex) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.Append("Exception: ") .Append(ex.GetType().FullName) .Append(NewLine) .Append("Message: ") .Append(RenderExceptionMessage(rendererMap, ex)) .Append(NewLine); #if !NETCF if (ex.Source != null && ex.Source.Length > 0) { sb.Append("Source: ").Append(ex.Source).Append(NewLine); } if (ex.StackTrace != null && ex.StackTrace.Length > 0) { sb.Append(ex.StackTrace).Append(NewLine); } #endif if (ex.InnerException != null) { sb.Append(NewLine) .Append("Nested Exception") .Append(NewLine) .Append(NewLine) .Append(RenderException(rendererMap, ex.InnerException)) .Append(NewLine); } return(sb.ToString()); }
public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { var ex = obj as Exception; if (ex == null) { // Shouldn't happen if only configured for the System.Exception type. rendererMap.DefaultRenderer.RenderObject(rendererMap, obj, writer); } else { rendererMap.DefaultRenderer.RenderObject(rendererMap, obj, writer); const int MAX_DEPTH = 10; int currentDepth = 0; var traversedExceptions = new List<Exception>(); while (ex != null && currentDepth <= MAX_DEPTH && !traversedExceptions.Contains(ex)) { traversedExceptions.Add(ex); this.RenderExceptionData(rendererMap, ex, writer, currentDepth); ex = ex.InnerException; currentDepth++; } } }
public void RenderObject(RendererMap rendererMap, object obj, System.IO.TextWriter writer) { var dictionary = obj as IDictionary; if (dictionary == null) writer.Write(SystemInfo.NullText); }
public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { var thrown = obj as Exception; while (thrown != null) { RenderException(thrown, writer); thrown = thrown.InnerException; } }
/// <summary> /// Render the object <paramref name="obj" /> to a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="obj">The object to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Render the object <paramref name="obj" /> to a string. /// </para> /// <para> /// The <paramref name="rendererMap" /> parameter is /// provided to lookup and render other objects. This is /// very useful where <paramref name="obj" /> contains /// nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object)" /> /// method can be used to render these objects. /// </para> /// <para> /// The default renderer supports rendering objects to strings as follows: /// </para> /// <list type="table"> /// <listheader> /// <term>Value</term> /// <description>Rendered String</description> /// </listheader> /// <item> /// <term><c>null</c></term> /// <description> /// <para>"(null)"</para> /// </description> /// </item> /// <item> /// <term><see cref="T:System.Array" /></term> /// <description> /// <para> /// For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. /// </para> /// <para> /// For example: <c>int[] {1, 2, 3}</c>. /// </para> /// <para> /// If the array is not one dimensional the /// <c>Array.ToString()</c> is returned. /// </para> /// </description> /// </item> /// <item> /// <term><see cref="T:System.Collections.IEnumerable" />, <see cref="T:System.Collections.ICollection" /> & <see cref="T:System.Collections.IEnumerator" /></term> /// <description> /// <para> /// Rendered as an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. /// </para> /// <para> /// For example: <c>{a, b, c}</c>. /// </para> /// <para> /// All collection classes that implement <see cref="T:System.Collections.ICollection" /> its subclasses, /// or generic equivalents all implement the <see cref="T:System.Collections.IEnumerable" /> interface. /// </para> /// </description> /// </item> /// <item> /// <term><see cref="T:System.Collections.DictionaryEntry" /></term> /// <description> /// <para> /// Rendered as the key, an equals sign ('='), and the value (using the appropriate /// renderer). /// </para> /// <para> /// For example: <c>key=value</c>. /// </para> /// </description> /// </item> /// <item> /// <term>other</term> /// <description> /// <para><c>Object.ToString()</c></para> /// </description> /// </item> /// </list> /// </remarks> public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (rendererMap == null) { throw new ArgumentNullException("rendererMap"); } if (obj == null) { writer.Write(SystemInfo.NullText); return; } Array array = obj as Array; if (array != null) { RenderArray(rendererMap, array, writer); return; } IEnumerable enumerable = obj as IEnumerable; if (enumerable != null) { ICollection collection = obj as ICollection; if (collection != null && collection.Count == 0) { writer.Write("{}"); return; } IDictionary dictionary = obj as IDictionary; if (dictionary != null) { RenderEnumerator(rendererMap, dictionary.GetEnumerator(), writer); } else { RenderEnumerator(rendererMap, enumerable.GetEnumerator(), writer); } } else { IEnumerator enumerator = obj as IEnumerator; if (enumerator != null) { RenderEnumerator(rendererMap, enumerator, writer); return; } if (obj is DictionaryEntry) { RenderDictionaryEntry(rendererMap, (DictionaryEntry)obj, writer); return; } string text = obj.ToString(); writer.Write((text == null) ? SystemInfo.NullText : text); } }
protected LoggerRepositorySkeleton(PropertiesDictionary properties) { this.m_properties = properties; this.m_rendererMap = new log4net.ObjectRenderer.RendererMap(); this.m_pluginMap = new log4net.Plugin.PluginMap(this); this.m_levelMap = new log4net.Core.LevelMap(); this.m_configurationMessages = EmptyCollection.Instance; this.m_configured = false; this.AddBuiltinLevels(); this.m_threshold = Level.All; }
private static void RenderValue(RendererMap rendererMap, TextWriter writer, object value) { if (value is string) { writer.Write(value); } else { IObjectRenderer keyRenderer = rendererMap.Get(value.GetType()); keyRenderer.RenderObject(rendererMap, value, writer); } }
/// <summary> /// Construct the repository using specific properties /// </summary> /// <param name="properties">the properties to set for this repository</param> /// <remarks> /// <para> /// Initializes the repository with specified properties. /// </para> /// </remarks> protected LoggerRepositorySkeleton(PropertiesDictionary properties) { m_properties = properties; m_rendererMap = new RendererMap(); m_pluginMap = new PluginMap(this); m_levelMap = new LevelMap(); m_configured = false; AddBuiltinLevels(); // Don't disable any levels by default. m_threshold = Level.All; }
/// <summary> /// Render the enumerator argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="enumerator">the enumerator to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Rendered as an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>{a, b, c}</c>. /// </para> /// </remarks> private void RenderEnumerator(RendererMap rendererMap, IEnumerator enumerator, TextWriter writer) { writer.Write("{"); if (enumerator != null && enumerator.MoveNext()) { rendererMap.FindAndRender(enumerator.Current, writer); while (enumerator.MoveNext()) { writer.Write(", "); rendererMap.FindAndRender(enumerator.Current, writer); } } writer.Write("}"); }
public void RenderObject(RendererMap rendererMap, object obj, System.IO.TextWriter writer) { var dictionary = obj as IDictionary; var jsonSerializerSettings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() }; var serializedLog = JsonConvert.SerializeObject(dictionary, Formatting.None, jsonSerializerSettings); if (dictionary == null) { writer.Write(SystemInfo.NullText); } else { writer.Write(serializedLog); } }
public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { var ex = obj as Exception; //if its not an exception, dump it. If it's an exception, log extended details. if (ex == null) { //by default log up to 10 levels deep. ObjectDumper.Write(obj, 10, writer); } else { while (ex != null) { RenderException(ex, writer); ex = ex.InnerException; } } }
/// <summary> /// Render the array argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="array">the array to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>int[] {1, 2, 3}</c>. /// </para> /// <para> /// If the array is not one dimensional the /// <c>Array.ToString()</c> is returned. /// </para> /// </remarks> private void RenderArray(RendererMap rendererMap, Array array, TextWriter writer) { if (array.Rank != 1) { writer.Write(array.ToString()); return; } writer.Write(array.GetType().Name + " {"); int length = array.Length; if (length > 0) { rendererMap.FindAndRender(array.GetValue(0), writer); for (int i = 1; i < length; i++) { writer.Write(", "); rendererMap.FindAndRender(array.GetValue(i), writer); } } writer.Write("}"); }
/// <summary> /// Render the array argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="array">the array to render</param> /// <returns>the string representation of the array</returns> /// <remarks> /// <para>For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>int[] {1, 2, 3}</c>.</para> /// <para>If the array is not one dimensional the /// <c>Array.ToString()</c> is returned.</para> /// </remarks> virtual protected string RenderArray(RendererMap rendererMap, Array array) { if (array.Rank != 1) { return(array.ToString()); } else { StringBuilder buffer = new StringBuilder(array.GetType().Name + " {"); int len = array.Length; if (len > 0) { buffer.Append(rendererMap.FindAndRender(array.GetValue(0))); for (int i = 1; i < len; i++) { buffer.Append(", ").Append(rendererMap.FindAndRender(array.GetValue(i))); } } return(buffer.Append("}").ToString()); } }
/// <summary> /// Render the array argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="array">the array to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>int[] {1, 2, 3}</c>. /// </para> /// <para> /// If the array is not one dimensional the /// <c>Array.ToString()</c> is returned. /// </para> /// </remarks> void RenderArray(RendererMap rendererMap, Array array, TextWriter writer) { if (array.Rank != 1) { writer.Write(array.ToString()); } else { writer.Write(array.GetType().Name + " {"); var len = array.Length; if (len > 0) { rendererMap.FindAndRender(array.GetValue(0), writer); for (var i = 1; i < len; i++) { writer.Write(", "); rendererMap.FindAndRender(array.GetValue(i), writer); } } writer.Write("}"); } }
/// <summary> /// Serialize any object into a string builder /// </summary> /// <param name="obj"></param> /// <param name="sb"></param> /// <param name="map">log4net renderer map</param> protected virtual void Serialize(object obj, TextWriter sb, RendererMap map, bool tryMapFirst) { var serialized = (tryMapFirst && SerializeObjectUsingRendererMap(obj, sb, map)) || SerializeNull(obj, sb) || // null gate first, others do not expect nulls SerializeDictionary(obj as IDictionary, sb, map) || SerializeString(obj as string, sb) || SerializeChars(obj as char[], sb) || SerializeBytes(obj as byte[], sb) || SerializeDateTime(obj, sb) || SerializeTimeSpan(obj, sb) || SerializePrimitive(obj, sb) || SerializeEnum(obj, sb) || SerializeGuid(obj, sb) || SerializeUri(obj as Uri, sb) || SerializeArray(obj as IEnumerable, sb, map) || // goes almost last not to interfere with string, char[], byte[]... SerializeObjectAsDictionary(obj, sb, map) // before last resort ; if (!serialized) { SerializeString(Convert.ToString(obj), sb); // last resort } }
// $PSRenderer = new-object PSLog4NET.PSObjectRenderer // $Repository = [log4net.LogManager]::GetRepository() // $Repository.RendererMap.Put([PSLog4NET.PSObjectRenderer],(new-object PSLog4NET.PSObjectRenderer) ) // # rver -> http://blogs.msdn.com/powershell/archive/2006/12/07/resolve-error.aspx // $PSRenderer|Add-Member -Force -MemberType ScriptMethod ToString { rver|Out-String } // trap {$Logger.Error($PSRenderer)} public void RenderObject(log4net.ObjectRenderer.RendererMap rendererMap, object obj, System.IO.TextWriter writer) { if (rendererMap == null) { throw new ArgumentNullException("rendererMap"); } if (obj == null) { writer.Write(SystemInfo.NullText); return; } PSObjectRenderer Instance = obj as PSObjectRenderer; if (Instance != null) //On laisse le scripteur redéclarer la méthode ToString à l'aide de Add-Member { writer.Write("{0}", Instance.ToString()); } else { writer.Write(SystemInfo.NullText); } }
/// <summary> /// Serialize an object as a dictionary (last resort) into a string builder /// </summary> /// <param name="obj"></param> /// <param name="sb"></param> /// <param name="map">log4net renderer map</param> protected virtual bool SerializeObjectAsDictionary(Object obj, TextWriter sb, RendererMap map) { if (obj == null) { return(false); } var dict = ObjToDict(obj, SaveType, SaveInternalType, TypeMemberName, Stringify, StringMemberName); SerializeDictionary(dict, sb, map); return(true); }
/// <summary> /// Renders the object as JSON. /// </summary> /// <param name="rendererMap">Renderer map for rendering overrides.</param> /// <param name="obj">Object to be serialized.</param> /// <param name="writer">Writer to write to.</param> public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { Serialize(obj, writer, rendererMap, false); }
/// <summary> /// Render the collection argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="collection">the collection to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Rendered as an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>{a, b, c}</c>. /// </para> /// </remarks> private void RenderCollection(RendererMap rendererMap, ICollection collection, TextWriter writer) { writer.Write("{"); if (collection.Count > 0) { IEnumerator enumerator = collection.GetEnumerator(); if (enumerator != null && enumerator.MoveNext()) { rendererMap.FindAndRender(enumerator.Current, writer); while(enumerator.MoveNext()) { writer.Write(", "); rendererMap.FindAndRender(enumerator.Current, writer); } } } writer.Write("}"); }
/// <summary> /// Render the exception message into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="ex">the exception to get the message from and render</param> /// <returns>the string representation of the exception message</returns> /// <remarks> /// <para>This method is called to render the exception's message into /// a string. This method should be overridden to extend the information /// that is rendered for a specific exception.</para> /// /// <para>See <see cref="RenderException"/> for more information.</para> /// </remarks> virtual protected string RenderExceptionMessage(RendererMap rendererMap, Exception ex) { return ex.Message; }
/// <summary> /// Render the array argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="array">the array to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>int[] {1, 2, 3}</c>. /// </para> /// <para> /// If the array is not one dimensional the /// <c>Array.ToString()</c> is returned. /// </para> /// </remarks> private void RenderArray(RendererMap rendererMap, Array array, TextWriter writer) { if (array.Rank != 1) { writer.Write(array.ToString()); } else { writer.Write(array.GetType().Name + " {"); int len = array.Length; if (len > 0) { rendererMap.FindAndRender(array.GetValue(0), writer); for(int i=1; i<len; i++) { writer.Write(", "); rendererMap.FindAndRender(array.GetValue(i), writer); } } writer.Write("}"); } }
/// <summary> /// Render the DictionaryEntry argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="entry">the DictionaryEntry to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Render the key, an equals sign ('='), and the value (using the appropriate /// renderer). For example: <c>key=value</c>. /// </para> /// </remarks> private void RenderDictionaryEntry(RendererMap rendererMap, DictionaryEntry entry, TextWriter writer) { rendererMap.FindAndRender(entry.Key, writer); writer.Write("="); rendererMap.FindAndRender(entry.Value, writer); }
public void RenderObject(RendererMap a, object b, TextWriter c) { }
/// <summary> /// Render the DictionaryEntry argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="entry">the DictionaryEntry to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Render the key, an equals sign ('='), and the value (using the appropriate /// renderer). For example: <c>key=value</c>. /// </para> /// </remarks> private void RenderDictionaryEntry(RendererMap rendererMap, DictionaryEntry entry, TextWriter writer) { rendererMap.FindAndRender(entry.Key, writer); writer.Write("="); rendererMap.FindAndRender(entry.Value, writer); }
/// <summary> /// Render the exception message into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="ex">the exception to get the message from and render</param> /// <returns>the string representation of the exception message</returns> /// <remarks> /// <para>This method is called to render the exception's message into /// a string. This method should be overridden to extend the information /// that is rendered for a specific exception.</para> /// /// <para>See <see cref="RenderException"/> for more information.</para> /// </remarks> virtual protected string RenderExceptionMessage(RendererMap rendererMap, Exception ex) { return(ex.Message); }
static RendererMap() { _instance = new RendererMap(); }
/// <summary> /// Get Json.NET settings /// </summary> /// <remarks> /// This object itself is the settings. RendererMap is not supported. /// </remarks> /// <param name="obj">Value to be serialized</param> /// <param name="type">Type to serialize as</param> /// <param name="map">Renderer map</param> /// <returns>Settings for this call</returns> protected virtual JsonSerializerSettings GetSettings(object obj, Type type, RendererMap map) => this;
public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (obj is SQSDatum) RenderAppenderLogDatum((SQSDatum)obj, writer); }
/// <summary> /// Serialize value into text writer /// </summary> /// <remarks> /// I've tried and failed to support the RendereMap here in some /// decent way. Pull requests welcome. Until then, map is ignored. /// </remarks> /// <param name="rendererMap">Renderer map - ignored</param> /// <param name="value">Value to be serialized</param> /// <param name="writer">Where JSON will be written</param> public void RenderObject(RendererMap rendererMap, object value, TextWriter writer) { var json = Serialize(value, rendererMap); writer.Write(json); }
public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { }
/// <summary> /// Serialize an object into a string builder using another serializer registered in the renderer map /// </summary> /// <param name="obj"></param> /// <param name="sb"></param> /// <param name="map">log4net renderer map</param> protected virtual bool SerializeObjectUsingRendererMap(Object obj, TextWriter sb, RendererMap map) { if (obj == null) { return(false); } if (map == null) { return(false); } var customSerializer = map.Get(obj) as IJsonRenderer; if (customSerializer == null) { return(false); } customSerializer.RenderObject(map, obj, sb); return(true); }
/// <summary> /// Render the object <paramref name="obj"/> to a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="obj">The object to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Render the object <paramref name="obj"/> to a string. /// </para> /// <para> /// The <paramref name="rendererMap"/> parameter is /// provided to lookup and render other objects. This is /// very useful where <paramref name="obj"/> contains /// nested objects of unknown type. The <see cref="RendererMap.FindAndRender(object)"/> /// method can be used to render these objects. /// </para> /// <para> /// The default renderer supports rendering objects to strings as follows: /// </para> /// <list type="table"> /// <listheader> /// <term>Value</term> /// <description>Rendered String</description> /// </listheader> /// <item> /// <term><c>null</c></term> /// <description> /// <para>"(null)"</para> /// </description> /// </item> /// <item> /// <term><see cref="Array"/></term> /// <description> /// <para> /// For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. /// </para> /// <para> /// For example: <c>int[] {1, 2, 3}</c>. /// </para> /// <para> /// If the array is not one dimensional the /// <c>Array.ToString()</c> is returned. /// </para> /// </description> /// </item> /// <item> /// <term><see cref="IEnumerable"/>, <see cref="ICollection"/> & <see cref="IEnumerator"/></term> /// <description> /// <para> /// Rendered as an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. /// </para> /// <para> /// For example: <c>{a, b, c}</c>. /// </para> /// <para> /// All collection classes that implement <see cref="ICollection"/> its subclasses, /// or generic equivalents all implement the <see cref="IEnumerable"/> interface. /// </para> /// </description> /// </item> /// <item> /// <term><see cref="DictionaryEntry"/></term> /// <description> /// <para> /// Rendered as the key, an equals sign ('='), and the value (using the appropriate /// renderer). /// </para> /// <para> /// For example: <c>key=value</c>. /// </para> /// </description> /// </item> /// <item> /// <term>other</term> /// <description> /// <para><c>Object.ToString()</c></para> /// </description> /// </item> /// </list> /// </remarks> public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (rendererMap == null) { throw new ArgumentNullException("rendererMap"); } if (obj == null) { writer.Write(SystemInfo.NullText); return; } Array objArray = obj as Array; if (objArray != null) { RenderArray(rendererMap, objArray, writer); return; } // Test if we are dealing with some form of collection object IEnumerable objEnumerable = obj as IEnumerable; if (objEnumerable != null) { // Get a collection interface if we can as its .Count property may be more // performant than getting the IEnumerator object and trying to advance it. ICollection objCollection = obj as ICollection; if (objCollection != null && objCollection.Count == 0) { writer.Write("{}"); return; } // This is a special check to allow us to get the enumerator from the IDictionary // interface as this guarantees us DictionaryEntry objects. Note that in .NET 2.0 // the generic IDictionary<> interface enumerates KeyValuePair objects rather than // DictionaryEntry ones. However the implementation of the plain IDictionary // interface on the generic Dictionary<> still returns DictionaryEntry objects. IDictionary objDictionary = obj as IDictionary; if (objDictionary != null) { RenderEnumerator(rendererMap, objDictionary.GetEnumerator(), writer); return; } RenderEnumerator(rendererMap, objEnumerable.GetEnumerator(), writer); return; } IEnumerator objEnumerator = obj as IEnumerator; if (objEnumerator != null) { RenderEnumerator(rendererMap, objEnumerator, writer); return; } if (obj is DictionaryEntry) { RenderDictionaryEntry(rendererMap, (DictionaryEntry)obj, writer); return; } string str = obj.ToString(); writer.Write((str == null) ? SystemInfo.NullText : str); }
/// <summary> /// Render the object <paramref name="obj"/> to a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="obj">The object to render</param> /// <returns>the object rendered as a string</returns> /// <remarks> /// <para>Render the object <paramref name="obj"/> to a /// string.</para> /// /// <para>The <paramref name="rendererMap"/> parameter is /// provided to lookup and render other objects. This is /// very useful where <paramref name="obj"/> contains /// nested objects of unknown type. The <see cref="RendererMap.FindAndRender"/> /// method can be used to render these objects.</para> /// /// <para>The default renderer supports rendering objects to strings as follows:</para> /// /// <list type="table"> /// <listheader> /// <term>Value</term> /// <description>Rendered String</description> /// </listheader> /// <item> /// <term><c>null</c></term> /// <description> /// <para>"(null)"</para> /// </description> /// </item> /// <item> /// <term><see cref="Array"/></term> /// <description> /// <para>For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>int[] {1, 2, 3}</c>.</para> /// <para>If the array is not one dimensional the /// <c>Array.ToString()</c> is returned.</para> /// /// <para>The <see cref="RenderArray"/> method is called /// to do the actual array rendering. This method can be /// overridden in a subclass to provide different array /// rendering.</para> /// </description> /// </item> /// <item> /// <term><see cref="Exception"/></term> /// <description> /// <para>Renders the exception type, message /// and stack trace. Any nested exception is also rendered.</para> /// /// <para>The <see cref="RenderException"/> method is called /// to do the actual exception rendering. This method can be /// overridden in a subclass to provide different exception /// rendering.</para> /// </description> /// </item> /// <item> /// <term>other</term> /// <description> /// <para><c>Object.ToString()</c></para> /// </description> /// </item> /// </list> /// </remarks> virtual public string DoRender(RendererMap rendererMap, object obj) { if (rendererMap == null) { throw new ArgumentNullException("rendererMap"); } if (obj == null) { return "(null)"; } if (obj is Array) { return RenderArray(rendererMap, (Array)obj); } else if (obj is Exception) { return RenderException(rendererMap, (Exception)obj); } else { return obj.ToString(); } }
/// <summary> /// Render the object <paramref name="obj"/> to a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="obj">The object to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Render the object <paramref name="obj"/> to a string. /// </para> /// <para> /// The <paramref name="rendererMap"/> parameter is /// provided to lookup and render other objects. This is /// very useful where <paramref name="obj"/> contains /// nested objects of unknown type. The <see cref="RendererMap.FindAndRender(object)"/> /// method can be used to render these objects. /// </para> /// <para> /// The default renderer supports rendering objects to strings as follows: /// </para> /// <list type="table"> /// <listheader> /// <term>Value</term> /// <description>Rendered String</description> /// </listheader> /// <item> /// <term><c>null</c></term> /// <description> /// <para>"(null)"</para> /// </description> /// </item> /// <item> /// <term><see cref="Array"/></term> /// <description> /// <para> /// For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. /// </para> /// <para> /// For example: <c>int[] {1, 2, 3}</c>. /// </para> /// <para> /// If the array is not one dimensional the /// <c>Array.ToString()</c> is returned. /// </para> /// </description> /// </item> /// <item> /// <term><see cref="IEnumerable"/>, <see cref="ICollection"/> & <see cref="IEnumerator"/></term> /// <description> /// <para> /// Rendered as an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. /// </para> /// <para> /// For example: <c>{a, b, c}</c>. /// </para> /// <para> /// All collection classes that implement <see cref="ICollection"/> its subclasses, /// or generic equivalents all implement the <see cref="IEnumerable"/> interface. /// </para> /// </description> /// </item> /// <item> /// <term><see cref="DictionaryEntry"/></term> /// <description> /// <para> /// Rendered as the key, an equals sign ('='), and the value (using the appropriate /// renderer). /// </para> /// <para> /// For example: <c>key=value</c>. /// </para> /// </description> /// </item> /// <item> /// <term>other</term> /// <description> /// <para><c>Object.ToString()</c></para> /// </description> /// </item> /// </list> /// </remarks> public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (rendererMap == null) { throw new ArgumentNullException("rendererMap"); } if (obj == null) { writer.Write(SystemInfo.NullText); return; } Array objArray = obj as Array; if (objArray != null) { RenderArray(rendererMap, objArray, writer); return; } // Test if we are dealing with some form of collection object IEnumerable objEnumerable = obj as IEnumerable; if (objEnumerable != null) { // Get a collection interface if we can as its .Count property may be more // performant than getting the IEnumerator object and trying to advance it. ICollection objCollection = obj as ICollection; if (objCollection != null && objCollection.Count == 0) { writer.Write("{}"); return; } // This is a special check to allow us to get the enumerator from the IDictionary // interface as this guarantees us DictionaryEntry objects. Note that in .NET 2.0 // the generic IDictionary<> interface enumerates KeyValuePair objects rather than // DictionaryEntry ones. However the implementation of the plain IDictionary // interface on the generic Dictionary<> still returns DictionaryEntry objects. IDictionary objDictionary = obj as IDictionary; if (objDictionary != null) { RenderEnumerator(rendererMap, objDictionary.GetEnumerator(), writer); return; } RenderEnumerator(rendererMap, objEnumerable.GetEnumerator(), writer); return; } IEnumerator objEnumerator = obj as IEnumerator; if (objEnumerator != null) { RenderEnumerator(rendererMap, objEnumerator, writer); return; } if (obj is DictionaryEntry) { RenderDictionaryEntry(rendererMap, (DictionaryEntry)obj, writer); return; } string str = obj.ToString(); writer.Write( (str==null) ? SystemInfo.NullText : str ); }
/// <summary> /// Render the array argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="array">the array to render</param> /// <returns>the string representation of the array</returns> /// <remarks> /// <para>For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>int[] {1, 2, 3}</c>.</para> /// <para>If the array is not one dimensional the /// <c>Array.ToString()</c> is returned.</para> /// </remarks> virtual protected string RenderArray(RendererMap rendererMap, Array array) { if (array.Rank != 1) { return array.ToString(); } else { StringBuilder buffer = new StringBuilder(array.GetType().Name + " {"); int len = array.Length; if (len > 0) { buffer.Append(rendererMap.FindAndRender(array.GetValue(0))); for(int i=1; i<len; i++) { buffer.Append(", ").Append(rendererMap.FindAndRender(array.GetValue(i))); } } return buffer.Append("}").ToString(); } }
/// <summary> /// Render the enumerator argument into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="enumerator">the enumerator to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Rendered as an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>{a, b, c}</c>. /// </para> /// </remarks> private void RenderEnumerator(RendererMap rendererMap, IEnumerator enumerator, TextWriter writer) { writer.Write("{"); if (enumerator != null && enumerator.MoveNext()) { rendererMap.FindAndRender(enumerator.Current, writer); while (enumerator.MoveNext()) { writer.Write(", "); rendererMap.FindAndRender(enumerator.Current, writer); } } writer.Write("}"); }
/// <summary> /// Render the exception into a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="ex">the exception to render</param> /// <returns>the string representation of the exception</returns> /// <remarks> /// <para>Renders the exception type, message, and stack trace. Any nested /// exceptions are also rendered.</para> /// /// <para>The <see cref="RenderExceptionMessage(RendererMap,Exception)"/> /// method is called to render the Exception's message into a string. This method /// can be overridden to change the behaviour when rendering /// exceptions. To change or extend only the message that is /// displayed override the <see cref="RenderExceptionMessage(RendererMap,Exception)"/> /// method instead.</para> /// </remarks> virtual protected string RenderException(RendererMap rendererMap, Exception ex) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.Append("Exception: ") .Append(ex.GetType().FullName) .Append(NewLine) .Append("Message: ") .Append(RenderExceptionMessage(rendererMap, ex)) .Append(NewLine); #if !NETCF if (ex.Source != null && ex.Source.Length > 0) { sb.Append("Source: ").Append(ex.Source).Append(NewLine); } if (ex.StackTrace != null && ex.StackTrace.Length > 0) { sb.Append(ex.StackTrace).Append(NewLine); } #endif if (ex.InnerException != null) { sb.Append(NewLine) .Append("Nested Exception") .Append(NewLine) .Append(NewLine) .Append(RenderException(rendererMap, ex.InnerException)) .Append(NewLine); } return sb.ToString(); }
/// <summary> /// Renderiza una excepción como JSON. /// </summary> /// <param name="rendererMap">The renderMap.</param> /// <param name="obj">Excepción a renderizar como JSON.</param> /// <param name="writer">The writer.</param> public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { writer.Write((obj as Exception).ToJson()); }
/// <summary> /// Render the object <paramref name="obj"/> to a string /// </summary> /// <param name="rendererMap">The map used to lookup renderers</param> /// <param name="obj">The object to render</param> /// <param name="writer">The writer to render to</param> /// <remarks> /// <para> /// Render the object <paramref name="obj"/> to a string. /// </para> /// <para> /// The <paramref name="rendererMap"/> parameter is /// provided to lookup and render other objects. This is /// very useful where <paramref name="obj"/> contains /// nested objects of unknown type. The <see cref="RendererMap.FindAndRender"/> /// method can be used to render these objects. /// </para> /// <para> /// The default renderer supports rendering objects to strings as follows: /// </para> /// <list type="table"> /// <listheader> /// <term>Value</term> /// <description>Rendered String</description> /// </listheader> /// <item> /// <term><c>null</c></term> /// <description> /// <para>"(null)"</para> /// </description> /// </item> /// <item> /// <term><see cref="Array"/></term> /// <description> /// <para> /// For a one dimensional array this is the /// array type name, an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>int[] {1, 2, 3}</c>. /// </para> /// <para> /// If the array is not one dimensional the /// <c>Array.ToString()</c> is returned. /// </para> /// </description> /// </item> /// <item> /// <term><see cref="ICollection"/></term> /// <description> /// <para> /// Rendered as an open brace, followed by a comma /// separated list of the elements (using the appropriate /// renderer), followed by a close brace. For example: /// <c>{a, b, c}</c>. /// </para> /// </description> /// </item> /// <item> /// <term><see cref="DictionaryEntry"/></term> /// <description> /// <para> /// Rendered as the key, an equals sign ('='), and the value (using the appropriate /// renderer). For example: <c>key=value</c>. /// </para> /// </description> /// </item> /// <item> /// <term>other</term> /// <description> /// <para><c>Object.ToString()</c></para> /// </description> /// </item> /// </list> /// </remarks> public void RenderObject(RendererMap rendererMap, object obj, TextWriter writer) { if (rendererMap == null) { throw new ArgumentNullException("rendererMap"); } if (obj == null) { writer.Write("(null)"); return; } Array objArray = obj as Array; if (objArray != null) { RenderArray(rendererMap, objArray, writer); return; } ICollection objCollection = obj as ICollection; if (objCollection != null) { RenderCollection(rendererMap, objCollection, writer); return; } if (obj is DictionaryEntry) { RenderDictionaryEntry(rendererMap, (DictionaryEntry)obj, writer); return; } string str = obj.ToString(); writer.Write( (str==null) ? "(null)" : str ); }