C# Pipeline.Instance类代码示例

        public override object FindObject(Type pluginType, Instance instance)
        {
            _dependencyStack.Push(new BuildDependency(pluginType, instance));

            try
            {
                //clearBuildStack();
                return base.FindObject(pluginType, instance);
            }
            catch (StructureMapException ex)
            {
                _dependencyStack.Pop();

                // Don't log exceptions for inline instances.  I
                // think it would cause more confusion that not
                // because the name is a Guid
                if (!_explicitInstances.Contains(instance))
                {
                    throw;
                }

                _errors.LogError(instance, pluginType, ex, _dependencyStack);

                throw;
            }
        }

        public void Apply(Type pluginType, Instance instance)
        {
            _policies.Where(x => !instance.AppliedPolicies.Contains(x))
                .Each(policy =>
                {
                    try
                    {
                        policy.Apply(pluginType, instance);
                    }
                    finally
                    {
                        instance.AppliedPolicies.Add(policy);
                    }
                });

            var configured = instance.As<IConfiguredInstance>();
            if (configured != null)
            {
                configured.Constructor.GetParameters()
                    .Each(param => param.ForAttribute<StructureMapAttribute>(att => att.Alter(configured, param)));

                configured.SettableProperties()
                    .Each(prop => prop.ForAttribute<StructureMapAttribute>(att => att.Alter(configured, prop)));
            }
        }

 public IEnumerable<IInterceptor> DetermineInterceptors(Type pluginType, Instance instance)
 {
     if (pluginType == typeof(IService))
     {
         yield return new FuncInterceptor<IService>((context, service) => new DecoratorService(instance.Name, service));
     }
 }

 public ValidationError(Type pluginType, Instance instance, Exception exception, MethodInfo method)
 {
     PluginType = pluginType;
     Instance = instance;
     Exception = exception;
     MethodName = method.Name;
 }

 public void FillTypeInto(Type pluginType, Instance instance)
 {
     if (!_instances.ContainsKey(pluginType))
     {
         _instances.Add(pluginType, instance);
     }
 }

 /// <summary>
 /// FOR TESTING ONLY!
 /// </summary>
 /// <param name="pluginType"></param>
 /// <param name="instance"></param>
 /// <param name="inner"></param>
 /// <param name="interceptionPlan"></param>
 public BuildPlan(Type pluginType, Instance instance, IDependencySource inner, IInterceptionPlan interceptionPlan)
 {
     _pluginType = pluginType;
     _instance = instance;
     _inner = inner;
     _interceptionPlan = interceptionPlan;
 }

 public bool Has(Type pluginType, Instance instance)
 {
     return _lock.Read(() => {
         var key = instance.InstanceKey(pluginType);
         return _objects.ContainsKey(key);
     });
 }

        public object Get(Type pluginType, Instance instance, IBuildSession session)
        {
            object result = null;
            int key = instance.InstanceKey(pluginType);
            _lock.EnterUpgradeableReadLock();
            if (_objects.ContainsKey(key))
            {

                result = _objects[key];
                _lock.ExitUpgradeableReadLock();
            }
            else
            {
                _lock.EnterWriteLock();
                try
                {
                    result = buildWithSession(pluginType, instance, session);
                    _objects.Add(key, result);
                }
                finally
                {
                    _lock.ExitWriteLock();
                }
            }

            return result;
        }

        public void LogError(
            Instance instance,
            Type pluginType,
            StructureMapException ex,
            IEnumerable<BuildDependency> dependencies)
        {
            if (_buildErrors.ContainsKey(instance))
            {
                BuildError existingError = _buildErrors[instance];
                addDependenciesToError(instance, dependencies, existingError);
            }

            if (_brokenInstances.Contains(instance))
            {
                return;
            }

            InstanceToken token = ((IDiagnosticInstance) instance).CreateToken();
            var error = new BuildError(pluginType, instance);
            error.Exception = ex;

            _buildErrors.Add(instance, error);

            addDependenciesToError(instance, dependencies, error);
        }

 public IEnumerable<IInterceptor> DetermineInterceptors(Type pluginType, Instance instance)
 {
     if (MatchesType(instance.ReturnedType))
      {
      Expression<Action<IContext, object>> register = (c, o) => c.GetInstance<IEventPublisher>().Subscribe(o);
      yield return new ActivatorInterceptor<object>(register);
      }
 }

        public static Expression WrapFunc(Type returnType, Instance instance, Expression inner)
        {
            var push = Expression.Call(Parameters.Session, PushMethod, Expression.Constant(instance));
            var block = Expression.Block(returnType, push, inner);
            var pop = Expression.Call(Parameters.Session, PopMethod);

            return Expression.TryFinally(block, pop);
        }

 /// <summary>
 /// Applies explicit configuration to an IConfiguredInstance
 /// </summary>
 /// <param name="pluginType"></param>
 /// <param name="instance"></param>
 public void Apply(Type pluginType, Instance instance)
 {
     var configured = instance as IConfiguredInstance;
     if (configured != null)
     {
         apply(pluginType, configured);
     }
 }

        public void Eject(Type pluginType, Instance instance)
        {
            var key = new InstanceKey(instance, pluginType);
            if (!_objects.Has(key)) return;

            var disposable = _objects[key] as IDisposable;
            _objects.Remove(key);
            disposable.SafeDispose();
        }

 public IEnumerable<IInterceptor> DetermineInterceptors(Type pluginType, Instance instance)
 {
     if (_filter(pluginType, instance))
     {
         var interceptorType = typeof(DynamicProxyInterceptor<>).MakeGenericType(pluginType);
         var interceptor = (IInterceptor)Activator.CreateInstance(interceptorType, new object[] { _interceptionBehaviors });
         yield return interceptor;
     }
 }

        public object Get(Type pluginType, Instance instance, IBuildSession session)
        {
            var @object = session.BuildNewInSession(pluginType, instance);
            if (@object is IDisposable)
            {
                _tracked.Add(@object);
            }

            return @object;
        }