public TimedHostedService(
ISomeService service,
ILogger <TimedHostedService> logger)
{
_service = service;
_logger = logger;
}
public MainViewModel(ISomeService someService, IPersonService personService)
{
_personService = personService;
_someService = someService;
Execute();
}
public override void AwakeFromNib()
{
if (Site == null || !Site.DesignMode)
{
service = MyIoCContainer.Get <ISomeService>();
}
}
public MainActor(ISomeService someService, IChildCreatorActor childCreatorActor)
{
this.someService = someService;
this.childCreatorActor = childCreatorActor;
Receive <bool>((x) => SendMessage(x));
}
public DataboundDatagridItemCreatorForm(ISomeService someService)
{
_view = new DataboundDatagridItemCreatorFormView();
var someText = LocalValueFieldBuilder.Build(_view.SomeText, Validator.IsNotNullRef);
var someNumber = LocalValueFieldBuilder.BuildNullableInt(_view.SomeNumber, Validator.IsNotNull, Validator.MustBePositive <int>());
var someBool = LocalValueFieldBuilder.Build(_view.SomeBool);
_view.SomeTrait.PermittedValues = EnumExtensions.GetEnumValues <SomeTraitType>().Select(x => (SomeTraitType?)x);
var someTrait = LocalValueFieldBuilder.Build(_view.SomeTrait, Validator.IsNotNull);
var createProduct = RemoteActionBuilder.Build(_view.CreateAction,
() => someService.Create(
new SomeDto {
SomeNumber = someNumber.Value.GetValueOrDefault(),
SomeText = someText.Value,
SomeBool = someBool.Value,
SomeTrait = someTrait.Value.Value
}),
x => {
CreatedItem = x;
Ended?.Invoke(this, Outcome.Created);
});
var isFormValid = new AggregatedErrorsValue <bool>(false, self => !self.Errors.Any(), x => {
x.Observes(someText);
x.Observes(someNumber);
x.Observes(someBool);
x.Observes(someTrait);
});
createProduct.BindEnableAndInitialize(isFormValid);
}
public DataboundDatagridProgram(ISomeService someService)
{
_datagrid = new DataboundDatagridForm();
_fetchData = new RemoteActionsCallerForm(o => o.Add(someService.FetchItems, x => _datagrid.Items.Items.Replace(x)));
_itemCreator = new DataboundDatagridItemCreatorForm(someService);
_itemEditor = new DataboundDatagridItemEditorForm(someService);
}
public Main(ISomeService someService, IOutput output)
{
Assert.NotNull(someService, nameof(someService));
Assert.NotNull(output, nameof(output));
m_someService = someService;
m_output = output;
}
public ValuesController(ILogger <ValuesController> logger, IHttpContextAccessor httpContextAccessor, ISomeService someService)
{
_logger = logger;
_httpContextAccessor = httpContextAccessor;
_traceIdentifierService = ServiceLocator.ServiceProvider.GetService <ITraceIdentifierService>();
_someService = someService;
}
public MyController(IntPtr handle) : base(handle)
{
if (Site == null || !Site.DesignMode)
{
service = MyIoCContainer.Get <ISomeService>();
}
}
public TestClass2(ISomeInstance someInstance, string testProperty1, ISomeService someService, string testProperty3)
{
this.InjectedService = someService;
this.TestProperty1 = testProperty1;
this.TestProperty2 = someInstance;
this.TestProperty3 = testProperty3;
}
public void ShouldIgnoreArgumentsOnGenericCallWhenTypeIsStruct()
{
// setup
MockRepository mocks = new MockRepository();
ISomeService m_SomeServiceMock = mocks.StrictMock <ISomeService>();
SomeClient sut = new SomeClient(m_SomeServiceMock);
using (mocks.Ordered())
{
Expect.Call(delegate
{
m_SomeServiceMock.DoSomething <string>(null, null);
});
LastCall.IgnoreArguments();
Expect.Call(delegate
{
m_SomeServiceMock.DoSomething <DateTime>(null, default(DateTime)); // can't use null here, because it's a value type!
});
LastCall.IgnoreArguments();
}
mocks.ReplayAll();
// test
sut.DoSomething();
// verification
mocks.VerifyAll();
// cleanup
m_SomeServiceMock = null;
sut = null;
}
public SomeController(ILogger <SomeController> logger, IValidator <SomeRequest> someValidator,
ISomeService someService)
{
_logger = logger;
_someValidator = someValidator;
_someService = someService;
}
public HomeController(Service1 service1, Service2 service2, Service3 service3, ISomeService someService)
{
_service1 = service1;
_service2 = service2;
_service3 = service3;
_someService = someService;
}
public void SimpleExpectationSetUp_BindingInputWithMultipleParametersToReturnValue_InvocationValuesAreAccessibleWhenStubbingMessage()
{
MsmqHelpers.Purge("shippingservice");
var service = Configure.Stub().NServiceBusSerializers().WcfEndPoints().Create(@".\Private$\orderservice");
var proxy = service.WcfEndPoint <ISomeService>("http://localhost:9101/something");
proxy.Setup(s => s.IHaveMultipleInputParameters(Parameter.Any <string>(), Parameter.Equals <string>(str => str == "snappy"), Parameter.Any <bool>())).Returns <string, string, bool>((param1, param2, param3) => param1)
.Send <IOrderWasPlaced, string>((msg, product) => { msg.OrderedProduct = product; }, "shippingservice");
service.Start();
string firstRequestReturnValue;
using (var factory = new ChannelFactory <ISomeService>(new BasicHttpBinding(), "http://localhost:9101/something"))
{
ISomeService channel = factory.CreateChannel();
firstRequestReturnValue = channel.IHaveMultipleInputParameters("hello", "snappy", false);
}
service.Dispose();
Assert.That(MsmqHelpers.PickMessageBody("shippingservice"), Is.StringContaining("hello"));
Assert.That(firstRequestReturnValue, Is.EqualTo("hello"));
}
public void SimpleExpectationSetUp_BindingInputWithMultipleParametersToReturnValue2_InvocationValuesArePassedToReturn()
{
var service = Configure.Stub().NServiceBusSerializers().WcfEndPoints().Create(@".\Private$\orderservice");
var proxy = service.WcfEndPoint <ISomeService>("http://localhost:9101/something");
proxy.Setup(s => s.IHave4InputParameters(Parameter.Any <string>(), Parameter.Equals <string>(str => str == "snappy"), Parameter.Any <bool>(), Parameter.Any <string>())).Returns <string, string, bool, string>((param1, param2, param3, param4) =>
new FourInputParamsReturnValue {
ReturnOne = param1, ReturnTwo = param2, ReturnThree = param3, ReturnFour = param4
});
service.Start();
FourInputParamsReturnValue retVal;
using (var factory = new ChannelFactory <ISomeService>(new BasicHttpBinding(), "http://localhost:9101/something"))
{
ISomeService channel = factory.CreateChannel();
retVal = channel.IHave4InputParameters("hello", "snappy", false, "poppy");
}
service.Dispose();
Assert.That(retVal.ReturnOne, Is.EqualTo("hello"));
}
public void SimpleExpectationSetUp_BindingInputToReturnValueByName_InvocationValuesArePassedToReturn()
{
var service = Configure.Stub().NServiceBusSerializers().WcfEndPoints().Create(@".\Private$\orderservice");
var proxy = service.WcfEndPoint <ISomeService>("http://localhost:9101/something");
proxy.Setup(s => s.IHave4InputParameters(Parameter.Any <string>(), Parameter.Any <string>(), Parameter.Any <bool>(), Parameter.Any <string>())).Returns <string>(fallback => new FourInputParamsReturnValue {
ReturnOne = fallback
});
service.Start();
FourInputParamsReturnValue actual;
using (var factory = new ChannelFactory <ISomeService>(new BasicHttpBinding(), "http://localhost:9101/something"))
{
ISomeService channel = factory.CreateChannel();
actual = channel.IHave4InputParameters("john doe", "somewhere", false, "to this");
}
service.Dispose();
Assert.That(actual.ReturnOne, Is.EqualTo("to this"));
}
public BusinessLogic(ISomeService someService, ISyncPolicy policy)
{
_someService = someService;
_policy = policy;
Log.Information("BusinessLogic ctor done");
}
public void RegisterAndResolve()
{
IServiceProvider provider = GetServiceProvider();
ISomeService someService = provider.GetService <ISomeService>();
Assert.NotNull(someService);
Assert.IsType <SomeService>(someService);
}
public void Run()
{
ISomeService service = DependencyService.Resolve <ISomeService>();
int number = service.AddNumbers(1, 2);
service.DoImportantJob(number);
}
public MainViewModel(ISomeService someService, IPersonService personService)
{
_personService = personService;
_someService = someService;
Name = "Slim Shady";
Execute();
}
public SecondPageViewModel(ISomeService someService, INavigationService navigationService)
{
_someService = someService;
_navigationService = navigationService;
DoAnything = new DelegateCommand(InvokeDoAnything);
NavigateToMainPage = new DelegateCommand(async() => await InvokeNavigateToMainPage());
}
public SampleEntityPipelineService(IPluginExecutionContextAccessor executionContextAccessor, ILogger logger,
IOrganizationService organizationService, ISettingsProvider settingsProvider, ISomeService someService) :
base(executionContextAccessor, logger)
{
_organizationService = organizationService;
_settingsProvider = settingsProvider;
_someService = someService;
}
public QueueTimeless(ISomeService someService)
{
_someService = someService;
_internalPipline = new BlockingCollection <Packet <TItem> >();
_cancellation = new CancellationTokenSource();
_currentPacket = new Packet <TItem>(maxSize);
_monitor = StartQueue();
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get")]
HttpRequest req, ILogger log, ISomeService someService)
{
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
return(new OkObjectResult(someService.GetSomeOption()));
}
public UploaderDemoFlow(ISomeService someService, IHttpRequester httpRequester)
{
_fetchFiles = new RemoteActionsCallerForm(x => x.Add(
someService.OrderAttachmentGetFiles,
y => _files = y));
_demo = new UploaderDemoForm(httpRequester);
_params = new UploaderDemoParamsForm();
_params.SetParent(_demo.GetUploadControl());
}
public ValuesController(
ISomeService service,
IAnotherService anotherService,
ILogger <ValuesController> logger)
{
_service = service;
_anotherService = anotherService;
_logger = logger;
}
public static ISomeService Factory(Container c)
{
// Register the service by type...
c.RegisterAutoWiredType(typeof(SomeService), ReuseScope.Hierarchy);
// ... and force auto-wiring to happen.
ISomeService result = (ISomeService)c.TryResolve(typeof(SomeService));
return(result);
}
public void UseSomeServiceImpl()
{
IWindsorContainer container = new WindsorContainer();
container.Register(Component.For <ISomeService>().ImplementedBy <SomeServiceImpl>());
container.Register(Component.For <ISomeInnerService>().ImplementedBy <SomeInnerServiceImpl>());
ISomeService service = container.Resolve <ISomeService>();
Assert.IsNotNull(service);
}
public TestViewModel(ISomeService someService)
{
_id = someService.GetRandomInt();
ClickCommand = new ActionCommand(OnClickCommandExecute);
// MessageBox.Show("wow" +_id);
TextToShow = _id.ToString();
TextToShow = "sadsads";
}
public async Task InvokeAsync(HttpContext context, ISomeService service)
{
context.Response.OnStarting(() =>
{
service.SetHeader(context.Response);
return(Task.CompletedTask);
});
await _next.Invoke(context);
}
public MainViewModel(ISomeService someService)
{
receiver = new UdpSocketReceiver();
receiver.MessageReceived += OnMessageReceived;
Messages = new ObservableCollection<UDPMessage>();
Task.Run(() => Init().Wait());
}
public SomeClient(ISomeService someSvc)
{
m_SomeSvc = someSvc;
}
public DIActor(string id, IActorRuntime runtime, ISomeService service) : base(id, runtime)
{
this.service = service;
}
public AMoreComplexService()
{
_dependentService = new SomeService();
}
public TestClass2NonMatchingName(
ISomeInstance someInstance,
string nonMatchingTestProperty1,
ISomeService someService,
string nonMatchingTestProperty3)
{
this.InjectedService = someService;
this.TestProperty1 = nonMatchingTestProperty1;
this.TestProperty2 = someInstance;
this.TestProperty3 = nonMatchingTestProperty3;
}
private static async Task<string> SomeFuncAsync(ISomeService someTasks)
{
var response = await someTasks.FirstTaskAsync();
return await someTasks.SecondTaskAsync(response);
}
public SomeServiceProxy()
{
_someService = new SomeService();
}
public DIActor(ISomeService service)
{
this.service = service;
}
public TestClass2(ISomeInstance testProperty2, string testProperty1, ISomeService someService, string testProperty3)
{
this.InjectedService = someService;
this.TestProperty3 = testProperty3;
this.TestProperty1 = testProperty1;
this.TestProperty2 = testProperty2;
}
public ProductsController(IMediator mediator, ISomeService someService)
{
_mediator = mediator;
_someService = someService;
}