C# 如何通过POST将参数传递给Azure函数？

我正在尝试做一个简单的Azure函数来了解它。将有3个功能：

• 1函数将行插入数据库的表中。此表将包含当前日期和由用户键入并由GET传递的字符串参数
• 1函数类似于前一个函数，但通过POST传递参数
• 1函数读取表格并显示其内容

我已经能做第一个和第三个了。但是我不能通过POST传递参数。我已经寻找了一些例子，但我无法成功地运行它们。客户端应用程序是Windows窗体应用程序

有人能给我举个例子说明如何通过POST将参数传递给函数以及如何读取参数吗

谢谢，这是事先准备好的

编辑：

下面是通过GET传递参数的代码（这工作正常）：

private void按钮2\u单击（对象发送者，事件参数e）
{
字符串cadena=lsql1.Text+“？notas=“+tNotas.Text；
尝试
{
HttpWebRequest req=（HttpWebRequest）WebRequest.Create（cadena）；
HttpWebResponse res=（HttpWebResponse）req.GetResponse（）；
if（res.StatusCode==HttpStatusCode.OK）
{
MessageBox.Show（“Grabado”）；
}
其他的
{
MessageBox.Show（res.StatusDescription）；
}
}捕获（WebException ex）
{
使用（流s=ex.Response.GetResponseStream（））
{
StreamReader sr=新的StreamReader；
string text=sr.ReadToEnd（）；
text=text.Substring（1，text.Length-2）；
高级关闭（）；
text=文本。替换（“\\”，“”）；
text=“{”+text+“}”；
错误mensajeError=JsonConvert.DeserializeObject（文本）；
MessageBox.Show（mensajeError.ExceptionMessage）；
}
}
}

下面是接收和插入的代码（这也起作用）：

[FunctionName（“sql1”）]
公共静态异步任务运行（HttpRequestMessage请求、TraceWriter日志）
{
尝试
{
Info（“C#HTTP触发器函数处理了一个请求。”）；
var cnnString=“Server=SERVIDOR；Database=base\u prueba；User ID=azure；Password=0000；Trusted\u Connection=False；Encrypt=False；”；
使用（SqlConnection连接=新的SqlConnection（cnnString））
{
connection.Open（）；
SqlCommand cmd=connection.CreateCommand（）；
DateTime fecha=DateTime.Today；
字符串notas=req.GetQueryNameValuePairs（）
.FirstOrDefault（q=>string.Compare（q.Key，“notas”，true）==0）
价值
//将日志插入数据库
cmd.CommandText=“插入Prueba_Azure（fecha，notas）值（“+fecha.ToString（）+”，“+notas+”）”；
cmd.ExecuteNonQuery（）；
}
//获取请求主体
动态数据=wait req.Content.ReadAsAsync（）；
返回名称==req.CreateResponse（HttpStatusCode.OK，“Done”）；
}
捕获（例外情况除外）
{
HttpResponseMessage res=req.CreateErrorResponse（HttpStatusCode.InternalServerError，ex）；
返回res；
}
}

---

我要寻找的是通过POST来获取请求内容。要从请求正文（POST请求）获取请求内容，可以使用req.content.ReadAsAsync方法。下面是代码示例

样本请求主体

{
    "name": "Azure"
}

定义一个类来反序列化post数据

public class PostData
{
    public string name { get;set; }    
}

获取post数据并显示它

PostData data = await req.Content.ReadAsAsync<PostData>();
log.Info("name:" + data.name);

---

您需要将数据附加到post请求的正文并正确处理它：

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, TraceWriter log) {
    // This reads your post request body into variable "data"
    string data = await req.Content.ReadAsStringAsync();
    // Here you can process json into an object
    dynamic parsed = JsonConvert.DeserializeObject(data);

    return exitstring == null
        ? req.CreateResponse(HttpStatusCode.BadRequest, "Something went wrong, sorry")
        : req.CreateResponse(HttpStatusCode.OK);
}

公共静态异步任务运行（HttpRequestMessage请求，TraceWriter日志）{
//这会将post请求正文读入变量“data”
字符串数据=wait req.Content.ReadAsStringAsync（）；
//在这里，您可以将json处理为一个对象
dynamic parsed=JsonConvert.DeserializeObject（数据）；
返回exitstring==null
？req.CreateResponse（HttpStatusCode.BadRequest，“出错，抱歉”）
：req.CreateResponse（HttpStatusCode.OK）；
}

您可以找到一个稍微不同的示例和确切的示例。

查询字符串（名称/值对）默认情况下在POST请求的HTTP消息体中发送，而不是作为查询字符串发送。该方法将解析查询字符串，并且默认情况下不适用于POST请求

对于POST请求，您可以使用类似以下内容：

var content = request.Content;
string contentInString = content.ReadAsStringAsync().Result;

---

