uIoC - A WINCE IOC library for compact framework 2.0

In these days at workplace i'm working on a WINCE project,
I had to do some optimization to my old code and I wish to make it more readable,
so bearing in mind this I start to Google around
searching for an IoC container/framework that works on Compact framework 2.0 but
I was embittered since i cannot find any IoC implementation for Compact Framework.
Since i haven't special needs instead of using frameworks like spring.net or Windsor
i would use something simple but straightforward, like picocontainer
or this one ;D :
kentaIOC
I start to thought how complex could be to write my own IoC implementation for Compact Framework, I was dazzled when I see that what i needed was so simple to achieve!

So i write my own implementation that let register object and initialize that by constructor.

For now is very basic, need some extra works but since, at least for me,
it do its dirty work i thought to share my efford.

I think somebody can find it useful, so
i opened a project on codeplex, you can find the project page at this address:
uIoc and you can download the source
on the Release page

[jsn]Configuring JSUnit for Visual Studio 200X

I want to share this things, because today it take me a while to get the hang of it.
I now going to explain how to integrate JSUnit into your visual studio 2005/2008 Express/Standard/* version.
the procedure is the same, so now I show you what you need:

• 
  JSUnit, get the latest version here


• A copy of Visual Studio (I tried on Express, Standard and Professional) 200X,
  i not tried with 2003, but for what I remember the procedure is the same


• Mozilla firefox

I only get this method work on firefox, probably because an IE restriction on file: protocol,
is not mandatory but i reccomend to install this both plugin for Firefox:
Firebug and web developer toolbar

Ok,

1. open up Visual Studio


2. On the menu go under Tools (Alt+T)- External Tools (E)


3. Click on the Add button


4. in the title box write "JSUnit"


5. click on the "..." button to search your firefox executable (probably under "C:\Program Files\Mozilla Firefox\firefox.exe") and fill the Command Box


6. on the Arguments box write "file://path/to/jsUnit/testRunner.html?testPage=$(ItemPath)&autoRun=true"


7. Click on the OK button

where path/to/jsUnit is the path where you install your jsunit copy.


to test it open the file
path/to/jsUnit/tests/jsUnitAssertionTests and from Tools select JSUnit.

ps.following the instruction on this page
you can also install javascript lint :D

KentaIoC - A js IOC library - english version

Thanks to Rey9999 for this marvelous translation.
original document here: Italian version

I've been lately using an IOC framework at my workplace and I grasp the potential of such an approach right from the start, since it lets you keep your classes conceptually separated. 

To achieve this, we follow a single concept: keep the logic that binds the classes together outside of those classes.

Often, in traditional programming, an object "A" inside a method configures another object "B", before calling some other method of the latter.

With Inversion of Control instead, object "A" will never need to configure object "B", instead it will just call it directly.

Probably I was not clear enough, so I invite whoever wishes to understand better this topic to study it deeply elsewhere - I will now pragmatically focus on writing some code which will let us use IOC in JavaScript.


How do we set up IOC?

Usually we have a class "A", keeping inside a member "B" extending a known interface: this way, even if "A" does not know the actual implementation of "B", it can communicate with it, as between "A" and "B" there's a kind of "contract" defined by the interface.

Sure, but in Javascript there are no interfaces, so programming through interfaces is impossible!

Of course, this is the first problem that I will write about.
Let me first point out that JS is a dynamic language and it has no Strict Typing (even if Andr3a will surely argue).

Technically, it could be possible to simulate interfaces using JS - but this would violate the KISS principle, so I will use an alternative approach, that whilst being completely unrelated to interfaces, will let us work around this limitation.

This approach is called Duck typing, that can be summarized as:
<< If our class moves like a duck and has wings like a duck, then for us it's a duck (even if it is actually a pheasant) >>.

Another concept must be explained along with IOC: Dependency Injection,
which roughly says that an object "C" which knows neither objects "A" or "B" will be in charge of putting "the right B" inside "A".

"C" is also our container.


What exactly does a container do?
A container wraps a table uniquely identifying an object instance (usually components: tiny objects which do a single thing - but do it RIGHT), associating an unique identifier to it.

Yeah, right, cool stuff, but isn't it right about time to show some code?

Here's how we can easily manage a container:

var c={};
    //configuration of c
    c.B = { getMessage: function(){ return "test Container" } }
    
    //A doesn't know exactly B it only know that B have getMessage(duck typing approach)
    var A = {
        B: c.B, //A doesn't have the implementation of B,it rely on C to pass the correct one.
        test: function(){ alert(this.B.getMessage()) }
    }
    
    A.test();

Excuse me, but from what I understood so far, isn't "C" just a hashtable?

Well, no. Actually I'm introducing a concept at a time - in our implementation "C" is an hashtable, but to get a correct management of the IOC, this is not enough, a container must do more than that.

Depending on the configuration, a container must be able to instance the correct object (Factory). Here's where injection comes in: our container must be able to inject the object inside another object.

Each framework use different methodologies to inject dependencies. 

The two most common ways, which you will probably find in every framework, are injection by constructor and injection by setter. To keep things simple, my script depends from the extend script by Andrea Giammarchi, so make sure to include before your script.

var A ={
    test: function(){ alert(this.B.getMessage()) } //duck typing 
};

var container = {
    C : {},
     register:function (id,component){
       this.C[id]=component;
     },
     find: function (id){
       return this.C[id];
     },
     bySetter: function(){
       var id=arguments[0];
     
       var Obj = this.find(id);
       
       for(var i=1,max=arguments.length;i<max;i++  ){
         Obj = Obj.extend(arguments[i]);
     
       }

       return Obj;
     
    },
    byConstructor : function(){
  
      var id = arguments[0];
      var pars = new Array();
      for(var i=1,max=arguments.length;i<max;i++  )
       pars.push(arguments[i]);
  

      var Obj=this.find(id);
      return Obj.apply(Obj,pars);
 

   }

}

/*Start setter configuration*/
container.register('AS', A);

