/// <summary>
/// Registra el fin de la ejecución de un método, guardando la fecha de termino, el valor de retorno y su tipo.
/// Se debe logear antes de retornar. Requiere que se haya logeado el inicio del método.
/// </summary>
/// <example>
/// public int Sumar(int valor1, int valor2)
/// {
/// log.Inicio(valor1, valor2);
/// int resultado = valor1 + valor2;
/// log.Retorno(resultado);
/// return resultado;
/// }
/// </example>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="valor">Valor de retorno del método.</param>
public void Retorno(object valor)
{
Llamada++;
string valorJson = string.Empty;
try
{
valorJson = JsonConverterFactory.ObtenerJsonConverter().ToJson(valor, true);
}
catch (Exception e)
{
valorJson = "Error al transformar a Json - " + e.Message;
}
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
ValorVariable = valorJson,
Correlativo = Llamada,
Tipo = Tipo.Retorno
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Retorno))
{
writer.Guardar(registro);
}
}
}
private void Deserialize()
{
arbol_JSON.Nodes.Clear();
JavaScriptSerializer js = new JavaScriptSerializer();
try
{
TreeNode rootNode = new TreeNode("Parametros");
arbol_JSON.Nodes.Add(rootNode);
foreach (ParametroTO parametro in Sesion.MetodoActual.Parametros)
{
TreeNode nodoParametro = new TreeNode(string.Format("[{0}]", parametro.Nombre));
rootNode.Nodes.Add(nodoParametro);
IJsonConverter converter = JsonConverterFactory.ObtenerJsonConverter();
try
{
parametro.Valor = converter.ToObject(parametro.Valor.ToString(), true);
}
catch { }
Dictionary <string, object> dic = js.Deserialize <Dictionary <string, object> >(converter.ToJson(parametro));
BuildTree(dic, nodoParametro);
}
}
catch (ArgumentException)
{
MessageBox.Show("JSON data is not valid", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public JsonConverterFactoryDecorator(JsonConverterFactory innerFactory)
{
if (innerFactory == null)
{
throw new ArgumentNullException(nameof(innerFactory));
}
this.innerFactory = innerFactory;
}
public static IEnumerable <object[]> ResourceExplorerRegistrationTestData()
{
var testProviders = new ResourceProvider[] { new TestResourceProvider() };
var testDeclarativeTypes = new DeclarativeType[] { new DeclarativeType <ResourceExplorerOptionsTests>("test") };
var testConverterFactories = new JsonConverterFactory[] { new JsonConverterFactory <TestDeclarativeConverter>() };
var testLegacyComponentTypes = new IComponentDeclarativeTypes[] { new TestDeclarativeComponentRegistration() };
// params: ResourceExplorerOptions options
// Initial declarative types only
yield return(new object[] { new ResourceExplorerOptions(null, testDeclarativeTypes, testConverterFactories)
{
DeclarativeTypes = null
}, null });
// Initial IComponentDeclarativeTypes only
yield return(new object[] { new ResourceExplorerOptions(null, null, null)
{
DeclarativeTypes = testLegacyComponentTypes
}, null });
// Initial declarative types and IComponentDeclarativeTypes
yield return(new object[] { new ResourceExplorerOptions(null, testDeclarativeTypes, testConverterFactories)
{
DeclarativeTypes = testLegacyComponentTypes
}, null });
// Legacy registration only
yield return(new object[] { new ResourceExplorerOptions(null, null, null)
{
DeclarativeTypes = null
}, new TestDeclarativeComponentRegistration() });
// Legacy bridged registration only
yield return(new object[] { new ResourceExplorerOptions(null, null, null)
{
DeclarativeTypes = null
}, new LegacyTestComponentRegistration() });
// All at once, should to union of all registrations
yield return(new object[] { new ResourceExplorerOptions(null, testDeclarativeTypes, testConverterFactories)
{
DeclarativeTypes = testLegacyComponentTypes
}, new LegacyTestComponentRegistration() });
}
/// <summary>
/// Registra la información relevante de una excepción lanzada por un método. Se debe logear antes de ser lanzada.
/// Requiere que el inicio y el retorno del método esté logeado.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="excepcion">Excepción lanzada.</param>
/// <param name="permiteContinuar">Valor que indica si la excepción interrumpe el flujo (no permite continuar).
/// En caso de ser falso, se logea automáticamente el retorno del método como Excepción.</param>
public void Excepcion(Exception excepcion, bool permiteContinuar)
{
Llamada++;
string valorJson = string.Empty;
try
{
valorJson = JsonConverterFactory.ObtenerJsonConverter().ToJson(excepcion.Data, true);
}
catch (Exception ex)
{
valorJson = "Error al transformar a Json - " + ex.Message;
}
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
StackTrace = excepcion.StackTrace,
Data = valorJson,
TipoExcepcion = excepcion.GetType().FullName,
Mensaje = excepcion.Message,
Correlativo = Llamada,
Tipo = Tipo.Excepcion
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Excepcion))
{
writer.Guardar(registro);
}
}
if (!permiteContinuar)
{
Retorno("<" + registro.Tipo + ">");
}
}
public static IEnumerable <object[]> ResourceExplorerOptionsTestData()
{
var testProviders = new ResourceProvider[] { new TestResourceProvider() };
var testDeclarativeTypes = new DeclarativeType[] { new DeclarativeType <ResourceExplorerOptionsTests>("test") };
var testConverterFactories = new JsonConverterFactory[] { new JsonConverterFactory <ActivityConverter>() };
// params:
// IEnumerable<ResourceProvider> resourceProviders
// IEnumerable<DeclarativeType> declarativeTypes
// IEnumerable<JsonConverterFactory> converterFactories
yield return(new object[] { null, null, null });
yield return(new object[] { testProviders, null, null });
yield return(new object[] { null, testDeclarativeTypes, null });
yield return(new object[] { null, null, testConverterFactories });
yield return(new object[] { testProviders, testDeclarativeTypes, testConverterFactories });
}
private DataObjectConverter <TInterface, TImplementation> AddPropertyConverter <TExpression>
(
Expression <TExpression> expression,
JsonConverterFactory converterFactory
)
{
if (!(expression.Body is MemberExpression memberExpression))
{
throw new InvalidOperationException();
}
var member = memberExpression.Member;
if (!(member is PropertyInfo property))
{
throw new InvalidOperationException();
}
_converterFactoryOverrides.Add(property, converterFactory);
return(this);
}
private void Deserialize()
{
Sesion.ExcepcionActual = Sesion.MetodoActual.Excepcion;
if (Sesion.ExcepcionActual != null)
{
MostrarModelo(new ExcepcionModel()
{
ThreadGUID = Sesion.ExcepcionActual.Metodo.Hilo.ThreadGUID,
Clase = Sesion.ExcepcionActual.Metodo.Clase,
MethodGUID = Sesion.ExcepcionActual.Metodo.MethodGUID,
Metodo = Sesion.ExcepcionActual.Metodo.Nombre,
Tipo = Sesion.ExcepcionActual.Tipo,
Mensaje = Sesion.ExcepcionActual.Mensaje,
StackTrace = Sesion.ExcepcionActual.StackTrace,
Data = Sesion.ExcepcionActual.Data
});
}
arbol_JSON.Nodes.Clear();
JavaScriptSerializer js = new JavaScriptSerializer();
try
{
TreeNode rootNode = new TreeNode(Sesion.MetodoActual.Retorno.Tipo);
arbol_JSON.Nodes.Add(rootNode);
IJsonConverter converter = JsonConverterFactory.ObtenerJsonConverter();
try
{
Sesion.MetodoActual.Retorno.Valor = converter.ToObject(Sesion.MetodoActual.Retorno.Valor.ToString(), true);
}
catch { }
Dictionary <string, object> dic = js.Deserialize <Dictionary <string, object> >(converter.ToJson(Sesion.MetodoActual.Retorno));
BuildTree(dic, rootNode);
}
catch
{
}
}
/// <summary>
/// Registra el inicio de un método, guarda la hora actual y cada parametro especificando
/// nombre, tipo y valor. Se recomienda que esta sea la primera instrucción de cada método.
/// Si se logea el inicio, es obligatorio logear el retorno aunque el método sea Void.
/// </summary>
/// <example>
/// public void Metodo1(int a, string b, bool c)
/// {
/// log.Inicio(a, b, c);
/// log.Retorno();
/// }
///
/// public void Metodo2()
/// {
/// log.Inicio();
/// log.Retorno();
/// }
/// </example>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="parametros">Lista de parametros del método actual.</param>
public void Inicio(params object[] parametros)
{
Writers = Log4MeBO.ObtenerWriters(InstanciaLog.Metodo);
Log4MeManager.CurrentInstance = InstanciaLog;
Llamada++;
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
Correlativo = Llamada,
Tipo = Tipo.Inicio
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Inicio))
{
writer.Guardar(registro);
}
}
int numParametro = 0;
if (parametros != null && parametros.Length > 0)
{
foreach (ParameterInfo param in InstanciaLog.Metodo.GetParameters())
{
Llamada++;
string valor = string.Empty;
try
{
valor = JsonConverterFactory.ObtenerJsonConverter().ToJson(parametros[numParametro], true);
}
catch (Exception e)
{
valor = "Error al transformar a Json - " + e.Message.Replace("\n", "\t");
}
RegistroInLineTO parametro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
NombreVariable = param.Name,
ValorVariable = valor,
Correlativo = Llamada,
Tipo = Tipo.Parametro
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Parametro))
{
writer.Guardar(parametro);
}
}
numParametro++;
}
}
}
/// <summary>
/// Overrides the converter of the given property.
/// </summary>
/// <param name="propertyExpression">The property expression.</param>
/// <param name="converterFactory">The JSON converter factory.</param>
/// <typeparam name="TProperty">The property type.</typeparam>
/// <returns>The converter, with the property name.</returns>
public DataObjectConverter <TInterface, TImplementation> WithPropertyConverter <TProperty>
(
Expression <Func <TImplementation, TProperty> > propertyExpression,
JsonConverterFactory converterFactory
) => AddPropertyConverter(propertyExpression, converterFactory);
public TypeJsonConverter()
{
converterFactory = new JsonStringEnumConverter(JsonNamingPolicy.CamelCase, false);
}
public OptOutJsonConverterFactory(JsonConverterFactory innerFactory, params Type [] optOutTypes) : base(innerFactory) => this.optOutTypes = optOutTypes.ToHashSet();
