Refactorizando código

Si entiendo bien tu pregunta se me ocurre que podrías convertir las llamadas:

dal.MetodoA(..)
dal.MetodoB(..)

en

dal.Metodo(A,...)
dal.Metodo(B,...)




"AE" wrote:

Hola a todos,

tengo una serie de métodos (3 o 4 métodos de momento) que siguen esta
estructura:

...
if (listaProvincias.TieneElementos)
{
listaTipoVal = dal.ObtenerCodigosTipoValUsuario();

listaTareaWF = dal.LLAMADA_METODOXXX(
listaProvincias, listaTipoVal);
}
else if (listaEntidadBancaria.TieneElementos)
{
listaTipoVal = dal.ObtenerCodigosTipoValUsuario();

listaTareaWF = dal.LLAMADA_METODOXXX(
listaEntidadBancaria, listaTipoVal);
}


Lo único que cambia es la llamada a un método de una clase dal, que indico
como dal.LLAMADA_METODOXXX, que en cada uno métodos va a ser distinto el
nombre, pero el número y tipo de parámetros será el mismo, por ejemplo:
dal.MetodoA(..)
dal.MetodoB(..)

El caso que el comportamiento se repite en cada método , sólo cambia la
llamada ese método dal.LLAMADA_METODOXXX.

Existe alguna manera de refactorizar ese código y de reutilizar el código ??
Sobre todo si existe alguna manera que no penalice el rendimiento, por lo
tanto descarto reflexión, no?.


Saludos y gracias.

Hola,

tengo estos métodos a los que llamar en lo que comenté antes

dal.ObtenerPorEncargo(..)
dal.ObtenerPorExpediente()
dal.ObtenerAsignadas()

Usted indica esta forma,

dal.Obtener("Encargo",..);
...

Yo en estos temas ya queda todo difuso la separación entre capa DAL (acceso
a datos) y la BL (Lógica Negocio).

Si le pasara el discriminante con el nombre del método a
dal.Obtener("Encargo",..); ya estaría indicando que la lógica se encargar la
capa DAL, y conceptualmente no estaría bien ? O si?.

Saludos.

"carlosmsr" wrote:

Si entiendo bien tu pregunta se me ocurre que podrías convertir las llamadas:

dal.MetodoA(..)
dal.MetodoB(..)

en

dal.Metodo(A,...)
dal.Metodo(B,...)




"AE" wrote:

> Hola a todos,
>
> tengo una serie de métodos (3 o 4 métodos de momento) que siguen esta
> estructura:
>
> ...
> if (listaProvincias.TieneElementos)
> {
> listaTipoVal = dal.ObtenerCodigosTipoValUsuario();
>
> listaTareaWF = dal.LLAMADA_METODOXXX(
> listaProvincias, listaTipoVal);
> }
> else if (listaEntidadBancaria.TieneElementos)
> {
> listaTipoVal = dal.ObtenerCodigosTipoValUsuario();
>
> listaTareaWF = dal.LLAMADA_METODOXXX(
> listaEntidadBancaria, listaTipoVal);
> }
>
>
> Lo único que cambia es la llamada a un método de una clase dal, que indico
> como dal.LLAMADA_METODOXXX, que en cada uno métodos va a ser distinto el
> nombre, pero el número y tipo de parámetros será el mismo, por ejemplo:
> dal.MetodoA(..)
> dal.MetodoB(..)
>
> El caso que el comportamiento se repite en cada método , sólo cambia la
> llamada ese método dal.LLAMADA_METODOXXX.
>
> Existe alguna manera de refactorizar ese código y de reutilizar el código ??
> Sobre todo si existe alguna manera que no penalice el rendimiento, por lo
> tanto descarto reflexión, no?.
>
>
> Saludos y gracias.

Muy interesante la pregunta.
Yo consideraría que de alguna lógica siempre se va a encargar la capa de
acceso a datos, me refiero a que no deja de ser una serie de pasos ordenados
según cierta lógica y entendiendo a la vez el concepto de "lógica" por
aquello que sustenta algún tipo de "orden".
El tema es si la capa de este orden tiene que ver con el proceso de acceder
a los datos o con el proceso de llevar a cabo el negocio según sus reglas.
Pasar este descriptor a la capa de acceso a datos en principio no es operar
sobre la lógica del negocio sino describir el tipo de datos que se espera de
vuelta.
Esto, de todos modos podría ser algo que quisieras extraer de la capa de
acceso a datos y en ese caso creo que tendrías que intentar separa las
operaciones aplicando una mayor abstracción a aquellos métodos que quieres
dejar en la capa de datos.

