/// <summary>
/// Set 'Content-MD5' http header.
/// </summary>
/// <param name="request">Instantiated request object</param>
private void SetContentMd5(IRestRequest request)
{
if (request.Method == Method.PUT || request.Method.Equals(Method.POST))
{
var bodyParameter = request.Parameters.FirstOrDefault(p => p.Type.Equals(ParameterType.RequestBody));
if (bodyParameter == null)
{
return;
}
var isMultiDeleteRequest = false;
if (request.Method == Method.POST)
{
isMultiDeleteRequest = request.Parameters.Any(p => p.Name.Equals("delete", StringComparison.OrdinalIgnoreCase));
}
// For insecure, authenticated requests set sha256 header instead of MD5.
if (!isSecure && !isAnonymous && !isMultiDeleteRequest)
{
return;
}
// All anonymous access requests get Content-MD5 header set.
byte[] body = null;
if (bodyParameter.Value is XElement)
{
bodyParameter.DataFormat = DataFormat.None;
// After next line bodyParameter.Value is string
// and next if will be executed
bodyParameter.Value = request.XmlSerializer.Serialize(bodyParameter.Value);
}
if (bodyParameter.Value is string)
{
body = System.Text.Encoding.UTF8.GetBytes(bodyParameter.Value as string);
}
if (bodyParameter.Value is byte[])
{
body = bodyParameter.Value as byte[];
}
if (body == null)
{
body = new byte[0];
}
var md5 = MD5.Create();
byte[] hash = md5.ComputeHash(body);
string base64 = Convert.ToBase64String(hash);
request.AddOrUpdateParameter("Content-MD5", base64, ParameterType.HttpHeader);
}
}
public static void Demo(string[] args)
{
Console.WriteLine("Searching begins...");
// hcOS Document Api tenant configuration info
Configuration configuration = JsonConvert.DeserializeObject <Configuration>(File.ReadAllText("../../configurations/Configuration.Searching.json"));
Search[] searches = JArray.Parse(File.ReadAllText("../../data/Searches.json")).ToObject <Search[]>();
IRestClient client = new RestClient(configuration.BaseUrl);
client.Authenticator = new searching.Authenticator(configuration.AppId, configuration.AppSecret, configuration.TenantId);
Results results = new Results();
IRestRequest request = configuration.NewRequest($"/api/v1/{configuration.TenantId}/document/search", Method.POST);
IRestResponse response = null;
foreach (Search search in searches)
{
results.Total++;
Console.WriteLine($"Begin: {search.Description}");
Console.WriteLine(JsonConvert.SerializeObject(search.Query, Formatting.Indented));
request.AddOrUpdateParameter("application/json", JsonConvert.SerializeObject(search.Query), ParameterType.RequestBody);
response = client.Execute(request);
if ((response.ResponseStatus == ResponseStatus.Completed) && (response.StatusCode == HttpStatusCode.OK))
{
QueryResponse queryResponse = JsonConvert.DeserializeObject <QueryResponse>(response.Content);
Console.WriteLine($"searchResponse.Offset: {queryResponse.Offset}");
Console.WriteLine($"searchResponse.RecordCount: {queryResponse.RecordCount}");
Console.WriteLine($"searchResponse.TotalRecordCount: {queryResponse.TotalRecordCount}");
int count = 1;
foreach (DocumentEntry entry in queryResponse.Hits)
{
Console.WriteLine($"{count}) {entry.DocumentRoot}-{entry.DocumentExtension}-{entry.DocumentTypeExtension}");
count++;
}
results.Success++;
}
else
{
results.Errors++;
Console.WriteLine($"OOPS something wrong.{System.Environment.NewLine}\tResponseStatus: {response.ResponseStatus}{System.Environment.NewLine}\tHttpStatusCode: {response.StatusCode}{System.Environment.NewLine}\tContent: {response.Content}");
}
Console.WriteLine($"Ends: {search.Description}{System.Environment.NewLine}");
}
Console.WriteLine(results.CurrentStats);
}
public void Authenticate(IRestClient client, IRestRequest request)
{
if (_forceTokenUpdate)
{
request.AddOrUpdateParameter("Authorization", _authHeader, ParameterType.HttpHeader);
return;
}
// only add the Authorization parameter if it hasn't been added by a previous Execute
if (!request.Parameters.Any(p => p.Type.Equals(ParameterType.HttpHeader) &&
p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
{
request.AddParameter("Authorization", _authHeader, ParameterType.HttpHeader);
}
}
public void Authenticate(IRestClient client, IRestRequest request)
{
if (string.IsNullOrEmpty(_authToken) && !_scopedAuth)
{
AcquireBearerToken();
}
else if (!string.IsNullOrEmpty(_authToken) && _scopedAuth)
{
AcquireBearerTokenScopedAuth();
}
// Set auth token
string _authHeader = $"Bearer {_authToken}";
request.AddOrUpdateParameter("Authorization", _authHeader, ParameterType.HttpHeader);
}
public void Authenticate(IRestClient client, IRestRequest request)
{
// perform authentication request
if (State == AuthState.NotAuthenticated)
{
State = AuthState.InProgress;
AuthToken = Credentials.Authenticate(Client);
SetAuthToken(AuthToken.Token);
State = AuthState.Authenticated;
}
// add authorization header if any
if (!string.IsNullOrWhiteSpace(AuthHeader))
{
request.AddOrUpdateParameter("Authorization", AuthHeader, ParameterType.HttpHeader);
}
}
public virtual void Authenticate(IRestClient client, IRestRequest request)
{
// perform authentication request
if (State == AuthState.NotAuthenticated)
{
State = AuthState.InProgress;
AuthToken = Credentials.Authenticate(Client);
SetAuthHeader(AuthToken);
State = AuthState.Authenticated;
}
// add authorization header if specified
if (AuthHeader != null)
{
request.AddOrUpdateParameter(AuthHeader.Item1, AuthHeader.Item2, ParameterType.HttpHeader);
}
}
/// <summary>
/// Implements Authenticate interface method for IAuthenticator.
/// </summary>
/// <param name="client">Instantiated IRestClient object</param>
/// <param name="request">Instantiated IRestRequest object</param>
public void Authenticate(IRestClient client, IRestRequest request)
{
DateTime signingDate = DateTime.UtcNow;
this.SetContentMd5(request);
this.SetContentSha256(request);
if (client.BaseUrl.Port == 80 || client.BaseUrl.Port == 443)
{
this.SetHostHeader(request, client.BaseUrl.Host);
}
else
{
this.SetHostHeader(request, client.BaseUrl.Host + ":" + client.BaseUrl.Port);
}
this.SetDateHeader(request, signingDate);
this.SetSessionTokenHeader(request, this.sessionToken);
SortedDictionary <string, string> headersToSign = this.GetHeadersToSign(request);
string signedHeaders = this.GetSignedHeaders(headersToSign);
string canonicalRequest = this.GetCanonicalRequest(request, headersToSign);
byte[] canonicalRequestBytes = System.Text.Encoding.UTF8.GetBytes(canonicalRequest);
string canonicalRequestHash = this.BytesToHex(this.ComputeSha256(canonicalRequestBytes));
string region = this.GetRegion(client.BaseUrl.Host);
string stringToSign = this.GetStringToSign(region, signingDate, canonicalRequestHash);
byte[] signingKey = this.GenerateSigningKey(region, signingDate);
byte[] stringToSignBytes = System.Text.Encoding.UTF8.GetBytes(stringToSign);
byte[] signatureBytes = this.SignHmac(signingKey, stringToSignBytes);
string signature = this.BytesToHex(signatureBytes);
string authorization = this.GetAuthorizationHeader(signedHeaders, signature, signingDate, region);
request.AddOrUpdateParameter("Authorization", authorization, ParameterType.HttpHeader);
}
/// <summary>
/// Set 'Host' http header.
/// </summary>
/// <param name="request">Instantiated request object</param>
/// <param name="hostUrl">Host url</param>
private void SetHostHeader(IRestRequest request, string hostUrl)
{
request.AddOrUpdateParameter("Host", hostUrl, ParameterType.HttpHeader);
}
/// <summary>
/// Sets 'x-amz-date' http header.
/// </summary>
/// <param name="request">Instantiated request object</param>
/// <param name="signingDate">Date for signature to be signed</param>
private void SetDateHeader(IRestRequest request, DateTime signingDate)
{
request.AddOrUpdateParameter("x-amz-date", signingDate.ToString("yyyyMMddTHHmmssZ"), ParameterType.HttpHeader);
}
/// <summary>
/// Authenticate request
/// </summary>
/// <param name="client">The <see cref="IRestClient"/></param>
/// <param name="request">The <see cref="IRestRequest"/></param>
public void Authenticate(IRestClient client, IRestRequest request)
=> request.AddOrUpdateParameter("apikey", _apiKey);
public static IRestRequest AddFile(this IRestRequest request, FileParameter parameter)
{
return(request.AddOrUpdateParameter(parameter));
}
/// <summary>
/// Add a file parameter to a REST request
/// </summary>
/// <param name="request">The REST request to add this parameter to</param>
/// <param name="name">Name of the parameter</param>
/// <param name="input">File content</param>
/// <param name="fileName">File name</param>
/// <param name="contentType">Content type for the parameter (only applicable to a Body parameter)</param>
/// <returns>The REST request to allow call chains</returns>
public static IRestRequest AddFile(this IRestRequest request, string name, Stream input, string fileName, string contentType)
{
return(request.AddOrUpdateParameter(FileParameter.Create(name, input, fileName, contentType)));
}
/// <summary>
/// Add a file parameter to a REST request
/// </summary>
/// <param name="request">The REST request to add this parameter to</param>
/// <param name="name">Name of the parameter</param>
/// <param name="bytes">File content</param>
/// <param name="fileName">File name</param>
/// <returns>The REST request to allow call chains</returns>
public static IRestRequest AddFile(this IRestRequest request, string name, byte[] bytes, string fileName)
{
return(request.AddOrUpdateParameter(FileParameter.Create(name, bytes, fileName)));
}
/// <summary>
/// Add or updates a parameter to a REST request
/// </summary>
/// <param name="request">The REST request to add or update this parameter to</param>
/// <param name="name">Name of the parameter</param>
/// <param name="value">Value of the parameter</param>
/// <returns>The REST request to allow call chains</returns>
public static IRestRequest AddOrUpdateParameter(this IRestRequest request, string name, object value)
{
return(request.AddOrUpdateParameter(new Parameter {
Name = name, Value = value, Type = ParameterType.GetOrPost
}));
}
public void BeforeIntercept(IRestRequest request)
{
if (!_enabled)
{
//
// Disabled
//
request.AddOrUpdateParameter("Accept-Encoding", "identity", ParameterType.HttpHeader);
request.AddDecompressionMethod(DecompressionMethods.None);
}
else if (ContentRegex.Match(request.Resource).Success)
{
//
// GZIP request
//
request.AddOrUpdateParameter("Content-Encoding", "gzip", ParameterType.HttpHeader);
request.AddOrUpdateParameter("Accept-Encoding", "identity", ParameterType.HttpHeader);
request.AddDecompressionMethod(DecompressionMethods.None);
var body = request.Parameters.FirstOrDefault(parameter =>
parameter.Type.Equals(ParameterType.RequestBody));
if (body != null)
{
byte[] bytes;
if (body.Value is byte[])
{
bytes = (byte[])body.Value;
}
else
{
bytes = Encoding.UTF8.GetBytes(body.Value.ToString());
}
using (var msi = new MemoryStream(bytes))
using (var mso = new MemoryStream()) {
using (var gs = new GZipStream(mso, CompressionMode.Compress)) {
msi.CopyTo(gs);
}
body.Value = mso.ToArray();
body.Name = "application/x-gzip";
}
}
}
else if (AcceptRegex.Match(request.Resource).Success)
{
//
// GZIP response
//
request.AddDecompressionMethod(DecompressionMethods.GZip);
}
else
{
//
// Disabled
//
request.AddOrUpdateParameter("Accept-Encoding", "identity", ParameterType.HttpHeader);
request.AddDecompressionMethod(DecompressionMethods.None);
}
}
private void AddOAuthData(IRestClient client, IRestRequest request, OAuthWorkflow workflow)
{
var url = client.BuildUri(request, false).ToString();
OAuthWebQueryInfo oauth;
var method = request.Method.ToString();
var parameters = new WebParameterCollection();
// include all GET and POST parameters before generating the signature
// according to the RFC 5849 - The OAuth 1.0 Protocol
// http://tools.ietf.org/html/rfc5849#section-3.4.1
// if this change causes trouble we need to introduce a flag indicating the specific OAuth implementation level,
// or implement a seperate class for each OAuth version
var useMultiPart = request.ContentCollectionMode == ContentCollectionMode.MultiPart
|| (request.ContentCollectionMode == ContentCollectionMode.MultiPartForFileParameters
&& (client.DefaultParameters.GetFileParameters().Any() || request.Parameters.GetFileParameters().Any()));
var requestParameters = client.MergeParameters(request).OtherParameters.AsEnumerable();
var effectiveMethod = client.GetEffectiveHttpMethod(request);
if (effectiveMethod == Method.GET)
{
requestParameters = requestParameters.Where(x => x.Type == ParameterType.GetOrPost || x.Type == ParameterType.QueryString);
foreach (var p in requestParameters)
{
parameters.Add(new WebParameter(p.Name, p.Value.ToString(), WebParameterType.Query));
}
}
else if (!useMultiPart && effectiveMethod == Method.POST)
{
foreach (var p in requestParameters.Where(x => x.Type == ParameterType.QueryString))
{
parameters.Add(new WebParameter(p.Name, p.Value.ToString(), WebParameterType.Query));
}
foreach (var p in requestParameters.Where(x => x.Type == ParameterType.GetOrPost))
{
parameters.Add(new WebParameter(p.Name, p.Value.ToString(), WebParameterType.Post));
}
}
else
{
// if we are sending a multipart request, only the "oauth_" parameters should be included in the signature
foreach (var p in requestParameters.Where(p => p.Name.StartsWith("oauth_", StringComparison.Ordinal)))
{
parameters.Add(new WebParameter(p.Name, p.Value.ToString(), WebParameterType.Internal));
}
}
switch (Type)
{
case OAuthType.RequestToken:
workflow.RequestTokenUrl = url;
oauth = workflow.BuildRequestTokenInfo(method, parameters);
break;
case OAuthType.AccessToken:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildAccessTokenInfo(method, parameters);
break;
case OAuthType.ClientAuthentication:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildClientAuthAccessTokenInfo(method, parameters);
break;
case OAuthType.ProtectedResource:
oauth = workflow.BuildProtectedResourceInfo(method, parameters, url);
break;
default:
throw new ArgumentOutOfRangeException();
}
switch (ParameterHandling)
{
case OAuthParameterHandling.HttpAuthorizationHeader:
parameters.Add("oauth_signature", oauth.Signature, WebParameterType.Internal);
request.AddHeader("Authorization", GetAuthorizationHeader(parameters));
break;
case OAuthParameterHandling.UrlOrPostParameters:
parameters.Add("oauth_signature", oauth.Signature, WebParameterType.Internal);
foreach (var parameter in parameters.Where(
parameter => !string.IsNullOrEmpty(parameter.Name)
&& (parameter.Name.StartsWith("oauth_") || parameter.Name.StartsWith("x_auth_"))))
{
var v = parameter.Value;
v = Uri.UnescapeDataString(v.Replace('+', ' '));
request.AddOrUpdateParameter(parameter.Name, v);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void Authenticate(IRestClient client, IRestRequest request)
{
var token = _tokenProvider.GetAccessTokenAsync().Result;
request.AddOrUpdateParameter("Authorization", $"Bearer {token}", ParameterType.HttpHeader);
}
public void Authenticate(IRestClient client, IRestRequest request)
=> request.AddOrUpdateParameter("Authorization", _authHeader, ParameterType.HttpHeader);
/// <summary>
/// Modifies the request to ensure that the authentication requirements are met.
/// </summary>
/// <param name="client">Client executing this request</param>
/// <param name="request">Request to authenticate</param>
/// <param name="credentials">The credentials used for the authentication</param>
/// <returns>The task the authentication is performed on</returns>
public override async Task PreAuthenticate(IRestClient client, IRestRequest request, ICredentials credentials)
{
request.AddOrUpdateParameter("oauth_token", await Client.GetCurrentToken(), ParameterType.GetOrPost);
}
private void AddOAuthData(IRestClient client, IRestRequest request, OAuthWorkflow workflow)
{
var requestUrl = client.BuildUriWithoutQueryParameters(request);
if (requestUrl.Contains('?'))
{
throw new ApplicationException("Using query parameters in the base URL is not supported for OAuth calls. Consider using AddDefaultQueryParameter instead.");
}
var url = client.BuildUri(request).ToString();
var queryStringStart = url.IndexOf('?');
if (queryStringStart != -1)
{
url = url.Substring(0, queryStringStart);
}
var method = request.Method.ToString().ToUpperInvariant();
var parameters = new WebParameterCollection();
// include all GET and POST parameters before generating the signature
// according to the RFC 5849 - The OAuth 1.0 Protocol
// http://tools.ietf.org/html/rfc5849#section-3.4.1
// if this change causes trouble we need to introduce a flag indicating the specific OAuth implementation level,
// or implement a seperate class for each OAuth version
if (!request.AlwaysMultipartFormData && !request.Files.Any())
{
parameters.AddRange(
client.DefaultParameters
.Where(p => p.Type == ParameterType.GetOrPost || p.Type == ParameterType.QueryString)
.Select(p => new WebPair(p.Name, p.Value.ToString())));
parameters.AddRange(
request.Parameters
.Where(p => p.Type == ParameterType.GetOrPost || p.Type == ParameterType.QueryString)
.Select(p => new WebPair(p.Name, p.Value.ToString())));
}
else
{
// if we are sending a multipart request, only the "oauth_" parameters should be included in the signature
parameters.AddRange(
client.DefaultParameters
.Where(p => (p.Type == ParameterType.GetOrPost || p.Type == ParameterType.QueryString) &&
p.Name.StartsWith("oauth_"))
.Select(p => new WebPair(p.Name, p.Value.ToString())));
parameters.AddRange(
request.Parameters
.Where(p => (p.Type == ParameterType.GetOrPost || p.Type == ParameterType.QueryString) &&
p.Name.StartsWith("oauth_"))
.Select(p => new WebPair(p.Name, p.Value.ToString())));
}
OAuthWebQueryInfo oauth;
switch (Type)
{
case OAuthType.RequestToken:
workflow.RequestTokenUrl = url;
oauth = workflow.BuildRequestTokenInfo(method, parameters);
break;
case OAuthType.AccessToken:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildAccessTokenInfo(method, parameters);
break;
case OAuthType.ClientAuthentication:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildClientAuthAccessTokenInfo(method, parameters);
break;
case OAuthType.ProtectedResource:
oauth = workflow.BuildProtectedResourceInfo(method, parameters, url);
break;
default:
throw new ArgumentOutOfRangeException();
}
switch (ParameterHandling)
{
case OAuthParameterHandling.HttpAuthorizationHeader:
parameters.Add("oauth_signature", oauth.Signature);
request.AddOrUpdateParameter("Authorization", GetAuthorizationHeader(parameters), ParameterType.HttpHeader);
break;
case OAuthParameterHandling.UrlOrPostParameters:
parameters.Add("oauth_signature", oauth.Signature);
var headers =
parameters.Where(p => !p.Name.IsNullOrBlank() &&
(p.Name.StartsWith("oauth_") || p.Name.StartsWith("x_auth_")))
.Select(p => new Parameter
{
Name = p.Name,
Value = HttpUtility.UrlDecode(p.Value),
Type = ParameterType.GetOrPost
});
foreach (var header in headers)
{
request.AddOrUpdateParameter(header);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Add or update a parameter to a REST request
/// </summary>
/// <param name="request">The REST request to add this parameter to</param>
/// <param name="name">Name of the parameter</param>
/// <param name="value">Value of the parameter</param>
/// <param name="type">Type of the parameter</param>
/// <param name="contentType">Content type for the parameter (only applicable to a Body parameter)</param>
/// <returns>The REST request to allow call chains</returns>
public static IRestRequest AddOrUpdateParameter(this IRestRequest request, string name, object value, ParameterType type, string contentType)
{
return(request.AddOrUpdateParameter(new Parameter {
Name = name, Value = value, Type = type, ContentType = contentType
}));
}
/// <summary>
/// Modifies the request to ensure that the authentication requirements are met.
/// </summary>
/// <param name="client">Client executing this request</param>
/// <param name="request">Request to authenticate</param>
/// <param name="credentials">The credentials used for the authentication</param>
/// <returns>The task the authentication is performed on</returns>
public override async Task PreAuthenticate(IRestClient client, IRestRequest request, ICredentials credentials)
{
request.AddOrUpdateParameter("oauth_token", await Client.GetCurrentToken(), ParameterType.GetOrPost);
}
private void AddOAuthData(IRestClient client, IRestRequest request, OAuthWorkflow workflow)
{
var url = client.BuildUri(request, false).ToString();
OAuthWebQueryInfo oauth;
var method = request.Method.ToString();
var parameters = new WebParameterCollection();
// include all GET and POST parameters before generating the signature
// according to the RFC 5849 - The OAuth 1.0 Protocol
// http://tools.ietf.org/html/rfc5849#section-3.4.1
// if this change causes trouble we need to introduce a flag indicating the specific OAuth implementation level,
// or implement a seperate class for each OAuth version
var useMultiPart = request.ContentCollectionMode == ContentCollectionMode.MultiPart ||
(request.ContentCollectionMode == ContentCollectionMode.MultiPartForFileParameters &&
(client.DefaultParameters.GetFileParameters().Any() || request.Parameters.GetFileParameters().Any()));
var requestParameters = client.MergeParameters(request).OtherParameters.AsEnumerable();
var effectiveMethod = client.GetEffectiveHttpMethod(request);
if (effectiveMethod == Method.GET)
{
requestParameters = requestParameters.Where(x => x.Type == ParameterType.GetOrPost || x.Type == ParameterType.QueryString);
foreach (var p in requestParameters)
{
parameters.Add(new WebParameter(p.Name, p.Value.ToString(), WebParameterType.Query));
}
}
else if (!useMultiPart && effectiveMethod == Method.POST)
{
foreach (var p in requestParameters.Where(x => x.Type == ParameterType.QueryString))
{
parameters.Add(new WebParameter(p.Name, p.Value.ToString(), WebParameterType.Query));
}
foreach (var p in requestParameters.Where(x => x.Type == ParameterType.GetOrPost))
{
parameters.Add(new WebParameter(p.Name, p.Value.ToString(), WebParameterType.Post));
}
}
else
{
// if we are sending a multipart request, only the "oauth_" parameters should be included in the signature
foreach (var p in requestParameters.Where(p => p.Name.StartsWith("oauth_", StringComparison.Ordinal)))
{
parameters.Add(new WebParameter(p.Name, p.Value.ToString(), WebParameterType.Internal));
}
}
switch (Type)
{
case OAuthType.RequestToken:
workflow.RequestTokenUrl = url;
oauth = workflow.BuildRequestTokenInfo(method, parameters);
break;
case OAuthType.AccessToken:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildAccessTokenInfo(method, parameters);
break;
case OAuthType.ClientAuthentication:
workflow.AccessTokenUrl = url;
oauth = workflow.BuildClientAuthAccessTokenInfo(method, parameters);
break;
case OAuthType.ProtectedResource:
oauth = workflow.BuildProtectedResourceInfo(method, parameters, url);
break;
default:
throw new ArgumentOutOfRangeException();
}
switch (ParameterHandling)
{
case OAuthParameterHandling.HttpAuthorizationHeader:
parameters.Add("oauth_signature", oauth.Signature, WebParameterType.Internal);
request.AddHeader("Authorization", GetAuthorizationHeader(parameters));
break;
case OAuthParameterHandling.UrlOrPostParameters:
parameters.Add("oauth_signature", oauth.Signature, WebParameterType.Internal);
foreach (var parameter in parameters.Where(
parameter => !string.IsNullOrEmpty(parameter.Name) &&
(parameter.Name.StartsWith("oauth_") || parameter.Name.StartsWith("x_auth_"))))
{
var v = parameter.Value;
v = Uri.UnescapeDataString(v.Replace('+', ' '));
request.AddOrUpdateParameter(parameter.Name, v);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}