Inyección de funcionalidad (I)

En el anterior post planteaba un ejemplo hipotético sobre algunas de las fallas más comunes en la inyección de dependencias. En especial cómo, al estar atados a tipos hace que la IDD se vea opacada. Además, claro, por su uso en lugares donde definitivamente no es necesario.

Aunque el anterior ejemplo haya tenido olor a poco probable, les puedo asegurar que es común, y la falla principal está, como comentaba, en que al final es necesario “depender” de algo en lenguajes tipados, sea en la estructura pre definida de una interfaz, sea en una clase abstracta, en definitiva, en alguna firma.

Por lo tanto, una de las principales cuestiones de las que es necesario romper relaciones, es con las firmas, o sea, permitir el libre flujo de funcionalidad independientemente de que se inyecte.

Pensemos que el objetivo final es (Para el post anterior) obtener un objeto con determinados datos, sin importar el valor de entrada. O sea, un output específico independientemente de los inputs.

En JavaScript, una aproximación sería la siguiente:

function IDD() {
    var self = this;
   
    this.dependency = {};
   
    this.getTheAccountForEntity = function(entity){
   
        if (entity.constructor == Company) {
            return {
                AccountName: entity.getName,
                Balance: self.dependency.CalculateBalance(entity)
            };
        } else {
            return {
                AccountName: entity.getName,
                Balance: self.dependency.ObtainLastMovements(entity)
            };
        }
    };

}

function Dependency1() {
    this.CalculateBalance = function (entity) {
        return 0;
    };
}

function Dependency2() {
    this.ObtainLastMovements = function (entity) {
        return 0;
    };
}

function Company() {
}

var company = new Company();
var idd = new IDD();
idd.dependency = new Dependency1();

var account = idd.getTheAccountForEntity(company);

El ejemplo anterior intenta replicar el comportamiento del código en C#, por lo que, posiblemente, no esté tan orientado a la manera de JavaScript. Así y todo es posible ver que no existe una innecesaria declaración de firmas, o que la dependencia inyectada no requiere crear nuevos elementos solo para cumplir con la firma, haciendo, al mismo tiempo, que la función que retorna la información, haga eso sin importar las entradas.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.