Un poco más en concreto. Si: dal.ObtenerPorEncargo(..);
dal.ObtenerPorExpediente() y dal.ObtenerAsignadas() hacen casi lo mismo y
tiene código compartido para reusar (tal vez sólo se diferencien el el string
que declara el query que se ejecuta en la base de datos), entonces ya hay
cierta lógica aplicada. No en tiempo de ejecución, pero sí en el diseño.

Algo que podrías hacer si quisieras evitar esto (y no estoy seguro de si
aplique al diseño de tu aplicación) es:

dal.PropiedadDiscriminante = "Encargo";
dal.Obtener(...);

Eso te permitiría mantener la lógica en el objeto que instancia e invoca a
dal (idealmente un objeto totalmente contenido en la capa de BL).

Espero tu opinión...



"AE" wrote:

Hola,

tengo estos métodos a los que llamar en lo que comenté antes

dal.ObtenerPorEncargo(..)
dal.ObtenerPorExpediente()
dal.ObtenerAsignadas()

Usted indica esta forma,

dal.Obtener("Encargo",..);
...

Yo en estos temas ya queda todo difuso la separación entre capa DAL (acceso
a datos) y la BL (Lógica Negocio).

Si le pasara el discriminante con el nombre del método a
dal.Obtener("Encargo",..); ya estaría indicando que la lógica se encargar la
capa DAL, y conceptualmente no estaría bien ? O si?.

Saludos.

"carlosmsr" wrote:

> Si entiendo bien tu pregunta se me ocurre que podrías convertir las llamadas:
>
> dal.MetodoA(..)
> dal.MetodoB(..)
>
> en
>
> dal.Metodo(A,...)
> dal.Metodo(B,...)
>
>
>
>
> "AE" wrote:
>
> > Hola a todos,
> >
> > tengo una serie de métodos (3 o 4 métodos de momento) que siguen esta
> > estructura:
> >
> > ...
> > if (listaProvincias.TieneElementos)
> > {
> > listaTipoVal = dal.ObtenerCodigosTipoValUsuario();
> >
> > listaTareaWF = dal.LLAMADA_METODOXXX(
> > listaProvincias, listaTipoVal);
> > }
> > else if (listaEntidadBancaria.TieneElementos)
> > {
> > listaTipoVal = dal.ObtenerCodigosTipoValUsuario();
> >
> > listaTareaWF = dal.LLAMADA_METODOXXX(
> > listaEntidadBancaria, listaTipoVal);
> > }
> >
> >
> > Lo único que cambia es la llamada a un método de una clase dal, que indico
> > como dal.LLAMADA_METODOXXX, que en cada uno métodos va a ser distinto el
> > nombre, pero el número y tipo de parámetros será el mismo, por ejemplo:
> > dal.MetodoA(..)
> > dal.MetodoB(..)
> >
> > El caso que el comportamiento se repite en cada método , sólo cambia la
> > llamada ese método dal.LLAMADA_METODOXXX.
> >
> > Existe alguna manera de refactorizar ese código y de reutilizar el código ??
> > Sobre todo si existe alguna manera que no penalice el rendimiento, por lo
> > tanto descarto reflexión, no?.
> >
> >
> > Saludos y gracias.

Hola,

En mi caso actual, tengo esa lógica en varios métodos que comenté en el
primer post. En cada método llamo a métodos del estilo dal.LLAMADA_METODOXXX
, pero al contrario de lo que dije, el tipo de retorno no es igual para
todos, ni los parámetros.

Lo que comentas tiene sentido, la capa DAL puede recibir un discriminante
para determinar el tipo de datos a obtener. En este caso, la lógica está muy
definida pues según listas de valores tengan valores o no, se necesitarán
obtener más listas de valores.

Supongo que para refactorizar el código lo único que me quedaría pienso es
eventos y delegados.

Saludos y gracias.
"carlosmsr" wrote:

Muy interesante la pregunta.
Yo consideraría que de alguna lógica siempre se va a encargar la capa de
acceso a datos, me refiero a que no deja de ser una serie de pasos ordenados
según cierta lógica y entendiendo a la vez el concepto de "lógica" por
aquello que sustenta algún tipo de "orden".
El tema es si la capa de este orden tiene que ver con el proceso de acceder
a los datos o con el proceso de llevar a cabo el negocio según sus reglas.
Pasar este descriptor a la capa de acceso a datos en principio no es operar
sobre la lógica del negocio sino describir el tipo de datos que se espera de
vuelta.
Esto, de todos modos podría ser algo que quisieras extraer de la capa de
acceso a datos y en ese caso creo que tendrías que intentar separa las
operaciones aplicando una mayor abstracción a aquellos métodos que quieres
dejar en la capa de datos.

