Пример #1
0
        /// <summary>
        /// Debugs the content to a file/attachment with file name/key identifier as debug level
        /// </summary>
        /// <typeparam name="TLogProvider">The log provider to act on</typeparam>
        /// <typeparam name="T">The object to be stored</typeparam>
        /// <param name="content">The content to be stored in the file/attachment</param>
        /// <param name="identifier">The file name/identifier of the file/attachment</param>
        /// <param name="customFormat">(Optional) the custom serializer format</param>
        /// <returns>True if the log provider exists in the providers list</returns>
        public static bool DebugTo <TLogProvider, T>(
            T content,
            string identifier,
            SerializerFormat customFormat = SerializerFormat.NONE)
            where TLogProvider : ILogProvider
            where T : class, new()
        {
            var type = typeof(TLogProvider);

            var provider = Providers.SingleOrDefault(p => type == p.GetType());

            if (provider == null)
            {
                return(false);
            }

            var category = GetCategory();

            if (Filters.Any(f => !f.Filter(type.FullName, LogLevel.DEBUG, category, string.Empty)))
            {
                return(false);
            }

            provider.Debug(category, content, identifier, customFormat);

            return(true);
        }
Пример #2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="HttpClientService" /> class.
        /// </summary>
        /// <param name="format">序列化格式</param>
        public HttpClientService(SerializerFormat format)
        {
            this._serializer = this.GetSerialzar(format);

            this.MaxResponseContentBufferSize = int.MaxValue;

            this.Timeout = TimeSpan.FromSeconds(100);

            this.InitMediaTypeHeaderValue(format);
        }
Пример #3
0
        /// <summary>
        /// Save the serializer version of <paramref name="content" /> in the file <paramref name="identifier" />,
        /// using default SerializerFormat, or a custom serializer format provided by <paramref name="customFormat" />.
        /// </summary>
        /// <typeparam name="T">The type of the parameter <paramref name="content" /></typeparam>
        /// <param name="content">The object/instance of a class to be serialized and saved in a disk file</param>
        /// <param name="identifier">The file name to be persisted to disk with the content</param>
        /// <param name="customFormat">Whatever or not to use a custom Serializer adapter different that one that is default for type</param>
        /// <remarks>Requires LogLevel.DEBUG flag</remarks>

        public void Debug <T>(T content, string identifier, SerializerFormat customFormat = SerializerFormat.NONE) where T : class
        {
            if (customFormat == SerializerFormat.NONE)
            {
                WriteInternal(LogLevel.DEBUG, (string)content.GetSerializer());
            }
            else
            {
                WriteInternal(LogLevel.DEBUG, (string)content.GetCustomSerializer(customFormat));
            }
        }
Пример #4
0
 /// <summary>
 /// Converts the content type to a media type.
 /// </summary>
 /// <param name="serializerFormat">The serializer format.</param>
 /// <returns></returns>
 /// <exception cref="ArgumentOutOfRangeException">serializerFormat</exception>
 public static string ToMediaType(SerializerFormat serializerFormat)
 {
     switch (serializerFormat)
     {
         case SerializerFormat.JSON:
             return JsonContentType;
         case SerializerFormat.XML:
             return XmlContentType;
         default:
             throw new ArgumentOutOfRangeException("serializerFormat");
     }
 }
Пример #5
0
        /// <summary>
        /// 初始化MediaTypeWithQualityHeaderValue
        /// </summary>
        /// <param name="format">序列化的格式</param>
        private void InitMediaTypeHeaderValue(SerializerFormat format)
        {
            switch (format)
            {
            case SerializerFormat.Json:
                this.MediaTypeHeaderValue = new MediaTypeWithQualityHeaderValue("application/json");
                break;

            case SerializerFormat.Xml:
                this.MediaTypeHeaderValue = new MediaTypeWithQualityHeaderValue("application/xml");
                break;
            }
        }
Пример #6
0
        /// <summary>
        /// 取得實作序列化的物件
        /// </summary>
        /// <param name="format">序列化的格式</param>
        /// <returns>實作序列化物件</returns>
        private ISerializer GetSerialzar(SerializerFormat format)
        {
            switch (format)
            {
            case SerializerFormat.Json:
                return(JsonHelper.Instance);

            //case SerializerFormat.Xml:
            //    return XmlHelper.Instance;
            default:
                throw new NotImplementedException("Serializer Format Not Implemented.");
            }
        }
Пример #7
0
        /// <summary>
        /// Save the serializer version of <paramref name="content" /> in the file <paramref name="identifier" />,
        /// using default SerializerFormat, or a custom serializer format provided by <paramref name="customFormat" />.
        /// </summary>
        /// <typeparam name="T">The type of the parameter <paramref name="content" /></typeparam>
        /// <param name="content">The object/instance of a class to be serialized and saved in a disk file</param>
        /// <param name="identifier">The file name to be persisted to disk with the content</param>
        /// <param name="customFormat">Whatever or not to use a custom Serializer adapter different that one that is default for type</param>
        /// <remarks>Requires LogLevel.DEBUG flag</remarks>
        public void Debug <T>(T content, string identifier, SerializerFormat customFormat = SerializerFormat.NONE)
            where T : class
        {
            if (!_level.HasFlag(LogLevel.DEBUG))
            {
                return;
            }

            var contentAsString = customFormat == SerializerFormat.NONE
                ? content.GetSerializer()
                : content.GetCustomSerializer(customFormat);

            Debug((string)contentAsString, identifier);
        }
