We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Activation \ LocalActivator

SSCLI

// ==++==
//
//
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
//
// ==--==
/*============================================================
**
** File: ActivationServices.cs
**
** Author(s):
**
** Purpose:
**
**
===========================================================*/
namespace System.Runtime.Remoting.Activation
{
using System;
using System.Security;
using System.Threading;
using System.Runtime.InteropServices;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Contexts;
using System.Runtime.Remoting.Proxies;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Metadata;
using System.Collections;
using System.Reflection;
using System.IO;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Globalization;
using System.Runtime.CompilerServices;
// Implements various activation services
static internal class ActivationServices
{
private static IActivator activator = null;
private static Hashtable _proxyTable = new Hashtable();
private static Type proxyAttributeType = typeof(System.Runtime.Remoting.Proxies.ProxyAttribute);
private static ProxyAttribute _proxyAttribute = new ProxyAttribute();
[ThreadStaticAttribute()]
static internal ActivationAttributeStack _attributeStack;
internal const string ActivationServiceURI = "RemoteActivationService.rem";
internal const string RemoteActivateKey = "Remote";
internal const string PermissionKey = "Permission";
internal const string ConnectKey = "Connect";
//1 private static LocalActivator localActivator = null;
// ActivationListener is the object that listens to incoming
// activation requests. It delegates the incoming request to
// the local activator.
//2 private static ActivationListener ActivationListener = null;
//3 private static Object staticSyncObject = new Object();
//4 private static bool bInitializing = false;
// This gets called upon the first attempt to activate
// anything that is ContextBound or MarshalByRef
private static void Startup()
{
DomainSpecificRemotingData remData = Thread.GetDomain().RemotingData;
// wait on the lock if a)activation has not been initialized yet
// or b) activation is being initialized by another thread!
if ((!remData.ActivationInitialized) || remData.InitializingActivation) {
object configLock = remData.ConfigLock;
bool fLocked = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
Monitor.ReliableEnter(configLock, ref fLocked);
remData.InitializingActivation = true;
// Ensure that some other thread did not complete
// the work while we were waiting on the lock.
if (!remData.ActivationInitialized) {
// Startup the activation service
BCLDebug.Trace("REMOTE", "Starting up activation service ", Thread.CurrentContext);
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// NOTE: This should be the first step in Startup!
// Otherwise activation will recurse, when we try
// to create the ActivationListener (which is MarshalByRef)
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
remData.LocalActivator = new LocalActivator();
// Add the Lifetime service property to the appdomain.
// For now we are assuming that this is the only property
// If there are more properties, then an existing array
// will need to be expanded to add this property
// This is activated in RemotingServices.DomainSpecificRemotingData()
// IContextProperty[] contextProperties = new IContextProperty[1];
// contextProperties[0] = new System.Runtime.Remoting.LeaseLifeTimeServiceProperty();
// Thread.GetDomain().RemotingData.AppDomainContextProperties = contextProperties;
remData.ActivationListener = new ActivationListener();
remData.ActivationInitialized = true;
}
remData.InitializingActivation = false;
}
//lock (remData)
finally {
if (fLocked) {
Monitor.Exit(configLock);
}
}
}
}
private static void InitActivationServices()
{
// If activation services has not been loaded do it now and create
// the instace that will service the activation requests.
if (null == activator) {
activator = GetActivator();
if (null == activator) {
Message.DebugOut("Fatal Error... Could not create activator\n");
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_BadInternalState_ActivationFailure")));
}
}
}
// Determine whether the current context is ok for the activation.
private static MarshalByRefObject IsCurrentContextOK(Type serverType, object[] props, bool bNewObj)
{
BCLDebug.Assert(!serverType.IsInterface, "!serverType.IsInterface");
MarshalByRefObject retObj = null;
// Initialize activation services if needed.
// (we temporary null out the activation attributes in case
// InitActivationServices creates an MBR).
InitActivationServices();
// Obtain the method info which will create an instance
// of type RealProxy
ProxyAttribute pa = GetProxyAttribute(serverType);
BCLDebug.Assert(null != pa, "null != pa");
if (Object.ReferenceEquals(pa, DefaultProxyAttribute))
retObj = pa.CreateInstanceInternal(serverType);
else {
retObj = pa.CreateInstance(serverType);
// We called a custom proxy attribute .. make sure it is
// returning a server of the correct type.
if (retObj != null) {
// If a transparent proxy is returned we are fine.
// If not then the object's type MUST be compatible
// with the type we were requested to activate!
if (!RemotingServices.IsTransparentProxy(retObj) && !serverType.IsAssignableFrom(retObj.GetType())) {
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Activation_BadObject"), serverType));
}
}
}
BCLDebug.Assert(null != retObj, "null != retObj");
return retObj;
}
// For types with no proxy attribute, we take the default route of
// querying attributes if the current context is suitable for
// activation.
private static bool IsCurrentContextOK(Type serverType, object[] props, ref ConstructorCallMessage ctorCallMsg)
{
//Get callSite attributes
object[] callSiteAttr = PeekActivationAttributes(serverType);
// Clear from the attribute stack
if (callSiteAttr != null) {
PopActivationAttributes(serverType);
}
object[] womAttr = new object[1];
womAttr[0] = GetGlobalAttribute();
// Get the type context attributes
object[] typeAttr = GetContextAttributesForType(serverType);
// Get the client context (current context)
Context cliCtx = Thread.CurrentContext;
// Create a ctorCallMsg with the reqd info
ctorCallMsg = new ConstructorCallMessage(callSiteAttr, womAttr, typeAttr, serverType);
// This is the activator that handles activation in *all* cases
// Based on whether what the activation attributes do.... other
// activators may get chained ahead of this one and may take
// over the activation process... (possibly) delegating to this
// only in the last stage.
// Note: currently, this does not get used in the same context (MBR)
// scenarios ... because of the 2-step activation model of JIT.
ctorCallMsg.Activator = new ConstructionLevelActivator();
// Ask all attributes if they are happy with the current context
// NOTE: if someone says no, we do not ask the rest of the attributes
// This is why, womAttr (which is the global activation service
// attribute) *must* be the first one we query.
bool bCtxOK = QueryAttributesIfContextOK(cliCtx, ctorCallMsg, womAttr);
if (bCtxOK == true) {
bCtxOK = QueryAttributesIfContextOK(cliCtx, ctorCallMsg, callSiteAttr);
if (bCtxOK == true) {
bCtxOK = QueryAttributesIfContextOK(cliCtx, ctorCallMsg, typeAttr);
}
}
return bCtxOK;
}
private static void CheckForInfrastructurePermission(Assembly asm)
{
// Make a security check to ensure that the context attribute
// is from a trusted assembly!
if (asm != RemotingServices.s_MscorlibAssembly) {
CodeAccessSecurityEngine.CheckAssembly(asm, RemotingServices.s_RemotingInfrastructurePermission);
}
}
private static bool QueryAttributesIfContextOK(Context ctx, IConstructionCallMessage ctorMsg, object[] attributes)
{
bool bCtxOK = true;
if (attributes != null) {
for (int i = 0; i < attributes.Length; i++) {
// All the attributes, including callsite attributes should
// expose IContextAttribute. If not, then we throw an
// exception.
IContextAttribute attr = attributes[i] as IContextAttribute;
if (null != attr) {
Assembly asm = attr.GetType().Assembly;
// Make a security check to ensure that the context attribute
// is from a trusted assembly!
CheckForInfrastructurePermission(asm);
bCtxOK = attr.IsContextOK(ctx, ctorMsg);
if (bCtxOK == false) {
break;
}
}
else {
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_BadAttribute"));
}
}
}
return bCtxOK;
}
static internal void GetPropertiesFromAttributes(IConstructionCallMessage ctorMsg, object[] attributes)
{
if (attributes != null) {
for (int i = 0; i < attributes.Length; i++) {
// All the attributes, including callsite attributes should
// expose IContextAttribute. If not, then we throw an
// exception.
IContextAttribute attr = attributes[i] as IContextAttribute;
if (null != attr) {
Assembly asm = attr.GetType().Assembly;
// Make a security check to ensure that the context attribute
// is from a trusted assembly!
CheckForInfrastructurePermission(asm);
// We ask each attribute to contribute its properties.
// The attributes can examine the current list of properties
// from the ctorCallMsg and decide which properties to add.
// They can also tweak the Activator chain during this process
attr.GetPropertiesForNewContext(ctorMsg);
}
else {
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_BadAttribute"));
}
}
}
}
// Return the default implementation of the proxy attribute
static internal ProxyAttribute DefaultProxyAttribute {
get { return _proxyAttribute; }
}
// Iterate over the custom attributes of the class and see if it
// defines a ProxyAttribute. If one is not defined then return
// the default proxy attribute defined by us.
static internal ProxyAttribute GetProxyAttribute(Type serverType)
{
BCLDebug.Assert(serverType.IsMarshalByRef, "type should be at least marshal-by-ref");
if (!serverType.HasProxyAttribute)
return DefaultProxyAttribute;
// Type has a non-default proxy attribute ... see if we have
// it cached?
ProxyAttribute pa = _proxyTable[serverType] as ProxyAttribute;
if (pa == null) {
object[] ca = Attribute.GetCustomAttributes(serverType, proxyAttributeType, true);
if ((null != ca) && (0 != ca.Length)) {
if (!serverType.IsContextful) {
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_MBR_ProxyAttribute"));
}
pa = ca[0] as ProxyAttribute;
}
BCLDebug.Assert(pa != null, "expect proxy attribute");
if (!_proxyTable.Contains(serverType)) {
lock (_proxyTable) {
if (!_proxyTable.Contains(serverType)) {
// Create a new entry
_proxyTable.Add(serverType, pa);
}
}
}
}
return pa;
}
// Creates either an uninitialized object or a proxy depending on
// whether the current context is OK or not.
static internal MarshalByRefObject CreateInstance(Type serverType)
{
// Use our activation implementation
MarshalByRefObject retObj = null;
ConstructorCallMessage ctorCallMsg = null;
bool bCtxOK = IsCurrentContextOK(serverType, null, ref ctorCallMsg);
if (bCtxOK && !serverType.IsContextful) {
// Marshal by ref case
Message.DebugOut("Allocating blank marshal-by-ref object");
// We create an uninitialized instance of the actual type and
// let the regular jit-activation execute the constructor on it.
retObj = RemotingServices.AllocateUninitializedObject(serverType);
}
else {
// (context not OK) || (serverType is Contextful)
// We always return a proxy and the jit-activation's attempt
// to execute the constructor gets intercepted by the TP stub
// and routed to RemotingServices.Activate() below.
// if context *is* OK
// this is a contextBound type being activated for which
// we always create a proxy (proxies-everywhere!)
// if context *is not* OK
// this could be a MarshalByRef or ContextBound type
// being activated outside this appDomain
// OR
// this could be a ContextBound type being activated cross-ctx
RemotingProxy rp;
// See if the object-type is configured for Connect (with a URL)
retObj = (MarshalByRefObject)ConnectIfNecessary(ctorCallMsg);
if (retObj == null) {
// not configured for connect, take the usual route of
// creating a proxy
Message.DebugOut("Creating remoting proxy for " + serverType.FullName + " in context " + Thread.CurrentContext);
rp = new RemotingProxy(serverType);
Message.DebugOut("Created remoting proxy\n");
retObj = (MarshalByRefObject)rp.GetTransparentProxy();
}
else {
Message.DebugOut("NewObj did a Connect!");
rp = (RemotingProxy)RemotingServices.GetRealProxy(retObj);
}
// Store the constructor call message in the proxy
rp.ConstructorMessage = ctorCallMsg;
if (!bCtxOK) {
// Chain in the context level activator now
ContextLevelActivator activator = new ContextLevelActivator();
activator.NextActivator = ctorCallMsg.Activator;
ctorCallMsg.Activator = activator;
}
else {
// Set the flag to indicate that the activation
// will not be leaving the client context .. in this case
// the default construction level activator is enough
// to complete the activation process.
ctorCallMsg.ActivateInContext = true;
}
}
return retObj;
}
//
// NOTE: This is an internal method used by RemotingProxy to do Activation
//
// Starts off the activation chain by sending the constructor call message to
// the activator or the client context sink chain. On return, a constructor
// return message is made and the out parameters are propagated.
//
static internal IConstructionReturnMessage Activate(RemotingProxy remProxy, IConstructionCallMessage ctorMsg)
{
IConstructionReturnMessage ctorRetMsg = null;
if (((ConstructorCallMessage)ctorMsg).ActivateInContext) {
// The current context was approved for activation
BCLDebug.Assert(ctorMsg.Activator.Level == ActivatorLevel.Construction, "activator level must ActivatorLevel.Construction!");
// This has to be a ContextBound type (proxies-everywhere)
BCLDebug.Assert(ctorMsg.ActivationType.IsContextful, "Inconsistent state during activation");
// Ask the activator in the message to take over
ctorRetMsg = ctorMsg.Activator.Activate(ctorMsg);
if (ctorRetMsg.Exception != null) {
throw ctorRetMsg.Exception;
}
}
else {
// Client context was not approved for activation ...
BCLDebug.Assert(ctorMsg.Activator.Level >= ActivatorLevel.Context, "activator level must be at least x-context!");
// Check with ActivationServices if we did a "Connect" with
// a remote server during IsContextOK
BCLDebug.Assert(ActivationServices.CheckIfConnected(remProxy, ctorMsg) == null, "We shouldn't come through this path on a Connect.");
// Client context was not approved for activation ...
// This is the more elaborate (real) activation case i.e.
// we have to go at least out of the client context to
// finish the work.
// Prepare for the handoff to Activation Service
// Ask various attributes to contribute properties
// The attributes may chain in other activators into
// the activation chain (to hijack/participate in
// the activation process).
ActivationServices.GetPropertiesFromAttributes((IConstructionCallMessage)ctorMsg, ctorMsg.CallSiteActivationAttributes);
ActivationServices.GetPropertiesFromAttributes(ctorMsg, ((ConstructorCallMessage)ctorMsg).GetWOMAttributes());
ActivationServices.GetPropertiesFromAttributes((IConstructionCallMessage)ctorMsg, ((ConstructorCallMessage)ctorMsg).GetTypeAttributes());
// Fetch the client context chain
IMessageSink cliCtxChain = Thread.CurrentContext.GetClientContextChain();
// Ask the client context chain to take over from here.
IMethodReturnMessage retMsg = (IMethodReturnMessage)cliCtxChain.SyncProcessMessage(ctorMsg);
ctorRetMsg = retMsg as IConstructionReturnMessage;
if (null == retMsg) {
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_Failed"));
}
else if (retMsg.Exception != null) {
throw retMsg.Exception;
}
}
// Note: PropagateOutParameters is now handled by RealProxy
// CallContext from retMsg should be already set by RealProxy
BCLDebug.Assert(null != ctorRetMsg, "Activate returning null ConstructorReturnMessage");
return ctorRetMsg;
}
// This function is called by ActivationServices in case
// the activation needs to be within the same appdomain. These
// are only for ContextBound types.
// It is also called to do satisfy remote incoming requests from
// the activation services. These could be for both ContextBound
// and MarshalByRef types.
static internal IConstructionReturnMessage DoCrossContextActivation(IConstructionCallMessage reqMsg)
{
bool bCtxBound = reqMsg.ActivationType.IsContextful;
Context serverContext = null;
if (bCtxBound) {
// If the type is context bound, we need to create
// the appropriate context and activate the object inside
// it.
// Create a new Context
serverContext = new Context();
ArrayList list = (ArrayList)reqMsg.ContextProperties;
Assembly asm = null;
for (int i = 0; i < list.Count; i++) {
IContextProperty prop = list[i] as IContextProperty;
if (null == prop) {
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_BadAttribute"));
}
asm = prop.GetType().Assembly;
// Make a security check to ensure that the context property
// is from a trusted assembly!
CheckForInfrastructurePermission(asm);
// This ensures that we don't try to add duplicate
// attributes (eg. type attributes common on both client
// and server end)
if (serverContext.GetProperty(prop.Name) == null) {
serverContext.SetProperty(prop);
}
}
// No more property changes to the server context from here.
serverContext.Freeze();
// (This seems like an overkill but that is how it is spec-ed)
// Ask each of the properties in the context we formed from
// if it is happy with the current context.
for (int i = 0; i < list.Count; i++) {
if (!((IContextProperty)list[i]).IsNewContextOK(serverContext)) {
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_PropertyUnhappy"));
}
}
}
IConstructionReturnMessage replyMsg;
InternalCrossContextDelegate xctxDel = new InternalCrossContextDelegate(DoCrossContextActivationCallback);
object[] args = new object[] {reqMsg};
if (bCtxBound) {
replyMsg = Thread.CurrentThread.InternalCrossContextCallback(serverContext, xctxDel, args) as IConstructionReturnMessage;
}
else {
replyMsg = xctxDel(args) as IConstructionReturnMessage;
}
return replyMsg;
}
static internal object DoCrossContextActivationCallback(object[] args)
{
IConstructionCallMessage reqMsg = (IConstructionCallMessage)args[0];
IConstructionReturnMessage replyMsg = null;
// call the first sink in the server context chain
IMethodReturnMessage retMsg = (IMethodReturnMessage)Thread.CurrentContext.GetServerContextChain().SyncProcessMessage(reqMsg);
Exception e = null;
replyMsg = retMsg as IConstructionReturnMessage;
if (null == replyMsg) {
if (retMsg != null) {
e = retMsg.Exception;
}
else {
e = new RemotingException(Environment.GetResourceString("Remoting_Activation_Failed"));
}
replyMsg = new ConstructorReturnMessage(e, null);
// We have created our own message ... transfer the callcontext
// from the request message.
((ConstructorReturnMessage)replyMsg).SetLogicalCallContext((LogicalCallContext)reqMsg.Properties[Message.CallContextKey]);
}
return replyMsg;
}
static internal IConstructionReturnMessage DoServerContextActivation(IConstructionCallMessage reqMsg)
{
BCLDebug.Assert(reqMsg != null, "NULL ctorReqMsg");
Exception e = null;
Type serverType = reqMsg.ActivationType;
object serverObj = ActivateWithMessage(serverType, reqMsg, null, out e);
IConstructionReturnMessage replyMsg = SetupConstructionReply(serverObj, reqMsg, e);
BCLDebug.Assert(replyMsg != null, "NULL ctorRetMsg");
return replyMsg;
}
static internal IConstructionReturnMessage SetupConstructionReply(object serverObj, IConstructionCallMessage ctorMsg, Exception e)
{
IConstructionReturnMessage replyMsg = null;
if (e == null) {
replyMsg = new ConstructorReturnMessage((MarshalByRefObject)serverObj, null, 0, (LogicalCallContext)ctorMsg.Properties[Message.CallContextKey], ctorMsg);
}
else {
replyMsg = new ConstructorReturnMessage(e, null);
// We have created our own message ... transfer the callcontext
// from the request message.
((ConstructorReturnMessage)replyMsg).SetLogicalCallContext((LogicalCallContext)ctorMsg.Properties[Message.CallContextKey]);
}
return replyMsg;
}
static internal object ActivateWithMessage(Type serverType, IMessage msg, ServerIdentity srvIdToBind, out Exception e)
{
object server = null;
e = null;
// Create a blank instance!
server = RemotingServices.AllocateUninitializedObject(serverType);
object proxyForObject = null;
if (serverType.IsContextful) {
if (msg is ConstructorCallMessage) {
// If it is a strictly x-context activation then
// this pointer for the message is the TP that we
// returned to JIT in first phase of activation
proxyForObject = ((ConstructorCallMessage)msg).GetThisPtr();
}
else {
// we are out of the app-domain, so wrap this object now
proxyForObject = null;
}
// This associates the proxy with the real object and sets
// up the proxy's native context, ID etc.
proxyForObject = RemotingServices.Wrap((ContextBoundObject)server, proxyForObject, false);
BCLDebug.Assert(RemotingServices.IsTransparentProxy(proxyForObject), "Wrapped object should be a transparent proxy");
}
else {
// Since this is an MBR type, something really bad
// happened if we are not in the default context
if (Thread.CurrentContext != Context.DefaultContext) {
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_Failed"));
}
// Marshal-by-ref case we just return the naked object
proxyForObject = server;
}
// Create the dispatcher which will help run the CTOR
IMessageSink dispatcher = (IMessageSink)new StackBuilderSink(proxyForObject);
// This call runs the CTOR on the object
IMethodReturnMessage retMsg = (IMethodReturnMessage)dispatcher.SyncProcessMessage(msg);
if (retMsg.Exception == null) {
if (serverType.IsContextful) {
// call wrap to finish the operation.
return RemotingServices.Wrap((ContextBoundObject)server);
}
else {
return server;
}
}
else {
e = retMsg.Exception;
return null;
}
}
static internal void StartListeningForRemoteRequests()
{
// Get the activation services set up.
Startup();
DomainSpecificRemotingData remData = Thread.GetDomain().RemotingData;
if (!remData.ActivatorListening) {
object configLock = remData.ConfigLock;
bool fLocked = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
Monitor.ReliableEnter(configLock, ref fLocked);
if (!remData.ActivatorListening) {
BCLDebug.Log("Registering remoting activator");
// Marshal the object so that it is ready to take remote
// calls. We have to create the objref because that is when
// the channels start listening for requests.
RemotingServices.MarshalInternal(Thread.GetDomain().RemotingData.ActivationListener, ActivationServiceURI, typeof(System.Runtime.Remoting.Activation.IActivator));
ServerIdentity srvID = (ServerIdentity)IdentityHolder.ResolveIdentity(ActivationServiceURI);
// Set Singleton to prevent lease from being created
srvID.SetSingletonObjectMode();
//DBG Console.WriteLine("Activator URI: = " + activatorURI);
remData.ActivatorListening = true;
}
}
finally {
if (fLocked) {
Monitor.Exit(configLock);
}
}
}
}
// This returns the local activator
static internal IActivator GetActivator()
{
DomainSpecificRemotingData remData = Thread.GetDomain().RemotingData;
if (remData.LocalActivator == null) {
Startup();
}
return (IActivator)remData.LocalActivator;
}
static internal void Initialize()
{
GetActivator();
}
// This returns the attribute that takes part in every activation
// The local activator itself exposes that functionality
static internal ContextAttribute GetGlobalAttribute()
{
DomainSpecificRemotingData remData = Thread.GetDomain().RemotingData;
if (remData.LocalActivator == null) {
Startup();
}
return (ContextAttribute)remData.LocalActivator;
}
// This function returns the array of custom attributes of
// type "ContextAttribute" walking the entire class hierarchy
// of the serverType
// If duplicates are found the attribute on the more derived
// type is kept.
// The return array may be sparse and is terminated by a NULL.
static internal IContextAttribute[] GetContextAttributesForType(Type serverType)
{
if (!(typeof(ContextBoundObject).IsAssignableFrom(serverType)) || serverType.IsCOMObject) {
return new ContextAttribute[0];
}
Type currType = serverType;
object[] currAttr = null;
int retSize = 8;
IContextAttribute[] retAttr = new IContextAttribute[retSize];
int numAttr = 0;
// Obtain the custom attributes that implement
// IContextAttribute for this type
currAttr = currType.GetCustomAttributes(typeof(IContextAttribute), true);
// recursively on the typeHierarchy
bool bDupe;
foreach (IContextAttribute attr in currAttr) {
Type attrType = attr.GetType();
bDupe = false;
for (int i = 0; i < numAttr; i++) {
if (attrType.Equals(retAttr[i].GetType())) {
bDupe = true;
break;
}
}
if (!bDupe) {
// We must add this attribute to our list
numAttr++;
// Check if we have enough space to store it
// Leaving one spot for a NULL value!
if (numAttr > retSize - 1) {
IContextAttribute[] newAttr = new IContextAttribute