Un poco más en concreto. Si: dal.ObtenerPorEncargo(..);
dal.ObtenerPorExpediente() y dal.ObtenerAsignadas() hacen casi lo mismo y
tiene código compartido para reusar (tal vez sólo se diferencien el el string
que declara el query que se ejecuta en la base de datos), entonces ya hay
cierta lógica aplicada. No en tiempo de ejecución, pero sí en el diseño.

Algo que podrías hacer si quisieras evitar esto (y no estoy seguro de si
aplique al diseño de tu aplicación) es:

dal.PropiedadDiscriminante = "Encargo";
dal.Obtener(...);

Eso te permitiría mantener la lógica en el objeto que instancia e invoca a
dal (idealmente un objeto totalmente contenido en la capa de BL).

Espero tu opinión...



"AE" wrote:

>
> Hola,
>
> tengo estos métodos a los que llamar en lo que comenté antes
>
> dal.ObtenerPorEncargo(..)
> dal.ObtenerPorExpediente()
> dal.ObtenerAsignadas()
>
> Usted indica esta forma,
>
> dal.Obtener("Encargo",..);
> ...
>
> Yo en estos temas ya queda todo difuso la separación entre capa DAL (acceso
> a datos) y la BL (Lógica Negocio).
>
> Si le pasara el discriminante con el nombre del método a
> dal.Obtener("Encargo",..); ya estaría indicando que la lógica se encargar la
> capa DAL, y conceptualmente no estaría bien ? O si?.
>
> Saludos.
>
> "carlosmsr" wrote:
>
> > Si entiendo bien tu pregunta se me ocurre que podrías convertir las llamadas:
> >
> > dal.MetodoA(..)
> > dal.MetodoB(..)
> >
> > en
> >
> > dal.Metodo(A,...)
> > dal.Metodo(B,...)
> >
> >
> >
> >
> > "AE" wrote:
> >
> > > Hola a todos,
> > >
> > > tengo una serie de métodos (3 o 4 métodos de momento) que siguen esta
> > > estructura:
> > >
> > > ...
> > > if (listaProvincias.TieneElementos)
> > > {
> > > listaTipoVal = dal.ObtenerCodigosTipoValUsuario();
> > >
> > > listaTareaWF = dal.LLAMADA_METODOXXX(
> > > listaProvincias, listaTipoVal);
> > > }
> > > else if (listaEntidadBancaria.TieneElementos)
> > > {
> > > listaTipoVal = dal.ObtenerCodigosTipoValUsuario();
> > >
> > > listaTareaWF = dal.LLAMADA_METODOXXX(
> > > listaEntidadBancaria, listaTipoVal);
> > > }
> > >
> > >
> > > Lo único que cambia es la llamada a un método de una clase dal, que indico
> > > como dal.LLAMADA_METODOXXX, que en cada uno métodos va a ser distinto el
> > > nombre, pero el número y tipo de parámetros será el mismo, por ejemplo:
> > > dal.MetodoA(..)
> > > dal.MetodoB(..)
> > >
> > > El caso que el comportamiento se repite en cada método , sólo cambia la
> > > llamada ese método dal.LLAMADA_METODOXXX.
> > >
> > > Existe alguna manera de refactorizar ese código y de reutilizar el código ??
> > > Sobre todo si existe alguna manera que no penalice el rendimiento, por lo
> > > tanto descarto reflexión, no?.
> > >
> > >
> > > Saludos y gracias.

podrías utilizar una serié de sobrecargas de un método que recolectaran los
datos y luego invocaran a un método que ejecute la consulta sobre la base de
datos. algo como:

public bool sobrecargaMétodo(int a, obj b, string c)
{ return metodoBase(a, b.Propiedad, c, null); }

public bool sobrecargaMétodo(string a, obj b, string c)
{ return metodoBase(int.Parse(a), b.Propiedad, c, null); }

public bool sobrecargaMétodo(obj a, obj b, string c, int d)
{ return metodoBase((string)a, b.Propiedad, c, d); }


En cuanto a la sobrecarga del valor de retorno, es algo un poco discutido
pero posible y válido.

"AE" wrote:

Hola,

En mi caso actual, tengo esa lógica en varios métodos que comenté en el
primer post. En cada método llamo a métodos del estilo dal.LLAMADA_METODOXXX
, pero al contrario de lo que dije, el tipo de retorno no es igual para
todos, ni los parámetros.

Lo que comentas tiene sentido, la capa DAL puede recibir un discriminante
para determinar el tipo de datos a obtener. En este caso, la lógica está muy
definida pues según listas de valores tengan valores o no, se necesitarán
obtener más listas de valores.

Supongo que para refactorizar el código lo único que me quedaría pienso es
eventos y delegados.

