public override void OnExit(MethodExecutionArgs args)
{
MethodInfo methodInfo = args.Method as MethodInfo;
if (Tipo == null)
{
Tipo = methodInfo.ReturnType;
}
IObjeto objeto = ObjetoFactory.ObtenerObjeto();
if (objeto.esColeccion(Tipo))
{
Tipo = Type.GetType(objeto.TipoSingular(Tipo));
EsColeccion = true;
}
object instancia = null;
if (Ensamblado != null)
{
if (EsColeccion)
{
instancia = DynamicLoaderManager.ObtenerInstancias(Tipo, Ensamblado);
}
else
{
instancia = DynamicLoaderManager.ObtenerInstancia(Tipo, Ensamblado);
}
}
if (instancia == null)
{
if (Dominio != null)
{
if (EsColeccion)
{
instancia = DynamicLoaderManager.ObtenerInstancias(Tipo, Dominio);
}
else
{
instancia = DynamicLoaderManager.ObtenerInstancia(Tipo, Dominio);
}
}
}
if (instancia == null)
{
if (EsColeccion)
{
instancia = DynamicLoaderManager.ObtenerInstancias(Tipo);
}
else
{
instancia = DynamicLoaderManager.ObtenerInstancia(Tipo);
}
}
if (instancia != null)
{
args.ReturnValue = Convert.ChangeType(instancia, methodInfo.ReturnType);
}
else
{
args.ReturnValue = Activator.CreateInstance(methodInfo.ReturnType);
}
}
/// <summary>
/// Mapea la respuesta de la ejecución de un comando a el tipo C# especificado.
/// Puede ser un objeto definido por el usuario, por ejemplo, un TO.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <typeparam name="T">Tipo de la respuesta (entidad).</typeparam>
/// <param name="record">Respuesta obtenida de la ejecución de un comando en una base de datos.</param>
/// <param name="campoPropiedad">Diccionario que asocia el campo de la respuesta con una propiedad de un objeto.</param>
/// <returns>Una instancia cargada del tipo especificado y datos obtenidos de IDataReader (parámetro).</returns>
/// <exception cref="System.InvalidOperationException">Excepción lanzada al ocurrir un erro al mapear la respuesta.</exception>
public virtual RespuestaEjecucion <T> Mapear <T>(IDataRecord record, IDictionary <string, string> campoPropiedad)
{
if (record == null)
{
throw new NullReferenceException("¡Record no puede ser nulo!");
}
if (campoPropiedad == null)
{
throw new NullReferenceException("¡CampoPropiedad no puede ser nulo!");
}
try
{
RespuestaEjecucion <T> retorno = new RespuestaEjecucion <T>();
//Si es un objeto definido por el usuario.
if (!ObjetoFactory.ObtenerObjeto().esPrimitivo(typeof(T)))
{
bool esInmutable = false;
//Obtener los atributos personalizados (Annotations) del tipo.
var attributos = typeof(T).GetCustomAttributes(false);
foreach (var atributo in attributos)
{
if (atributo is Inmutable)
{
esInmutable = (atributo as Inmutable).EsInmutable;
}
}
if (!esInmutable)
{
retorno.Respuesta = Activator.CreateInstance <T>();
IList <PropertyInfo> parametros = typeof(T).GetProperties();
for (int x = 0; x < record.FieldCount; x++)
{
string campo = record.GetName(x);
bool existeCampo = false;
PropertyInfo[] propiedades = retorno.Respuesta.GetType().GetProperties();
foreach (PropertyInfo propiedad in propiedades)
{
//Comprueba existencia de Property con mismo nombre que el campo y el mismo tipo.
if (propiedad.Name == campo)
{
if (record.GetValue(x).GetType() == propiedad.PropertyType)
{
object valor = record[x];
if (valor.GetType() == typeof(DBNull))
{
valor = null;
}
if (valor is string && RecortarTexto)
{
valor = valor.ToString().Trim();
}
propiedad.SetValue(retorno.Respuesta, valor, null);
existeCampo = true;
break;
}
else if (ObjetoFactory.ObtenerObjeto().esEnumeracion(propiedad.PropertyType))
{
try
{
object valorEnum = Enum.Parse(propiedad.PropertyType, record.GetString(x));
propiedad.SetValue(retorno.Respuesta, valorEnum, null);
}
catch { }
}
}
}
//Si no existe una coincidencia directa (nombre) entre Campo y Propiedad.
if (!existeCampo)
{
//Obtiene desde el diccionario la propiedad correspondiente al campo y carga el valor.
object valor = record[x];
if (valor is string && RecortarTexto)
{
valor = valor.ToString().Trim();
}
//Comprueba existencia de Mapeador entre Campo y Propiedad.
if (campoPropiedad != null)
{
bool existePropiedad = false;
foreach (string xpropCampoPropiedad in campoPropiedad.Keys)
{
if (valor.GetType() == typeof(DBNull))
{
valor = null;
}
if (xpropCampoPropiedad.Contains(campo))
{
existePropiedad = true;
ObjetoFactory.ObtenerObjeto().SetValorPropiedad(retorno.Respuesta, xpropCampoPropiedad, valor);
}
}
if (!existePropiedad)
{
//Agrega el campo a las propiedades omitidas.
retorno.PropiedadesOmitidas.Add(campo, valor);
}
}
else
{
//Agrega el campo a las propiedades omitidas.
retorno.PropiedadesOmitidas.Add(campo, valor);
}
}
}
return(retorno);
}
else
{
for (int x = 0; x < record.FieldCount; x++)
{
string campo = record.GetName(x);
object valor = record.GetValue(x);
if (valor is string && RecortarTexto)
{
valor = valor.ToString().Trim();
}
retorno.PropiedadesOmitidas.Add(campo, valor);
}
return(retorno);
}
}
else
{
object valor = record.GetValue(0);
if (valor is string && RecortarTexto)
{
valor = valor.ToString().Trim();
}
return(new RespuestaEjecucion <T>()
{
Respuesta = (T)Convert.ChangeType(valor, typeof(T), CultureInfo.InvariantCulture)
});
}
}
catch (Exception e)
{
throw new InvalidOperationException("¡No se ha podido convertir la respuesta al tipo especificado!", e);
}
}