// TODO: Move to ServicedComponent static method
public static void DeactivateObject(Object otp, bool disposing)
{
RealProxy rp = RemotingServices.GetRealProxy(otp);
ServicedComponentProxy scp = rp as ServicedComponentProxy;
DBG.Assert(scp != null, "CS.DeactivateObject called on a non-ServicedComponentProxy");
if (!scp.IsProxyDeactivated)
{
DBG.Assert(scp.HomeToken == Thunk.Proxy.GetCurrentContextToken(), "Deactivate called from wrong context");
if (scp.IsObjectPooled)
{
DBG.Info(DBG.SC, "CS.DeactivateObject calling ReconnectForPooling");
ReconnectForPooling(scp);
}
// this would wack the real server also so do this last
DBG.Info(DBG.SC, "CS.DeactivateObject calling scp.DeactivateProxy");
scp.DeactivateProxy(disposing);
}
DBG.Assert(scp.IsProxyDeactivated, "scp not deactive");
}
// TODO: @cleanup: Move to ServicedComponentProxy
private static void ReconnectForPooling(ServicedComponentProxy scp)
{
Type serverType = scp.GetProxiedType();
bool fIsJitActivated = scp.IsJitActivated;
bool fIsTypePooled = scp.IsObjectPooled;
bool fAreMethodsSecure = scp.AreMethodsSecure;
ProxyTearoff tearoff = null;
DBG.Assert(fIsTypePooled == true, "CS.ReconnectForPooling called on a non-pooled proxy!");
DBG.Info(DBG.SC, "CS.ReconnectForPooling (type is pooled) " + serverType);
ServicedComponent server = scp.DisconnectForPooling(ref tearoff);
// now setup a new SCP that we can add to the pool
// with the current server object and the CCW
ServicedComponentProxy newscp = new ServicedComponentProxy(serverType, fIsJitActivated, fIsTypePooled, fAreMethodsSecure, false);
DBG.Info(DBG.SC, "CS.ReconnectForPooling (calling newscp.ConnectForPooling)");
newscp.ConnectForPooling(scp, server, tearoff, false);
// switch the CCW from oldtp to new tp
DBG.Info(DBG.SC, "CS.ReconnectForPooling (SwitchingWrappers)");
EnterpriseServicesHelper.SwitchWrappers(scp, newscp);
// Strengthen the CCW: The only reference now held is
// the reference from the pool.
if (tearoff != null)
{
Marshal.ChangeWrapperHandleStrength(tearoff, false);
}
Marshal.ChangeWrapperHandleStrength(newscp.GetTransparentProxy(), false);
}
MarshalByRefObject ICustomFactory.CreateInstance(Type serverType)
{
RealProxy realProxy = null;
ServicedComponentProxy.CleanupQueues(false);
int num = ServicedComponentInfo.SCICachedLookup(serverType);
bool fIsJitActivated = (num & 8) != 0;
bool fIsPooled = (num & 0x10) != 0;
bool fAreMethodsSecure = (num & 0x20) != 0;
if (fIsJitActivated)
{
object obj2 = IdentityTable.FindObject(Proxy.GetCurrentContextToken());
if (obj2 != null)
{
realProxy = RemotingServices.GetRealProxy(obj2);
}
}
if (realProxy == null)
{
realProxy = new ServicedComponentProxy(serverType, fIsJitActivated, fIsPooled, fAreMethodsSecure, true);
}
else if (realProxy is ServicedComponentProxy)
{
((ServicedComponentProxy)realProxy).ConstructServer();
}
return((MarshalByRefObject)realProxy.GetTransparentProxy());
}
/// <include file='doc\ServicedComponent.uex' path='docs/doc[@for="ServicedComponent.DisposeObject"]/*' />
public static void DisposeObject(ServicedComponent sc)
{
RealProxy rp = RemotingServices.GetRealProxy(sc);
if (rp is ServicedComponentProxy)
{
DBG.Info(DBG.SC, "DisposeObject(): Disposing ServicedComponentProxy");
ServicedComponentProxy scp = (ServicedComponentProxy)rp;
RemotingServices.Disconnect(sc);
// dispose the actual proxy
scp.Dispose(true);
}
else if (rp is RemoteServicedComponentProxy)
{
DBG.Info(DBG.SC, "DisposeObject(): Disposing RemoteServicedComponentProxy");
RemoteServicedComponentProxy rscp = (RemoteServicedComponentProxy)rp;
// dispose the remote instance first
sc.Dispose();
// then dispose the local proxy
rscp.Dispose(true);
}
else // We're off in magic land, with no proxy of our own.
{
sc.Dispose();
}
}
/// <include file='doc\ServicedComponent.uex' path='docs/doc[@for="ServicedComponent.ServicedComponent"]/*' />
public ServicedComponent()
{
ServicedComponentProxy pxy = RemotingServices.GetRealProxy(this) as ServicedComponentProxy;
DBG.Assert(pxy != null, "RealProxy() is null during constructor!");
pxy.SuppressFinalizeServer();
Type thisType = this.GetType();
_denyRemoteDispatch = ServicedComponentInfo.AreMethodsSecure(thisType);
// Get the methodinfo for finalize...
// REVIEW: Do we have to do anything special to make sure we
// get the one furthest down the chain?
bool bFoundInCache = false;
_finalize = _finalizeCache.Get(thisType, out bFoundInCache) as MethodInfo;
if (bFoundInCache == false)
{
_finalize = GetDeclaredFinalizer(thisType);
_finalizeCache.Put(thisType, _finalize);
}
_calledDispose = false;
}
void IObjectControl.Deactivate()
{
ServicedComponentProxy target = (ServicedComponentProxy)this._scp.Target;
if (target != null)
{
ComponentServices.DeactivateObject(target.GetTransparentProxy(), true);
}
}
public static void DeactivateObject(object otp, bool disposing)
{
ServicedComponentProxy realProxy = RemotingServices.GetRealProxy(otp) as ServicedComponentProxy;
if (!realProxy.IsProxyDeactivated)
{
if (realProxy.IsObjectPooled)
{
ReconnectForPooling(realProxy);
}
realProxy.DeactivateProxy(disposing);
}
}
private static void ReconnectForPooling(ServicedComponentProxy scp)
{
Type proxiedType = scp.GetProxiedType();
bool isJitActivated = scp.IsJitActivated;
bool isObjectPooled = scp.IsObjectPooled;
bool areMethodsSecure = scp.AreMethodsSecure;
ProxyTearoff proxyTearoff = null;
ServicedComponent server = scp.DisconnectForPooling(ref proxyTearoff);
ServicedComponentProxy newcp = new ServicedComponentProxy(proxiedType, isJitActivated, isObjectPooled, areMethodsSecure, false);
newcp.ConnectForPooling(scp, server, proxyTearoff, false);
EnterpriseServicesHelper.SwitchWrappers(scp, newcp);
if (proxyTearoff != null)
{
Marshal.ChangeWrapperHandleStrength(proxyTearoff, false);
}
Marshal.ChangeWrapperHandleStrength(newcp.GetTransparentProxy(), false);
}
internal void ConnectForPooling(ServicedComponentProxy oldscp, ServicedComponent server, ProxyTearoff proxyTearoff, bool fForJit)
{
if (oldscp != null)
{
this._fReturnedByFinalizer = oldscp._fFinalized;
if (fForJit)
{
this._pPoolUnk = oldscp._pPoolUnk;
oldscp._pPoolUnk = IntPtr.Zero;
}
}
if (server != null)
{
base.AttachServer(server);
}
this._proxyTearoff = proxyTearoff;
this._proxyTearoff.Init(this);
}
public static void DisposeObject(ServicedComponent sc)
{
RealProxy realProxy = RemotingServices.GetRealProxy(sc);
if (realProxy is ServicedComponentProxy)
{
ServicedComponentProxy proxy2 = (ServicedComponentProxy)realProxy;
RemotingServices.Disconnect(sc);
proxy2.Dispose(true);
}
else if (realProxy is RemoteServicedComponentProxy)
{
RemoteServicedComponentProxy proxy3 = (RemoteServicedComponentProxy)realProxy;
sc.Dispose();
proxy3.Dispose(true);
}
else
{
sc.Dispose();
}
}
internal void ActivateObject()
{
IntPtr currentContextToken = Proxy.GetCurrentContextToken();
if ((this.IsObjectPooled && this.IsJitActivated) && (this.HomeToken != currentContextToken))
{
object obj2 = IdentityTable.FindObject(currentContextToken);
if (obj2 != null)
{
ServicedComponentProxy realProxy = (ServicedComponentProxy)RemotingServices.GetRealProxy(obj2);
ProxyTearoff proxyTearoff = null;
ServicedComponent server = this.DisconnectForPooling(ref proxyTearoff);
proxyTearoff.SetCanBePooled(false);
realProxy.ConnectForPooling(this, server, proxyTearoff, true);
EnterpriseServicesHelper.SwitchWrappers(this, realProxy);
realProxy.ActivateProxy();
return;
}
}
this.ActivateProxy();
}
internal override void Init(ServicedComponentProxy scp)
{
this._scp = scp;
}
internal override void Init(ServicedComponentProxy scp)
{
this._scp = new WeakReference(scp, true);
}
internal override void Init(ServicedComponentProxy scp)
{
this._scp = new WeakReference(scp, true);
}
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);
}
MarshalByRefObject ICustomFactory.CreateInstance(Type serverType)
{
// Platform.Assert(Platform.W2K, "ServicedComponent");
DBG.Info(DBG.SC, "SCPA.CreateInstance(" + serverType + ") for unmanaged request");
DBG.Assert(ServicedComponentInfo.IsTypeServicedComponent(serverType),
"unconfigured type passed to ICustomFactory.CreateInstance");
RealProxy rp = null;
// The reason we don't want to cleanup GIT cookies from inside here (passing false) is
// because we will already be in a new context, and RevokeInterfaceFromGlobal will be very expensive
// (like 5x), as it needs to switch context. A more appropriate place to do this is in the managed CreateInstance
// before we even call CoCreateInstance
ServicedComponentProxy.CleanupQueues(false);
int iSCInfo = ServicedComponentInfo.SCICachedLookup(serverType);
bool fIsTypeJITActivated = (iSCInfo & ServicedComponentInfo.SCI_JIT) != 0;
bool fIsTypePooled = (iSCInfo & ServicedComponentInfo.SCI_OBJECTPOOLED) != 0;
bool fAreMethodsSecure = (iSCInfo & ServicedComponentInfo.SCI_METHODSSECURE) != 0;
if (fIsTypeJITActivated)
{
// NOTE: If the component is JIT activated, we may be trying
// to connect a new backing object to an existing TP held
// by a managed client. So we look in our handy table
// to see if there is a component registered for this context.
// Because it is JIT activated, COM+ ensures that it will
// have been the distinguished object in this context.
IntPtr token = Thunk.Proxy.GetCurrentContextToken();
DBG.Info(DBG.SC, "SCPA.CreateInstance looking for JIT object in IdentityTable. token=" + token);
Object otp = IdentityTable.FindObject(token);
if (otp != null)
{
DBG.Info(DBG.SC, "SCPA.CreateInstance found JIT object in IdentityTable.");
rp = RemotingServices.GetRealProxy(otp);
DBG.Assert(rp is ServicedComponentProxy, "Cached something that wasn't a serviced component proxy in the ID table!");
DBG.Assert(rp != null, " GetTransparentProxy.. real proxy is null");
DBG.Assert(serverType == rp.GetProxiedType(), "Invalid type found in Deactivated list");
}
}
if (rp == null)
{
DBG.Info(DBG.SC, "SCPA.CreateInstance creating new SCP fJIT=" + fIsTypeJITActivated + " fPooled=" + fIsTypePooled + " fMethodsSecure=" + fAreMethodsSecure);
rp = new ServicedComponentProxy(serverType, fIsTypeJITActivated, fIsTypePooled, fAreMethodsSecure, true);
}
else if (rp is ServicedComponentProxy)
{
ServicedComponentProxy scp = (ServicedComponentProxy)rp;
scp.ConstructServer();
}
MarshalByRefObject mo = (MarshalByRefObject)rp.GetTransparentProxy();
DBG.Assert(mo != null, " GetTransparentProxy returned NULL");
DBG.Info(DBG.SC, "SCPA.ICustomFactory.CreateInstance done.");
return(mo);
}
internal void ConnectForPooling(ServicedComponentProxy oldscp, ServicedComponent server, ProxyTearoff proxyTearoff, bool fForJit)
{
if (oldscp != null)
{
this._fReturnedByFinalizer = oldscp._fFinalized;
if (fForJit)
{
this._pPoolUnk = oldscp._pPoolUnk;
oldscp._pPoolUnk = IntPtr.Zero;
}
}
if (server != null)
{
base.AttachServer(server);
}
this._proxyTearoff = proxyTearoff;
this._proxyTearoff.Init(this);
}
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);
}
internal ServicedComponentStub(ServicedComponentProxy scp)
{
this.Refresh(scp);
}
internal void Refresh(ServicedComponentProxy scp)
{
this._scp = new WeakReference(scp, true);
}
internal static bool CleanupQueues(bool bGit)
{
bool flag = true;
bool flag2 = true;
if (!_asyncFinalizeEnabled)
{
return(true);
}
if (bGit)
{
if (_gitQueue.Count > 0)
{
bool flag3 = false;
int cookie = 0;
lock (_gitQueue)
{
if (_gitQueue.Count > 0)
{
cookie = (int)_gitQueue.Dequeue();
flag3 = true;
flag = _gitQueue.Count <= 0;
}
}
if (flag3)
{
Proxy.RevokeObject(cookie);
}
}
}
else if (_gitQueue.Count > 0)
{
lock (_gitQueue)
{
if ((_gitQueue.Count > 0) && (_QueuedItemsCount < 0x19))
{
try
{
ThreadPool.QueueUserWorkItem(new WaitCallback(ServicedComponentProxy.RevokeAsync), _gitQueue.Count);
Interlocked.Increment(ref _QueuedItemsCount);
}
catch (Exception exception)
{
if ((exception is NullReferenceException) || (exception is SEHException))
{
throw;
}
}
}
}
}
object obj2 = null;
if (_ctxQueue.Count > 0)
{
lock (_ctxQueue)
{
if (_ctxQueue.Count > 0)
{
obj2 = _ctxQueue.Dequeue();
flag2 = _ctxQueue.Count <= 0;
}
}
if (obj2 != null)
{
if (!Util.ExtendedLifetime)
{
Marshal.Release((IntPtr)obj2);
}
else
{
ServicedComponentProxy proxy = (ServicedComponentProxy)obj2;
try
{
proxy.SendDestructionEvents(false);
}
catch (Exception exception2)
{
if ((exception2 is NullReferenceException) || (exception2 is SEHException))
{
throw;
}
}
try
{
proxy.ReleaseContext();
}
catch (Exception exception3)
{
if ((exception3 is NullReferenceException) || (exception3 is SEHException))
{
throw;
}
}
}
}
}
return(flag2 & flag);
}
internal abstract void Init(ServicedComponentProxy scp);
internal void Refresh(ServicedComponentProxy scp)
{
this._scp = new WeakReference(scp, true);
}
void IManagedObjectInfo.GetIObjectControl(out IObjectControl pCtrl)
{
ServicedComponentProxy target = (ServicedComponentProxy)this._scp.Target;
pCtrl = target.GetProxyTearoff() as IObjectControl;
}
internal ServicedComponentStub(ServicedComponentProxy scp)
{
this.Refresh(scp);
}
internal override void Init(ServicedComponentProxy scp)
{
this._scp = scp;
}
private static void ReconnectForPooling(ServicedComponentProxy scp)
{
Type proxiedType = scp.GetProxiedType();
bool isJitActivated = scp.IsJitActivated;
bool isObjectPooled = scp.IsObjectPooled;
bool areMethodsSecure = scp.AreMethodsSecure;
ProxyTearoff proxyTearoff = null;
ServicedComponent server = scp.DisconnectForPooling(ref proxyTearoff);
ServicedComponentProxy newcp = new ServicedComponentProxy(proxiedType, isJitActivated, isObjectPooled, areMethodsSecure, false);
newcp.ConnectForPooling(scp, server, proxyTearoff, false);
EnterpriseServicesHelper.SwitchWrappers(scp, newcp);
if (proxyTearoff != null)
{
Marshal.ChangeWrapperHandleStrength(proxyTearoff, false);
}
Marshal.ChangeWrapperHandleStrength(newcp.GetTransparentProxy(), false);
}