container.register('BS', {getMessage: function(){return 'Hello setter injection!'}});
container.register('BS2', {getMessage: function(){return 'Hello setter injection #2!'}});



container.bySetter('AS', {'B': container.find('BS')} ).test();
container.bySetter('AS', {'B': container.find('BS2')} ).test();


/*Constructor injection example*/
function AC(B){

  return {
    test:function(){alert(B.getMessage())}
  }
}

container.register('BC', { getMessage: function(){return 'Hello constructor injection '} });
container.register('AC', AC);


container.byConstructor('AC', container.find('BC')).test();

The reusable part of the script above is the container I wrote. It lets us register the components using register(id, component), as well as searching already registered components with find(id).
Last but not least, it lets you injecting by constructor with byConstructor(id, parameters) and injecting dependencies through a setter with bySetter(id, setterObject)


Finally, thanks to Andrea Giammarchi, you can find the code here: http://www.devpro.it/code/164.html

KentaIoC - A js IOC library

English version)

Ultimamente a lavoro sto usando un framework IOC

e fin da subito ho capito le potenzialità di un simile approccio, il quale permette
di separare concettualmente le proprie classi.
Per fare ciò ci si basa su un unico concetto, separare la logica che lega le classi esternamente.

Mentre nella programmazione tradizionale spesso accade che un oggetto A all' interno di un metodo configuri un oggetto B prima di invocare qualche metodo di ques'ultimo,
con l' Inversion of Control A non dovrà mai configurare B ma invocarlo direttamente.

probabilmente mi sono spiegato male e invito chi desiderasse capire meglio il concetto ad approfondire in maniera teorica l' argomento altrove in quanto ora mi concentrerò in maniera pragmatica nella scrittura di un codice che permetta l'utilizzo della IOC in javascript.

