public string Protect(StringValues value, ProtectType protectType)
{
if (string.IsNullOrEmpty(value) || string.IsNullOrWhiteSpace(value))
{
return(value);
}
if (protectType == ProtectType.Truncate)
{
ReadOnlySpan <char> valueSpan = value.ToString();
return(new string(valueSpan.Slice(0, valueSpan.Length / 2)));
}
else
{
using var derivedBytes = new Rfc2898DeriveBytes(value.ToString(),
saltSize: 16,
iterations: 50000,
HashAlgorithmName.SHA256);
var key = derivedBytes.GetBytes(16);
return(Encoding.UTF8.GetString(key));
}
}
/// <summary>Invoke middleware</summary>
/// <param name="context">Http request context</param>
public async Task Invoke(HttpContext context)
{
StringValues traceId = string.Empty, xOriginalFor = string.Empty;
context.Request.Headers.TryGetValue("X-Original-For", out xOriginalFor);
if (context.Request.Headers.TryGetValue("TraceId", out traceId) == false)
{
traceId = Guid.NewGuid().ToString();
context.Request.Headers.Add("TraceId", traceId);
}
using (LogContext.PushProperty("TraceId", traceId.ToString()))
{
context
.Response
.OnStarting(
state =>
{
var httpContext = (HttpContext)state;
httpContext.Response.Headers.Add("TraceId", traceId.ToString());
var keysName = string.Join(",", httpContext.Response.Headers.Keys);
httpContext.Response.Headers.Add("Access-Control-Expose-Headers", keysName);
return(Task.CompletedTask);
},
context
);
await Next(context);
}
}
public async Task PostUploadChunk([FromBody] object obj)
{
bool IsChunkData = compress.IsChunkData(obj.ToString());
ChunkData dataChunk = null;
if (IsChunkData)
{
dataChunk = Newtonsoft.Json.JsonConvert.DeserializeObject <ChunkData>(obj.ToString());
var RequestHeaders = this.Request.Headers;
StringValues ChunkKeyCurrent = "";
if (RequestHeaders.Keys.Contains(compress.ChunkResponseUploadHeader))
{
RequestHeaders.TryGetValue(compress.ChunkResponseUploadHeader, out ChunkKeyCurrent);
}
if (!string.IsNullOrEmpty(ChunkKeyCurrent))
{
string[] checkChunk = ChunkKeyCurrent.ToString().Split("_");
string key1 = string.Empty;
string key2 = string.Empty;
if (checkChunk.Count() > 1)
{
await CompressObject.GetInstance.ChunkDataUploadSvr(dataChunk);
MemoryCacher.GetInstance.AddMinutes(ChunkKeyCurrent.ToString(), dataChunk, dataChunk.ChunkTimeMinutes);
}
}
}
}
/// <summary>
/// 获取用户IP地址
/// </summary>
/// <returns></returns>
private static string GetRealIP()
{
var request = CoreHttpContext.Current.Request;
if (request.Headers == null)
{
return(string.Empty);
}
StringValues ipVal = new StringValues("");
if (request.Headers.TryGetValue("CF-CONNECTING-IP", out ipVal))
{
return(ipVal.ToString());
}
if (request.Headers.TryGetValue("HTTP_LX_IP", out ipVal))
{
return(ipVal.ToString());
}
if (request.Headers.TryGetValue("HTTP_X_FORWARDED_FOR", out ipVal))
{
return(ipVal.ToString());
}
if (request.Headers.TryGetValue("X_FORWARDED_FOR", out ipVal))
{
return(ipVal.ToString());
}
if (request.Headers.TryGetValue("REMOTE_ADDR", out ipVal))
{
return(ipVal.ToString());
}
return(string.Empty);
}
public IActionResult Create(UserDto dto)
{
// TODO: use jwt auth
StringValues id = string.Empty;
Request.Headers.TryGetValue("user_id", out id);
if (string.IsNullOrEmpty(id.ToString()))
{
return(Unauthorized("Unauthorized access blocked. Please log in as admin"));
}
User loggedInUser = _uow.Users.GetUser(int.Parse(id.ToString()));
if (loggedInUser.UserType.ToLower() != "admin")
{
return(Unauthorized("Unauthorized access blocked. Please log in as admin"));
}
// TODO: consider using automapper
var user = new User {
Name = dto.Name, Email = dto.Email, Password = HasherUtil.Hash(dto.Password), Phone = dto.Phone, State = dto.State, IsActive = dto.IsActive, DateAdded = DateTime.Now, Notes = dto.Notes, UserType = dto.UserType
};
_uow.Users.AddUser(user);
_uow.Complete();
return(Ok());
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/k-admin/Home/Error");
}
//app.UseStaticFiles();
app.UseAuthentication();
app.UseSession();
app.UseStaticFiles(new StaticFileOptions()
{
RequestPath = new PathString("/k-admin")
});
app.Use((context, next) =>
{
context.Response.Headers.Add("Cache-Control", "max-age=0");
if (IsHostedOnAlicloud())
{
try {
StringValues aliHost = "";
context.Request.Headers.TryGetValue("Ali-Swift-Log-Host", out aliHost);
if (!String.IsNullOrEmpty(aliHost.ToString()))
{
context.Request.Headers.Remove("Host");
context.Request.Headers.Add("Host", aliHost.ToString());
}
} catch (ArgumentNullException ex) {
Console.WriteLine(JsonConvert.SerializeObject(ex));
}
}
return(next());
});
//var options = new RewriteOptions().AddRedirect(@"(.*[(\.js)])$", "kadmin/$1");
//app.UseRewriter(options);
////Handles all routing coming from forwarded loadbalancer
//app.UseMiddleware<RouteHandlerMiddleware>();
app.UseRouting();
app.UseAuthorization();
app.UseCors("AnyOrigin");
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(name: "default",
pattern: "k-admin/{controller=Home}/{action=Index}/{id?}");
});
}
public async Task Invoke(HttpContext httpContext,
IConnectionManager manager,
IStreamCompressor compressor,
ILoggerFactory loggerFactory)
{
if (httpContext.WebSockets.IsWebSocketRequest)
{
string connectionId = string.Empty;
string connectorName = string.Empty;
StringValues headerValue = "";
if (httpContext.Request.Headers.TryGetValue(NCSConstants.ConnectorName, out headerValue))
{
connectorName = headerValue.ToString();
}
if (httpContext.Request.Headers.TryGetValue(NCSConstants.ConnectionId, out headerValue))
{
connectionId = headerValue.ToString();
}
if (string.IsNullOrEmpty(connectorName))
{
if (httpContext.Request.Query.ContainsKey(NCSConstants.ConnectorName))
{
connectorName = httpContext.Request.Query[NCSConstants.ConnectorName];
}
}
if (string.IsNullOrEmpty(connectionId))
{
if (httpContext.Request.Query.ContainsKey(NCSConstants.ConnectionId))
{
connectionId = httpContext.Request.Query[NCSConstants.ConnectionId];
Guid connectionIdGuid = Guid.Empty;
if (!Guid.TryParse(connectionId, out connectionIdGuid))
{
connectionId = string.Empty;
}
}
}
var webSocket = await httpContext.WebSockets.AcceptWebSocketAsync();
if (string.IsNullOrEmpty(connectionId))
{
connectionId = Guid.NewGuid().ToString("N");
}
await manager.ConnectAsync(webSocket, connectionId : connectionId, connectorName : connectorName, cancellationToken : _cancellationToken);
}
else
{
await _next(httpContext);
}
}
public ActionResult <IList <Evaluation> > GetEvaluations()
{
return(this.ExecuteRequestAndHandle(
() =>
{
StringValues pageSize = string.Empty;
StringValues pageNumber = string.Empty;
StringValues sortValue = string.Empty;
StringValues matchValue = string.Empty;
var sortCriteria = new SortCriteria();
if (!this.TryGetQueryParam("page[size]", out pageSize))
{
throw new HttpException(StatusCodes.Status400BadRequest, "Page size is required");
}
if (!this.TryGetQueryParam("page[number]", out pageNumber))
{
throw new HttpException(StatusCodes.Status400BadRequest, "Page number is required");
}
if (this.TryGetQueryParam("sort", out sortValue))
{
sortCriteria.SortOption = SortOption.Ascendent;
if (sortValue.ToString().StartsWith("-"))
{
sortValue = sortValue.ToString().Replace("-", string.Empty);
sortCriteria.SortOption = SortOption.Descendent;
}
sortCriteria.Property = sortValue;
}
this.TryGetQueryParam("filter", out matchValue);
var queryParam = new QueryParameters()
{
SortCriteria = sortCriteria,
SearchCriteria = new SearchCriteria()
{
Property = "Name", MatchInput = matchValue
},
PageNumber = int.Parse(pageNumber),
PageSize = int.Parse(pageSize)
};
var evaluations = ServicesFacade.Instance.GetEvaluationsService().GetEvaluations(queryParam);
Log.Info(string.Format("Found {0} evaluations", evaluations.Data.Count));
return evaluations;
},
StatusCodes.Status200OK));
}
public static T GetHeaderValueAs <T>(string headerName)
{
StringValues values = default;
if (HttpContext?.Request?.Headers?.TryGetValue(headerName, out values) ?? false)
{
string rawValues = values.ToString(); // writes out as Csv when there are multiple.
if (!rawValues.IsNullEmpty())
{
return((T)Convert.ChangeType(values.ToString(), typeof(T)));
}
}
return(default(T));
}
/// <summary>Gets the header value as.</summary>
/// <typeparam name="T"></typeparam>
/// <param name="context">The context.</param>
/// <param name="headerName">Name of the header.</param>
/// <returns></returns>
private T GetHeaderValueAs <T>(HttpContext context, string headerName)
{
StringValues values = default;
if (context?.Request?.Headers?.TryGetValue(headerName, out values) ?? false)
{
string rawValues = values.ToString(); // writes out as Csv when there are multiple.
if (!string.IsNullOrWhiteSpace(rawValues))
{
return((T)Convert.ChangeType(values.ToString(), typeof(T)));
}
}
return(default);
public static T?GetHeaderValueAsNullableReference <T>(HttpContext p_httpContext, string p_headerName) where T : class // string is class, not struct
{
StringValues values = string.Empty;
if (p_httpContext?.Request?.Headers?.TryGetValue(p_headerName, out values) ?? false)
{
string rawValues = values.ToString(); // writes out as Csv when there are multiple.
if (!String.IsNullOrEmpty(rawValues))
{
return((T)Convert.ChangeType(values.ToString(), typeof(T)));
}
}
return(default(T));
}
public bool TryTransform(HttpRequestRecord record, ReadOnlySpan <byte> body, StringValues contentTypeHeaderValues, out BodyDataTransformResult result)
{
var json = MessagePackSerializer.ConvertToJson(body.ToArray(), MessagePack.Resolvers.ContractlessStandardResolver.Options);
result = new BodyDataTransformResult(Encoding.UTF8.GetBytes(json), contentTypeHeaderValues.ToString(), "application/json");
return(true);
}
// used in samples
public static BinderResult TryStringValidateLength(this StringValues stringValues, Action <string> setter, int length)
{
var v = stringValues.ToString();
setter(v);
return(new BinderResult(v.Length > length ? new[] { "Too long!" } : null));
}
public IActionResult SendEmail([FromBody] Email email)
{
try
{
StringValues accessToken = new StringValues();
Request.Headers.TryGetValue("Authorization", out accessToken);
if (accessToken.Count() == 0)
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (accessToken.FirstOrDefault().ToString() == null || accessToken.FirstOrDefault().ToString() == "")
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (_validation.CheckValidation(accessToken.ToString()))
{
_smtpLogic.SendEmail(email);
return(Ok());
}
return(StatusCode(403, "This is an invalid access token."));
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
return(StatusCode(500, e.Message));
}
}
public IActionResult PutStartAutomatedTestingEC2(bool start)
{
try
{
StringValues accessToken = new StringValues();
Request.Headers.TryGetValue("Authorization", out accessToken);
if (accessToken.Count() == 0)
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (accessToken.FirstOrDefault().ToString() == null || accessToken.FirstOrDefault().ToString() == "")
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (_validation.CheckValidation(accessToken.ToString()))
{
_ec2Logic.StartAutomatedTestingEC2();
return(Ok());
}
return(StatusCode(403, "This is an invalid access token."));
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
return(StatusCode(500));
}
}
public IActionResult DeleteArcadeMachine(int arcadeMachineId)
{
try
{
StringValues accessToken = new StringValues();
Request.Headers.TryGetValue("Authorization", out accessToken);
if (accessToken.Count() == 0)
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (accessToken.FirstOrDefault().ToString() == null || accessToken.FirstOrDefault().ToString() == "")
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (_validation.CheckValidation(accessToken.ToString()))
{
_rdsLogic.DeleteArcadeMachine(arcadeMachineId);
return(StatusCode(204));
}
return(StatusCode(403, "This is an invalid access token."));
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
return(StatusCode(500, e.Message));
}
}
public IActionResult GetInfo()
{
try
{
StringValues accessToken = new StringValues();
Request.Headers.TryGetValue("Authorization", out accessToken);
if (accessToken.Count() == 0)
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (accessToken.FirstOrDefault().ToString() == null || accessToken.FirstOrDefault().ToString() == "")
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (_validation.CheckValidation(accessToken.ToString()))
{
return(Ok("Knights Arcade Restricted"));
}
return(StatusCode(403, "This is an invalid access token."));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(StatusCode(500, e.Message));
}
}
public IActionResult PostNewEntry([FromBody] NewEntry newEntry)
{
try
{
StringValues accessToken = new StringValues();
Request.Headers.TryGetValue("Authorization", out accessToken);
if (accessToken.Count() == 0)
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (accessToken.FirstOrDefault().ToString() == null || accessToken.FirstOrDefault().ToString() == "")
{
return(StatusCode(401, "Empty or no authorization header."));
}
if (_validation.CheckValidation(accessToken.ToString()))
{
Tuple <Games, int> tuple = _rdsLogic.PostNewEntry(newEntry);
if (tuple.Item2 == 1)
{
return(StatusCode(409, "That game name already exists."));
}
_ec2Logic.StartAutomatedTestingEC2();
return(StatusCode(201, tuple.Item1));
}
return(StatusCode(403, "This is an invalid access token."));
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
return(StatusCode(500, e.Message));
}
}
/// <summary>
/// Make an evaluation that filter assets
/// </summary>
/// <param name="before"></param>
/// <param name="after"></param>
/// <param name="amount_min"></param>
/// <param name="amount_max"></param>
/// <param name="result"></param>
/// <returns></returns>
public static IQueryable <IAssetAnotation> FilterAssets(string term, StringValues before, StringValues after, StringValues amount_min, StringValues amount_max, IQueryable <IAssetAnotation> result)
{
if (term != StringValues.Empty)
{
result = result.Where(x => x.Concept.Contains(term.ToString()));
}
if (before != StringValues.Empty && DateTime.TryParse(before, out DateTime instanceBefore))
{
result = result.Where(x => x.AtCreated < instanceBefore);
}
if (before != StringValues.Empty && DateTime.TryParse(after, out DateTime instanceAfter))
{
result = result.Where(x => x.AtCreated > instanceAfter);
}
if (amount_min != StringValues.Empty && int.TryParse(amount_min.ToString(), out int instanceMin))
{
result = result.Where(x => x.Amount >= instanceMin);
}
if (amount_max != StringValues.Empty && int.TryParse(amount_max.ToString(), out int instanceMax))
{
result = result.Where(x => x.Amount <= instanceMax);
}
return(result);
}
/// <summary>
/// 从请求中获取值
/// </summary>
/// <param name="request"></param>
/// <param name="key"></param>
/// <returns></returns>
public static String GetRequestValue(this HttpRequest request, String key)
{
var value = new StringValues();
if (request.HasFormContentType)
{
value = request.Form[key];
}
if (value.Count > 0)
{
return(value);
}
value = request.Query[key];
if (value.Count > 0)
{
return(value.ToString());
}
// 拒绝output关键字，避免死循环
if (key == "output")
{
return(null);
}
var entityBody = request.GetRequestBody <NullableDictionary <String, Object> >();
if (entityBody == null)
{
return(null);
}
return(!entityBody.TryGetValue(key, out var v) ? null : v?.ToString());
}
public ActionResult Create(IFormCollection collection)
{
try
{
var courseName = new StringValues();
var description = new StringValues();
var token = new StringValues();
string id = "";
if (collection.TryGetValue("CourseName", out courseName) && collection.TryGetValue("Description", out description) && collection.TryGetValue("token", out token))
{
var username = AuthLogic.CheckToken(token.ToString());
if (username == "")
{
throw new Exception("NotAuthorized");
}
// save course
id = Course.CreateCourse(courseName.ToString(), description.ToString(), username);
}
return(RedirectToAction("Details", new { token = token, id = id }));
}
catch
{
return(View());
}
}
private T ChangeType <T>(StringValues obj)
{
var value = obj.ToString();
if (string.IsNullOrWhiteSpace(value))
{
return(default);
public static string GetToken(StringValues value)
{
var splitValue = value.ToString().Split(';');
var token = splitValue[0].Split('=');
return(token[1]);
}
//[Obsolete("无法处理JsonHttpContent")]
public static string GetValue(this HttpRequest request, string key, bool includeCookie = false)
{
ThrowIf.Empty(key, nameof(key));
StringValues value = StringValues.Empty;
//QueryString
if (StringValues.IsNullOrEmpty(value) && request != null && request.Query != null)
{
value = request.Query[key];
}
//Request的Body
if (StringValues.IsNullOrEmpty(value) && request != null && request.HasFormContentType)
{
value = request.Form[key];
}
if (includeCookie)
{
//Request Cookie
if (StringValues.IsNullOrEmpty(value) && request != null && request.Cookies != null)
{
value = request.Cookies[key];
}
}
return(value.ToString());
}
public async Task<IActionResult> OnGetAsync(string id)
{
try
{
ShortenLink = await _db.ShortenLinks.FindAsync(id);
if (ShortenLink != null)
{
Request.Headers.TryGetValue("Referer", out originValues);
ShortenLinkLog = new ShortenLinkLog();
ShortenLinkLog.ShortLinkId = ShortenLink.Id;
ShortenLinkLog.LongLink = ShortenLink.LongLink;
ShortenLinkLog.ShortLink = ShortenLink.ShortLink;
ShortenLinkLog.Origen = originValues.ToString();
ShortenLinkLog.DateAccess = DateTime.Now;
_db.ShortenLinkLogs.Add(ShortenLinkLog);
ShortenLink.AccessCount++;
_db.Attach(ShortenLink).State = EntityState.Modified;
await _db.SaveChangesAsync();
return Redirect(ShortenLink.LongLink);
}
else
{
return Page();
}
}
catch
{
return Page();
}
}
private async Task <string> GetUserAuthorizationJwtAsync(
HttpContext httpContext,
IHttpClientFactory httpClientFactory,
IMemoryCache memoryCache,
StringValues value,
int key)
{
using (HttpClient client = httpClientFactory.CreateClient(AuthorizationHttpClientName))
{
client.DefaultRequestHeaders.Add(HeaderNames.Authorization, value.ToString());
HttpResponseMessage response = await client.GetAsync(_jwtAuthorizationOptions.AuthorizationUrl + httpContext.Request.Path.Value);
if (response.IsSuccessStatusCode)
{
string jwtToken = await response.Content.ReadAsStringAsync();
SetTokenToCache(memoryCache, key, jwtToken, httpContext.Request);
return(jwtToken);
}
else
{
throw GetExceptionForResponse(response);
}
}
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException(nameof(bindingContext));
}
var formReq = bindingContext.HttpContext.Request.Query;
var page = new StringValues();
formReq.TryGetValue("page", out page);
var limit = new StringValues();
formReq.TryGetValue("limit", out limit);
var groupBy = new StringValues();
formReq.TryGetValue("groupBy", out groupBy);
var groupByDirection = new StringValues();
formReq.TryGetValue("groupByDirection", out groupByDirection);
var result = new GetPlayersGroupingDto()
{
page = Convert.ToInt16(page),
limit = Convert.ToInt16(limit),
groupBy = groupBy.ToString(),
groupByDirection = groupByDirection.ToString()
};
bindingContext.Result = ModelBindingResult.Success(result);
return(Task.CompletedTask);
}
private string DetermineTransactionId(StringValues transactionIds)
{
var alreadyPresentTransactionId = transactionIds.ToString();
if (String.IsNullOrWhiteSpace(alreadyPresentTransactionId))
{
if (_options.Transaction.GenerateWhenNotSpecified)
{
_logger.LogTrace("No transactional ID was found in the request, generating one...");
string newlyGeneratedTransactionId = _options.Transaction.GenerateId();
if (String.IsNullOrWhiteSpace(newlyGeneratedTransactionId))
{
throw new InvalidOperationException(
$"Correlation cannot use function '{nameof(_options.Transaction.GenerateId)}' to generate an transaction ID because the resulting ID value is blank");
}
_logger.LogTrace("Generated '{TransactionId}' as transactional correlation ID", newlyGeneratedTransactionId);
return(newlyGeneratedTransactionId);
}
_logger.LogTrace("No transactional correlation ID found in request header '{HeaderName}' but since the correlation options specifies that no transactional ID should be generated, there will be no ID present",
_options.Transaction.HeaderName);
return(null);
}
_logger.LogTrace("Found transactional correlation ID '{TransactionId}' in request header '{HeaderName}'", alreadyPresentTransactionId, _options.Transaction.HeaderName);
return(alreadyPresentTransactionId);
}
public IActionResult Login(IFormCollection collection)
{
var email = new StringValues();
var pass = new StringValues();
string token = "";
if (collection.TryGetValue("Email", out email) && collection.TryGetValue("Password", out pass))
{
try
{
var auth = new AuthLogic();
auth.Email = email.ToString();
auth.Password = pass.ToString();
token = auth.Login();
return(RedirectToAction("Index", "Profile", new { token = token }));
}
catch (Exception)
{
return(Error());
}
}
else
{
return(Error());
}
}
public async Task PostGet()
{
var metadataOnly = GetBoolValueQueryString("metadataOnly", required: false) ?? false;
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
var docs = await context.ReadForMemoryAsync(RequestBodyStream(), "docs");
if (docs.TryGet("Ids", out BlittableJsonReaderArray array) == false)
{
ThrowRequiredPropertyNameInRequest("Ids");
}
var ids = new string[array.Length];
for (int i = 0; i < array.Length; i++)
{
ids[i] = array.GetStringByIndex(i);
}
context.OpenReadTransaction();
// init here so it can be passed to TW
var idsStringValues = new StringValues(ids);
if (TrafficWatchManager.HasRegisteredClients)
{
AddStringToHttpContext(idsStringValues.ToString(), TrafficWatchChangeType.Documents);
}
await GetDocumentsByIdAsync(context, idsStringValues, metadataOnly);
}
}
string QueryToJson(IQueryCollection query)
{
var dict = new Dictionary<string,string>();
foreach (var key in query.Keys) {
StringValues @value = new StringValues();
query.TryGetValue(key, out @value);
dict.Add(key, @value.ToString());
}
return JsonConvert.SerializeObject(dict);
}
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());
}
