[c#] Event met eigen signature aan button.click toewijzen

[4of9]

Hallo,

Ik zit met een simpel probleempje waar ik niet uitkom.

Ik wil een eventhandler met een eigen signature aan een button.Click event hangen.

Ik heb een delegate gemaakt

C#:

public delegate void HandleButtonClick(string name);

en aan mijn button:

C#:

button.Click += new HandleButtonClick( ButtonClick);
...

private void ButtonClick(string name)
{
 ....
}

Hoe kan ik nu echter mijn name param mee geven aan mijn ButtonClick?

[Crazy D]

In de standaard buttonclick handler krijg je de sender (object) en eventargs als parameters mee, sender kun je dus gebruiken om te bekijken welke button er is geklikt. Je hoeft daar zelf geen delegate voor te maken.

C#:

this.cmdClose.Click += new System.EventHandler(this.cmdClose_Click);

private void cmdClose_Click(object sender, System.EventArgs e)
{
    // do something
}

[ Voor 30% gewijzigd door Crazy D op 31-10-2006 11:53 ]

[PhysicsRules]

Wat je wil kan zo niet. de Click event van Button is van het signature EventHandler. Als je een eigen versie wilt toevoegen zul je de button moeten overerven en een eigen implementatie maken met daarin het event. Dat event kun je dan vuren vanuit de standaard Click Handler:

C#:

button.Click += New EventHandler(button1_Click)
...

private void button1_Click(object sender, System.EventArgs e)
{
     MySpecialButton myButton = (MySpecialButton) sender;
     if (myButton.MyEvent != null) myButton.MyEvent(myButton.EventComando);
}

Dat EventComando is dan natuurlijk een property van je eigen Buttonclass definiëren

[4of9]

Het probleem is dat ik mijn event moet toevoegen in een methode die een locale member heeft die ik als parameter mee wil geven aan mijn Click event.

Is er geen ander manier om mijn event custom parameters mee te geven? via de EventArgs ofzo?

[whoami]

Bij het 'toevoegen' van je event, zal je die locale variable niet kunnen doorgeven. Daar 'hang' je enkel je event-handler aan je event vast.

Die dingen worden enkel doorgegeven als je event geraised wordt.

Ik denk dat je hier idd zult moeten subclassen van de Button class.
Maak dus je eigen Button class, die je overerft van de System.Windows.Forms.Button, en maak een property in uw eigen class, waarin je die variable set.
Bv, bij het creeëren van je button:

code:

MyButtonClass btn = new MyButtonClass();
btn.MyProperty = "bliep";

Maak ook je eigen eventhandler:

code:

public delegate void MyButtonClickEventHandler( object sender, MyButtonClickEventArgs e);

public class MyButtonClickEventArgs : EventArgs
{
    private string _name;

   public string Name { get { return _name; } }
}

In je overge-erfde Button class raise je dan jouw event:

code:

public class MyButtonClass : Button
{
    ...
    private string _myProp;

    public string MyProperty
    {
        get
        {
             return _myProp;
        }
        set
        { 
             _myProp = value;
        }
    }

    public event MyButtonClickEventHandler Click;

    protected void OnMyButtonClickEventHandler()
    {
          if( Click != null )
             Click (this, new MyButtonClickEventArgs (_myProp));
    }

   ....
}
}

Je moet er dan wel nog voor zorgen dat je eigen Click event geraised wordt ipv dat je het 'gewone' click event raised van de System.Windows.Forms.Button class.

Misschien is het daarom gemakkelijker om een UserControl te maken ipv een 'Component'. Bij het maken van een UserControl maak je nl. gebruik van 'composition' ipv inheritance, en op die manier kan je gewoon in het click event van de button die op je user-control staat, je eigen click event raisen, en enkel uw eigen click event beschikbaar stellen aan de buitenwereld.

code:

public class MyButtonUserControl : UserControl
{
    private Button button1;

    private string _name;    
    ...

   public event MyButtonClickEventHandler Click;

   private void button1_Click( object sender, EventArgs e )
   {
       OnMyButtonClick (new MyButtonClickEventArgs (_name));
   }

   ...
}

[ Voor 23% gewijzigd door whoami op 31-10-2006 12:20 ]

[4of9]

Ik moet er wel bij zeggen dat het ASP.NET is.

Ik weet niet of dit heel veel verschil maakt?

