I've seen many examples of how to add a click event to a dynamically created button, but none of the examples show how to pass arguments with the event.
I am new to C# and just looking for a simple solution. See the code below:
public partial class Main : Form {
public Main() {
InitializeComponent();
// Add a button dynamically
Button Test = new Button();
this.Controls.Add(Test);
Test.Left = 0;
Test.Top = 0;
Test.Width = 100;
Test.Height = 20;
Test.Text = "Hello";
int param1 = 1;
string param2 = "Test";
// Add click event handler with parameters ????
// I know this syntax is wrong, but how do I get param1 & 2
// into the Test_Click ????
Test.Click += Test_Click(param1,param2);
}
private void Test_Click(int param1, string param2) {
MessageBox.Show(param1.ToString() + ": " + param2);
}
You do not provide arguments when adding the event but you provide it in the event it self, in this case the click event arguments are:
private void Test_Click(object sender, EventArgs e)
{
}
the first argument is usually object sender while the second changes depending on the event type, in case of click event it's "EventArgs e"
and for the adding event :
Test.Click += Test_Click;
Hope i helped you.
Ok. I know this is a little ugly, but this is what I came up with from the comments above. If there is a better way to do this, please let me know:
public partial class Main : Form {
public Dictionary<object, Tuple<int, string>> Params = new Dictionary<object, Tuple<int,string>>();
public Main() {
InitializeComponent();
// Add a button dynamically
Button Test = new Button();
this.Controls.Add(Test);
Test.Left = 0;
Test.Top = 0;
Test.Width = 100;
Test.Height = 20;
Test.Text = "Hello";
Test.Name = "Test";
// Add click event handler with parameters
Params.Add(Test, new Tuple<int, string>(1, "Test"));
Test.Click += Test_Click;
}
private void Test_Click(object sender, EventArgs e) {
Tuple<int,string> value;
if (Params.TryGetValue(sender, out value)) {
MessageBox.Show(value.Item1.ToString() + ": " + value.Item2);
}
else {
MessageBox.Show(sender.ToString() + " not found.");
}
}
Here is another solution I came up with without using Dictionary or Tuple by adding the button and the parameters together into a class structure. I like this one better:
class MyButton {
private Button oButton;
private int iParam1;
private string sParam2;
public MyButton(Form Me, int Left, int Top, int Width, int Height, string Text, int Param1, string Param2) {
oButton = new Button();
Me.Controls.Add(oButton);
oButton.Left = Left;
oButton.Top = Top;
oButton.Width = Width;
oButton.Height = Height;
oButton.Text = Text;
iParam1 = Param1;
sParam2 = Param2;
oButton.Click += Click;
}
private void Click(object sender, EventArgs e) {
MessageBox.Show(iParam1.ToString() + ": " + sParam2);
}
}
public partial class Main : Form {
public Main() {
InitializeComponent();
MyButton Test = new MyButton(this, 0, 0, 100, 20, "Hello", 1, "Test");
}
}
Here's a bit cleaner version of what I was talking about (sorry, I wasn't near a computer earlier). The initial implementation of Tuple was truly clunky; it's since become part of the language.
I started with the auto-generated:
public partial class MyForm : Form
{
public MyForm()
{
InitializeComponent();
}
}
And then added this to the form class:
private Dictionary<string, (int param1, string param2)> _parametersMap = new Dictionary<string, (int param1, string param2)>();
If you are using the latest compiler, you can simplify this to:
private Dictionary<string, (int param1, string param2)> _parametersMap = new();
Then I added a method to the form class that the click handler will call:
public void ShowSomething (string buttonName, int i, string s)
{
MessageBox.Show(this, $"Button: {buttonName} cliked: i={i}, s = {s}");
}
All button click handlers have the same method signature. It's determined by the code that raises the click event. So...
public void OnDynamicButtonClick (object sender, EventArgs e)
{
if (sender is Button button)
{
var (param1, param2) = _parametersMap[button.Name];
ShowSomething(button.Name, param1, param2);
}
}
Notice that the if statement uses a pattern matching if mechanism. The code within the if sees button as the sender cast to a Button.
Then, to match your initial code, I put this in the form constructor (after InitializeComponent. It really doesn't belong there. It should be in some event handler, at the very least the Form Load handler, more likely wherever it is that you want to create the buttons (creating them in the constructor kind of defeats the idea of dynamically constructing them):
var firstButton = new Button
{
Name = "FirstButton",
Text = "First",
Location = new Point(100, 100),
Size = new Size(200, 50),
Parent = this,
};
firstButton.Click += OnDynamicButtonClick;
_parametersMap.Add(firstButton.Name, (42, "Test1"));
Controls.Add(firstButton);
var secondButton = new Button
{
Name = "SecondButton",
Text = "Second",
Location = new Point(100, 300),
Size = new Size(200, 50),
Parent = this,
};
secondButton.Click += OnDynamicButtonClick;
_parametersMap.Add(secondButton.Name, (111, "Test2"));
Controls.Add(firstButton);
Note that I created two buttons, both pointing to the same button click handler (that's the point of the sender argument.
If you are going to be doing this a lot, an alternative approach would be to sub-class the Button class, adding your Param1 and Param2 as properties:
public class MyButtonSubClass : Button
{
public int Param1 { get; set; }
public string Param2 { get; set; }
}
(hopefully giving them more meaningful names)
Instances of your subclass are Buttons, just with two extra properties, so you can do this:
var firstButton = new MyButtonSubclass
{
Name = "FirstButton",
Text = "First",
Location = new Point(100, 100),
Size = new Size(200, 50),
Parent = this,
Param1 = 42,
Param2 = "Some Test",
};
firstButton.Click += OnDynamicButtonClick;
Controls.Add(firstButton);
//same for the second button
And then change the click event handler to:
public void OnDynamicButtonClick (object sender, EventArgs e)
{
if (sender is MyButtonSubclass button)
{
ShowSomething(button.Name, button.Param1, button.Param2);
}
}
And the program will appear to work in the same way.
Or, at this point, you could change the event handler to look like:
public void OnDynamicButtonClick(object sender, EventArgs e)
{
if (sender is MyButtonSubclass button)
{
MessageBox.Show(this, $"Button: {button.Name} cliked: i={button.Param1}, s = {button.Param1}");
}
}
Related
I have a dynamical create button object where I want it to send an event to the mainform when I click on a button inside this object.
I have the code like this :
class Class1
{
internal class FObj_BtnRow
{
private Button[] _Btnmembers;
internal event EventHandler<SelValue_EArgs>[] e_BtnMember; //subscribe to a change
internal class SelValue_EArgs : EventArgs//events args (selected value)
{//return arguments in events
internal SelValue_EArgs(Boolean ivalue) { refreshed = ivalue; }//ctor
internal Boolean refreshed { get; set; }//accessors
}
private Boolean[] _ActONOFFValue; //Pump=0, valveInput = 1, Shower = 3, Washtool = 4 , WashWPcs = 5
private Boolean ActONOFFValue(int number)
{
_ActONOFFValue[number] = !_ActONOFFValue[number];
{
if (e_BtnMember[number] != null && number == 0) e_BtnMember[number](this, new SelValue_EArgs(_ActONOFFValue[number]));
}
return _ActONOFFValue[number];
}
public FObj_BtnRow(String[] TxtBtn, String UnitName)//ctor
{
_Btnmembers = new Button[TxtBtn.Length];
e_BtnMember = new EventHandler<SelValue_EArgs>[TxtBtn.Length];
for (int i = 0; i < TxtBtn.Length / 2; i++)
{
_Btnmembers[i].Click += new EventHandler(_Btnmembers_Click);
}
}
protected virtual void _Btnmembers_Click(object sender, EventArgs e)
{
int index = Array.IndexOf(_Btnmembers, (Button)sender);
ActONOFFValue(index);
}
}
}
But in the line : internal event EventHandler[] e_BtnMember;
the compiler told me that I should use a delegate. I don't understand good this remark, could you help me?
At the end the mainform should only subscribe to the event button click it wants.
And then in main we could use it to now when a button in the object multibutton row is clicked... like this:
public void main()
{
String[] txtbtn = new String[] { "btn1", "btn2", "btn3" };
FObj_BtnRow thisbtnrow = new FObj_BtnRow(txtbtn);
thisbtnrow.e_BtnMember[0] += new EventHandler<FObj_BtnRow.SelValue_EArgs> (btnmember0haschanged);
}
public void btnmember0haschanged(object sender, FObj_BtnRow.SelValue_EArgs newvalue)
{
bool thisnewvalue = newvalue.refreshed;
}
Can you help me?
Thanks in advance!!
I solved the problem by myself, thanks for your advices.
Code
class Class1
{
internal class FObj_BtnRowtest
{
private Button[] _Btnmembers;
public delegate void del_Btnmember(Boolean value);
public del_Btnmember[] btnvaluechanged;
internal class SelValue_EArgs : EventArgs//events args (selected value)
{//return boolean arguments in events
internal SelValue_EArgs(Boolean ivalue) { refreshed = ivalue; }//ctor
internal Boolean refreshed { get; set; }//accessors
}
private Boolean[] _ActONOFFValue;
private Boolean ActONOFFValue(int number)
{
_ActONOFFValue[number] = !_ActONOFFValue[number];
return _ActONOFFValue[number];
}
public FObj_BtnRowtest(int numofbtn, String UnitName)//ctor
{
_Btnmembers = new Button[numofbtn];
btnvaluechanged = new del_Btnmember[numofbtn];
_ActONOFFValue = new bool[numofbtn];
for (int i = 0; i < numofbtn / 2; i++)
{
_Btnmembers[i].Click += new EventHandler(_Btnmembers_Click);
}
}
protected virtual void _Btnmembers_Click(object sender, EventArgs e)
{
int index = Array.IndexOf(_Btnmembers, (Button)sender);
if (btnvaluechanged[index] != null) btnvaluechanged[index](ActONOFFValue(index));
}
}
}
And then in main
thisrow = new Class1.FObj_BtnRowtest(4,"thisunittest");//4 buttons
thisrow.btnvaluechanged[0] += new Class1.FObj_BtnRowtest.del_Btnmember(valuetesthaschanged);//to subscribe to btn0 change
using delegates make it easier. and yes we do need those kinds of stuffs to make code clearer and faster to developp.
Thanks all!!
Relative noob here coming from Python trying to build a UWP app in c# and XAML.
The short version: How do I refer to a button using its string 'Name' to change its color. It seems that if I have given it a name I should be able to refer to it by its name, something like:
"navBtn5".Background = myColor;
//or
navBtn5.Background = myColor;
I have looked all over, the best I found was this from here on stackOverflow:
How to control a xaml button from C# in WPF
which looks exactly like what I want. However this does not work, will not even build as I just get told:
Error CS0103 The name 'navBtn5' does not exist in the current context
This could be because I am using UWP and that is for WPF.
The long Version: My app is creating the navigation menu by data binding to a List that is put together in a separate class. I am creating a type of MenuButton in my class then returning a list of them. This is a stripped down version of my class:
class MenuButton{
public string buttonName { get; set; }
public string buttonContentText { get; set; }
public int buttonWidth { get; set; }
public int buttonHeight { get; set; }
public List<byte> buttonColor { get; set; }
}
class menuButtonManager{
public static List<MenuButton> getButtons(){
var menuButtons = new List<MenuButton>();
menuButtons.Add(new MenuButton{
buttonName = "navBtn1",
buttonWidth = 50,
buttonHeight = 50,
buttonContentText = "\uE173",
buttonColor = new List<byte> { 255, 82, 190, 128 },
});
menuButtons.Add(new MenuButton{
buttonName = "navBtn2",
//and so on
});
menuButtons.Add(new MenuButton{
//and so on
});
}
return menuButtons;
}
At Run Time, when the user clicks a button I want to loop through all the buttons in the List and change their color to grey if it was not that one that was clicked, green if it was the clicked button. something like this:
private void navClick(object sender, RoutedEventArgs e){
//who called me
string senderName = ((Button)sender).Name;
foreach(MenuButton m in menuButtons){
if(m.buttonName == senderName){
Button senderButton = (Button)sender;
senderButton.Background = myFunkyColor;
// I can already do this as I already have
// the sender cast to a button
}
else{
// change button to grey
// This is where I am stuck
// I know m.buttonName as a string
// how do I create a usable button object from it?
}
}
}
As you can see I have no trouble changing the properties of the button that was the sender as I have cast it to a type of Button which I can use. The problem for me is when I am acting on a button that is not the sender and all I have is it's string name.
You do not have to create a new class if you are using default properties(Unless it is your requirement).
Make your List of Buttons Global
List< Button> menuButtons = new List< Button>();
public static List<Button> getButtons()
{
for ( int i=0; i<5; i++)
{
Button _button = new Button
{
Name = "navBtn" + i.ToString(),
Width = 50,
Height = 50,
Content = "\uE173",
Background = new SolidColorBrush(Colors.Gray)
};
_button.Click += _button_Click;
menuButtons.Add(_button);
}
return menuButtons;
}
The above will return 5 new buttons( something like your requirement ). Look at
_button.Click += _button_Click;
An event for click will be explicitly created for each button in the list.
private static void _button_Click(object sender, RoutedEventArgs e)
{
Button Clicked = (Button)sender;
foreach(Button btn in menuButtons)
{
if (Clicked.Name == btn.Name)
{
btn.Background = myFunkyColour;
}
else
{
btn.Background = //Your Disabled Colour.
}
}
}
Click event will return you the button that was clicked.
Hope this helps.
I'm trying to add a button to the form using code and iv'e looked it up on the internet but nothing works.
public void addSnake()
{
Button btn = new Button();
btn.Location = new Point(360, 390);
btn.Size = new Size(10, 10);
btn.Text = "";
btn.Name = num + "";
btn.Tag = this.oneD;
btn.IsAccessible = false;
Controls.Add(btn);
}
public Point getPoint()
{
Button btn = (Button)Controls.Find(num + "");
return this.pos; //temporary
}
it says "The name 'Controls' does not exist in the current context". (for both functions)
Note: the functions addSnake and getPoint are inside a Class I made
Full code here: deleted
Your class is not inheriting from System.Windows.Forms.Form. So there is no such property called Controls.
What you can do is pass a reference of the form to the constructor of SnakeB:
public class SnakeB
{
private System.Windows.Forms.Form parentForm;
public SnakeB(System.Windows.Forms.Form parent)
{
parentForm = parent;
}
}
and use it in your methods like this:
public Point getPoint()
{
Button b = parentForm.Controls.Find(num + "") as Button;
return b.Location;
}
public void addSnake(bool isFirst)
{
Button b = new Button();
// ...
parentForm.Controls.Add(b);
}
Usage:
public Form1()
{
InitializeComponent();
SnakeB snake = new SnakeB(this);
}
You need to have instance of the form in your class and add the control to that instance like
public class SnakeB
{
int num;
int oneD;
Point pos = new Point();
Form1 frm1 = new Form1();
frm1.Controls.Add(btn);
How will you have the instance of the form? Like below
public Form1()
{
InitializeComponent();
SnakeB snake = new SnakeB(this);
}
In your class have a similar consructor
public class SnakeB
{
int num;
int oneD;
Point pos = new Point();
Form1 frm1;
public SnakeB()
{
this.num = 0;
this.oneD = 2;
//here construct the maain head button and 2 reguler ones
addSnake(true);
addSnake(false);
addSnake(false);
}
public SnakeB(Form1 frm) : this()
{
this.frm1 = frm;
}
Increasing my score label 137 points per item I pickup
fMain
//HUD Score
public int Score()
{
labScore.Text = Convert.ToString(score);
labScore.Text = "00000" + score;
if (score >= 10)
labScore.Text = "0000" + score;
if (score >= 100)
labScore.Text = "000" + score;
if (score >= 1000)
labScore.Text = "00" + score;
return score;
}
And I want my labScore2.Text to be the same as labScore.text. But they are in different forms.
fMain2
public void btnIntroducir_Click(object sender, EventArgs e)
{
fMain f = new fMain();
f.Score();
try
{
string n = txtNombre.Text;
int s = int32.Parse(labScore2.Text);
lista[indice] = new Koby(n, s);
indice++;
muestraLista(ref lstJugadores);
txtNombre.Clear();
txtNombre.Enabled = false;
}
what you are doing is putting the value in a string that is not public. Either make the string public and access it from the other form or you can create a class and put all such variables in that class then access them from there when you need.
You could probably create a Custom Event for in FMain2 that would reflect back to your FMain LabScore.Text.
In your FMain2, create the Custom Event. Let's say we create a Custom Event with score as parameter. We will have the following:
public partial class FMain2 : Form
{
public delegate void ScoreChangedEvent(String score); // Event Handler Delegate
public event ScoreChangedEvent ScoreChanged; // Event Handler to subscribe to the Delegate
public FMain2()
{
InitializeComponent();
}
}
In your FMain you could initialize the event and make the necessary changes when event is triggered, like:
private void btnChangeScore_Click(object sender, EventArgs e)
{
FormMain2 FMain2 = new FormMain2();
FMain2.ScoreChanged += new FMain2.ScoreChangedEvent(FMain2_ScoreChanged);
FMain2.Show();
}
void FMain2_ScoreChanged(string score)
{
labScore.Text = score; // This will receive the changes from FMain2 LabScore2.Text
}
Then back in your FMain2 you add the following:
public void btnIntroducir_Click(object sender, EventArgs e)
{
try
{
string n = txtNombre.Text;
int s = int32.Parse(labScore2.Text);
ScoreChanged(labScore2.Text); // This will reflect back to FMain labScore.Text
lista[indice] = new Koby(n, s);
indice++;
muestraLista(ref lstJugadores);
txtNombre.Clear();
txtNombre.Enabled = false;
}
}
So, your final code behind for your FMain2 would be:
public partial class FMain2 : Form
{
public delegate void ScoreChangedEvent(String score); // Event Handler Delegate
public event ScoreChangedEvent ScoreChanged; // Event Handler to subscribe to the Delegate
public FMain2()
{
InitializeComponent();
}
public void btnIntroducir_Click(object sender, EventArgs e)
{
try
{
string n = txtNombre.Text;
int s = int32.Parse(labScore2.Text);
ScoreChanged(labScore2.Text); // This will reflect back to FMain labScore.Text
lista[indice] = new Koby(n, s);
indice++;
muestraLista(ref lstJugadores);
txtNombre.Clear();
txtNombre.Enabled = false;
}
}
}
I have a simple application. Here's how it works. I have a class (MyForm) that inherits from Windows.Forms. It has a button, a label and a textbox. It looks like a chat window.
There's another class (Cliente) that takes an array of strings and it returns a List with a MyForm instance for each element in the array.
I have a third class (Prueba) that makes use of the previous two classes to test them. This class creates four instances of MyForm, and displays them. (I will omit some code and functionality because I know it works correctly.)
I need to be able to type something in one window and when click on the button, it should broadcast this message and display it in all the other windows.
I know I have to use event handlers and delegates, but after hours of looking at tutorials everywhere I can't figure out what to put where.
Would you please help me? If you can point me to a good tutorial or example it'd be enough, but if you can be more specific on my code, it'd be great.
(I can't figure out how to make one instance of MyForm be aware of the other instances, who should be the listener here? I was thinking that Client, but I can't see how to do it.)
Any help will be appreciated!
//MyForm
namespace Dia26 {
//public delegate void ChangedEventHandler(object sender, EventArgs e);
public class MyForm : System.Windows.Forms.Form {
public Button btn = new Button();
public TextBox textbox = new TextBox();
public Label label = new Label();
public Button btnEnviar = new Button();
public delegate void OwnerChangedEventHandler(string newOwner); //~
public event OwnerChangedEventHandler OwnerChanged;
protected void btn_Click(object sender, System.EventArgs e) {
this.Close();
}
protected void btnEnviar_Click(object sender, System.EventArgs e) {
label.Text += textbox.Text + "\n";
textbox.Text = "";
if (this.OwnerChanged != null) {
this.OwnerChanged("something?");
}
}
public MyForm() {
btn.Text = "cerrar";
btn.Left = 400;
btn.Top = 280;
btn.Click += new EventHandler(this.btn_Click);
btnEnviar.Click += new EventHandler(this.btnEnviar_Click);
textbox.Left = 15;
textbox.Top = 20;
textbox.Width = 330;
label.Left = 15;
label.Top = 50;
label.AutoSize = false;
label.Height = 210;
label.Width = 450;
label.BackColor = Color.White;
btnEnviar.Left = 350;
btnEnviar.Top = 17;
btnEnviar.Text = "Enviar";
this.Controls.Add(textbox);
this.Controls.Add(label);
this.Controls.Add(btn);
this.Controls.Add(btnEnviar);
this.SuspendLayout();
this.Name = "MyForm";
this.ResumeLayout(false);
return;
}
}
}
//Cliente.cs
namespace Dia26Prueba {
public class Cliente {
public int creadas;
public int nocreadas;
public List<MyForm> MostrarVentanas(out bool error, ref int creadas, params string[] nombres) {
List<MyForm> list = new List<MyForm>();
int bienCreadas = 0;
foreach (string str in nombres) {
if (str.Length >= 1) {
MyForm mf = new MyForm();
mf.Text = str;
//mf.OwnerChanged += new OwnerChangedEventHandler(mf_OwnerChanged);
list.Add(mf);
mf.Show();
bienCreadas++;
}
}
error = (bienCreadas == creadas);
nocreadas = bienCreadas - creadas;
creadas = bienCreadas;
return list;
}
public void ModificarPosicionYMedidas(MyForm mf, int x = 262, int y = 209, int width = 500, int height = 350) {
mf.Left = x;
mf.Top = y;
mf.Width = width;
mf.Height = height;
}
}
}
// Prueba
namespace Dia29 {
class Prueba {
static void Main(string[] args) {
Cliente cliente = new Cliente();
int n = 4;
Console.WriteLine(cliente.Autor);
if (args.Length != n) {
return;
}
int InstanciasCreadas = n;
bool HayErrores;
List<Dia26.MyForm> list;
list = cliente.MostrarVentanas(
creadas: ref InstanciasCreadas,
error: out HayErrores,
nombres: new string[] { "FirstWindow", "2nd", "3rd", "4th" });
cliente.ModificarPosicionYMedidas(list.ElementAt<MyForm>(0), 0, 0, 512, 384);
cliente.ModificarPosicionYMedidas(list.ElementAt<MyForm>(1), 512, 0, 512, 384);
cliente.ModificarPosicionYMedidas(list.ElementAt<MyForm>(2), 0, 384, 512, 384);
cliente.ModificarPosicionYMedidas(list.ElementAt<MyForm>(3), 512, 384, 512, 384);
for (int i = 0; i < n; i++) {
// .....
Application.Run(list.ElementAt<MyForm>(i));
}
Console.ReadLine();
}
}
}
Here is a small sample. I'm using a interface to remove the coupling between the MainWindow and the ChatWindows.
public class ChatEventArgs : EventArgs
{
public string ChatEventArgs(string message)
{
Message = message;
}
public string Message { get; private set; }
}
public interface IChatMessageProvider
{
event EventHandler<ChatEventArgs> MessageArrived;
void TriggerEvent(object source, ChatEventArgs args);
}
public class MainWindow : IChatMessageProvider
{
public event EventHandler<ChatEventArgs> MessageArrived = delegate{};
public void AddChatWindow()
{
ChatWindow window = new ChatWindow(this);
window.Show();
}
public void TriggerEvent(object source, ChatEventArgs args)
{
MessageArrived(source, args);
}
}
public class ChatWindow :
{
IChatMessageProvider _provider;
public ChatWindow(IChatMessageProvider provider)
{
_provider = provider;
provider.MessageArrived += OnMessage;
}
public void OnMesage(object source, ChatEventArgs args)
{
// since we could have sent the message
if (source == this)
return;
myListBox.Items.Add(args.Message);
}
public void SendButton_Click(object source, EventArgs e)
{
_provider.TriggerEvent(this, new ChatEventArgs(Textbox1.Text));
}
}
There are actualy multiple ways to do it.
Simply make method on Cliente and call it from Prueba. This is simplest and most intuitive solutoin.
Add event to Prueba, pass instance of Prueba to Cliente and let Cliente register to this event.
Use some kind of global static messenger class. Either using events, or simple message passing.