In general you only want to make an object MarshalByRef if you're going to use it in a Remoting / WCF context. This is usually a special-enough case that it's not a pain.
Suppose you had a general type, and you wanted to derive from it and specialise it, and then remote the derived type - now you have a problem, because to be remoted an object must inherit from MarshalByRefObject, and your original general type didn't. Suppose you can't change it because you're doing binary inheritance, or because it itself derives from a base class you can't change? As the questioner points out, since C# (and .NET in general) doesn't allow MI, you can't inherit from both.
The short answer is that you're sort-of screwed. You either change the general type to inhert from MarshalByRefObject (or go far enough up the chain that you can insert it somewhere effective), or else you can think about mucking about with proxy objects.
You could for example create an interface contract that describes your type's interface, and then build a proxy type inheriting from MarshalByRefObject that also implements that interface by composition and delegation to an instance of your type (ie a wrapper). You could then remote an instance of that proxy type which would instantiate your type and do the work as expected - but all return types from methods have to be [Serializable].
public interface IMyType
{
string SayHello();
string BaseTypeMethodIWantToUse();
}
public class MyType : MyBaseType, IMyType
{
public string SayHello()
{
return "Hello!";
}
}
public class MyRemoteableType : MarshalByRefObject, IMyType
{
private MyType _instance = new MyType();
public string SayHello()
{
return _instance.SayHello();
}
public string BaseTypeMethodIWantToUse()
{
return _instance.BaseTypeMethodIWantToUse();
}
}
Seems like a lot of work, though. Ultimately if you're in this scenario I'd suggest a redesign or a rethink.