E 'possibile aggiungere un riferimento a qualche codice sorgente da includere in un file sorgente in vb.net, WinForms?

Question

Non so che cosa questo si chiama così ho faticato a trovare una risposta da parte di Google, ma ho un vago ricordo di esso da giorni t'old.

Ho sub-classificati (* vedi sotto) circa 8 controlli quadro, sovrascritto alcune proprietà e ha aggiunto alcune funzionalità in ciascuno di essi. I cambiamenti che ho fatto sono identici in ogni caso. Se faccio un cambiamento, devo passare attraverso ogni classe e applicare la stessa modifica lì. Speravo ci può essere una parola chiave come che posso mettere in ogni classe.

C'è qualche possibilità?

(* nota) Uso il termine sub-classificati, ma non so se questo è la terminologia corretta. Ho visto anche in passato per i call-back. È sub-classificato il termine corretto da usare?

Answer 1

Ho seri dubbi sul fatto che sta andando a lavorare per voi. Non è possibile utilizzare un file di inclusione di marmellata cambiamenti nei controlli derivati. Normalmente ci si apportano le modifiche in una classe base comune, uno derivato da Control per esempio, allora derivano i singoli controlli da quella classe di base. Ma che non sta andando a lavorare se hai personalizzato 8 classi di controllo separati. Copia e incolla è il tuo sacco.

Answer 2

Questa potrebbe essere una pazza idea, ma ...

1. Creare un file common.vb con il codice necessario.
2. Crea file parziali classi per ognuno dei vostri comandi in cui si aggiungerà il codice di esempio.
3. Creare un file batch che copia i dati dal vostro common.vb nelle vostre classi parziali
4. Crea una fase di pre-costruzione che esegue il file batch.

Se è necessario il codice copiato le classi parziali prima della compilazione, si può sempre eseguire il file batch.

E che è naturalmente assumendo che VB.NET ha il concetto di classi parziali. E no, non ho provato a casa ... ;-D

Answer 3

Mi piacerebbe sostengo la risposta di nobugz. Anche se c'è è stato una dichiarazione #Include, non credo che sarebbe una buona idea. Qualsiasi cambiamento nel file di inclusione potrebbe facilmente rompere le tue 8 controlli utente sottoclasse.

MA : Che solo potrebbe di lavoro, se tutte le modifiche più comuni possono essere integrati nei controlli utente sottoclassi tramite i gestori di eventi, < em> o se le modifiche sono del tipo in cui si impostano le proprietà comuni dei vostri controlli utente a valori particolari, è una classe che si applica il codice cambia ad alcun controllo utente passato ad esso:

Class CommonChanges

    Private Readonly WithEvents DerivedUserControl As Windows.Forms.Control

    Public Sub New(ByVal derivedUserControl As Windows.Forms.Control)
        Me.DerivedUserControl = derivedUserControl
    End Sub

    Private Sub DerivedUserControl_OnClick(sender As Object, e As EventArgs) _
                Handles DerivedUserControl.Click
        ' ... '
    End Sub

    ...  ' (more event handlers with common code go here) '

End Class

Quindi, è definire le 8 controlli utente personalizzati come:

Class MyDerivedUserControl
    Extends Button  ' (or whatever control it extends) '

    Private ReadOnly Changes As CommonChanges

    Public Sub New
        Changes = New CommonChanges(Me)
        ' ^ 'CommonChanges' will subscribe to this class's events and possibly
        '   apply other changes to the control object 'Me'.
        ...
    End Sub
End Class

Questo oggetto Changes di tipo CommonChanges sottoscriverà eventi della vostra classe MyDerivedUserControl e agganciare i gestori definiti CommonChanges a loro.

Inoltre, è possibile applicare direttamente le modifiche all'oggetto Control passato al costruttore di CommonChanges questo modo.

Answer 4

Ricordo di aver letto da qualche parte che Microsoft ha preso una decisione di progettazione specifica (almeno in C #) non consentire compreso il codice sorgente esterna in questo modo.

Si è ritenuto che, mentre tra i file di origine potrebbero essere utili in C ++, potrebbe anche introdurre complessità e ridurre la leggibilità.

In un linguaggio OO di solito ci sono buone alternative, la più ovvia composizione dell'essere oggetto e la delega.

Ecco come ho gestito questa situazione in passato:

class CommonCode
{
    public void HandlePaint(Control c, PaintEventArgs a)
    {
        // Do shared code
    }
    public void HandleResize(Control c)
    {
        // Do shared code
    }

}

class MyButton : Button
{
    private CommonCode m_common=null;

    public MyButton()
    {
        m_common=new CommnCode();        
    }
    protected override OnPaint(PaintEventArgs a)
    {
        m_common.HandlePaint(this,a);
    }

    protected override void OnResize(EventArgs e)
    {
        m_common.HandleResize(this);
    }

}

class MyTextbox :Textbox
{

    private CommonCode m_common=null;

    public MyTextbox()
    {
        m_common=new CommnCode();        
    }
    protected override OnPaint(PaintEventArgs a)
    {
        m_common.HandlePaint(this,a);
    }

    protected override void OnResize(EventArgs e)
    {
        m_common.HandleResize(this);
    }

}

Answer 5

compilare il classi comuni nella propria DLL.

Quindi impostare il riferimento per la DLL in Visual Studio facendo clic destro sulla cartella Riferimenti in Esplora soluzioni.

Infine, aggiungere Utilizzo di istruzioni alle classi del vostro progetto per lo spazio dei nomi (s) nella tua nuova DLL.

Answer 6

È possibile creare un progetto di libreria di classi (che l'uscita sarà una dll) da Visual Studio:

Nuovo progetto -> Libreria di classi

È possibile inserire tutto il codice lì allora si può semplicemente aggiungere un riferimento alla libreria di classi per il progetto che si desidera utilizzare da (tasto destro del mouse su riferimenti Esplora soluzioni):

Riferimenti -> Aggiungi riferimento -> Progetti -> MyClassLibrary

Per essere in grado di trovare MyClassLibrary nella scheda progetti di entrambi i progetti devono essere nella stessa soluzione -. Altrimenti ou può semplicemente andare 'browse' e puntare al dll sé

Poi nel file VB è necessario utilizzare le classi che si può fare un MyClassLibrary di importazione:

// assuming the namespace is MyClassLibrary
imports MyClassLibrary

A questo punto si può semplicemente utilizzare le sottoclassi e controlli. Se si va MyClassLibrary. IntelliSense vi mostrerà tutte le classi.