Ik heb de button gemaakt dmv Inheritance.Ik heb de originele Click event gehide dmv het new keyword.

Alleen als ik nu op de button klik gaat mijn toegewezen methode niet af.

C#:

public class MyButtonClickEventArgs : EventArgs
{ 
    private string _name;

    public MyButtonClickEventArgs(string name)
      {
          this._name = name;
      }

    public string Name
    {
        get { return _name; }
    }
}

public delegate void HandleButtonClick(object o, MyButtonClickEventArgs e);

public class MyButton : System.Web.UI.WebControls.Button
{
    private string _imgName;

    public string ImgName
    {
        get
        {
             return _imgName;
        }
        set
        { 
             _imgName = value;
        }
    }

    public new event HandleButtonClick Click;

    protected void OnMyButtonClickEventHandler()
    {
          if( Click != null )
             Click (this, new MyButtonClickEventArgs (_imgName));
    }
}

public class MyClass
{
  private void MyMethod()
  {
        MyButton newButton = new MyButton();
        newButton.ImgName = file.Name;
        newButton.Text = "Selecteer";
       
        newButton.Click += new HandleButtonClick(ButtonClick); 
  }

   private void ButtonClick(object sender, MyButtonClickEventArgs e)
    {
        Response.Write(e.ToString());
    }
}

ik doe nog iets verkeerd blijkbaar.

[PhysicsRules]

Ik vermoed dat het clicken op de knop gelinkt is aan de oorspronkelijke click-event. Deze raak je dus kwijt. Daarom kun je beter de events doorlinken, zoals whoami en ik al eerder schreven.

[4of9]

Ik krijg het niet voor elkaar om een custom button te maken en het event door te geven.

[4of9]

Ik heb nu het volgende:

C#:

public class MyButtonClickEventArgs : EventArgs
{ 
    private string _name;

    public MyButtonClickEventArgs(string name)
      {
          this._name = name;
      }

    public string Name
    {
        get { return _name; }
    }
}



public class MyButton : System.Web.UI.WebControls.Button
{

    public delegate void MyButtonClickEventHandler(object o, MyButtonClickEventArgs e);
    public event MyButtonClickEventHandler MyClick;

   // private Button button1;

    private string _imgName;

    public string ImgName
    {
        get
        {
             return _imgName;
        }
        set
        { 
             _imgName = value;
        }
    }


    protected virtual void OnClick(object o, MyButtonClickEventArgs e)
    {
        if (MyClick != null)
        {
            MyClick(this,e);  // Notify Subscribers
        }
    }

    private void MyButton_Click(object sender, System.EventArgs e)
    {
         OnClick(this,new MyButtonClickEventArgs (_imgName));
    }
   
}

en in mijn aanroepende class

C#:

private void MyMethod()
{
       MyButton newButton = new MyButton();
        newButton.UseSubmitBehavior = true;
        
        newButton.ImgName = file.Name;
        newButton.ID = "btn_" + file.Name;
        newButton.Text = "Selecteer";

        newButton.MyClick += this.ButtonClicked; 
}

private void ButtonClicked(object sender, MyButtonClickEventArgs e)
{
   Response.Write(e.ToString());
}

Op het moment dat ik de button klik wordt er geen enkel event getriggerd.
Ik krijg ook geen compile error ofzo. Doe ik nog iets fout?

ps: ik heb o.a naar deze link nog gekeken, samen met jullie tips:
http://www.akadia.com/services/dotnet_user_controls.html

[PhysicsRules]

kijk eens op een tutorial via google gevonden.

Edit:
Je gaat er in je code vanuit dat het Click event altijd de OnClick method aanroept. Dit is juist andersom. OnClick veroorzaakt over het algemeen een Click-event.

Je linkt precies verkeerd om. Wat je wilt (alsik het goed begrijp wat je vraag is:)

• User klikt op knop
• Click event van knop vuurt
• Je eigen button class vangt dit af
• Je eigen button class vuurt zijn eigen event
• Je applicatie vangt dit op

Om dit te laten gebeuren zul je dus in je eigen buttonclass het event moeten afvangen:

C#:

in contstructor:
base.click += new EventHandler(Button_Clicked);

...
private void Button_Clicked(sender,e)
{
    this.OnMyClick(sometext);
}

private void OnMyClick(string sometext)
{
    eigen event aanroepen.
}

