public Task <SumResponse> SumAsync(SumRequest sumRequest)
{
return(Task.FromResult(new SumResponse
{
Sum = sumRequest.X + sumRequest.Y
}));
}
/// <summary>
/// 服务端流求和
/// </summary>
/// <param name="request"></param>
/// <param name="responseStream"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task SumServerStream(SumRequest request, IServerStreamWriter <IntMessage> responseStream, ServerCallContext context)
{
var result = new IntMessage();
result.Value = request.Num;
await responseStream.WriteAsync(result);
}
// POST: api/Sum
public SumResponse Post([FromBody] SumRequest request)
{
var result = _operationFactory.Create(request).Execute(request);
return((SumResponse)result);
// return new SumResponse();
}
public override Task <SumResponse> Sum(SumRequest request, ServerCallContext context)
{
return(Task.FromResult(new SumResponse
{
Result = request.X + request.Y
}));
}
static void Main(string[] args)
{
Channel channel = new Channel(target, ChannelCredentials.Insecure);
channel.ConnectAsync().ContinueWith((task) =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
Console.WriteLine("The client connected successfully");
}
});
var client = new CalculatorService.CalculatorServiceClient(channel);
var request = new SumRequest()
{
A = 3,
B = 10
};
var response = client.Sum(request);
Console.WriteLine(response.Result);
channel.ShutdownAsync().Wait();
Console.ReadKey();
}
public override Task <SumReply> SaySum(SumRequest request, ServerCallContext context)
{
var suma = Convert.ToInt32(request.ValueOne) + Convert.ToInt32(request.ValueTwo);
return(Task.FromResult(new SumReply {
Result = suma.ToString()
}));
}
public override Task <SumResponse> Sum(SumRequest request, ServerCallContext context)
{
int result = request.A + request.B;
return(Task.FromResult(new SumResponse()
{
Result = result
}));
}
public override Task <SumReply> Sum(SumRequest request, ServerCallContext context)
{
var user = context.GetHttpContext().User;
SumReply reply = new SumReply();
reply.Message = request.Number1 + request.Number2;
return(Task.FromResult(reply));
}
public override async Task <SumResponse> Sum(SumRequest request, ServerCallContext context)
{
Console.WriteLine($"sum request received: {request.A}:{request.B}");
var result = request.A + request.B;
return(new SumResponse {
Result = result
});
}
public void ShouldReturnZeroForEmptyString()
{
var controller = new CalculatorController(new CalculatorService());
var numbers = new SumRequest {
Numbers = string.Empty
};
var response = controller.Post(numbers);
response.Result.Should().Be(0);
}
public override Task <SumResponse> SumNumbers(SumRequest request, ServerCallContext context)
{
int sumresult = Int32.Parse(request.Sum.FirstNumber) + Int32.Parse(request.Sum.LastNumber);
string result = String.Format("Sum of {0} {1} = {2}", request.Sum.FirstNumber, request.Sum.LastNumber, sumresult);
return(Task.FromResult(new SumResponse()
{
Result = result
}));
}
static async Task Sum(Channel channel)
{
WriteHeader("Sum");
var client = new CalculatorService.CalculatorServiceClient(channel);
var sumRequest = new SumRequest {
A = 10, B = 3
};
var response = await client.SumAsync(sumRequest);
Console.WriteLine($"Response received: {response.Result}\r\n");
}
public override async Task<SumResponse> Sum(SumRequest request, ServerCallContext context)
{
var task = await Task.Run(() =>
{
var response = new SumResponse();
response.Result = request.S1 + request.S2;
return response;
});
return task;
}
public override Task <SumResponse> Sum(SumRequest request, ServerCallContext context)
{
var result = request.Number1 + request.Number2;
var sumResponse = new SumResponse()
{
Result = result
};
return(Task.FromResult(sumResponse));
//return base.Sum(request, context);
}
public override Task <OperationResponse> Calculate(SumRequest request, ServerCallContext context)
{
var result = request.FirstOperand + request.SecondOperand;
System.Console.WriteLine("Sum request -> {0} + {1} = {2}", request.FirstOperand, request.SecondOperand, request.FirstOperand + request.SecondOperand);
return(Task.FromResult(new OperationResponse()
{
Result = result
}));
}
public void ItShouldAcceptNewlineDelimiter(string input, int expected)
{
var controller = new CalculatorController(new CalculatorService());
var numbers = new SumRequest {
Numbers = input
};
var response = controller.Post(numbers);
response.Result.Should().Be(expected);
}
public void TestMethod1()
{
SumRequest sum = new SumRequest()
{
a = 3, b = 4
};
IOperationFactory operationFactory = new OperationFactory(_logger, _sumRepository, _subtractRepository);
var operation = operationFactory.Create(sum);
Assert.AreEqual(typeof(SumOperation), operation.GetType());
}
public override Task <SumResponse> Sum(SumRequest request, ServerCallContext context)
{
long sum = request.FirstNumber + request.SecondNumber;
SumResponse sumResponse = new()
{
Result = sum
};
return(Task.FromResult(sumResponse));
}
}
public void ShouldReturnTheNumberPassedIn()
{
const string input = "1";
const int expected = 1;
var controller = new CalculatorController(new CalculatorService());
var numbers = new SumRequest {
Numbers = input
};
var response = controller.Post(numbers);
response.Result.Should().Be(expected);
}
public IActionResult SumValues([FromQuery] SumRequest result)
{
if (result.A == null || result.B == null)
{
ModelState.AddModelError("", "Required params not set");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(result));
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
internal static string GetSumText(SumRequest request)
{
if (cache.TryGetValue(request, out var commandText) == false)
{
var statementBuilder = EnsureStatementBuilder(request.Connection, request.StatementBuilder);
commandText = statementBuilder.CreateSum(new QueryBuilder(),
request.Name,
request.Field,
request.Where,
request.Hints);
cache.TryAdd(request, commandText);
}
return(commandText);
}
public void CheckSum()
{
SumRequest sum = new SumRequest()
{
a = 3, b = 4
};
IOperation sumOperation = new SumOperation(_logger, _repositoryMock.Object);
_repositoryMock.Setup(x => x.Sum(sum.a, sum.b)).Returns(7);
var result = (SumResponse)sumOperation.Execute(sum);
Assert.AreEqual(7, result.Result);
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Characters.CharactersClient(channel);
if (1 == 2)
{
var response = await client.GetCharacterAsync(new CharacterRequest { Id = 3 });
Console.WriteLine($"character is: {response.Character.FirstName} {response.Character.LastName}");
}
if (1 == 2)
{
var request = client.SearchCharacters(new SearchRequest {
Query = "s"
});
await foreach (var response in request.ResponseStream.ReadAllAsync())
{
Console.WriteLine($"charater is: {response.Character.FirstName} {response.Character.LastName}");
}
}
var key = Console.ReadKey();
using (var call = client.DoSum())
{
while (char.IsDigit(key.KeyChar))
{
var number = int.Parse(key.KeyChar.ToString());
var request = new SumRequest {
Value = number
};
await call.RequestStream.WriteAsync(request);
key = Console.ReadKey();
}
await call.RequestStream.CompleteAsync();
var response = await call.ResponseAsync;
Console.WriteLine();
Console.WriteLine($"Total is {response.Total}");
}
Console.ReadKey();
}
//Unary Sum
public static void DoSimpleSum(Channel channel)
{
var client = new SumService.SumServiceClient(channel);
var sum = new Sum.Sum()
{
FirstNumber = "3",
LastNumber = "10"
};
var request = new SumRequest()
{
Sum = sum
};
var response = client.SumNumbers(request);
Console.WriteLine(response.Result);
}
static void Main(string[] args)
{
try
{
Thread.Sleep(1000);
Channel channel = new Channel($"localhost:{_port}", ChannelCredentials.Insecure);
channel.ConnectAsync().ContinueWith((task) =>
{
//var taskResult = (task.Status == Tasks.TaskStatus.RanToCompletion ?
// "Client Ran Successfully" :
// $"TaskStatus : {task.ToString()}");
//Console.ReadKey();
//Console.WriteLine(taskResult);
if (task.Status == Tasks.TaskStatus.RanToCompletion)
{
Console.WriteLine("The Client connected successfully");
}
else
{
Console.WriteLine($"Client Task Status: {task.ToString()}");
}
});
var client = new SumService.SumServiceClient(channel);
var request = new SumRequest()
{
Number1 = 10,
Number2 = 3
};
Console.WriteLine($"Client sending {request.Number1}, {request.Number2}");
var response = client.Sum(request);
Console.WriteLine($"Result: {response.Result}");
Console.ReadKey();
}
catch (IOException ex)
{
Console.WriteLine($"Error : {ex.Message}");
}
}
public static string Add()
{
SumRequest req = new SumRequest();
Console.WriteLine("Introduce cuantos numeros deseas sumar");
int cuantos = ParseStringToInteger(Console.ReadLine());
req.Addends = new int[cuantos];
Console.WriteLine("Introduce los " + cuantos + " numeros a sumar");
for (int i = 0; i < cuantos; i++)
{
req.Addends[i] = ParseStringToInteger(Console.ReadLine());
}
var rep = JsonConvert.DeserializeObject <SumResponse>(LaunchRequestAndReceiveResponse(req, "add"));
return(rep.Sum.ToString());
}
public async Task ItShouldReturnSumOfNumbers(string input, int expected)
{
using (var client = TestClient.CreateClient())
{
var numbers = new SumRequest {
Numbers = input
};
var content = new StringContent(JsonConvert.SerializeObject(numbers), Encoding.UTF8, "application/json");
using (var response = await client.PostAsync("/api/calculator", content))
{
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsStreamAsync();
result.Should().Be(expected);
}
}
}
public async Task <ActionResult <SumResponse> > PostSum([FromBody] SumRequest request)
{
var validate = sumValidator.Validate(request);
if (!validate.IsValid)
{
return(BadRequest(new ErrorResponse("BadRequest", "Unable to process request", "400", validate.Errors)));
}
var parameters = mapper.Map <SumParams>(request);
var operation = GetOp <SumParams, IntResult>(nameof(SumService));
var result = await operation.Execute(parameters);
logger.LogInformation($"PostSum executed");
var resultResponse = this.mapper.Map <SumResponse>(result);
return(resultResponse);
}
public SumResponse Postadd([FromBody] SumRequest sumandos)
{
SumResponse sum = new SumResponse
{
Sum = 0
};
foreach (int num in sumandos.Addends)
{
sum.Sum = sum.Sum + num;
}
if (Request.Headers["X-Evi-Tracking-Id"].Any())
{
var identification = Request.Headers["X-Evi-Tracking-Id"];
var currentUser = UsersHandler.KnownOrNot(identification);
currentUser.Operations.Add(new AddOperation(sumandos, sum));
}
return(sum);
}
public SumResponse Sum([FromQuery] SumRequest request)
{
var res = CreateSumResponse();
try
{
lock (objLock)
{
var sum = request.a + request.b;
res.Sum = sum;
}
}
catch (Exception ex)
{
res.Error = ex.Message;
res.Succeeded = false;
}
return(res);
}
