Deserializzazione di un oggetto all'inizio del programma che viene utilizzato (molto) in seguito

Dipende da come vuoi accedere ai tuoi oggetti ( Usa come meno astrazione se necessario ):

1) usa un Container come una Collezione o una Mappa per mettere semplicemente gli oggetti dentro. Le raccolte sono fatte solo per "contenere" le cose.

2) Se hai bisogno di più accesso a grana fine : crea un altro oggetto contenente il Container .

I later use those classifiers in multiple objects.

Che cosa significa più tardi in questo contesto? Ottieni gli oggetti quando hai effettivamente bisogno di loro: al ultimo tempo possibile.

they are "far away" from the initialization class, so even if they existed, passing the classifiers through multiple classes is a code smell.

Perché lo pensi? Da quello che stai scrivendo, che è molto astratto, non c'è modo di decidere, se sia o non sia un odore di codice.

Se sono necessari gli oggetti necessari per tempo di vita dell'oggetto, il ultimo tempo possibile sarebbe il punto più iniziale nel durata dell'oggetto che ha bisogno dell'altro oggetto. Iniezione del costruttore sarebbe un modo per affrontarlo.

Crea un oggetto "titolare del classificatore", consegnalo ai classificatori quando vengono creati e quando gli oggetti che usano il classificatore ne hanno bisogno, chiedi al titolare di dargliene uno.

Immagino tu abbia qualcosa di simile?

public class Main(string[] args)
{
    string param = args[0]; //load parameter from config
    Classifier c = new Classifier(param)

    SomeClass x = new SomeClass(c);
    var o = x.DoSomething();
}

public class SomeClass
{
    OtherClass o;

    //doesnt use the classifier but needs it for OtherClass, 
    //hence required for passing down the chain
    public SomeClass(Classifier c) 
    {
        o = new OtherClass(c);
    }

    public object DoSomething() 
    {
        return o.DoSomthing();
    }
}

public class OtherClass
{
    public OtherClass(Classifier c) {} //uses classifier object 'far away'

    public object DoSomething() {}
}

E vuoi evitare di far passare l'oggetto Classifier attraverso il costruttore della catena, o di avere oggetti che non sono la lettura vera e propria dell'applicazione direttamente dalla configurazione?

Il mio suggerimento in questi casi è che puoi fare una delle due cose

A: Controlla che il tuo "superiore nelle classi di catena" stia rispettando il principio della responsabilità unica. Sarebbe meglio chiamare semplicemente OtherObject?

B: puoi spostare il parametro iniettato come parametro della chiamata di funzione? in questo caso x.DoSomething (c);

Nella maggior parte dei casi penso che sia un odore di codice. Se il codice è troppo "profondo" in questo modo, è probabile che i tuoi oggetti non facciano più una sola cosa, ma orchestrino varie altre classi per fare più cose. Anche se uno strato di questo è buono, supponiamo tu abbia un servizio () che avvolge tutta la logica e viene quindi implementato in un'app, un sito Web, un servizio Windows, ecc. Quando inizi a suddividere quel servizio in un altro servizio, in un altro servizio Penso che sia il momento di fare un passo indietro e vedere se non puoi semplicemente istanziare i servizi di livello inferiore di cui hai bisogno direttamente e chiamarli in un livello