Why no properties are supported? and why no events on interfaces?

[roozbehid-ic]

Hi I am wondering why there is a restriction on properties and also events on interfaces?
I am also not quite understanding how interfaces and objects implementing them is different?

Mostly I want to know if implementing them is easy maybe I can help there....

[roozbehid-ic]

I am totally lost!
So on marshalable objects (same as dynamic proxies?) is Properties supported?
So on marshalable objects is Events supported?
Is only way to have dynamic objects is with [RpcMarshalable] ? It seems that was added recently with #777.
So how was it working before that? (It seems just supporting IDisposable was enough? and that one supported events?)

[AArnott]

Properties are supported on serialized objects. They are not supported on marshaled interfaces because marshaled interfaces carry no data -- they are strictly remote controllers. As such, everything they do is fundamentally asynchronous. We don't support properties for the same reason we don't support synchronous methods: it would require blocking a thread for a fundamentally asynchronous operation.

Events are supported on regular RPC proxy interfaces. They are not yet supported on marshalled interfaces (i.e. interfaces that are used in arguments or return values) simply because supporting them is complex and we didn't want to block the main feature (#777) on implementation of a feature that could come later separately.

Several interfaces are what we call exotic types and have built-in marshalability. Any custom interfaces that you want remoted behavior instead of serialization behavior must bear the [RpcMarshable] attribute. IDisposable is an exotic type so we supported that before [RpcMarshable] came along, and IDisposable continues to work as it did before.

By default, anything you send in an argument or return value gets serialized. But when the type you declare (the parameter or return type, or the type of field or property inside a parameter type or return type) is an interface, your serializer had better know how to instantiate a concrete type that implements that interface at deserialization time, or it must be one of the exotic types, or attributed with [RpcMarshalable]. This is different from interfaces that a given object happens to implement, which has no bearing on whether it gets serialized or marshaled.

[roozbehid-ic]

Thanks for detailed explanation.

So I have an interface that uses events and I want it to be a RPC interface. How do you think I should solve the problem?
Does it work if I create a method in that interface so that it returns an object which has events in it then remote can use those events?

[AArnott]

The first thing I'd just caution you on is that most people I talk to that say they want marshaled objects are thinking of a sub-optimal design. Using marshaled objects brings in complex lifetime concerns, and there is usually a simpler way to model it that doesn't involve marshaled objects. So before you jump into this feature and want to use events, I would just advise you to consider alternatives where the event is on the top-level RPC interface instead of on a marshaled object.

Does it work if I create a method in that interface so that it returns an object which has events in it then remote can use those events?

That would be events on a marshaled object, which isn't supported yet. The only supported use of events is on standard RPC target objects. Will that work for you?

If not, consider that events are simply a means for the "server" to invoke methods on the "client" (I use quotes because JSON-RPC is a peer-to-peer protocol -- there is no formal client or server roles). So if you must pass an object around that has "events", try passing a different object the other direction. For example, if you have an RPC target object with a GetMarshaledObject method on it, and that method would return an IFoo with an event on it, try instead adding a parameter to GetMarshaledObject that accepts a marshaled object with the events defined as methods and then the GetMarshaledObject method can store that object somewhere in order to "raise events" on it by invoking those methods.

[roozbehid-ic]

Also is my understanding correct that this will work (regarding events)

interface IMyRpcInterface
{
    event EventHandler<ChangeDetails> EmployeesChanged;
    Task<List<Order>> ListOrders(int employee, string employeeid);
    Task<List<Employee> ListEmployees();
    Task<List<Customer> ListCustomers();
}

But this one does not work or result of GetMyRPCInterface does not trigger events on remote.

interface IMyRpcInterface
{
    event EventHandler<ChangeDetails> EmployeesChanged;
    Task<List<Order>> ListOrders(int employee, string employeeid);
    Task<List<Employee> ListEmployees();
    Task<List<Customer> ListCustomers();
    Task<GetMyRPCInterface> GetMyRPCInterface();
}