Più sottoscrittori per un singolo evento UserControl ASP.NET?

Question

Sono confuso su un problema di impianto idraulico sulla mia pagina. Ho un singolo UserControl ASP.NET che monitora alcuni eventi lato browser e li eleva come Update-ascan-post-back-back al server. Chiamiamolo EventPump. Include alcuni controlli JavaScript e sul lato server per gestire gli eventi. Funziona alla grande.

Ho diversi altri controlli sulla stessa pagina che non si conoscono l'un l'altro ma vorrei iscrivermi ad alcuni degli eventi generati da EventPump. Normalmente un controllo si iscriveva agli eventi di un altro includendo quel controllo nel suo markup e collegando gli eventi. Ma in questo caso mi darebbe più istanze di EventPump, cosa che non voglio.

Come posso avere più UserControls per sottoscrivere eventi del controllo EventPump comune?

Answer 1

Poche opzioni aggiuntive che posso pensare:

1. codice per le interfacce, in modo che il controllo di EventPump implementa IEventPump che ha un vari eventi pubblici.La pagina contenente implementa IEventPumpContainer con una proprietà chiamata EventPump che permette a tutti gli altri controlli utente di registrare in questo modo:

   ((IEventPumpContainer)Page).EventPump.MyEvent += MyEventHandler; 
   

2. Se la pagina è consapevole dei controlli che devono iscriversi si potrebbe avere chiamare i metodi appropriati sui controlli quando gli eventi sparano. Per esempio:

   EventPump.MyEvent += (s, e) => SomeControl.SomeMethod(); 
   

3. alternativa e probabilmente migliore è quello di rendere gli eventi cittadini di prima classe e hanno un dispatcher evento che può essere utilizzato per sottoscrivere e generare eventi. Per esempio:

   Events.Register<MyEvent>(e => TextBox.Text = "MyEvent Happened"); 
   ... 
   Events.Raise(new MyEvent()); 
   

Answer 2

Creare gestori di eventi nei controlli utente e iscrivere tutti gli eventi allo stesso gestore nella pagina.

UserControl1:

public event EventHandler SomethingChanged; 

protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs e) 
{ 
    //do OnSelectedIndexChanged logic 

    if (this.SomethingChanged != null) 
     this.SomethingChanged(this, e); 
} 

protected void CheckBox1_CheckedChanged(object sender, EventArgs e) 
{ 
    //do OnCheckedChanged logic 

    if (this.SomethingChanged != null) 
     this.SomethingChanged(this, e); 
} 

UserControl2:

public event EventHandler SomethingElseChanged; 

protected void TextBox1_TextChanged(object sender, EventArgs e) 
{ 
    //do OnTextChanged logic 

    if (this.SomethingElseChanged != null) 
     this.SomethingElseChanged(this, e); 
} 

protected void Button1_Click(object sender, EventArgs e) 
{ 
    //do OnClick logic 

    if (this.SomethingElseChanged != null) 
     this.SomethingElseChanged(this, e); 
}  

Pagina:

<uc:UserControl1 ID="UserControl1" runat="server" SomethingChanged="UserControl_Changed" ... /> 
<uc:UserControl2 ID="UserControl2" runat="server" SomethingElseChanged="UserControl_Changed" ... /> 

Codice-behind:

protected void UserControl_Changed(object sender, EventArgs e) 
{ 
    Label1.Text = "Stuff has changed..."; 
} 

EDIT

consulta questo articolo per invocare gli eventi attraverso controlli utente:

http://www.codeproject.com/KB/aspnet/EventsAcrossUCs.aspx

Answer 3

un paio di opzioni:

1. Mettere l'EventPump su una pagina master e creare una proprietà che lo fa riferimento (rendendo la pagina master "fortemente digitata" tramite la direttiva @MasterType)

2. Aggiungere un metodo di supporto statico che accetta un'istanza di pagina come parametro e trova l'istanza di EventPump nella pagina. Invece di usare FindControl per questo, che sarà lento su pagine grandi, puoi semplicemente registrare il controllo in Page.Items. Questo approccio si combina al meglio con il codice nel controllo EventPump che garantisce l'esistenza di una sola istanza EventPump sulla pagina.

3. Creare un controllo EventPumpProxy nello stile di ScriptManagerProxy. Questo è piuttosto kludgy, ma carino se preferisci avere un markup dichiarativo localmente invece di un sacco di code-behind. Non conosco i dettagli esatti dell'implementazione, ma dovresti essere in grado di vederli smontando le fonti di framework AJAX.