private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions)
{
var statements = new LinkedList <StatementSyntax>();
const string MultipartVariableName = "multipartContent";
const string MultipartAddMethodName = "Add";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(
MultipartVariableName,
nameof(MultipartContent))));
if (!string.IsNullOrEmpty(curlOptions.Payload))
{
var stringContentCreation = CreateStringContentCreation(curlOptions);
var addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(stringContentCreation)));
statements.AddLast(addStatement.AppendWhiteSpace());
}
foreach (var file in curlOptions.Files)
{
var fileReadExpression = RoslynExtensions.CreateInvocationExpression(
"File",
"ReadAllBytes",
RoslynExtensions.CreateStringLiteralArgument(file));
var byteArrayContentExpression = RoslynExtensions.CreateObjectCreationExpression(
"ByteArrayContent",
SyntaxFactory.Argument(fileReadExpression));
var addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(byteArrayContentExpression)));
statements.AddLast(addStatement);
}
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}
/// <summary>
/// Generates the multipart content statements.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/>.</returns>
/// <remarks>
/// var multipartContent = new MultipartContent();
/// multipartContent.Add(new StringContent("test", Encoding.UTF8, "application/x-www-form-urlencoded"));
/// multipartContent.Add(new ByteArrayContent(File.ReadAllBytes("file1.txt")));
/// request.Content = multipartContent;
/// </remarks>
private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions)
{
var statements = new LinkedList <StatementSyntax>();
const string MultipartVariableName = "multipartContent";
const string MultipartAddMethodName = "Add";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(
MultipartVariableName,
nameof(MultipartContent))));
if (!string.IsNullOrEmpty(curlOptions.Payload))
{
var stringContentCreation = CreateStringContentCreation(curlOptions);
var addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(stringContentCreation)));
statements.AddLast(addStatement.AppendWhiteSpace());
}
foreach (var file in curlOptions.DataFiles)
{
var byteArrayContentExpression = CreateNewByteArrayContentExpression(file);
var addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(byteArrayContentExpression)));
statements.AddLast(addStatement);
}
statements.AddLast(SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
RequestContentPropertyName,
SyntaxFactory.IdentifierName(MultipartVariableName))));
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <param name="result">The result.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(
CurlOptions curlOptions,
ConvertResult <string> result)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy)
{
if (IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"Proxy",
RoslynExtensions.CreateObjectCreationExpression("WebProxy", RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUri.ToString())));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
else
{
result.Warnings.Add($"Proxy scheme \"{curlOptions.ProxyUri.Scheme}\" is not supported");
}
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy && IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = CreateProxyStatements(curlOptions);
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.IsCompressed)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"AutomaticDecompression",
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.BitwiseNotExpression, RoslynExtensions.CreateMemberAccessExpression("DecompressionMethods", "None")));
memberAssignmentExpression = memberAssignmentExpression
.PrependComment(Chars.NewLineString + "// If you are using .NET Core 3.0+ you can replace `~DecompressionMethods.None` to `DecompressionMethods.All`");
statementSyntaxs.AddLast(SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasCertificate && IsSupportedCertificate(curlOptions.CertificateType))
{
foreach (var declarationSyntax in CreateCertificateStatement(curlOptions))
{
statementSyntaxs.AddLast(declarationSyntax);
}
}
if (curlOptions.Insecure)
{
var parameterListSyntax = RoslynExtensions.CreateParameterListSyntax(
"requestMessage",
"certificate",
"chain",
"policyErrors");
var lambdaExpression = SyntaxFactory.ParenthesizedLambdaExpression(
parameterListSyntax,
SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, SyntaxFactory.Token(SyntaxKind.TrueKeyword)));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ServerCertificateCustomValidationCallback",
lambdaExpression))));
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
/// <summary>
/// Generates the multipart content statements.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/>.</returns>
/// <remarks>
/// var multipartContent = new MultipartFormDataContent();
/// multipartContent.Add(new StringContent("John"), "name");
/// multipartContent.Add(new ByteArrayContent(File.ReadAllBytes("D:\\text.txt")), "shoesize", Path.GetFileName("D:\\text.txt"));
/// request.Content = multipartContent;
/// </remarks>
private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions)
{
var statements = new LinkedList <StatementSyntax>();
const string MultipartVariableName = "multipartContent";
const string MultipartAddMethodName = "Add";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(
MultipartVariableName,
nameof(MultipartFormDataContent))));
int fileCounter = 1;
foreach (var data in curlOptions.FormData)
{
StatementSyntax addStatement;
if (data.Type == UploadDataType.Inline)
{
var contentExpression = RoslynExtensions.CreateObjectCreationExpression(
nameof(StringContent),
RoslynExtensions.CreateStringLiteralArgument(data.Content));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name)));
}
else if (data.Type == UploadDataType.BinaryFile)
{
var getFileNameArgument = string.IsNullOrEmpty(data.FileName)
? SyntaxFactory.Argument(
RoslynExtensions.CreateInvocationExpression(
nameof(Path),
nameof(Path.GetFileName),
RoslynExtensions.CreateStringLiteralArgument(data.Content)))
: RoslynExtensions.CreateStringLiteralArgument(data.FileName);
// If the file has content type, we should add it to ByteArrayContent headers
var contentExpression = CreateNewByteArrayContentExpression(data.Content);
ExpressionSyntax contentArgumentExpression;
if (string.IsNullOrEmpty(data.ContentType))
{
contentArgumentExpression = contentExpression;
}
else
{
var byteArrayVariableName = "file" + fileCounter;
var byteArrayContentInitialization = RoslynExtensions.CreateVariableInitializationExpression(byteArrayVariableName, contentExpression);
statements.AddLast(SyntaxFactory.LocalDeclarationStatement(byteArrayContentInitialization));
statements.AddLast(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
byteArrayVariableName,
"Headers",
"Add",
RoslynExtensions.CreateStringLiteralArgument("Content-Type"),
RoslynExtensions.CreateStringLiteralArgument(data.ContentType))));
contentArgumentExpression = SyntaxFactory.IdentifierName(byteArrayVariableName);
}
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentArgumentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name),
getFileNameArgument));
}
else
{
var contentExpression = RoslynExtensions.CreateObjectCreationExpression(
nameof(StringContent),
SyntaxFactory.Argument(CreateFileReadAllTextExpression(data.Content)));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name)));
}
statements.AddLast(addStatement);
}
statements.AddLast(SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
RequestContentPropertyName,
SyntaxFactory.IdentifierName(MultipartVariableName))));
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}
/// <summary>
/// Generates the string content creation statements.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/>.</returns>
/// <remarks>
/// request.Content = new StringContent("{\"status\": \"resolved\"}", Encoding.UTF8, "application/json");
/// </remarks>
private IEnumerable <StatementSyntax> CreateStringContentAssignmentStatement(CurlOptions curlOptions)
{
var expressions = new LinkedList <ExpressionSyntax>();
foreach (var data in curlOptions.UploadData)
{
if (data.IsUrlEncoded)
{
ExpressionSyntax dataExpression;
if (data.IsFile)
{
dataExpression = CreateFileReadAllTextExpression(data.Content);
}
else
{
dataExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(data.Content));
}
dataExpression = RoslynExtensions.CreateInvocationExpression("Uri", "EscapeDataString", SyntaxFactory.Argument(dataExpression));
if (data.HasName)
{
dataExpression =
RoslynExtensions.CreateInterpolatedStringExpression($"{data.Name}=", dataExpression);
}
expressions.AddLast(dataExpression);
continue;
}
if (data.Type == UploadDataType.BinaryFile)
{
var readFileExpression = CreateFileReadAllTextExpression(data.Content);
expressions.AddLast(readFileExpression);
continue;
}
if (data.Type == UploadDataType.InlineFile)
{
var readFileExpression = CreateFileReadAllTextExpression(data.Content);
var replaceNewLines = RoslynExtensions.CreateInvocationExpression(
"Regex",
"Replace",
SyntaxFactory.Argument(readFileExpression),
RoslynExtensions.CreateStringLiteralArgument(@"(?:\r\n|\n|\r)"),
SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("string", "Empty")));
expressions.AddLast(replaceNewLines);
continue;
}
expressions.AddLast(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(data.Content)));
}
var statements = new LinkedList <StatementSyntax>();
ArgumentSyntax stringContentArgumentSyntax;
if (expressions.Count > 1)
{
var contentListVariableName = "contentList";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(contentListVariableName, "List<string>")));
foreach (var expression in expressions)
{
statements.AddLast(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
contentListVariableName,
"Add",
SyntaxFactory.Argument(expression))));
}
stringContentArgumentSyntax = SyntaxFactory.Argument(
RoslynExtensions.CreateInvocationExpression(
"string",
"Join",
RoslynExtensions.CreateStringLiteralArgument("&"),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName(contentListVariableName))));
}
else
{
stringContentArgumentSyntax = SyntaxFactory.Argument(expressions.First.Value);
}
var stringContentCreation = CreateStringContentCreation(
stringContentArgumentSyntax);
statements.AddLast(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
RequestContentPropertyName,
stringContentCreation)));
var memberAccessExpressionSyntax = RoslynExtensions.CreateMemberAccessExpression(
RoslynExtensions.CreateMemberAccessExpression(
RoslynExtensions.CreateMemberAccessExpression(RequestVariableName, RequestContentPropertyName),
"Headers"),
"ContentType");
statements.AddLast(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
memberAccessExpressionSyntax,
RoslynExtensions.CreateInvocationExpression("MediaTypeHeaderValue", "Parse", RoslynExtensions.CreateStringLiteralArgument(curlOptions.GetHeader(HeaderNames.ContentType))))));
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy && IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = CreateProxyStatements(curlOptions);
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasCertificate && IsSupportedCertificate(curlOptions.CertificateType))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ClientCertificateOptions",
RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual"));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
}
var newCertificateExpression = RoslynExtensions.CreateObjectCreationExpression(
"X509Certificate2",
newCertificateArguments.ToArray());
var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression(
HandlerVariableName,
"ClientCertificates",
"Add",
SyntaxFactory.Argument(newCertificateExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression)));
}
if (curlOptions.Insecure)
{
var parameterListSyntax = RoslynExtensions.CreateParameterListSyntax(
"requestMessage",
"certificate",
"chain",
"policyErrors");
var lambdaExpression = SyntaxFactory.ParenthesizedLambdaExpression(
parameterListSyntax,
SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, SyntaxFactory.Token(SyntaxKind.TrueKeyword)));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(
SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ServerCertificateCustomValidationCallback",
lambdaExpression))));
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
/// <summary>
/// Generate the statements for HttpClient handler configuration.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns>
/// <remarks>
/// var handler = new HttpClientHandler();
/// handler.UseCookies = false;
/// </remarks>
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions)
{
var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>();
var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression(
HandlerVariableName,
nameof(HttpClientHandler));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization)));
if (curlOptions.HasCookies)
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"UseCookies",
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasProxy && IsSupportedProxy(curlOptions.ProxyUri))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"Proxy",
RoslynExtensions.CreateObjectCreationExpression("WebProxy", RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUri.ToString())));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
}
if (curlOptions.HasCertificate && IsSupportedCertificate(curlOptions.CertificateType))
{
var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression(
HandlerVariableName,
"ClientCertificateOptions",
RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual"));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)));
var newCertificateArguments = new LinkedList <ArgumentSyntax>();
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName));
if (curlOptions.HasCertificatePassword)
{
newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword));
}
var newCertificateExpression = RoslynExtensions.CreateObjectCreationExpression(
"X509Certificate2",
newCertificateArguments.ToArray());
var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression(
HandlerVariableName,
"ClientCertificates",
"Add",
SyntaxFactory.Argument(newCertificateExpression));
statementSyntaxs.AddLast(
SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression)));
}
statementSyntaxs.TryAppendWhiteSpaceAtEnd();
return(statementSyntaxs);
}
/// <summary>
/// Generates the multipart content statements.
/// </summary>
/// <param name="curlOptions">The curl options.</param>
/// <returns>Collection of <see cref="StatementSyntax"/>.</returns>
/// <remarks>
/// var multipartContent = new MultipartFormDataContent();
/// multipartContent.Add(new StringContent("John"), "name");
/// multipartContent.Add(new ByteArrayContent(File.ReadAllBytes("D:\\text.txt")), "shoesize", Path.GetFileName("D:\\text.txt"));
/// request.Content = multipartContent;
/// </remarks>
private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions)
{
var statements = new LinkedList <StatementSyntax>();
const string MultipartVariableName = "multipartContent";
const string MultipartAddMethodName = "Add";
statements.AddLast(
SyntaxFactory.LocalDeclarationStatement(
RoslynExtensions.CreateVariableFromNewObjectExpression(
MultipartVariableName,
nameof(MultipartFormDataContent))));
foreach (var data in curlOptions.FormData)
{
StatementSyntax addStatement;
if (data.Type == UploadDataType.Inline)
{
var contentExpression = RoslynExtensions.CreateObjectCreationExpression(
nameof(StringContent),
RoslynExtensions.CreateStringLiteralArgument(data.Content));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name)));
}
else if (data.Type == UploadDataType.BinaryFile)
{
var contentExpression = CreateNewByteArrayContentExpression(data.Content);
var getFileNameSyntax = RoslynExtensions.CreateInvocationExpression(
nameof(Path),
nameof(Path.GetFileName),
RoslynExtensions.CreateStringLiteralArgument(data.Content));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name),
SyntaxFactory.Argument(getFileNameSyntax)));
}
else
{
var contentExpression = RoslynExtensions.CreateObjectCreationExpression(
nameof(StringContent),
SyntaxFactory.Argument(CreateFileReadAllTextExpression(data.Content)));
addStatement = SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateInvocationExpression(
MultipartVariableName,
MultipartAddMethodName,
SyntaxFactory.Argument(contentExpression),
RoslynExtensions.CreateStringLiteralArgument(data.Name)));
}
statements.AddLast(addStatement);
}
statements.AddLast(SyntaxFactory.ExpressionStatement(
RoslynExtensions.CreateMemberAssignmentExpression(
RequestVariableName,
RequestContentPropertyName,
SyntaxFactory.IdentifierName(MultipartVariableName))));
statements.TryAppendWhiteSpaceAtEnd();
return(statements);
}