Пример #8
0
        /// <summary>
        /// Logs the message as a file/attachment with a file name/identifier with debug level using a custom serializer or default.
        /// </summary>
        /// <typeparam name="T">any class that can be serialized to the <paramref name="customFormat" /> serializer format</typeparam>
        /// <param name="category">The category</param>
        /// <param name="content">The object to be serialized</param>
        /// <param name="identifier">The filename/attachment identifier (file name or key)</param>
        /// <param name="customFormat">(Optional) the custom serializer format</param>
        public void Debug <T>(string category, T content, string identifier, SerializerFormat customFormat = SerializerFormat.NONE) where T : class, new()
        {
            if (!_level.HasFlag(LogLevel.DEBUG))
            {
                return;
            }

            _adapter.Debug(identifier);
            if (customFormat == SerializerFormat.NONE)
            {
                _adapter.Debug((string)content.GetSerializer());
            }
            else
            {
                _adapter.Debug((string)content.GetCustomSerializer(customFormat));
            }
        }
Пример #9
0
        /// <summary>
        /// Logs the message as a file/attachment with a file name/identifier with debug level using a custom serializer or default.
        /// </summary>
        /// <typeparam name="T">any class that can be serialized to the <paramref name="customFormat" /> serializer format</typeparam>
        /// <param name="category">The category</param>
        /// <param name="content">The object to be serialized</param>
        /// <param name="identifier">The filename/attachment identifier (file name or key)</param>
        /// <param name="customFormat">(Optional) the custom serializer format</param>
        public void Debug <T>(string category, T content, string identifier, SerializerFormat customFormat = SerializerFormat.NONE) where T : class, new()
        {
            if (!_level.HasFlag(LogLevel.DEBUG))
            {
                return;
            }

            string serialized;

            if (customFormat == SerializerFormat.NONE)
            {
                serialized = (string)content.GetSerializer();
            }
            else
            {
                serialized = (string)content.GetCustomSerializer(customFormat);
            }

            PropagateInternal(Serialize(LogLevel.DEBUG, category, serialized, identifier));
        }
Пример #10
0
 /// <inheritdoc />
 public void Debug <T>(T content, string identifier, SerializerFormat customFormat = SerializerFormat.NONE) where T : class
 {
     throw new NotImplementedException();
 }
Пример #11
0
        public static SerializerConverter <T> GetCustomSerializer <T>(SerializerFormat format) where T : class
        {
            var obj = (T)Activator.CreateInstance(typeof(T));

            return(GetCustomSerializer(obj, format));
        }
Пример #12
0
 public static SerializerConverter <T> GetCustomSerializer <T>(this T obj, SerializerFormat format) where T : class
 {
     return(GetSerializer(obj, new SerializerAttribute(format)));
 }
Пример #13
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SerializerAttribute"/> class.
 /// </summary>
 /// <param name="format">The format.</param>
 /// <param name="isStrict">if set to <c>true</c> [is strict].</param>
 public SerializerAttribute(SerializerFormat format = SerializerFormat.XML, bool isStrict = true)
 {
     Format   = format;
     IsStrict = isStrict;
 }
Пример #14
0
 /// <summary>
 /// Does nothing
 /// </summary>
 /// <typeparam name="T">Not used</typeparam>
 /// <param name="category">The category</param>
 /// <param name="content">Not used</param>
 /// <param name="identifier">Not used</param>
 /// <param name="customFormat">Not used</param>
 public void Debug <T>(string category, T content, string identifier, SerializerFormat customFormat = SerializerFormat.NONE)
     where T : class, new()
 {
     _adapter.Debug(content, identifier, customFormat);
 }
Пример #15
0
        /// <summary>
        /// Logs the message as a file/attachment with a file name/identifier with debug level using a custom serializer or default.
        /// </summary>
        /// <typeparam name="T">any class that can be serialized to the <paramref name="customFormat"/> serializer format</typeparam>
        /// <param name="content">The object to be serialized</param>
        /// <param name="identifier">The filename/attachment identifier (file name or key)</param>
        /// <param name="customFormat">(Optional) the custom serializer format</param>
        public static void Debug <T>(T content, [Localizable(false)] string identifier, SerializerFormat customFormat = SerializerFormat.NONE)
            where T : class, new()
        {
            var category = GetCategory();

            foreach (var provider in Providers.Where(p =>
                                                     Filters.All(f => f.Filter(p.GetType().FullName, LogLevel.DEBUG, category, string.Empty))))
            {
                provider.Debug(category, content, identifier, customFormat);
            }
        }
Пример #16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="JSONSerializer"/> class.
 /// </summary>
 /// <param name="format">The format.</param>
 public JSONSerializer(SerializerFormat format) {
     this.format = format;
 }