C# ServiceContext类代码示例

		/// <summary>
		/// Creates a new instance, using the init parameters of a <see cref="StatefulService"/>
		/// </summary>
		/// <param name="receiver">(Required) Processes incoming messages.</param>
		/// <param name="context">(Optional) The context that was used to init the Reliable Service that uses this listener.</param>
		/// <param name="serviceBusQueueName">The name of the monitored Service Bus Queue</param>
		/// <param name="serviceBusSendConnectionString">(Optional) A Service Bus connection string that can be used for Sending messages. 
		/// (Returned as Service Endpoint.) When not supplied, an App.config appSettings value with key 'Microsoft.ServiceBus.ConnectionString.Receive'
		///  is used.</param>
		/// <param name="serviceBusReceiveConnectionString">(Optional) A Service Bus connection string that can be used for Receiving messages. 
		///  When not supplied, an App.config appSettings value with key 'Microsoft.ServiceBus.ConnectionString.Receive'
		///  is used.</param>
		public ServiceBusQueueCommunicationListener(IServiceBusMessageReceiver receiver, ServiceContext context, string serviceBusQueueName, string serviceBusSendConnectionString = null, string serviceBusReceiveConnectionString = null)
			: base(receiver, context, serviceBusSendConnectionString, serviceBusReceiveConnectionString)
		{
			if (string.IsNullOrWhiteSpace(serviceBusQueueName)) throw new ArgumentOutOfRangeException(nameof(serviceBusQueueName));

			ServiceBusQueueName = serviceBusQueueName;
		}

 public void CreateDomainManager()
 {
     var context = new ServiceContext();
     _domainManager = new DomainManager();
     context.Add(_domainManager);
     context.ServiceManager.StartServices();
 }

 public void CreateServiceContext()
 {
     var services = new ServiceContext();
     _runtimeService = new RuntimeFrameworkService();
     services.Add(_runtimeService);
     services.ServiceManager.StartServices();
 }

	static void Main(string[] args)
	{
		var ctx = new ServiceContext();
		var service = new AgentService();
		service.Launch(12000);
		ctx.Run();
	}

 public WebHostCommunicationListener(ServiceContext serviceContext, string appPath, string endpointName, Func<string, ServiceCancellation, IWebHost> build)
 {
     this.serviceContext = serviceContext;
     this.endpointName = endpointName;
     this.build = build;
     this.appPath = appPath;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="OrleansCommunicationListener" /> class.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="configuration">The configuration.</param>
        public OrleansCommunicationListener(ServiceContext context, ClusterConfiguration configuration)
        {
            this.configuration = configuration;
            if (this.configuration == null)
            {
                this.configuration = new ClusterConfiguration();
                this.configuration.StandardLoad();
            }

            this.SiloName = Regex.Replace(context.ServiceName.PathAndQuery.Trim('/'), "[^a-zA-Z0-9_]", "_") + "_" +
                            context.ReplicaOrInstanceId.ToString("X");

            // Gather configuration from Service Fabric.
            var activation = context.CodePackageActivationContext;
            var endpoints = activation.GetEndpoints();
            var siloEndpoint = GetEndpoint(endpoints, "OrleansSiloEndpoint");
            var gatewayEndpoint = GetEndpoint(endpoints, "OrleansProxyEndpoint");

            // Set the endpoints according to Service Fabric configuration.
            var nodeConfig = this.configuration.Defaults;
            if (string.IsNullOrWhiteSpace(nodeConfig.HostNameOrIPAddress))
            {
                nodeConfig.HostNameOrIPAddress = context.NodeContext.IPAddressOrFQDN;
            }

            nodeConfig.Port = siloEndpoint.Port;
            nodeConfig.ProxyGatewayEndpoint = new IPEndPoint(nodeConfig.Endpoint.Address, gatewayEndpoint.Port);
        }

 public void CreateServiceContext()
 {
     var services = new ServiceContext();
     _projectService = new ProjectService();
     services.Add(_projectService);
     services.ServiceManager.StartServices();
 }

        public static void SetConfigurationValue(ServiceContext context, string package, string section, string name, string value)
        {
            MockCodePackageActivationContext mockContext = context.CodePackageActivationContext as MockCodePackageActivationContext;
            if (mockContext == null)
            {
                throw new ArgumentException("MockCodePackageActivationContext expected");
            }

            ConfigurationPackage config;
            if (!mockContext.GetConfigurationPackageNames().Contains(package))
            {
                config = CreateConfigurationPackage();
                mockContext.AddConfigurationPackage(package, config);
            }
            else
            {
                config = mockContext.GetConfigurationPackageObject(package);
            }

            System.Fabric.Description.ConfigurationSettings settings = config.Settings;
            if (!settings.Sections.Contains(section))
            {
                ConfigurationSection newSection = (ConfigurationSection)Activator.CreateInstance(typeof(ConfigurationSection), nonPublic: true);
                typeof(ConfigurationSection).GetProperty("Name").SetValue(newSection, section);
                settings.Sections.Add(newSection);
            }

            var s = settings.Sections[section];

            ConfigurationProperty p = (ConfigurationProperty) Activator.CreateInstance(typeof(ConfigurationProperty), nonPublic: true);
            typeof(ConfigurationProperty).GetProperty("Name").SetValue(p, name);
            typeof(ConfigurationProperty).GetProperty("Value").SetValue(p, value);

            s.Parameters.Add(p);
        }

 public void CreateServiceContext()
 {
     var services = new ServiceContext();
     _factory = new CoreTestRunnerFactory();
     services.Add(_factory);
     services.ServiceManager.StartServices();
 }

 public void SetUp()
 {
     var services = new ServiceContext();
     services.Add(new Services.SettingsService());
     recentFiles = new RecentFilesService();
     services.Add(recentFiles);
 }

        public OwinCommunicationListener(Action<IAppBuilder> startup, ServiceContext serviceContext, ServiceEventSource eventSource, string endpointName, string appRoot)
        {
            if (startup == null)
            {
                throw new ArgumentNullException(nameof(startup));
            }

            if (serviceContext == null)
            {
                throw new ArgumentNullException(nameof(serviceContext));
            }

            if (endpointName == null)
            {
                throw new ArgumentNullException(nameof(endpointName));
            }

            if (eventSource == null)
            {
                throw new ArgumentNullException(nameof(eventSource));
            }

            this.startup = startup;
            this.serviceContext = serviceContext;
            this.endpointName = endpointName;
            this.eventSource = eventSource;
            this.appRoot = appRoot;
        }

        public static AggregationCategorizationService GetService(Cache cache, String userId)
        {

            try
            {
                if (cache["AggCatService_" + userId] == null)
                {
                    string certificateFile = System.Configuration.ConfigurationManager.AppSettings["PrivateKeyPath"];
                    string password = System.Configuration.ConfigurationManager.AppSettings["PrivateKeyPassword"];
                    X509Certificate2 certificate = new X509Certificate2(certificateFile, password);

                    string consumerKey = System.Configuration.ConfigurationManager.AppSettings["ConsumerKey"];
                    string consumerSecret = System.Configuration.ConfigurationManager.AppSettings["ConsumerSecret"];
                    string issuerId = System.Configuration.ConfigurationManager.AppSettings["SAMLIdentityProviderID"];

                    SamlRequestValidator samlValidator = new SamlRequestValidator(certificate, consumerKey, consumerSecret, issuerId, userId);

                    ServiceContext ctx = new ServiceContext(samlValidator);
                    cache.Add("AggCatService_" + userId, new AggregationCategorizationService(ctx), null, DateTime.Now.AddMinutes(50),
                              Cache.NoSlidingExpiration, CacheItemPriority.High, null);
                }
                return (AggregationCategorizationService)cache["AggCatService_" + userId];
            }
            catch (Exception ex)
            {
                throw new Exception("Unable to create AggCatService: " + ex.Message);
            }
        }

        private ICommunicationListener CreateInternalListener(ServiceContext context)
        {
            // Partition replica's URL is the node's IP, port, PartitionId, ReplicaId, Guid
            EndpointResourceDescription internalEndpoint = context.CodePackageActivationContext.GetEndpoint("ProcessingServiceEndpoint");

            // Multiple replicas of this service may be hosted on the same machine,
            // so this address needs to be unique to the replica which is why we have partition ID + replica ID in the URL.
            // HttpListener can listen on multiple addresses on the same port as long as the URL prefix is unique.
            // The extra GUID is there for an advanced case where secondary replicas also listen for read-only requests.
            // When that's the case, we want to make sure that a new unique address is used when transitioning from primary to secondary
            // to force clients to re-resolve the address.
            // '+' is used as the address here so that the replica listens on all available hosts (IP, FQDM, localhost, etc.)
            
            string uriPrefix = String.Format(
                "{0}://+:{1}/{2}/{3}-{4}/",
                internalEndpoint.Protocol,
                internalEndpoint.Port,
                context.PartitionId,
                context.ReplicaOrInstanceId,
                Guid.NewGuid());

            string nodeIP = FabricRuntime.GetNodeContext().IPAddressOrFQDN;

            // The published URL is slightly different from the listening URL prefix.
            // The listening URL is given to HttpListener.
            // The published URL is the URL that is published to the Service Fabric Naming Service,
            // which is used for service discovery. Clients will ask for this address through that discovery service.
            // The address that clients get needs to have the actual IP or FQDN of the node in order to connect,
            // so we need to replace '+' with the node's IP or FQDN.
            string uriPublished = uriPrefix.Replace("+", nodeIP);
            return new HttpCommunicationListener(uriPrefix, uriPublished, this.ProcessInternalRequest);
        }

        public InstitutionModel GetDefaultInstitutions()
        {
            InstitutionModel model = new InstitutionModel();

            //Demo purposes only.  The OAuth tokens returned by the SAML assertion are valid for 1 hour and do not need to be requested before each API call.
            SamlRequestValidator validator = new SamlRequestValidator(AggCatAppSettings.Certificate,
                                                                      AggCatAppSettings.ConsumerKey,
                                                                      AggCatAppSettings.ConsumerSecret,
                                                                      AggCatAppSettings.SamlIdentityProviderId,
                                                                      AggCatAppSettings.CustomerId);
            ServiceContext ctx = new ServiceContext(validator);
            AggregationCategorizationService svc = new AggregationCategorizationService(ctx);
            try
            {
                List<Institution> institutions = svc.GetInstitutions().institution.ToList<Institution>();
                model.Institutions = institutions;
                model.Error = null;
                model.Success = true;
            }
            catch (AggregationCategorizationException ex)
            {
                model.Institutions = null;
                model.Error = ex.ToString();
                model.Success = false;
            }

            return model;
        }

        internal InstitutionModel GetInstitutionDetails(InstitutionModel institutionModel)
        {
            try
            {
                //Demo purposes only.  The OAuth tokens returned by the SAML assertion are valid for 1 hour and do not need to be requested before each API call.
                SamlRequestValidator validator = new SamlRequestValidator(AggCatAppSettings.Certificate,
                                                                          AggCatAppSettings.ConsumerKey,
                                                                          AggCatAppSettings.ConsumerSecret,
                                                                          AggCatAppSettings.SamlIdentityProviderId,
                                                                          AggCatAppSettings.CustomerId);
                ServiceContext ctx = new ServiceContext(validator);
                AggregationCategorizationService svc = new AggregationCategorizationService(ctx);
                institutionModel.InstitutionDetail = svc.GetInstitutionDetails(institutionModel.InstitutionId);
                institutionModel.Success = true;
                institutionModel.Error = null;
            }
            catch (AggregationCategorizationException ex)
            {
                institutionModel.InstitutionDetail = null;
                institutionModel.Success = false;
                institutionModel.Error = ex.ToString();
            }

            return institutionModel;
        }