/// <summary> /// Fetch our own <see cref="PatternConverter"/> SerializingConverter. /// </summary> /// <param name="info">description of the PatternConverter</param> /// <returns>pattern converter set up</returns> /// <remarks> /// <para> /// Please note that properties are only supported with log4net 1.2.11 and above. /// </para> /// </remarks> protected virtual PatternConverter CreateSerializingConverter(ConverterInfo info) { var conv = info.Type == null ? null : Activator.CreateInstance(info.Type) as PatternConverter; if (conv == null) { conv = new JsonPatternConverter(); } #if !LOG4NET_1_2_10_COMPATIBLE conv.Properties = info.Properties; #endif return(conv); }
/// <summary> /// Create an instance from a <see cref="ConverterInfo"/>, instantiating it's <see cref="PatternConverter"/>. /// </summary> /// <remarks> /// Properties["option"] (a <see cref="String"/>) can be used to set an option on the converter instance. /// </remarks> /// <remarks> /// Properties are only supported in log4net 1.2.11 and later. /// </remarks> /// <param name="info"></param> public RawCallLayout(ConverterInfo info) { Name = info.Name; var conv = (PatternConverter)Activator.CreateInstance(info.Type); #if !LOG4NET_1_2_10_COMPATIBLE conv.Properties = info.Properties; if (info.Properties.Contains("option")) { conv.Option = Convert.ToString(info.Properties["option"]); } #endif if (conv is IOptionHandler) { ((IOptionHandler)conv).ActivateOptions(); } m_getter = (e) => Format(conv, e); m_info = info; }
/// <summary> /// Activate the options that were previously set with calls to properties. /// </summary> /// <remarks> /// <para> /// This allows an object to defer activation of its options until all /// options have been set. This is required for components which have /// related options that remain ambiguous until all are set. /// </para> /// <para> /// If a component implements this interface then this method must be called /// after its properties have been set before the component can be used. /// </para> /// <para> /// The strange constructor call to this method is suspended using /// <see cref="m_constructed"/>. /// </para> /// </remarks> public override void ActivateOptions() { if (!m_constructed) { return; } // pass control to parent in case we do not get a serializer :o[ base.ActivateOptions(); // just to get those converters var parser = CreatePatternParser(String.Empty); #if LOG4NET_1_2_10_COMPATIBLE int convord = 0; var converters = new ConverterInfo[parser.PatternConverters.Count]; foreach (DictionaryEntry entry in parser.PatternConverters) { converters[convord++] = new ConverterInfo() { Name = Convert.ToString(entry.Key), Type = (Type)entry.Value }; } #else // Extract discovered converters var converters = Enumerable.ToArray( Enumerable.Cast <ConverterInfo>( parser.PatternConverters.Values ) ); #endif var arrangement = new MultipleArrangement(); if (m_arrangement.Arrangements.Count != 0) { arrangement.AddArrangement(m_arrangement); } var patternArrangement = ArrangementConverter.GetArrangement(ConversionPattern, converters); if (patternArrangement != null) { arrangement.AddArrangement(patternArrangement); } if (arrangement.Arrangements.Count == 0) { // cater for bare defaults arrangement.AddArrangement(new DefaultArrangement()); } var serconv = SerializingConverter; if (serconv == null) { var name = SerializerName ?? DefaultSerializerName; var info = (parser.PatternConverters.ContainsKey(name) ? parser.PatternConverters[name] as ConverterInfo : null ) ?? CreateSerializingConverterInfo(name, typeof(JsonPatternConverter)); SerializingConverter = serconv = CreateSerializingConverter(info); } if (serconv != null) { SetUpSerializingConverter(serconv, converters, arrangement, m_fetcher, m_renderer, m_decorators.ToArray()); } }