要将参数作为POST请求传递，您需要执行以下操作：

为需要传递的参数建立Json模型，例如：

{"UserProfile":{ "UserId":"xyz1","FirstName":"Tom","LastName":"Hank" }}

使用类似客户端的POSTMAN发布数据模型

现在您将在HttpRequestMessage正文中获得发布的内容，示例代码如下：

[FunctionName("TestPost")]
public static HttpResponseMessage POST([HttpTrigger(AuthorizationLevel.Function, "put", "post", Route = null)]HttpRequestMessage req, TraceWriter log)
{
    try
    {
        //create redis connection and database
        var RedisConnection = RedisConnectionFactory.GetConnection();
        var serializer = new NewtonsoftSerializer();
        var cacheClient = new StackExchangeRedisCacheClient(RedisConnection, serializer);

        //read json object from request body
        var content = req.Content;
        string JsonContent = content.ReadAsStringAsync().Result;

        var expirytime = DateTime.Now.AddHours(Convert.ToInt16(ConfigurationSettings.AppSettings["ExpiresAt"]));

        SessionModel ObjModel = JsonConvert.DeserializeObject<SessionModel>(JsonContent);
        bool added = cacheClient.Add("RedisKey", ObjModel, expirytime); //store to cache 

        return req.CreateResponse(HttpStatusCode.OK, "RedisKey");
    }
    catch (Exception ex)
    {
        return req.CreateErrorResponse(HttpStatusCode.InternalServerError, "an error has occured");
    }
}

[FunctionName（“TestPost”）]
公共静态HttpResponseMessagePost（[HttpTrigger（AuthorizationLevel.Function，“put”，“POST”，Route=null）]HttpRequestMessage请求，TraceWriter日志）
{
尝试
{
//创建redis连接和数据库
var RedisConnection=RedisConnectionFactory.GetConnection（）；
var serializer=newnewtonsoftserializer（）；
var cacheClient=新的StackExchangeDiscacheClient（重新连接，序列化程序）；
//从请求体读取json对象
var内容=所需内容；
字符串JsonContent=content.ReadAsStringAsync（）.Result；
var expirytime=DateTime.Now.AddHours（Convert.ToInt16（ConfigurationSettings.AppSettings[“ExpiresAt”]）；
SessionModel ObjModel=JsonConvert.DeserializeObject（JsonContent）；
bool added=cacheClient.Add（“RedisKey”，ObjModel，expirytime）；//存储到缓存
返回请求CreateResponse（HttpStatusCode.OK，“RedisKey”）；
}
捕获（例外情况除外）
{
return req.CreateErrorResponse（HttpStatusCode.InternalServerError，“发生错误”）；
}
}

---

如果谷歌把你带到这里，这就是2019年3月的情况（Azure功能v3）：

公共静态异步
var content = request.Content;
string contentInString = content.ReadAsStringAsync().Result;

{"UserProfile":{ "UserId":"xyz1","FirstName":"Tom","LastName":"Hank" }}

[FunctionName("TestPost")]
public static HttpResponseMessage POST([HttpTrigger(AuthorizationLevel.Function, "put", "post", Route = null)]HttpRequestMessage req, TraceWriter log)
{
    try
    {
        //create redis connection and database
        var RedisConnection = RedisConnectionFactory.GetConnection();
        var serializer = new NewtonsoftSerializer();
        var cacheClient = new StackExchangeRedisCacheClient(RedisConnection, serializer);

        //read json object from request body
        var content = req.Content;
        string JsonContent = content.ReadAsStringAsync().Result;

        var expirytime = DateTime.Now.AddHours(Convert.ToInt16(ConfigurationSettings.AppSettings["ExpiresAt"]));

        SessionModel ObjModel = JsonConvert.DeserializeObject<SessionModel>(JsonContent);
        bool added = cacheClient.Add("RedisKey", ObjModel, expirytime); //store to cache 

        return req.CreateResponse(HttpStatusCode.OK, "RedisKey");
    }
    catch (Exception ex)
    {
        return req.CreateErrorResponse(HttpStatusCode.InternalServerError, "an error has occured");
    }
}

public static async void Run(
            [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)]
            HttpRequest req,
            ILogger log)
        {
            var content = await new StreamReader(req.Body).ReadToEndAsync();

            MyClass myClass = JsonConvert.DeserializeObject<MyClass>(content);
            
        }

