C#

// in the main form (Form1)

// create a new instance of the secondary form
private Form2 theForm2 = new Form2();

private void Form1_Load(object sender, EventArgs e)
{
    // assign an anonymous method to the ChangeLabels Action field of the secondary form
    theForm2.ChangeLabels = delegate(string s1, string s2, string s3)
    {
        // update the labels
        label1.Text = s1;
        label2.Text = s2;
        label3.Text = s3;
    };

    // expose the secondary form
    theForm2.Show();
}

// in the secondary form (Form2)

// a template for a method that takes three string parameters and returns void
public Action<string, string, string> ChangeLabels;

// a button in the secondary form that will call the method
// injected into the secondary form by its creator, the main form
private void TestChangeForm1Labels_Click(object sender, EventArgs e)
{
    // test
    ChangeLabels("1", "2", "3");
}

// in LocationChange (aka Form2)
        private string _holdSecLoc;
        private string _holdTeam;
        private string _holdUname;

// a bunch of other form code here...

        // a template for a method that takes three string parameters and returns void
        public Action<string, string, string> ChangeLabels;

        private void ChgLoc()
            {
            GetPrimeLocBal.UidDal = Login.PassUserIdText;
            GetPrimeLocBal.NewLoc = tbLocId.Text;
            }

        private void btnChange_Click( object sender, EventArgs e )
            {
            // a button in the secondary form that will call the method
            // injected into the secondary form by its creator, the main form
            ChgLoc();
            GetPrimeLocBal.GetPrime();
            _holdUname = GetPrimeLocBal.UidDal;
            _holdTeam = GetPrimeLocBal.TeamName;
            _holdSecLoc = GetPrimeLocBal.SecondaryLoc;
            ChangeLabels( _holdUname, _holdTeam, _holdSecLoc );
            Close();
            }

// added this to private void MainDesktop_Load( object sender, EventArgs e )

            _locChgChange.ChangeLabels = delegate( string s1, string s2, string s3 )
            {
                // update the labels
                tssUserId.Text = s1;
                tssTeam.Text = s2;
                tssPrimeLoc.Text = s3;
            };

// instead of showing the form2 in the load...

        private void changeSitesToolStripMenuItem_Click( object sender, EventArgs e )
            {
            // expose the secondary form
            _locChgChange.Show();
            }

BillWoodruff wrote:

Using them "raw," without the usual business/ceremony

class MyArgs: EventArgs
{
  public string Str1 {get;set;}
  public string Str2 {get;set;}
}

BillWoodruff wrote:

If you think such usage of Action and Func are very bad things, why ?

BillWoodruff wrote:

Of course, if you assign an anonymous method as an EventHandler, you are
never going to be able to remove it from the delegate's method dispatch queue

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

"Delegates with more than one method in their invocation list derive from MulticastDelegate, which is a subclass of System.Delegate." 

"If you put your method in a delegate (say, a local variable or a field), and then bind it, you can also unbind it again using that reference"

BillWoodruff wrote:

Thanks for your very thoughtful reply

BillWoodruff wrote:

Aren't all delegates inherently multi-cast

BillWoodruff wrote:

It's interesting to me that some third-party controls I use that expose Events
really do not provide a practically useful object in the Events 'object sender
parameter.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

Eddy Vluggen wrote:

there's always a sender - it's an object, so there's no excuse for passing "null" there.

Event Design[^]

Do not pass null as the sender parameter when raising a non-static event.
On static events, the sender parameter should be null.

C# Event Implementation Fundamentals, Best Practices and Conventions[^]

Static events should pass null as the value of sender

private List<MyObject> MyList;
void Main()
{
   var items1 = Get(x => x.MyInt == 1);
   var items2 = Get(x => x.MyBool == false);
   var items3 = Get(x => x.MyString == "XXX");
   var items4 = Get(x => x.MyBool == false && x.MyString == "XXX");
}

public IEnumerable<MyObject> Get(Func<MyObject, bool> filter) {
	if(MyList == null) MyList = new List<MyObject>();
	if(MyList.Count==0) {
		MyList.Add(new MyObject { MyInt = 1, MyBool = true, MyString = "XXX" });
		MyList.Add(new MyObject { MyInt = 2, MyBool = false, MyString = "XXX" });
		MyList.Add(new MyObject { MyInt = 3, MyBool = false, MyString = "YYY" });
	}
	return MyList.Where(filter);
}

// a data object contained in the list
public class MyObject {
   public int MyInt { get; set; }
   public bool MyBool { get; set; }
   public string MyString { get; set; }
}

BillWoodruff wrote:

But, I guess if I were part of a team, on a large, complex, project, implementing Events in the usual way with custom EventArgs would probably pay off in the long-run. Possibly contributing to code consistency and maintainability ? Flexibility ?

BillWoodruff wrote:

However, I will point out that the implementation of a revised EventArgs class, and using it, will also require changes to each place in your code that raises the Event: to initialize the new parameters.

class Program {
    static void Main(string[] args) {
        var x = new MySender();
        x.MyEvent += MyHandler;
    }
    
    private static void MyHandler(object sender, EventArgs eventArgs) {
        // Do Stuff
    }
}
public class MySender {
    public event EventHandler MyEvent;    
    // Event Invocators etc.
}

class Program {
    static void Main(string[] args) {
        var x = new MySender();
        x.MyEvent += MyHandler;
    }
    
    private static void MyHandler(object sender, EventArgs eventArgs) {
        // Do Stuff
    }
}
public class MySender {
    public event EventHandler<CustomArgs> MyEvent;    
    // Event Invocators etc.
}
public class CustomArgs : EventArgs {
    public int MyInt { get; set; }
}

class Program {
    static void Main(string[] args) {
        var x = new MySender();
        x.MyEvent += MyHandler;
    }
    
    private static void MyHandler(object sender, CustomArgs eventArgs) {
        // Do Stuff
        var x = eventArgs.MyInt;
    }
}
public class MySender {
    public event EventHandler<CustomArgs> MyEvent;    
    // Event Invocators etc.
}
public class CustomArgs : EventArgs {
    public int MyInt { get; set; }
}