C# IKernel.ReleaseComponent方法代码示例

		/// <summary>
		/// Obtains the interceptors associated with the component.
		/// </summary>
		/// <param name="kernel">The kernel instance</param>
		/// <param name="model">The component model</param>
		/// <param name="context">The creation context</param>
		/// <returns>interceptors array</returns>
		protected IInterceptor[] ObtainInterceptors(IKernel kernel, ComponentModel model, CreationContext context)
		{
			var interceptors = new List<IInterceptor>();
			foreach (IReference<IInterceptor> interceptorRef in GetInterceptorsFor(model))
			{
				try
				{
					var interceptor = interceptorRef.Resolve(kernel, context);
					SetOnBehalfAware(interceptor as IOnBehalfAware, model);
					interceptors.Add(interceptor);
				}
				catch (Exception e)
				{
					foreach (var interceptor in interceptors)
					{
						kernel.ReleaseComponent(interceptor);
					}

					if(e is InvalidCastException)
					{
						var message = String.Format(
						"An interceptor registered for {0} doesn't implement the {1} interface",
						model.Name, typeof(IInterceptor).Name);

						throw new DependencyResolverException(message);
					}
					throw;
				}
			}

			return interceptors.ToArray();
		}

 private void OnCreateTaskWizardViewModel(IKernel k, TaskWizardViewModel o)
 {
     o.Closed += (s, e) =>
     {
         k.ReleaseComponent(o);
     };
 }

		private void ReleaseHook(ProxyGenerationOptions proxyGenOptions, IKernel kernel)
		{
			if (proxyGenOptions.Hook == null)
			{
				return;
			}
			kernel.ReleaseComponent(proxyGenOptions.Hook);
		}

        private static CloudQueueClient CreateCloudQueueClient(IKernel kernel)
        {
            var storageAccount = kernel.Resolve<CloudStorageAccount>();
            CloudQueueClient client = storageAccount.CreateCloudQueueClient();
            kernel.ReleaseComponent(storageAccount);

            return client;
        }

        private static CloudStorageAccount CreateCloudStorageAccount(IKernel kernel)
        {
            // Get Azure configurations
            var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
            string storageConnectionString = configRetriever.GetSetting(StorageConnectionStringAppSettingsKey);
            kernel.ReleaseComponent(configRetriever);

            return CloudStorageAccount.Parse(storageConnectionString);
        }

        private static LeaseManagerConfig CreateLeaseManagerConfig(IKernel kernel)
        {
            // Configure the lease manager
            var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
            var leaseManagerConfig = new LeaseManagerConfig { LeaseName = "SampleDataJobs", UniqueId = configRetriever.UniqueInstanceId };
            kernel.ReleaseComponent(configRetriever);

            return leaseManagerConfig;
        }

        private static MediaServicesCredentials CreateCredentials(IKernel kernel)
        {
            // Get Azure configurations
            var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
            string mediaServicesAccountName = configRetriever.GetSetting(MediaServicesNameAppSettingsKey);
            string mediaServicesAccountKey = configRetriever.GetSetting(MediaServicesKeyAppSettingsKey);
            kernel.ReleaseComponent(configRetriever);

            // Return the credentials
            return new MediaServicesCredentials(mediaServicesAccountName, mediaServicesAccountKey);
        }

 private static ISession CreateSession(IKernel kernel)
 {
     var sessionFactory = kernel.Resolve<ISessionFactory>();
     try
     {
         return sessionFactory.OpenSession();
     }
     finally
     {
         kernel.ReleaseComponent(sessionFactory);
     }
 }

        private static YouTubeService CreateYouTubeService(IKernel kernel)
        {
            var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
            string apiKey = configRetriever.GetSetting(YouTubeApiKey);
            kernel.ReleaseComponent(configRetriever);

            // Create client for YouTube API
            var youTubeInit = new BaseClientService.Initializer
            {
                ApiKey = apiKey,
                ApplicationName = "KillrVideo.SampleData.Worker"
            };
            return new YouTubeService(youTubeInit);
        }

        private static ISession CreateCassandraSession(IKernel kernel)
        {
            // Get cluster IP/host and keyspace from .config file
            var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
            string clusterLocation = configRetriever.GetSetting(ClusterLocationAppSettingsKey);
            kernel.ReleaseComponent(configRetriever);

            // Start a cluster builder for connecting to Cassandra
            Builder builder = Cluster.Builder();

            // Allow multiple comma delimited locations to be specified in the configuration
            string[] locations = clusterLocation.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(l => l.Trim()).ToArray();
            foreach (string location in locations)
            {
                string[] hostAndPort = location.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
                if (hostAndPort.Length == 1)
                {
                    // Just an IP address or host name
                    builder = builder.AddContactPoint(hostAndPort[0]);
                }
                else if (hostAndPort.Length == 2)
                {
                    // IP Address plus host name
                    var ipEndPoint = new IPEndPoint(IPAddress.Parse(hostAndPort[0]), int.Parse(hostAndPort[1]));
                    builder = builder.AddContactPoint(ipEndPoint);
                }
                else
                {
                    throw new InvalidOperationException(string.Format("Unable to parse Cassandra cluster location '{0}' from configuration.", location));
                }
            }

            // Use the Cluster builder to create a cluster
            Cluster cluster = builder.Build();

            // Use the cluster to connect a session to the appropriate keyspace
            ISession session;
            try
            {
                session = cluster.Connect(Keyspace);
            }
            catch (Exception e)
            {
                Logger.Error(string.Format("Exception while connecting to keyspace '{0}' using hosts '{1}'", Keyspace, clusterLocation), e);
                throw;
            }

            return session;
        }

		public void SetUp()
		{
			kernel = new DefaultKernel();

			kernel.AddFacility<StartableFacility>();

			kernel.Register(
				Component.For<StartableDisposableAndInitializableComponent>()
					.LifeStyle.Transient
				);

			component = kernel.Resolve<StartableDisposableAndInitializableComponent>();
			component.DoSomething();
			kernel.ReleaseComponent(component);

			calledMethods = component.calledMethods;
		}

        private static INotificationEndPoint CreateNotificationEndPoint(IKernel kernel)
        {
            var cloudMediaContext = kernel.Resolve<CloudMediaContext>();
            var cloudQueueClient = kernel.Resolve<CloudQueueClient>();

            try
            {
                // ReSharper disable once ReplaceWithSingleCallToFirstOrDefault
                INotificationEndPoint endpoint = cloudMediaContext.NotificationEndPoints
                                                                   .Where(ep => ep.Name == UploadConfig.NotificationQueueName)
                                                                   .FirstOrDefault();
                if (endpoint != null)
                    return endpoint;

                // Make sure the queue exists in Azure Storage
                var notificationQueue = cloudQueueClient.GetQueueReference(UploadConfig.NotificationQueueName);
                notificationQueue.CreateIfNotExists();

                // Create the endpoint
                return cloudMediaContext.NotificationEndPoints.Create(UploadConfig.NotificationQueueName, NotificationEndPointType.AzureQueue,
                                                                       UploadConfig.NotificationQueueName);
            }
            finally
            {
                kernel.ReleaseComponent(cloudMediaContext);
                kernel.ReleaseComponent(cloudQueueClient);
            }
        }

		/// <summary>
		/// Obtains the interceptors associated with the component.
		/// </summary>
		/// <param name="kernel">The kernel instance</param>
		/// <param name="model">The component model</param>
		/// <param name="context">The creation context</param>
		/// <returns>interceptors array</returns>
		protected IInterceptor[] ObtainInterceptors(IKernel kernel, ComponentModel model, CreationContext context)
		{
			var interceptors = new List<IInterceptor>();
			foreach (var interceptorRef in GetInterceptorsFor(model))
			{
				var handler = GetInterceptorHandler(interceptorRef, kernel);
				if (handler == null)
				{
					// This should be virtually impossible to happen
					// Seriously!
					throw new DependencyResolverException(string.Format("The interceptor {0} could not be resolved", interceptorRef));
				}

				if(handler.IsBeingResolvedInContext(context))
				{
					throw new DependencyResolverException(
						string.Format(
							"Cycle detected - interceptor {0} wants to use itself as its interceptor. This usually signifies a bug in custom {1}",
							handler.ComponentModel.Name, typeof(IModelInterceptorsSelector).Name));
				}

				try
				{
					var contextForInterceptor = RebuildContext(handler.Service, context);
					var interceptor = (IInterceptor)handler.Resolve(contextForInterceptor);

					interceptors.Add(interceptor);

					SetOnBehalfAware(interceptor as IOnBehalfAware, model);
				}
				catch (Exception e)
				{
					foreach (var interceptor in interceptors)
					{
						kernel.ReleaseComponent(interceptor);
					}

					if(e is InvalidCastException)
					{
						var message = String.Format(
						"An interceptor registered for {0} doesn't implement the {1} interface",
						model.Name, typeof(IInterceptor).Name);

						throw new DependencyResolverException(message);
					}
					throw;
				}
			}

			return interceptors.ToArray();
		}