[FunctionName("PostParameterFunction")]
public static async Task<HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]HttpRequestMessage req, ILogger log)
   {
      log.LogInformation("C# HTTP trigger function processed a request.");

       try
        {
             // Convert all request perameter into Json object

                var content = req.Content;
                string jsonContent = content.ReadAsStringAsync().Result;
                dynamic requestPram = JsonConvert.DeserializeObject<RequestModel>(jsonContent);

                // Validate the required param

                if (string.IsNullOrEmpty(requestPram.FirstName))
                {
                    return req.CreateResponse(HttpStatusCode.OK, "Please enter First Name!");
                }
                if (string.IsNullOrEmpty(requestPram.LastName))
                {
                    return req.CreateResponse(HttpStatusCode.OK, "Please enter Last Name!");
                }


                //Create object for partner Model to bind the response on it

                RequestModel objRequestModel = new RequestModel();

                objRequestModel.FirstName = requestPram.FirstName;
                objRequestModel.LastName = requestPram.LastName;

                //Return Request Model

                return req.CreateResponse(HttpStatusCode.OK, objRequestModel);
         }
        catch (Exception ex)
         {

                return req.CreateResponse(HttpStatusCode.OK, "Cannot Create Request! Reason: {0}", string.Format(ex.Message));
         }

        }

{
    "FirstName": "Kiron",
    "LastName":"Test"
}

using System;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Host;

namespace MyFunctions
{
    public static class MyFunctionsOperations
    {
        [FunctionName("MyFunctionsOperations")]
        public static async Task<HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)]HttpRequestMessage req, TraceWriter log)
        {
            log.Info("C# HTTP trigger function processed a request.");
            var headers = req.Headers;
            string collection = headers.GetValues("collection").First();   //getting parameter from header

            CosmosdbOperation obj = new CosmosdbOperation();
            dynamic data = await req.Content.ReadAsAsync<object>();  //getting body content
            Boolean response = await obj.MyFunctionExecution(data.ToString(), collection);

            return (response)
                ? req.CreateResponse(HttpStatusCode.BadRequest, "Please pass a proper argument in the request body")
                : req.CreateResponse(HttpStatusCode.OK, "Operation successfully executed..");
        }
    }
}

[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
[Binding]
public sealed class FromBodyAttribute : Attribute
{
}

public class FromBodyBinding : IBinding
{
    private readonly ILogger logger;
    public FromBodyBinding(ILogger logger)
    {
        this.logger = logger;
    }
    public Task<IValueProvider> BindAsync(BindingContext context)
    {
        // Get the HTTP request
        var request = context.BindingData["req"] as DefaultHttpRequest;

        return Task.FromResult<IValueProvider>(new FromBodyValueProvider(request, logger));
    }

    public bool FromAttribute => true;


    public Task<IValueProvider> BindAsync(object value, ValueBindingContext context)
    {
        return null;
    }

    public ParameterDescriptor ToParameterDescriptor() => new ParameterDescriptor();
}

public class FromBodyBindingProvider : IBindingProvider
{
    private readonly ILogger logger;
    public FromBodyBindingProvider(ILogger logger)
    {
        this.logger = logger;
    }

    public Task<IBinding> TryCreateAsync(BindingProviderContext context)
    {
        IBinding binding = new FromBodyBinding(this.logger);
        return Task.FromResult(binding);
    }
}

public class FromBodyValueProvider : IValueProvider
{
    private HttpRequest request;
    private ILogger logger;

    public FromBodyValueProvider(HttpRequest request, ILogger logger)
    {
        this.request = request;
        this.logger = logger;
    }

    public async Task<object> GetValueAsync()
    {
        try
        {
            string requestBody = await new StreamReader(this.request.Body).ReadToEndAsync();
            object result = JsonConvert.DeserializeObject(requestBody);
            return result;
        }
        catch (System.Exception ex)
        {
            this.logger.LogCritical(ex, "Error deserializing object from body");

            throw ex;
        }
    }

    public Type Type => typeof(object);

    public string ToInvokeString() => string.Empty;
}

public class BindingExtensionProvider : IExtensionConfigProvider
{
    private readonly ILogger logger;
    public BindingExtensionProvider(ILogger<Startup> logger)
    {
        this.logger = logger;
    }

    public void Initialize(ExtensionConfigContext context)
    {
        // Creates a rule that links the attribute to the binding
        context.AddBindingRule<FromBodyAttribute>().Bind(new FromBodyBindingProvider(this.logger));
    }
}

public class Startup : IWebJobsStartup
{
    public void Configure(IWebJobsBuilder builder)
    {
        JsonConvert.DefaultSettings = () =>
        {
            return new JsonSerializerSettings()
            {
                ContractResolver = new DefaultContractResolver
                {
                    NamingStrategy = new CamelCaseNamingStrategy()
                },
                Formatting = Formatting.Indented
            };
        };

        builder.Services.AddLogging();
        builder.AddExtension<BindingExtensionProvider>();

    }
}

[FunctionName("MyFunction")]
public async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
    [Binding.FromBody] dynamic data) // or you can change 'dynamic' to some class
{
    string username = data?.username;
    ...
}

public static async Task Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)]
    HttpRequest req,
    ILogger log)
{
    MyClass myClass = await JsonSerializer.DeserializeAsync<MyClass>(req.Body);
}