Saludos y gracias.
"carlosmsr" wrote:

> Muy interesante la pregunta.
> Yo consideraría que de alguna lógica siempre se va a encargar la capa de
> acceso a datos, me refiero a que no deja de ser una serie de pasos ordenados
> según cierta lógica y entendiendo a la vez el concepto de "lógica" por
> aquello que sustenta algún tipo de "orden".
> El tema es si la capa de este orden tiene que ver con el proceso de acceder
> a los datos o con el proceso de llevar a cabo el negocio según sus reglas.
> Pasar este descriptor a la capa de acceso a datos en principio no es operar
> sobre la lógica del negocio sino describir el tipo de datos que se espera de
> vuelta.
> Esto, de todos modos podría ser algo que quisieras extraer de la capa de
> acceso a datos y en ese caso creo que tendrías que intentar separa las
> operaciones aplicando una mayor abstracción a aquellos métodos que quieres
> dejar en la capa de datos.
>
> Un poco más en concreto. Si: dal.ObtenerPorEncargo(..);
> dal.ObtenerPorExpediente() y dal.ObtenerAsignadas() hacen casi lo mismo y
> tiene código compartido para reusar (tal vez sólo se diferencien el el string
> que declara el query que se ejecuta en la base de datos), entonces ya hay
> cierta lógica aplicada. No en tiempo de ejecución, pero sí en el diseño.
>
> Algo que podrías hacer si quisieras evitar esto (y no estoy seguro de si
> aplique al diseño de tu aplicación) es:
>
> dal.PropiedadDiscriminante = "Encargo";
> dal.Obtener(...);
>
> Eso te permitiría mantener la lógica en el objeto que instancia e invoca a
> dal (idealmente un objeto totalmente contenido en la capa de BL).
>
> Espero tu opinión...
>
>
>
> "AE" wrote:
>
> >
> > Hola,
> >
> > tengo estos métodos a los que llamar en lo que comenté antes
> >
> > dal.ObtenerPorEncargo(..)
> > dal.ObtenerPorExpediente()
> > dal.ObtenerAsignadas()
> >
> > Usted indica esta forma,
> >
> > dal.Obtener("Encargo",..);
> > ...
> >
> > Yo en estos temas ya queda todo difuso la separación entre capa DAL (acceso
> > a datos) y la BL (Lógica Negocio).
> >
> > Si le pasara el discriminante con el nombre del método a
> > dal.Obtener("Encargo",..); ya estaría indicando que la lógica se encargar la
> > capa DAL, y conceptualmente no estaría bien ? O si?.
> >
> > Saludos.
> >
> > "carlosmsr" wrote:
> >
> > > Si entiendo bien tu pregunta se me ocurre que podrías convertir las llamadas:
> > >
> > > dal.MetodoA(..)
> > > dal.MetodoB(..)
> > >
> > > en
> > >
> > > dal.Metodo(A,...)
> > > dal.Metodo(B,...)
> > >
> > >
> > >
> > >
> > > "AE" wrote:
> > >
> > > > Hola a todos,
> > > >
> > > > tengo una serie de métodos (3 o 4 métodos de momento) que siguen esta
> > > > estructura:
> > > >
> > > > ...
> > > > if (listaProvincias.TieneElementos)
> > > > {
> > > > listaTipoVal = dal.ObtenerCodigosTipoValUsuario();
> > > >
> > > > listaTareaWF = dal.LLAMADA_METODOXXX(
> > > > listaProvincias, listaTipoVal);
> > > > }
> > > > else if (listaEntidadBancaria.TieneElementos)
> > > > {
> > > > listaTipoVal = dal.ObtenerCodigosTipoValUsuario();
> > > >
> > > > listaTareaWF = dal.LLAMADA_METODOXXX(
> > > > listaEntidadBancaria, listaTipoVal);
> > > > }
> > > >
> > > >
> > > > Lo único que cambia es la llamada a un método de una clase dal, que indico
> > > > como dal.LLAMADA_METODOXXX, que en cada uno métodos va a ser distinto el
> > > > nombre, pero el número y tipo de parámetros será el mismo, por ejemplo:
> > > > dal.MetodoA(..)
> > > > dal.MetodoB(..)
> > > >
> > > > El caso que el comportamiento se repite en cada método , sólo cambia la
> > > > llamada ese método dal.LLAMADA_METODOXXX.
> > > >
> > > > Existe alguna manera de refactorizar ese código y de reutilizar el código ??
> > > > Sobre todo si existe alguna manera que no penalice el rendimiento, por lo
> > > > tanto descarto reflexión, no?.
> > > >
> > > >
> > > > Saludos y gracias.