Esempio n. 1
0
        /// <summary>
        ///   Logs the argument to the result.
        /// </summary>
        /// <param name="builder">The output result builder.</param>
        /// <param name="name">The name of parameter.</param>
        /// <param name="value">The value of parameter.</param>
        private void LogArgument(StringBuilder builder, string name, object value)
        {
            if (value == null)
            {
                AddParameter(builder, name, NullValue);
                return;
            }

            var type = value.GetType();

            if (IsPrimitiveType(type))
            {
                AddParameter(builder, name, value);
                return;
            }

            if (LogPrimitiveParametersOnly)
            {
                return;
            }

            if (IsCollection(type))
            {
                AddCollection(builder, name, value as ICollection);
                return;
            }

            foreach (
                var propertyInfo in
                value.GetType()
                .GetProperties()
                .WhereIf(!DeepLogging, x => IsPrimitiveType(x.PropertyType) || IsCollection(x.PropertyType)))
            {
                LogArgument(builder, ParameterName.FormatWith(name, propertyInfo.Name), propertyInfo.GetValue(value));
            }
        }
Esempio n. 2
0
 /// <summary>
 ///   Builds the name of the method.
 /// </summary>
 /// <param name="info">The method information.</param>
 /// <returns>The method name.</returns>
 private static string BuildMethodName(MethodBase info) =>
 MethodSignature.FormatWith(
     info.DeclaringType?.Name,
     info.Name,
     info.GetParameters().Select(x => ParameterName.FormatWith(x.ParameterType.Name, x.Name)).ToCommaSeparatedString());