Then I would use the 2.0 inline delegate syntax, but using the standard
event pattern. Depending on the scenario, the new value could be either in
the event-args, or back on the sender (typical for a SomethingChanged
event), i.e.

// EventHandler example
someInstance.SomethingChanged += delegate {
 someOtherInstancePossiblyThis.SomeProperty = someInstance.Something;
};
or
// SomeEventHandler example where SomeEventArgs has a .SomeValue property
someInstance.SomeEvent += delegate (object sender, SomeEventArgs args) {
 someOtherInstancePossiblyThis.SomeProperty = args.SomeValue;
};

(note that in either case you might also case "sender" instead of using
someOtherInstancePossiblyThis)

Marc

You can use reflection to set it up. A complete example is below. It's
pretty longwinded, but if you needed this on a regular basis you could
easily set it up in a helper method - especially with generics, if
you're using 2.0.

using System;
using System.Reflection;

delegate void SettingHandler (string value);

class PropertyClass
{
   string name;

   public string Name
   {
       get { return name; }
       set { name = value; }
   }
}

class EventClass
{
   public event SettingHandler SetEvent;
   
   public void RaiseEvent (string value)
   {
       SetEvent(value);
   }
}

class Test
{
   static void Main()
   {
       PropertyClass pc = new PropertyClass();
       
       EventClass ec = new EventClass();
       
       PropertyInfo prop = typeof(PropertyClass).GetProperty("Name");
       MethodInfo method = prop.GetSetMethod();
       
       SettingHandler handler = (SettingHandler)
            Delegate.CreateDelegate
                (typeof(SettingHandler), pc, method);
       
       ec.SetEvent += handler;
       
       ec.RaiseEvent ("testing");
       
       Console.WriteLine (pc.Name);
   }
}