public JsonRpcDispatcher(IService service) { if (service == null) throw new ArgumentNullException("service"); _service = service; }
public SearchController(IService<SearchRequest, SearchModel> service, IStudentSchoolAreaLinks studentSchoolLinks, ICurrentUserClaimInterrogator currentUserClaimInterrogator, IGradeLevelUtilitiesProvider gradeLevelUtilitiesProvider) { this.service = service; this.studentSchoolLinks = studentSchoolLinks; this.currentUserClaimInterrogator = currentUserClaimInterrogator; this.gradeLevelUtilitiesProvider = gradeLevelUtilitiesProvider; }
protected override void EstablishContext() { base.EstablishContext(); Project = new Mock<IProject>(); TimeService = new Mock<ITimeService>(); Service = new Service(Project.Object, null, TimeService.Object); }
protected JsonRpcServiceFeature(IService service) { if (service == null) throw new ArgumentNullException("service"); _service = service; }
/// <summary> /// ctor /// </summary> /// <param name="blogservices">Blog Services application methods</param> /// <param name="commentservices">Generic Comment Application Services</param> /// <param name="userservices">Generic User Service</param> /// <param name="postservices">Generic Post Service</param> public CommentController(IBlogServices blogservices, IService<Comment> commentservices, IService<User> userservices, IService<Post> postservices) { this.BlogServices = blogservices; this.CommentServices = commentservices; this.UserServices = userservices; this.PostServices = postservices; }
public ServiceRunner(IService service, string server, IDefaultBindingFactory defaultBindingFactory, IServerUriFactory serverUriFactory) { _service = service; _server = server; _defaultBindingFactory = defaultBindingFactory; _serverUriFactory = serverUriFactory; }
/// <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; }
private void submitButton_Click(object sender, RoutedEventArgs e) { var login = loginTextBox.Text; var pass = passwordTextBox.Password; Action<String> status = s => { statusLabel.Content = s; statusLabel.ToolTip = s; }; try { channelFactory = new DuplexChannelFactory<IService>(new ClientImplementation(_MainWindow), "DnDServiceEndPoint"); server = channelFactory.CreateChannel(); if (server.Login(login, pass)) { _MainWindow.InitializeServer(channelFactory, server); this.DialogResult = true; } else { statusLabel.Content = "Login lub hasło nie są poprawne!"; return; } } catch (Exception ex) { statusLabel.Content = "Nastąpił błąd! Spróbuj ponownie"; System.IO.StreamWriter file = new System.IO.StreamWriter("log.txt"); file.WriteLine(ex.ToString()); file.Close(); return; } this.Close(); }
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; }
public GetHandler(IService service) : base("GET", "/slipstream") { Service = service; Count = 0; m_log.Info("[SLIPSTREAM]: Handler Loading"); }
/// <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 void Initialize() { _clientRepositoryMock = new Mock<IClientRepository>(); _chainMock = new Mock<IChain>(); _invoiceRepositoryMock = new Mock<IInvoiceRepository>(); _service = new Service(_invoiceRepositoryMock.Object, _clientRepositoryMock.Object, _chainMock.Object); }
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"); }); }); }
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()); }
public ServiceRunner(IService service, string serviceName) { if (service == null) throw new ArgumentNullException("service"); if (serviceName == null) throw new ArgumentNullException("serviceName"); _service = service; ServiceName = serviceName; }
/// <summary> /// It build connection request instance based on the service descriptor object /// </summary> /// <param name="service">Instance of IService</param> /// <returns>IConnectionRequest instance</returns> public static IConnectionRequest PrepareConnectionRequest(IService service) { /* * Resolve All Referring Resources */ ServiceDescriptor serviceDescriptor = service.GetServiceDescriptor(); Connect.Model.ServiceDescriptor.Request request = serviceDescriptor.GetRequest(service.GetRequest()); String url = FormUrl(service); IEnumerator<Connect.Model.ServiceDescriptor.Request.QueryParameter> queryParameters = FormQueryParameters(service); IEnumerator<Connect.Model.ServiceDescriptor.Request.HeaderParameter> headerParameters = FormHeaderParameters(service); byte[] dataStream = FormDataStream(service); IConnectionRequest connectionRequest = new ConnectionRequest(); connectionRequest.SetUrl(url); connectionRequest.SetProtocol(serviceDescriptor.GetProtocol()); connectionRequest.SetType(request.GetType()); while(queryParameters.MoveNext()) { connectionRequest.AddQueryParameter(queryParameters.Current); } while(headerParameters.MoveNext()) { connectionRequest.AddHeaderParameter(headerParameters.Current); } connectionRequest.SetDataStream(dataStream); return connectionRequest; }
public CategoryController( IService<Category> categoriesService, ICategoriesService categories) { this.categoriesService = categoriesService; this.categories = categories; }
public TeachersController(IService<TeachersRequest, TeachersModel> service, IListMetadataProvider listMetadataProvider, IMetadataListIdResolver metadataListIdResolver, ISchoolCategoryProvider schoolCategoryProvider) { this.service = service; this.listMetadataProvider = listMetadataProvider; this.metadataListIdResolver = metadataListIdResolver; this.schoolCategoryProvider = schoolCategoryProvider; }
public SybilleWordPredictorEngine( IService<IWordPredictorFeature> wordPredictionFeature, string languageFileName, string userLanguageFileName, string userTextsFileName ) { _currentRetryCount = NB_RETRY; try { //Sybille can throw an exception "Loading error" LoadSybilleWordPredictor( languageFileName, userLanguageFileName, userTextsFileName ); //the plugin can be stopped before the construction have finished if( wordPredictionFeature.Status < InternalRunningStatus.Starting ) { _constructionSuccess = false; } else { _sybille.FilterAlreadyShownWords = wordPredictionFeature.Service.FilterAlreadyShownWords; _wordPredictionFeature = wordPredictionFeature; _wordPredictionFeature.Service.PropertyChanged += OnWordPredictionFeaturePropertyChanged; _constructionSuccess = true; } } catch( Exception e ) //Cannot instanciate the engine { _constructionSuccess = false; } }
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); } }
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; }
public CharacteristicDetail_TISensor (IAdapter adapter, IDevice device, IService service, ICharacteristic characteristic) { InitializeComponent (); this.characteristic = characteristic; Title = characteristic.Name; }
public LogInAsController(IService<CanLogInAsUserRequest, CanLogInAsUserModel> service, ILocalEducationAgencyAreaLinks localEducationAgencyAreaLinks, ISignInRequestMessageProvider signInRequestMessageProvider) { this.service = service; this.localEducationAgencyAreaLinks = localEducationAgencyAreaLinks; this.signInRequestMessageProvider = signInRequestMessageProvider; }
public SessionController() { this.accounts = new AccountService(); this.selectionCards = new SelectionCardService(); this.sessions = new SessionService(); this.sessionCards = new SessionCardService(); }
public CommandServicePresenter(IView view, IService service, ICommandExecutor executor) { _view = view; _service = service; _executor = executor; }
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 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)); }
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; }
public void Init() { container = new UnityContainer(); ContainerBootstrap.RegisterTypes(container); service = container.Resolve<IService>(); }
public LoginController(IService <User> userService, IService <UserType> userTypeService) { _userService = userService; _userTypeService = userTypeService; }
/** <inheritDoc /> */ public void DeployKeyAffinitySingleton <TK>(string name, IService service, string cacheName, TK affinityKey) { _services.DeployKeyAffinitySingletonAsync(name, service, cacheName, affinityKey).Wait(); }
public override bool Pass(IService test) { return(true); }
public override bool Match(IService test) { return(true); }
public abstract bool Match(IService test);
public virtual bool Pass(IService test) { return(Match(test)); }
public LoginController(IService service) { this.service = service; }
/** <inheritDoc /> */ public Task DeployKeyAffinitySingletonAsync <TK>(string name, IService service, string cacheName, TK affinityKey) { return(_services.DeployKeyAffinitySingletonAsync(name, service, cacheName, affinityKey)); }
/** <inheritDoc /> */ public void DeployNodeSingleton(string name, IService service) { _services.DeployNodeSingletonAsync(name, service).Wait(); }
/** <inheritDoc /> */ public Task DeployNodeSingletonAsync(string name, IService service) { return(_services.DeployNodeSingletonAsync(name, service)); }
public JsonRpcGetProtocol(IService service) : base(service) { }
/** <inheritDoc /> */ public Task DeployMultipleAsync(string name, IService service, int totalCount, int maxPerNodeCount) { return(_services.DeployMultipleAsync(name, service, totalCount, maxPerNodeCount)); }
internal void AddService(IService service) { _services[service.id] = service; }
/// <summary> /// Call this method in order to send a message from your code into the message routing system. /// The message is routed to a service that is defined to handle messages of this type. /// Once the service is identified, the destination property of the message is used to find a destination configured for that service. /// The adapter defined for that destination is used to handle the message. /// </summary> /// <param name="message">The message to be routed to a service.</param> /// <param name="endpoint">This can identify the endpoint that is sending the message but it is currently not used so you may pass in null.</param> /// <returns>The result of the message routing.</returns> internal IMessage RouteMessage(IMessage message, IEndpoint endpoint) { IService service = null; object result = null; IMessage responseMessage = null; if( log.IsDebugEnabled ) log.Debug(__Res.GetString(__Res.MessageBroker_RoutingMessage, message.ToString())); CommandMessage commandMessage = message as CommandMessage; if( commandMessage != null && (commandMessage.operation == CommandMessage.LoginOperation || commandMessage.operation == CommandMessage.LogoutOperation) )//Login, Logout { try { service = GetService(AuthenticationService.ServiceId); result = service.ServiceMessage(commandMessage); responseMessage = result as IMessage; } catch (UnauthorizedAccessException uae) { if (log.IsDebugEnabled) log.Debug(uae.Message); responseMessage = ErrorMessage.GetErrorMessage(message, uae); } catch (SecurityException exception) { if (log.IsDebugEnabled) log.Debug(exception.Message); responseMessage = ErrorMessage.GetErrorMessage(message, exception); } catch(Exception exception) { if(log.IsErrorEnabled) log.Error(__Res.GetString(__Res.MessageBroker_RoutingError), exception); responseMessage = ErrorMessage.GetErrorMessage(message, exception); } } else if (commandMessage != null && commandMessage.operation == CommandMessage.ClientPingOperation) { responseMessage = new AcknowledgeMessage(); responseMessage.body = true; } else { //The only case when context is not set should be when one starts a new thread in the backend //if( FluorineContext.Current != null ) // FluorineContext.Current.RestorePrincipal(this.LoginCommand); _loginManager.RestorePrincipal(); service = GetService(message); if (service != null) { try { service.CheckSecurity(message); result = service.ServiceMessage(message); } catch (UnauthorizedAccessException uae) { if (log.IsDebugEnabled) log.Debug(uae.Message); result = ErrorMessage.GetErrorMessage(message, uae); } catch (SecurityException exception) { if (log.IsDebugEnabled) log.Debug(exception.Message); result = ErrorMessage.GetErrorMessage(message, exception); } catch (ServiceException exception) { if (log.IsDebugEnabled) log.Debug(exception.Message); result = ErrorMessage.GetErrorMessage(message, exception); } catch (Exception exception) { if (log.IsErrorEnabled) log.Error(exception.Message, exception); result = ErrorMessage.GetErrorMessage(message, exception); } } else { string msg = __Res.GetString(__Res.Destination_NotFound, message.destination); if (log.IsErrorEnabled) log.Error(msg); result = ErrorMessage.GetErrorMessage(message, new FluorineException(msg)); } if (!(result is IMessage)) { responseMessage = new AcknowledgeMessage(); responseMessage.body = result; } else responseMessage = result as IMessage; } if( responseMessage is AsyncMessage ) { ((AsyncMessage)responseMessage).correlationId = message.messageId; } responseMessage.destination = message.destination; responseMessage.clientId = message.clientId; //Debug if( message.HeaderExists(AMFHeader.DebugHeader) ) { log.Debug("MessageBroker processing debug header"); ArrayList traceStack = NetDebug.GetTraceStack(); responseMessage.SetHeader(AMFHeader.DebugHeader, traceStack.ToArray(typeof(object)) as object[]); NetDebug.Clear(); } //The only case when we do not have context should be when the server side initiates a push if( FluorineContext.Current != null && FluorineContext.Current.Client != null ) responseMessage.SetHeader(MessageBase.FlexClientIdHeader, FluorineContext.Current.Client.Id); if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.MessageBroker_Response, responseMessage.ToString())); return responseMessage; }
public UniversityController(IService <UniversityDTO> universityService) { _universityService = universityService; }
internal void RegisterDestination(Destination destination, IService service) { _destinationServiceMap[destination.Id] = service.id; _destinations[destination.Id] = destination; }
public EmployeesController(IServiceUnitOfWork service) { _service = service.EmployeeService; }
/// <summary> /// Executed immediately after a service is executed. Use return to change response used. /// </summary> public virtual object OnPostExecuteServiceFilter(IService service, object response, IRequest httpReq, IResponse httpRes) { return(response); }
public CreateUser(IService service) { _service = service; }
public UsersController(IService iService, Users users) { this.IService = iService; this.users = users; }
public StudentsController() { this.studentService = new StudentService(); }
} // HubEventHandler() // // // // ************************************************* // **** Process Request() **** // ************************************************* private void ProcessRequest(RequestEventArg <RequestCode> eventArgs) { switch (eventArgs.RequestType) { case RequestCode.RequestServers: // This is trigger automatically at Start() request. // Here, we make all the conenctions necessary for collecting market data, info, etc. // Connect to the desired database. if (m_DatabaseReader == null) { // Search for database service. IService iService = null; if (AppServices.GetInstance().TryGetService("DatabaseReaderWriter", out iService)) { // Found database writer already in services. m_DatabaseReader = (DB.DatabaseReaderWriter)iService; m_DatabaseReader.QueryResponse += new EventHandler(this.HubEventEnqueue); } else { // Create db our own writer. m_DBInfo = DB.DatabaseInfo.Create(m_DBLocation); AppServices.GetInstance().TryAddService(m_DBInfo); m_DatabaseReader = new DB.DatabaseReaderWriter(m_DBInfo); m_DatabaseReader.QueryResponse += new EventHandler(this.HubEventEnqueue); m_DatabaseReader.Start(); } // Request info about exchanges and all products. DB.Queries.QueryBase query = new DB.Queries.ExchangeInfoQuery(); m_DatabaseReader.SubmitAsync(query); query = new DB.Queries.ProductInfoQuery(); m_DatabaseReader.SubmitAsync(query); } else { Log.NewEntry(LogLevel.Major, "ProcessRequest: Ignoring additional call to RequestServers."); } break; case RequestCode.RequestProducts: if (!m_IsDatabaseInitialized) { m_PendingRequests.Add(eventArgs); } else { } break; case RequestCode.RequestInstruments: if (!m_IsDatabaseInitialized) { m_PendingRequests.Add(eventArgs); } else { foreach (object o in eventArgs.Data) { // Validate this instrument request if (!(o is InstrumentName)) { continue; } InstrumentName instrName = (InstrumentName)o; InstrumentDetails instrDetails; if (!TryGetInstrumentDetails(instrName, out instrDetails) && m_PendingInstrumentQueries.Contains(instrName) != true) { // Details not exist yet and we have not requested them yet. Request them. Log.NewEntry(LogLevel.Minor, "ProcessRequest: Requesting instr details for {0}.", instrName); m_PendingInstrumentQueries.Add(instrName); // add to pending list (so we can't spam db). DB.Queries.InstrumentInfoQuery query = new DB.Queries.InstrumentInfoQuery(); query.InstrumentName = instrName; m_DatabaseReader.SubmitAsync(query); } } //next data object o } break; case RequestCode.RequestInstrumentPriceSubscription: if (!m_IsDatabaseInitialized) { m_PendingRequests.Add(eventArgs); } else { foreach (object o in eventArgs.Data) { // Validate this instrument request if (!(o is InstrumentName)) { continue; } InstrumentName instrName = (InstrumentName)o; int instrId = 0; InstrumentDetails instrDetails; if (TryLookupInstrumentID(instrName, out instrId) && instrId > -1) { continue; // instrument already has a book id! } // Get the isntrument details first, and make sure details exist. if (!TryGetInstrumentDetails(instrName, out instrDetails)) { // Details not exist yet. Request them. Log.NewEntry(LogLevel.Minor, "ProcessRequest: Need instr details for {0}. Delaying mkt subscription.", instrName); m_PendingRequests.Add(eventArgs); // push onto pending list for later resubmission. base.RequestInstruments(instrName); } else { // Make sure we have not already requested this data. bool isRequestAlreadyPending = false; foreach (DB.Queries.MarketDataQuery query in m_PendingMarketDataQueries) { if (query.InstrumentName == instrName) { isRequestAlreadyPending = true; break; } } if (isRequestAlreadyPending) { Log.NewEntry(LogLevel.Major, "ProcessRequest: Market data for {0} pending. Ignore", instrName); } else { // This request is NOT already pending, so request data now. DB.Queries.MarketDataQuery query = new DB.Queries.MarketDataQuery(); query.InstrumentName = instrName; query.StartDate = m_MktDataStartDateTime.ToUniversalTime(); // Query times in UTC. query.EndDate = query.StartDate.AddHours(m_MktDataBlockSize); m_PendingMarketDataQueries.Add(query); // add to pending list (so we can't spam db). Log.NewEntry(LogLevel.Major, "ProcessRequest: Requesting mkt data for {0} from {1} ({2} hours).", instrName, query.StartDate.ToString("MMM-dd-yyyy HH:mm:ss"), m_MktDataBlockSize); m_DatabaseReader.SubmitAsync(query); } } } } break; case RequestCode.RequestShutdown: if (m_DatabaseReader != null) { m_DatabaseReader.RequestStop(); m_DatabaseReader = null; } base.Stop(); break; default: Log.NewEntry(LogLevel.Major, "ProcessRequest: Unknown request."); break; } //switch on request type. } // ProcessRequest()
public IPrincipal AssertIdentity(object oToken, IService service) { throw new System.NotImplementedException(); }
public PersonsController(IService <Person> service) { _personService = service; }
public ScreenWithoutInterfaceViewModel(IService service) { _service = service; Title = "Screen without Interface"; }
public object TransformIdentity(IPrincipal principal, IService service) { throw new System.NotImplementedException(); }
public PedidoDetalleController( IService <PedidoDetalle> service, ILogger <PedidoDetalleController> logger) : base(service, logger) { }
public static void Register(IService service) { Services.Add(service); }
public DocsController(IService service) { _service = service; }
public Behavior1(IService service, IServiceLocator services, GuyWithService guy) { _service = service; _services = services; _guy = guy; }