public static object CreateProxyForType(Type type)
{
// Called by the runtime when creating an instance of a type
// that has been registered as remotely activated.
// First of all check for remote activation. If the object is not remote, then
// it may be contextbound.
ActivatedClientTypeEntry activatedEntry = RemotingConfiguration.IsRemotelyActivatedClientType(type);
if (activatedEntry != null)
{
return(RemotingServices.CreateClientProxy(activatedEntry, null));
}
WellKnownClientTypeEntry wellknownEntry = RemotingConfiguration.IsWellKnownClientType(type);
if (wellknownEntry != null)
{
return(RemotingServices.CreateClientProxy(wellknownEntry));
}
if (type.IsContextful)
{
return(RemotingServices.CreateClientProxyForContextBound(type, null));
}
#if !NET_2_1
if (type.IsCOMObject)
{
return(RemotingServices.CreateClientProxyForComInterop(type));
}
#endif
return(null);
}
public static object CreateProxyFromAttributes(Type type, object[] activationAttributes)
{
string activationUrl = null;
foreach (object attr in activationAttributes)
{
if (!(attr is IContextAttribute))
{
throw new RemotingException("Activation attribute does not implement the IContextAttribute interface");
}
if (attr is UrlAttribute)
{
activationUrl = ((UrlAttribute)attr).UrlValue;
}
}
if (activationUrl != null)
{
return(RemotingServices.CreateClientProxy(type, activationUrl, activationAttributes));
}
ActivatedClientTypeEntry activatedEntry = RemotingConfiguration.IsRemotelyActivatedClientType(type);
if (activatedEntry != null)
{
return(RemotingServices.CreateClientProxy(activatedEntry, activationAttributes));
}
if (type.IsContextful)
{
return(RemotingServices.CreateClientProxyForContextBound(type, activationAttributes));
}
return(null);
}
static void Main()
{
try
{
ChannelServices.RegisterChannel(new TcpChannel());
RemotingConfiguration.RegisterActivatedClientType(
typeof(MyServerImpl), "tcp://localhost:8085");
MyServerImpl myObject = new MyServerImpl();
for (int i = 0; i <= 4; i++)
{
Console.WriteLine(myObject.MyMethod("invoke the server method "
+ (i + 1) + " time."));
}
// <Snippet1>
// Check whether the 'MyServerImpl' type is registered as
// a remotely activated client type.
ActivatedClientTypeEntry myActivatedClientEntry =
RemotingConfiguration.IsRemotelyActivatedClientType(
typeof(MyServerImpl));
Console.WriteLine("The Object type is "
+ myActivatedClientEntry.ObjectType);
Console.WriteLine("The Application Url is "
+ myActivatedClientEntry.ApplicationUrl);
// </Snippet1>
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public static object CreateProxyForType(Type type)
{
ActivatedClientTypeEntry activatedClientTypeEntry = RemotingConfiguration.IsRemotelyActivatedClientType(type);
if (activatedClientTypeEntry != null)
{
return(RemotingServices.CreateClientProxy(activatedClientTypeEntry, null));
}
WellKnownClientTypeEntry wellKnownClientTypeEntry = RemotingConfiguration.IsWellKnownClientType(type);
if (wellKnownClientTypeEntry != null)
{
return(RemotingServices.CreateClientProxy(wellKnownClientTypeEntry));
}
if (type.IsContextful)
{
return(RemotingServices.CreateClientProxyForContextBound(type, null));
}
return(null);
}
static void Main()
{
try
{
ChannelServices.RegisterChannel(new TcpChannel());
RemotingConfiguration.RegisterActivatedClientType(
typeof(MyServerImpl), "tcp://localhost:8085");
MyServerImpl myObject = new MyServerImpl();
for (int i = 0; i <= 4; i++)
{
Console.WriteLine(myObject.MyMethod("invoke the server method "));
}
// Get the assembly for the 'MyServerImpl' object.
// <Snippet1>
Assembly myAssembly = Assembly.GetAssembly(typeof(MyServerImpl));
AssemblyName myName = myAssembly.GetName();
// Check whether the 'MyServerImpl' type is registered as
// a remotely activated client type.
ActivatedClientTypeEntry myActivatedClientEntry =
RemotingConfiguration.IsRemotelyActivatedClientType(
(typeof(MyServerImpl)).FullName, myName.Name);
Console.WriteLine("The Object type : "
+ myActivatedClientEntry.ObjectType);
Console.WriteLine("The Application Url : "
+ myActivatedClientEntry.ApplicationUrl);
if (myActivatedClientEntry != null)
{
Console.WriteLine("Object is client activated");
}
else
{
Console.WriteLine("Object is not client activated");
}
// </Snippet1>
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public override MarshalByRefObject CreateInstance(Type serverType)
{
// Platform.Assert(Platform.W2K, "ServicedComponent");
RealProxy rp = null;
MarshalByRefObject mo = null;
DBG.Info(DBG.SC, "SCPA.CreateInstance(" + serverType + ") for managed request");
ServicedComponentProxy.CleanupQueues(true);
// First check if the type is configured to be activated remotely or is a well
// known remote type.
if ((null != RemotingConfiguration.IsWellKnownClientType(serverType)) ||
(null != RemotingConfiguration.IsRemotelyActivatedClientType(serverType)))
{
// It is configured for remote activation. Ask remoting services to do the
// job of creating a remoting proxy and returning it.
mo = base.CreateInstance(serverType);
rp = RemotingServices.GetRealProxy(mo);
}
else
{
bool bIsAnotherProcess = false;
string uri = "";
bool bEventClass = ServicedComponentInfo.IsTypeEventSource(serverType);
IntPtr pUnk = Thunk.Proxy.CoCreateObject(serverType, !bEventClass, ref bIsAnotherProcess, ref uri);
if (pUnk != IntPtr.Zero)
{
try {
// TODO: Get rid of this useless foreknowledge requirement
// Is there a way we can tell by QI'ing this guy if he's
// an event class (or something else we need to artificially
// wrap?
if (bEventClass)
{
// events and queued components use RemoteServicedComponentProxy
// set up a TP & Remote ServicedComponentProxy pair
rp = new RemoteServicedComponentProxy(serverType, pUnk, true);
mo = (MarshalByRefObject)rp.GetTransparentProxy();
}
else
{
if (bIsAnotherProcess) // a-ha, we know it should be a RSCP now !!!!
{
FastRSCPObjRef oref = new FastRSCPObjRef(pUnk, serverType, uri);
mo = (MarshalByRefObject)RemotingServices.Unmarshal(oref);
DBG.Assert(mo != null, "RemotingServices.Unmarshal returned null!");
DBG.Assert(RemotingServices.GetRealProxy(mo) is RemoteServicedComponentProxy, "RemotingServices.Unmarshal did not return an RSCP!");
}
else // bummer, this will give us back a SCP
{
mo = (MarshalByRefObject)Marshal.GetObjectForIUnknown(pUnk);
DBG.Info(DBG.SC, "ret = " + mo.GetType());
DBG.Info(DBG.SC, "st = " + serverType);
DBG.Info(DBG.SC, "rt == sc = " + (mo.GetType() == serverType));
DBG.Info(DBG.SC, "instanceof = " + serverType.IsInstanceOfType(mo));
if (!(serverType.IsInstanceOfType(mo)))
{
throw new InvalidCastException(Resource.FormatString("ServicedComponentException_UnexpectedType", serverType, mo.GetType()));
}
rp = RemotingServices.GetRealProxy(mo);
if (!(rp is ServicedComponentProxy) && !(rp is RemoteServicedComponentProxy))
{
// in cross-appdomain scenario, we get back a RemotingProxy, SetCOMIUnknown has not been made on our server!
ServicedComponent sc = (ServicedComponent)mo;
sc.DoSetCOMIUnknown(pUnk);
}
}
}
}
finally
{
Marshal.Release(pUnk);
}
}
}
if (rp is ServicedComponentProxy)
{
// Here, we tell the server proxy that it needs to filter out
// constructor calls: We only need to do this if
// the proxy lives in the same context as the caller,
// otherwise we'll get an Invoke call and can do the
// filtering automagically:
ServicedComponentProxy scp = (ServicedComponentProxy)rp;
if (scp.HomeToken == Thunk.Proxy.GetCurrentContextToken())
{
scp.FilterConstructors();
}
}
DBG.Assert(mo is ServicedComponent, " CoCI returned an invalid object type");
DBG.Info(DBG.SC, "SCPA.CreateInstance done.");
return(mo);
}
public override MarshalByRefObject CreateInstance(Type serverType)
{
RealProxy realProxy = null;
MarshalByRefObject transparentProxy = null;
ServicedComponentProxy.CleanupQueues(false);
if ((RemotingConfiguration.IsWellKnownClientType(serverType) != null) || (RemotingConfiguration.IsRemotelyActivatedClientType(serverType) != null))
{
transparentProxy = base.CreateInstance(serverType);
realProxy = RemotingServices.GetRealProxy(transparentProxy);
}
else
{
bool bIsAnotherProcess = false;
string uri = "";
bool flag2 = ServicedComponentInfo.IsTypeEventSource(serverType);
IntPtr pUnk = Proxy.CoCreateObject(serverType, !flag2, ref bIsAnotherProcess, ref uri);
if (pUnk != IntPtr.Zero)
{
try
{
if (flag2)
{
realProxy = new RemoteServicedComponentProxy(serverType, pUnk, true);
transparentProxy = (MarshalByRefObject)realProxy.GetTransparentProxy();
}
else
{
bool flag3 = (RemotingConfiguration.IsWellKnownClientType(serverType) != null) || (null != RemotingConfiguration.IsRemotelyActivatedClientType(serverType));
if (bIsAnotherProcess && !flag3)
{
FastRSCPObjRef objectRef = new FastRSCPObjRef(pUnk, serverType, uri);
transparentProxy = (MarshalByRefObject)RemotingServices.Unmarshal(objectRef);
}
else
{
transparentProxy = (MarshalByRefObject)Marshal.GetObjectForIUnknown(pUnk);
if (!serverType.IsInstanceOfType(transparentProxy))
{
throw new InvalidCastException(Resource.FormatString("ServicedComponentException_UnexpectedType", serverType, transparentProxy.GetType()));
}
realProxy = RemotingServices.GetRealProxy(transparentProxy);
if ((!bIsAnotherProcess && !(realProxy is ServicedComponentProxy)) && !(realProxy is RemoteServicedComponentProxy))
{
((ServicedComponent)transparentProxy).DoSetCOMIUnknown(pUnk);
}
}
}
}
finally
{
Marshal.Release(pUnk);
}
}
}
if (realProxy is ServicedComponentProxy)
{
ServicedComponentProxy proxy2 = (ServicedComponentProxy)realProxy;
if (proxy2.HomeToken == Proxy.GetCurrentContextToken())
{
proxy2.FilterConstructors();
}
}
return(transparentProxy);
}