Posso utilizzare gli strumenti di costruzione di oggetti Ninject con un nome forte?

Question

Beh, non so se "denominazione forte" è il termine giusto, ma quello che voglio fare è come segue.

Attualmente utilizzo ConstructorArgument come ad es. questo:

public class Ninja 
{ 
    private readonly IWeapon _weapon; 
    private readonly string _name; 

    public Ninja(string name, IWeapon weapon) 
    { 
     _weapon = weapon; 
     _name = name; 
    } 
    // ..more code.. 
} 

public void SomeFunction() 
{ 
    var kernel = new StandardKernel(); 
    kernel.Bind<IWeapon>().To<Sword>(); 
    var ninja = kernel.Get<Ninja>(new ConstructorArgument("name", "Lee")); 
} 

Ora, se io rinominare il parametro "nome" (per esempio usando ReSharper) il ConstructorArgument non aggiornerà, e mi metterò un errore di runtime durante la creazione della Ninja. Per risolvere questo problema ho bisogno di trovare manualmente tutti i posti che specificano questo parametro attraverso un oggetto Constructor e aggiornarlo. Non va bene, e sono destinato a fallire a un certo punto anche se ho una buona copertura di test. Rinominare dovrebbe essere un'operazione a basso costo.

Esiste un modo per specificare un riferimento al parametro, in modo che venga aggiornato quando rinominare il parametro?

Answer 1

Se è possibile condividere più di ciò che si sta veramente cercando di ottenere, si otterrà una risposta migliore. In generale, non si vuole fare affidamento sul passaggio di un ConstructorArgument se ciò può essere aiutato - dovrebbe essere un modo estremo per archiviare un valore di parametro nella creazione di un componente che non si possiede e quindi poter contare su non essere ribattezzato [come] volente o nolente durante le attività di refactoring. Quindi per il codice normale, se si può provare a tenerlo alle interfacce per rendere le cose univoche e non fare affidamento sui nomi, è meglio.

Non riesco a trovare un esempio in questo momento, ma c'è un idioma piuttosto comune chiamato static reflection. Un ConstructorArgument fornito può corrispondere a qualsiasi parametro di quel nome attraverso uno qualsiasi dei costruttori, quindi la riflessione statica non è la cosa più appropriata in questa istanza.

qui la migliore che ti riflessione statica probabilmente permetterà di raggiungere è qualcosa di simile:

var ninja = ninject.Get<Ninja>(ParamNamesOf(()=>new Ninja("dummy", "dummy")).First()); 

Il tipico esempio vedrete è dove si vuole estrarre il nome di una proprietà a cui si accede su un caso. Questo è un po 'diverso in quanto ha bisogno di lavorare su un'espressione di richiamo del costruttore.

Come per trovare una lib appropriata che già ha questo, esercitare per il ricercatore: D (Ma io suggerirei di trovare un modo migliore per esprimere ciò che si vuole fare che non usa mai lo ConstructorArgument con questo approccio.)

Answer 2

Come già notato, questo approccio è molto fragile e dovrebbe essere evitato. Prova un design nel caso non fosse necessario aggiungere il nome come argomento costruttore. Si potrebbe fare questo ad esempio:

public class Ninja 
{ 
    private readonly IWeapon _weapon; 

    public Ninja(IWeapon weapon) 
    { 
     _weapon = weapon; 
    } 

    public string Name { get; set; } 

    // ..more code.. 
} 

public void SomeFunction() 
{ 
    var kernel = new StandardKernel(); 
    kernel.Bind<IWeapon>().To<Sword>(); 
    var ninja = ninject.Get<Ninja>(); 
    ninja.Name = "Lee"; 
} 

Spero che questo aiuti.

Answer 3

Sì, è possibile.

ho imlemented questo:

public string GiveConstuctorArgumentName(Type class, Type constructorArgument) 
    { 
     var cons = class.GetConstructors(); 

     foreach (var constructorInfo in cons) 
     { 
      foreach (var consParameter in constructorInfo.GetParameters()) 
      { 
      if (consParameter.ParameterType == constructorArgument) 
      { 
       return consParameter.Name; 
      } 
      } 
     } 

     throw new InstanceNotFoundException(); 
    } 

sua senza LINQ, ma è un buon punto di partenza per capire come il suo lavoro.