public SearchController(IService<SearchRequest, SearchModel> service, IStudentSchoolAreaLinks studentSchoolLinks, ICurrentUserClaimInterrogator currentUserClaimInterrogator, IGradeLevelUtilitiesProvider gradeLevelUtilitiesProvider)
 {
     this.service = service;
     this.studentSchoolLinks = studentSchoolLinks;
     this.currentUserClaimInterrogator = currentUserClaimInterrogator;
     this.gradeLevelUtilitiesProvider = gradeLevelUtilitiesProvider;
 }

        public JsonRpcDispatcher(IService service, IServiceProvider serviceProvider)
        {
            if (service == null)
                throw new ArgumentNullException("service");

            _service = service;

            if (serviceProvider == null)
            {
                //
                // No service provider supplied so check if the RPC service
                // itself is our service provider.
                //

                serviceProvider = service as IServiceProvider;

                //
                // If no service provider found so far, then create a default
                // one.
                //

                if (serviceProvider == null)
                    serviceProvider = new ServiceContainer();
            }

            _serviceProvider = serviceProvider;
        }

        /// <summary>
        /// Generates all schema classes for the specified service
        /// </summary>
        /// <param name="service"></param>
        /// <returns></returns>
        public CodeNamespace GenerateSchemaClasses(IService service)
        {
            service.ThrowIfNull("service");

            logger.Debug("Starting to generate schemas for {1} in namespace {0}", schemaNamespace, service.Name);
            LogDecorators();
            var codeNamespace = new CodeNamespace(schemaNamespace);
            codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
            codeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections"));
            codeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
            SchemaGenerator generator = new SchemaGenerator(decorators);

            // Generate implementation details
            IDictionary<JsonSchema, SchemaImplementationDetails> implementationDetails =
                implementationDetailsGenerator.GenerateDetails(service);

            // Generate schemas
            foreach (var schemaPair in service.Schemas)
            {
                logger.Debug("Generating Schema {0}", schemaPair.Key);

                // Create schema
                codeNamespace.Types.Add(
                    generator.CreateClass(schemaPair.Value, implementationDetails, service.Schemas.Keys));
            }
            return codeNamespace;
        }

        public void Init()
        {
            container = new UnityContainer();
            ContainerBootstrap.RegisterTypes(container);

            service = container.Resolve<IService>();
        }

        public JsonRpcDispatcher(IService service)
        {
            if (service == null)
                throw new ArgumentNullException("service");

            _service = service;
        }

 public ServiceRunner(IService service, string serviceName)
 {
     if (service == null) throw new ArgumentNullException("service");
     if (serviceName == null) throw new ArgumentNullException("serviceName");
     _service = service;
     ServiceName = serviceName;
 }

        public void SetUp()
        {
            _lastService = null;
            _manager = null;

            _defaultRegistry = (registry =>
            {
                //registry.ForRequestedType<IService>()
                //    .AddInstances(
                //    Instance<ColorService>().WithName("Red").WithProperty("color").
                //        EqualTo(
                //        "Red"),
                //    Object<IService>(new ColorService("Yellow")).WithName("Yellow"),
                //    ConstructedBy<IService>(
                //        delegate { return new ColorService("Purple"); })
                //        .WithName("Purple"),
                //    Instance<ColorService>().WithName("Decorated").WithProperty("color")
                //        .
                //        EqualTo("Orange")
                //    );

                registry.ForRequestedType<IService>().AddInstances(x =>
                {
                    x.OfConcreteType<ColorService>().WithName("Red").WithProperty("color").EqualTo("Red");

                    x.Object(new ColorService("Yellow")).WithName("Yellow");

                    x.ConstructedBy(() => new ColorService("Purple")).WithName("Purple");

                    x.OfConcreteType<ColorService>().WithName("Decorated").WithProperty("color").EqualTo("Orange");
                });
            });
        }

		public CharacteristicDetail_TISensor (IAdapter adapter, IDevice device, IService service, ICharacteristic characteristic)
		{
			InitializeComponent ();
			this.characteristic = characteristic;

			Title = characteristic.Name;
		}

 public void DecorateClass(IService service, CodeTypeDeclaration serviceClass)
 {
     serviceClass.Members.Add(CreateVersionField(service));
     serviceClass.Members.Add(CreateNameField(service));
     serviceClass.Members.Add(CreateUriField(service));
     serviceClass.Members.Add(CreateDiscoveryVersionField(service));
 }

        public LogInAsController(IService<CanLogInAsUserRequest, CanLogInAsUserModel> service, ILocalEducationAgencyAreaLinks localEducationAgencyAreaLinks,
			ISignInRequestMessageProvider signInRequestMessageProvider)
        {
            this.service = service;
            this.localEducationAgencyAreaLinks = localEducationAgencyAreaLinks;
            this.signInRequestMessageProvider = signInRequestMessageProvider;
        }

 public MultipleServiceManager(ILog log, IService[] services)
 {
     this.log = log;
     this.services = services.OrderBy(s => s.StartIndex).ToArray();
     ServiceName = "IronFoundryDEA"; // NB: must match installer Product.wxs
     AutoLog = true;
 }

   public CommandServicePresenter(IView view, IService service,
 ICommandExecutor executor)
   {
       _view = view;
         _service = service;
         _executor = executor;
   }

 public ServiceRunner(IService service, string server, IDefaultBindingFactory defaultBindingFactory, IServerUriFactory serverUriFactory)
 {
     _service = service;
     _server = server;
     _defaultBindingFactory = defaultBindingFactory;
     _serverUriFactory = serverUriFactory;
 }

 public CategoryController(
     IService<Category> categoriesService,
     ICategoriesService categories)
 {
     this.categoriesService = categoriesService;
     this.categories = categories;
 }

 internal CodeMemberField CreateNameField(IService service)
 {
     var name = new CodeMemberField(typeof(string), NameName);
     name.Attributes = MemberAttributes.Const | MemberAttributes.Private;
     name.InitExpression = new CodePrimitiveExpression(service.Name);
     return name;
 }

        protected override void EstablishContext()
        {
            //Prepare supplied data collections
            suppliedListOfSchoolMetricModel = GetListOfSchoolMetricModel();

            //Set up the mocks
            schoolMetricTableService = mocks.StrictMock<IService<SchoolMetricTableRequest, SchoolMetricTableModel>>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();

            //Set expectations
            Expect.Call(schoolMetricTableService.Get(null))
                .Constraints(
                    new ActionConstraint<SchoolMetricTableRequest>(x =>
                    {
                        Assert.That(x.LocalEducationAgencyId == suppliedLocalEducationAgencyId);
                        Assert.That(x.MetricVariantId == suppliedMetricVariantId);
                    })
                ).Return(new SchoolMetricTableModel { SchoolMetrics = suppliedListOfSchoolMetricModel, ListMetadata = new List<MetadataColumnGroup>() });

            Expect.Call(metadataListIdResolver.GetListId(ListType.SchoolMetricTable, SchoolCategory.None)).Return(
                MetadataListIdResolver.SchoolMetricTableListId);

            Expect.Call(listMetadataProvider.GetListMetadata(MetadataListIdResolver.SchoolMetricTableListId)).Return(getSuppliedMetadataColumnGroups());
        }

 internal CodeMemberField CreateUriField(IService service)
 {
     var uri = new CodeMemberField(typeof(string), BaseUriName);
     uri.Attributes = MemberAttributes.Const | MemberAttributes.Private;
     uri.InitExpression = new CodePrimitiveExpression(service.BaseUri.ToString());
     return uri;
 }

        /// <summary>
        /// Add the given service (<paramref name="a_service"/>) to this listing.
        /// </summary>
        /// <param name="a_service">Service to add.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="a_service"/> is null.</exception>
        public void Add(IService a_service)
        {
            #region Argument Validation

            if (a_service == null)
                throw new ArgumentNullException(nameof(a_service));

            #endregion

            if (a_service.Contract == null)
                throw new InvalidOperationException("Service does not have a contract type.");

            lock (l_servicesByTypeGuid)
            {
                List<IService> services;
                if (_servicesByTypeGuid.ContainsKey(a_service.Contract.GUID))
                    services = _servicesByTypeGuid[a_service.Contract.GUID];
                else
                    services = _servicesByTypeGuid[a_service.Contract.GUID] = new List<IService>();

                services.Add(a_service);
            }

            if (a_service.Name != null)
            {
                var name = CreateServiceName(a_service.Contract, a_service.Name);

                lock (l_serviceByName)
                {
                    if (!_servicesByName.ContainsKey(name))
                        _servicesByName.Add(name, a_service);
                }
            }
        }

        public async Task RunService(IService service, CancellationToken token)
        {
            _logger.InfoFormat("Running service {0}", service.Name);

            await TaskEx.Yield();

            var blobs = _client.GetContainerReference("locks");
            await blobs.CreateIfNotExistAsync();

            var blob = blobs.GetBlobReference(service.Name);

            while (!token.IsCancellationRequested)
            {
                try
                {
                    if (service is IScheduledService)
                        await HandleScheduledService((IScheduledService)service, blob, token);
                    else if (service is IClusteredService)
                        await HandleClusteredService((IClusteredService)service, blob, token);
                    else if (service is IContinuousService)
                        await HandleContinuousService((IContinuousService)service, blob, token);
                }
                catch (OperationCanceledException)
                {
                    // no-op
                }
                catch (Exception e)
                {
                    _logger.ErrorFormat("The main task of service \"{0}\" threw an exception.", e, service.Name);
                }
            }

            _logger.InfoFormat("Service {0} stopped", service.GetType().Name);
            throw new OperationCanceledException(token);
        }

        public object Invoke(IService service, object[] args)
        {
            if (service == null)
                throw new ArgumentNullException("service");

            try
            {
                if (Method.IsStatic)
                {
                    object[] argz = new object[args.Length + 1];
                    argz[0] = service;
                    args.CopyTo(argz, 1);
                    return Method.Invoke(null, argz);
                }
                else
                {
                    return Method.Invoke(service, args);
                }
            }
            catch (ArgumentException e)
            {
                throw TranslateException(e);
            }
            catch (TargetParameterCountException e)
            {
                throw TranslateException(e);
            }
            catch (TargetInvocationException e)
            {
                throw TranslateException(e);
            }
        }