public static string GetValue(this StringValues stringValues)
{
if (stringValues.Count == 1)
{
return(stringValues);
}
return(stringValues.ToArray().LastOrDefault());
}
public void AddHeader(string key, StringValues values)
{
var matching = Headers.Where(h => h.Key == key).SelectMany(h => h.Value);
if (matching.Count() > 0)
{
Headers.Remove(key);
Headers.Add(key, matching.Union(values));
}
else
{
Headers.Add(key, values.ToArray());
}
}
private JToken CreateJToken(StringValues values)
{
switch (values.Count)
{
case 0:
return(JToken.Parse("''"));
case 1:
var value = values.First().Replace("'", @"\'");
return(JToken.Parse($"'{value}'"));
default:
return(JToken.Parse($"['{string.Join("','", values.ToArray())}']"));
}
}
public static string SelectAttributes <T>(StringValues fields)
{
Type modelType = typeof(T);
var attributeMap = (Dictionary <string, string>)modelType.GetField("Fields")?.GetValue(null);
var attributes = fields.Count > 0 ? fields.ToArray() : attributeMap.Keys.ToArray();
var fetch = new StringBuilder();
foreach (var attribute in attributes)
{
if (attributeMap.ContainsKey(attribute))
{
fetch.Append($"<attribute name='{attributeMap[attribute]}' />");
}
}
return(fetch.ToString());
}
private static IEnumerable <UserAgent> GetUserAgents(this HttpRequest request)
{
IHeaderDictionary headers = request.Headers;
StringValues userAgents = headers[HeaderNames.UserAgent];
string allUserAgents = String.Join(" ", userAgents.ToArray());
string[] userAgentParts = allUserAgents.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < userAgentParts.Length; i++)
{
string name = null;
string version = null;
string comment = null;
string userAgent = userAgentParts[i];
int slashIndex = userAgent.IndexOf('/');
if (slashIndex == -1)
{
name = userAgent;
}
else
{
name = userAgent.Substring(0, slashIndex);
version = userAgent.Substring(slashIndex + 1);
}
if (i < userAgentParts.Length - 1)
{
string nextPart = userAgentParts[i + 1];
if (nextPart.StartsWith("("))
{
comment = nextPart;
// Skip the next part
i++;
}
}
yield return(new UserAgent(name, version, comment));
}
}
// Normalize order and casing
internal static StringValues GetOrderCasingNormalizedStringValues(StringValues stringValues)
{
if (stringValues.Count == 1)
{
return(new StringValues(stringValues.ToString().ToUpperInvariant()));
}
else
{
var originalArray = stringValues.ToArray();
var newArray = new string[originalArray.Length];
for (var i = 0; i < originalArray.Length; i++)
{
newArray[i] = originalArray[i].ToUpperInvariant();
}
// Since the casing has already been normalized, use Ordinal comparison
Array.Sort(newArray, StringComparer.Ordinal);
return(new StringValues(newArray));
}
}
/// <summary>
/// Adds a header to the http request
/// </summary>
/// <param name="request">The SolidHttpRequest</param>
/// <param name="name">The name of the header</param>
/// <param name="values">More values for the header</param>
/// <returns></returns>
public static SolidHttpRequest WithHeader(this SolidHttpRequest request, string name, StringValues values)
{
return(request.WithHeaders(headers => headers.Add(name, values.ToArray())));
}
private static void SetModelProperty(this IDictionary <string, object> sourceModel,
string paramName, StringValues value)
{
/*
* sample of paramName:
* string1
* list[]
* model2s[0][double2]
* model2s[0][model3][string3]
* model2s[0][model3s][0][string3]
*/
var listProperties = paramName.Replace("]", string.Empty).Split("["); // do not remove empty string here
IDictionary <string, object> currentModel = sourceModel;
string currentPropertyName = "";
var currentIndex = 0;
while (currentIndex < listProperties.Length)
{
currentPropertyName = listProperties[currentIndex];
// array of primitive data: list[]
if (currentIndex < listProperties.Length - 1 && string.IsNullOrEmpty(listProperties[currentIndex + 1]))
{
// create new array
if (!currentModel.ContainsKey(currentPropertyName))
{
currentModel[currentPropertyName] = new List <string>();
}
var list = (List <string>)currentModel[currentPropertyName];
// add new value
list.AddRange(value.ToArray());
// expect to stop here, there should be no more property
if (currentIndex != listProperties.Length - 2)
{
throw new ArgumentException($"Invalid parameter: name='{paramName}', value='{string.Join(",", value)}'");
}
return;
}
// array of complex data: model2s[0]
if (currentIndex < listProperties.Length - 1 && int.TryParse(listProperties[currentIndex + 1], out int itemIndex))
{
if (!currentModel.ContainsKey(currentPropertyName))
{
// create new array
currentModel[currentPropertyName] = new List <ExpandoObject>();
}
var list = (List <ExpandoObject>)currentModel[currentPropertyName];
if (list.Count <= itemIndex)
{
// create new model
list.Add(new ExpandoObject());
}
currentModel = list[itemIndex];
currentIndex += 2;
}
// normal property
else
{
// not yet last property => current index is a model
if (currentIndex < listProperties.Length - 1)
{
if (!currentModel.ContainsKey(currentPropertyName))
{
currentModel[currentPropertyName] = new ExpandoObject();
}
currentModel = (IDictionary <string, object>)currentModel[currentPropertyName];
}
currentIndex++;
}
}
ValidateSingleValue(value);
currentModel[currentPropertyName] = value[0];
}
public TypeWithStringValues(StringValues values, string other = "abc")
{
Other = other;
Values = values.ToArray();
}
public async Task InvokeAsync(HttpContext context, RequestDelegate next)
{
var _httpClient = new HttpClient(new HttpClientHandler()
{
AllowAutoRedirect = false
});
string curPort = "";
if (context.Request.Query.TryGetValue("port", out StringValues forcedPort))
{
context.Response.Cookies.Delete("port");
context.Response.Cookies.Append("port", forcedPort);
curPort = forcedPort;
}
else
{
if (context.Request.Cookies.TryGetValue("port", out string cachedPort))
{
curPort = cachedPort;
}
}
if (!_portMappings.Contains(curPort))
{
await next.Invoke(context);
}
HttpRequestMessage request = new HttpRequestMessage();
if (!string.Equals(context.Request.Method, "GET", StringComparison.OrdinalIgnoreCase) && !string.Equals(context.Request.Method, "HEAD", StringComparison.OrdinalIgnoreCase) && (!string.Equals(context.Request.Method, "DELETE", StringComparison.OrdinalIgnoreCase) && !string.Equals(context.Request.Method, "TRACE", StringComparison.OrdinalIgnoreCase)))
{
StreamContent streamContent = new StreamContent(context.Request.Body);
request.Content = streamContent;
}
foreach (KeyValuePair <string, StringValues> header in context.Request.Headers)
{
HttpRequestHeaders headers1 = request.Headers;
string key1 = header.Key;
StringValues stringValues = header.Value;
string[] array1 = stringValues.ToArray();
if (!headers1.TryAddWithoutValidation(key1, array1) && request.Content != null)
{
HttpContent content = request.Content;
if (content != null)
{
HttpContentHeaders headers2 = content.Headers;
string key2 = header.Key;
stringValues = header.Value;
string[] array2 = stringValues.ToArray();
headers2.TryAddWithoutValidation(key2, array2);
}
}
}
request.Headers.Host = $"localhost:{curPort}";
string uriString =
$"http://localhost:{ curPort}{ context.Request.PathBase}{ context.Request.Path}{ context.Request.QueryString}";
request.RequestUri = new Uri(uriString);
request.Method = new HttpMethod(context.Request.Method);
HttpResponseMessage responseMessage = null;
try
{
responseMessage = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, context.RequestAborted);
// 处理重定向
if (responseMessage.StatusCode == HttpStatusCode.MovedPermanently)
{
context.Response.Redirect(responseMessage.Headers.Location.ToString());
}
context.Response.StatusCode = (int)responseMessage.StatusCode;
foreach (KeyValuePair <string, IEnumerable <string> > header in responseMessage.Headers)
{
context.Response.Headers[header.Key] = header.Value.ToArray();
}
foreach (KeyValuePair <string, IEnumerable <string> > header in responseMessage.Content.Headers)
{
context.Response.Headers[header.Key] = header.Value.ToArray();
}
context.Response.Headers.Remove("transfer-encoding");
//// 避免重定向引起的页面缓存
//if (context.Response.Headers.TryGetValue("Cache-Control",out _))
//{
// context.Response.Headers.Remove("Cache-Control");
//}
//context.Response.Headers.Add("Cache-Control", "must-revalidate");
await responseMessage.Content.CopyToAsync(context.Response.Body);
}
catch (Exception e)
{
_logger.LogWarning(e, "代理访问调用失败,request:{request}", request.ToJson());
await next.Invoke(context);
}
finally
{
responseMessage?.Dispose();
}
}
private static string[] Convert(StringValues items)
{
return(items.ToArray());
}
private IEnumerable <FilterRequest> DeserializeFiltersAndCreateFilterRequests(StringValues filterValues)
{
return(filterValues.ToArray()
.SelectMany(this.DeserializeFilter)
.Select(f => this.InterpretFilterRequest(f.Key, f.Value)));
}
public StringValuesModel(StringValues value)
{
Value = value.Count == 1 ? value.ToString() : default;
Values = value.Count != 1 ? value.ToArray() : default;
}
public void DefaultNullOrEmpty_ExpectedValues(StringValues stringValues)
{
Assert.Equal(0, stringValues.Count);
Assert.Null((string)stringValues);
Assert.Equal((string)null, stringValues);
Assert.Equal(string.Empty, stringValues.ToString());
Assert.Equal(new string[0], stringValues.ToArray());
Assert.True(StringValues.IsNullOrEmpty(stringValues));
Assert.Throws<IndexOutOfRangeException>(() => stringValues[0]);
Assert.Throws<IndexOutOfRangeException>(() => ((IList<string>)stringValues)[0]);
Assert.Equal(string.Empty, stringValues.ToString());
Assert.Equal(-1, ((IList<string>)stringValues).IndexOf(null));
Assert.Equal(-1, ((IList<string>)stringValues).IndexOf(string.Empty));
Assert.Equal(-1, ((IList<string>)stringValues).IndexOf("not there"));
Assert.False(((ICollection<string>)stringValues).Contains(null));
Assert.False(((ICollection<string>)stringValues).Contains(string.Empty));
Assert.False(((ICollection<string>)stringValues).Contains("not there"));
Assert.Equal(0, stringValues.Count());
}
/// <summary> /// Sets the forwarded for value to a <see cref="LogEntry"/>. /// </summary> /// <param name="logEntry">The log entry.</param> /// <param name="forwardedFor">The forwarded for value.</param> /// <returns>The same log entry.</returns> public static LogEntry SetForwardedFor(this LogEntry logEntry, StringValues forwardedFor) => logEntry.SetForwardedFor(forwardedFor.ToArray());
public static string GetBestMatch(List <string> mimeTypes, StringValues stringValues)
{
var requestMime = string.Join(", ", stringValues.ToArray() ?? new string[] {}).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(a => a.Trim());
return(requestMime.FirstOrDefault(a => mimeTypes.Select(Normalize).Any(b => _equal(a, b)))?.ToString());
}
public static string ContvertToString(this StringValues stringValues)
{
return(String.Join("|", stringValues.ToArray()));
}
