Marshal-by-value objects are copied by the remoting system 
and passed in their entirety to the caller's application 
domain. Once copied to the caller's application domain (by 
the marshaling process), all method calls and property 
accesses are executed entirely within that domain. The 
entire object exists in the caller's domain, so there is no 
need to marshal accesses across domain boundaries. Using 
marshal-by-value objects can increase performance and 
reduce network traffic when used for small objects or 
objects to which you will be making many accesses. However, 
because the object exists entirely in the caller's 
application domain, no state changes to the object are 
communicated to the originating application domain, or from 
the originator back to the caller. Marshal-by-value is not 
a good choice for very large objects with many accesses. It 
makes little sense to marshal an entire large object across 
domain boundaries when all you need is access to a single 
field, method, or property.

Remoting makes an object in one process (the server) 
available to code in another process (the client). This is 
called marshalling, and there are two fundamentally 
different ways to marshal an object

-->Marshal by value: the server creates a copy of the 
object passes the copy to the client. 
-->Marshal by reference: the client creates a proxy for the 
object and then uses the proxy to access the object.

MBV:the server creates a value and send it to the Client .
MBR:The Server sends the reference of that value to the Client.