Edit:
Dubbel whoami was me voor

[ Voor 77% gewijzigd door PhysicsRules op 31-10-2006 13:53 ]

[whoami]

Je event wordt niet geraised omdat je het afaik nergens raised.
In de code die je nu hebt, zal je ergens dit moeten doen:

code:

base.Click += new EventHandler(ButtonClick);

private void ButtonClick( object sender, EventArgs e )
{
   OnClick();
}

Maar ik zou eens kijken naar WebUserControls oid.

[Woy]

als je gewoon een subclass maakt dan kun je een anonymous delegate aan je Click event hangen en die je eigen event laten aanroepen bijvoorbeeld.

C#:

public delegate void MyDelegate( string param );

public class MyButton : Button
{
    public event MyDelegate MyOwnClick;

    public MyButton()
    {
        Click += delegate{ OnMyOwnClick(); };
    }

    public void OnMyOwnClick()
    {
        if( MyOwnClick != null ) MyOwnClick( Text );
    }
}

[edit]
Ow kan voortaan beter even refreshen. Is een beetje hetzelfde als wat de 2 boven me zeggen alleen dan met anonymous delegate

[ Voor 12% gewijzigd door Woy op 31-10-2006 14:03 ]

[4of9]

Het is nu idd gelukt.

Ik moet hem idd nog aan de click event van mijn base classe toevoegen.

Ik ga me nog wat meer verdiepen in events en delegates want ik blijf dat toch moeilijke materie vinden.

hier even de code voor de zoekers:

De classes voor de EventArgs en Button

C#:

public class MyButtonClickEventArgs : EventArgs
{ 
    private string _var;

    public MyButtonClickEventArgs(string var)
      {
          this._var = var;
      }

    public string Var
    {
        get { return _var; }
    }
}

public class MyButton : System.Web.UI.WebControls.Button
{

    public delegate void MyButtonClickEventHandler(object o, MyButtonClickEventArgs e);
    public event MyButtonClickEventHandler MyClick;


    public MyButton() : base()
    {

        base.Click += new EventHandler(this_MyClick);

    }
   
    private string _var;

    public string Var
    {
        get
        {
             return _var;
        }
        set
        { 
             _var= value;
        }
    }


    protected virtual void OnClick(object o, MyButtonClickEventArgs e)
    {
        if (MyClick != null)
        {
            MyClick(this,e);  // Notify Subscribers
        }
    }

    private void this_MyClick(object sender, System.EventArgs e)
    {
         OnClick(this,new MyButtonClickEventArgs (_var));
    }
}

en de aanroepende classe

C#:

private void SomeMethod()
{
        MyButton newButton = new MyButton();
        newButton.UseSubmitBehavior = true;
        
        newButton.Var= "myString"
        newButton.Text = "Klik mij";

        newButton.MyClick += new MyButton.MyButtonClickEventHandler(this.ButtonClicked); 
}

private void ButtonClicked(object sender, MyButtonClickEventArgs e)
{
        Response.Write(e.Var);
}

dank je wel!

Wat ik me alleen af vraag is of er geen makkelijkere manier is, en of er nog meer mensen zijn die custom arguments mee willen geven aan een event. Ik zal toch niet de enige zijn dit dit wil? Of is mijn ontwerp gewoon broken?

[PhysicsRules]

ASP.Net Buttons hebben de CommandName en CommandArgument properties waaraan je eigen strings kan toevoegen. Maar ik weet te weinig van je prog om te zien waarom dat niet zou werken voor je.

[Woy]

Aan een click event wordt gewoon de data meegegeven die je wilt weten ( En dat is eigenlijk alleen de button die geclicked wordt ). Als je dan meer over de button wilt weten kan je dat gewoon aan de button vragen door middel van de sender.

Overigens heb je in .net 2.0 een handige generic eventhandler waardoor je niet zelf je delegate hoeft te definieren.

C#:

public class MyButton : Button
{
    public event EventHandler<MyButtonEventArgs> MyCustomEvent;

    protected void OnMyCustomEvent()
    {
        if( MyCustomEvent != null )
            MyCustomEvent( this, new MyButtonEventArgs() );
    }

    public class MyButtonEventArgs : EventArgs
    {
    }
}

Maar je zult altijd een extra event moeten maken als je wat aan de parameters wilt veranderen.