为什么将文件上传到 Slack 的两种（几乎）相似的方法（使用 c#）会导致不同的结果？

Question

so this question baffels me. I'll post quite abit of code to explain this one. First, I have and "old" version of code(c#), which I used to post messages and files to Slack. And this code works fine for me! The method of interest is the following:

public class PostMessage
    {       
        private string _token = "xoxp-MyToken";
        public string token { get { return _token; } }

        public string channel { get; set; }

        public string text { get; set; }

        public MultipartFormDataContent UploadFile()
        {
            var requestContent = new MultipartFormDataContent();
            var fileContent = new StreamContent(GetFile.ReadFile());
            requestContent.Add(new StringContent(token), "token");
            requestContent.Add(new StringContent(channel), "channels");
            requestContent.Add(fileContent, "file", Path.GetFileName(GetFile.path));

            return requestContent;
        }

    public static class GetFile
    {
        public static string path = @"C:\Users\f.held\Desktop\Held-Docs\Download.jpg";

        public static FileStream ReadFile()
        {            
            FileInfo fileInfo = new FileInfo(path);
            FileStream fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite);
            return fs;
        }
    }

Here is my client:

    public class SlackClient
    {
        public Uri _method { get; set; }
        private readonly HttpClient _httpClient = new HttpClient {};

        public SlackClient(Uri webhookUrl)
        {
            _method = webhookUrl;
        }

        public async Task<HttpResponseMessage> UploadFileAsync(MultipartFormDataContent requestContent)
        {           
            var response = await _httpClient.PostAsync(_method, requestContent);

            return response;
        }
}

And I call all of this in this Main:

    public static void Main(string[] args)
            {
                Task.WaitAll(TalkToSlackAsync());                    

            private static async Task TalkToSlackAsync()
            {

                            var webhookUrl = new Uri("https://slack.com/api/files.upload");
                            var slackClient = new SlackClient(webhookUrl);

                            PostMessage PM = new PostMessage();
                            PM.channel = "DCW21NBHD";

                            var cont = PM.UploadFile();

                            var response = await slackClient.UploadFileAsync(cont);
                            string content = await response.Content.ReadAsStringAsync();
        }          
}

So far, so good! But now it gets interesting. I build a similar version, in which I use Newtonsoft's Json NuGet-package

Now, first the code:

the client:

    public async Task<HttpResponseMessage> SendFileAsync(MultipartFormDataContent requestContent)
    {
        _httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "xoxp-MyToken");
        var response = await _httpClient.PostAsync(UriMethod, requestContent);

        return response;
    }

the same Filestram-method for reading the file:

public class Message
{
    public class GetFile // Just pass a path here as parameter!
    {
        public static string path = @"C:\Users\f.held\Desktop\Held-Docs\Download.jpg";

        public static FileStream ReadFile()
        {
            FileInfo fileInfo = new FileInfo(path);
            FileStream fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite);
            return fs;
        }
    }

the Json-class which I serialize:

public class JsonObject

    {
            [JsonProperty("file")]
            public string file { get; set; }
            [JsonProperty("channels")]
            public string channels { get; set; }
    }

And the Main:

class MainArea
{
    public static void Main( string[] args)
    {
        try
        {
            Task.WaitAll(SendMessage());
        }
        catch(Exception dudd)
        {
            Console.WriteLine(dudd);
            Console.ReadKey();
        }
    }
    private static async Task SendMessage()
    {
        var client = new BpsHttpClient("https://slack.com/api/files.upload");
        JsonObject JO = new JsonObject();
        JO.channels = "DCW21NBHD";

        var Json = JsonConvert.SerializeObject(JO, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });

        var StringJson = new StringContent(Json, Encoding.UTF8, "multipart/form-data");
        var DeSon = JsonConvert.DeserializeObject(Json);

        Console.WriteLine(DeSon);
        Console.ReadKey();

        var requestContent = new MultipartFormDataContent();
        var fileContent = new StreamContent(Message.GetFile.ReadFile());
        requestContent.Add(fileContent, "file", Path.GetFileName(Message.GetFile.path));
        requestContent.Add(StringJson);

        var ResponseFile = await client.SendFileAsync(requestContent);

        Console.WriteLine(ResponseFile);
        Console.ReadKey();
    }
}

So, both SEEM to work. But the latter of these methods does NOT post the file to the declared channel - it merely uploads it to Slack. Which would be fine, because I could then work with the 'public_url' to publicise it on any channel. BUT - BIG BUT - with the first method, it immediately loads it to my channel! And it tells me so in the response I get from Slack. The responses are in both exactly the same - except for the timestamps and file_id etc. obviously. But the ending is different! Here is the ending of the response from the old version:

"shares":{"private":{"DCW21NBHD":[{"reply_users":[],"reply_users_count":0,"reply_count":0,"ts":"1544025773.001700"}]}},"channels":[],"groups":[],"ims":["DCW21NBHD"]}}

and here is the answer from the new version:

"shares":{},"channels":[],"groups":[],"ims":[]}}

Okay now, why on god's green earth does one method do that and the other one does not? :D

Thanks to anybody who has some insight and knowledge on this specific "issue" and is willing to share!

Answer 1

As stated in the documentation for files.upload :

Present arguments as parameters in application/x-www-form-urlencoded querystring or POST body. This method does not currently accept application/json .

So the reason this does not work is that you are trying to provide the API parameters like channels as JSON, when this method does not support JSON. The result is that those properties are ignore, which is why the image is uploaded, but not shared in the designated channel.

To fix it simply provide your parameters as application/x-www-form-urlencoded querystring as you did in your 1st example.

Note that in general only a subset of the Slack API methods support using JSON for providing the parameters as listed here . If you want to use JSON, please double-check if the API method supports it, or stick with x-www-form-urlencoded (which is the standard for POST) to be on the safe side.