In che modo si mette in piedi l'IOC?
normalmente avremo una classe A che contiene al suo interno un membro B
che estende un interfaccia nota, in questo modo anche se A non conosce l'effettiva implementazione di B può dialogare con B poichè tra A e B c'è in piedi un contratto definito dall' interfaccia.
Si, ma in javascript non esiste il concetto di interfaccie, quindi la programmazione attraverso interfaccie non si può usare!
Ovviamente questo è il primo problema da affrontare, e a questo aggiungo che JS è un linguaggio dinamico e non ha lo Strict Type (non è un linguaggio fortemente tipizzato), anche se Andr3a sicuramente mi smentirà. volendo sarebbe possibile simulare le interfaccie in JS ma questo andrebbe contro il concetto KISS, quindi cercando un alternativa userò un concetto che nonostante non c'entri nulla con le interfaccie permette di lavorare lo stesso con questa metodologia.
Questo concetto che andrò a introdurre è il Duck typing,
ovvero se la nostra classe si muove come un fagiano e ha le ali di un fagiano allora per noi è un fagiano, anche se in realtà è un aquila.

Al pari con la IOC c'è un altro concetto, quello della Dependency Injection
che in pratica dice che un oggetto C che non conosce ne A ne B si occuperà di mettere "il giusto B" all' interno di A
C è inoltre il nostro Container.
Cosa fà esattamente un container?
Un container mantiene al suo interno una tabella che indica in maniera univoca un istanza di un oggetto(normalmente sono dei componenti, ovvero dei mini oggetti che fanno solo una cosa, ma la fanno bene) associandogli un identificativo.
Si, vabbè, ma non è ora di far vedere un po di codice?
Ecco come si può gestire facilmente un container.

var c={};
//configuration of c
    c.B={getMessage:function(){return "test Container"}}
    
    //A doesn't know exactly B it only know that B have getMessage(duck typing approach)
    var A = {
        B:c.B,//A doesn't have the implementation of B,it rely on C to have the correct one.
        test:function(){alert(this.B.getMessage())}
    }
    
    A.test();

Ma da quel che ho capito C è solo un hashtable?
No, in realtà sto introducendo un concetto alla volta, se è vero che C è un hashtable
a tutti gli effetti, per avere una corretta gestione della IoC il container deve fare altro.
In base alla configurazione, il container deve poter istanziare il corretto oggetto (Factory)
ed è qui che entra in azione l'injection, il nostro container deve poter iniettare l'oggetto all' interno di un altro oggetto.
I vari framework hanno varie metodologie per iniettare le dipendenze, sicuramente le 2 più usate e che troverete in qualsiasi framework sono l'iniezione per costruttore e per setter.
per semplificare le cose il mio script dipende dall' extend script di andrea giammarchi
, assicuratevi quindi di includerlo in testa al vostro script

var A ={
    test:function(){alert(this.B.getMessage())}//duck typing 
};

var container = {
    C : {},
 register:function (id,component){
  this.C[id]=component;
 },
 find: function (id){
  return this.C[id];
 },
 bySetter: function(){
     var id=arguments[0];
     
     var Obj = this.find(id);
     
     for(var i=1,max=arguments.length;i<max;i++  ){
     Obj = Obj.extend(arguments[i]);
     
     }

     return Obj;
     
    },
    byConstructor : function(){
  
 var id = arguments[0];
 var pars = new Array();
 for(var i=1,max=arguments.length;i<max;i++  )
  pars.push(arguments[i]);
  

 var Obj=this.find(id);
 return Obj.apply(Obj,pars);
 

    }

}

/*Start setter configuration*/
container.register('AS',A);

container.register('BS',{getMessage:function(){return 'Hello setter injection!'}});
container.register('BS2',{getMessage:function(){return 'Hello setter injection #2!'}});



container.bySetter('AS',{'B':container.find('BS')}).test();
container.bySetter('AS',{'B':container.find('BS2')}).test();


/*Constructor injection example*/
function AC(B){

return {
test:function(){alert(B.getMessage())}
}
}

container.register('BC',{getMessage:function(){return 'Hello constructor injection '}});
container.register('AC',AC);


container.byConstructor('AC',container.find('BC')).test();

La parte riutilizzabile dello script sopra è il container che ho scritto.
Il suddetto container permette di registrare i componenti usando register(id,component)
di cercare i componenti già registrati find(id)
permette infine di iniettare per costruttore byConstructor (id,parameters)
e di iniettare le dipendenze tramite setters bySetter(id,setterObject)

Grazie ad Andrea Giammarchi potete scaricare il codice da qui : http://www.devpro.it/code/164.html