public async IAsyncEnumerable <Data> DeserializeWithStreaming()
{
using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(serializedString));
await foreach (var item in JsonSerializer.DeserializeAsyncEnumerable <Data>(memStream))
{
yield return(item);
}
}
public static async Task Main()
{
using var stream = new MemoryStream(Encoding.UTF8.GetBytes("[0,1,2,3,4]"));
await foreach (int item in JsonSerializer.DeserializeAsyncEnumerable <int>(stream))
{
Console.WriteLine(item);
}
}
public async IAsyncEnumerable <T> DeserializeStreaming <T>(string data)
{
using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(data));
await foreach (var item in JsonSerializer.DeserializeAsyncEnumerable <T>(memStream))
{
yield return(item);
}
}
public async Task ManyTests(string json)
{
var bytes = System.Text.Encoding.UTF8.GetBytes(json);
await using var stream = new MemoryStream(bytes);
stream.Position = 0;
var leases = await JsonSerializer.DeserializeAsyncEnumerable <Models.DhcpResponseObject>(stream)
.ToListAsync();
Assert.NotNull(leases);
Assert.NotEmpty(leases);
Assert.DoesNotContain(default, leases);
public async IAsyncEnumerable <T> DeserializeStreaming <T>(string data)
{
using var memStream = new MemoryStream(Encoding.UTF8.GetBytes(data));
await foreach (var item in JsonSerializer.DeserializeAsyncEnumerable <T>(memStream))
{
Console.WriteLine("Inside Deserializing..");
yield return(item);
await Task.Delay(1000);
}
}
public async IAsyncEnumerable <Models.DhcpResponseObject> GetLeasesAsync(CancellationToken?cancellationToken = default)
{
await using var stream = await _httpClient.GetStreamAsync("/api/router", cancellationToken ?? CancellationToken.None);
var responses = JsonSerializer.DeserializeAsyncEnumerable <Models.DhcpResponseObject>(stream, cancellationToken: cancellationToken ?? CancellationToken.None);
await using var enumerator = responses.GetAsyncEnumerator(cancellationToken ?? CancellationToken.None);
while (await enumerator.MoveNextAsync(cancellationToken ?? CancellationToken.None))
{
yield return(enumerator.Current !);
}
}
public async Task Run([QueueTrigger("%TableNamespace%-transaction", Connection = "PwnedPasswordsConnectionString")] byte[] queueItem, CancellationToken cancellationToken)
{
QueueTransactionEntry?item = JsonSerializer.Deserialize <QueueTransactionEntry>(Encoding.UTF8.GetString(queueItem));
if (item == null)
{
throw new ArgumentException("Queue item contains no data.", nameof(queueItem));
}
Activity.Current?.AddTag("SubscriptionId", item.SubscriptionId).AddTag("TransactionId", item.TransactionId);
try
{
if (await _tableStorage.IsTransactionConfirmedAsync(item.SubscriptionId, item.TransactionId, cancellationToken).ConfigureAwait(false))
{
_log.LogInformation("Subscription {SubscriptionId} started processing for transaction {TransactionId}. Fetching transaction entries.", item.SubscriptionId, item.TransactionId);
using (Stream stream = await _fileStorage.GetIngestionFileAsync(item.TransactionId, cancellationToken).ConfigureAwait(false))
{
var entries = new List <QueuePasswordEntry>(100);
await foreach (PwnedPasswordsIngestionValue? entry in JsonSerializer.DeserializeAsyncEnumerable <PwnedPasswordsIngestionValue>(stream, cancellationToken: cancellationToken))
{
if (entry != null)
{
entries.Add(new QueuePasswordEntry {
SubscriptionId = item.SubscriptionId, TransactionId = item.TransactionId, SHA1Hash = entry.SHA1Hash.ToUpperInvariant(), NTLMHash = entry.NTLMHash.ToUpperInvariant(), Prevalence = entry.Prevalence
});
if (entries.Count == 100)
{
await _queueStorage.PushPasswordsAsync(entries, cancellationToken).ConfigureAwait(false);
entries.Clear();
}
}
}
if (entries.Count > 0)
{
await _queueStorage.PushPasswordsAsync(entries, cancellationToken).ConfigureAwait(false);
}
}
}
}
catch (Exception e)
{
_log.LogError(e, "Error processing transaction with id = {TransactionId} for subscription {SubscriptionId}.", item.TransactionId, item.SubscriptionId);
}
}
public async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = "append")] HttpRequest req)
{
// Check that the data has been passed as JSON
if (req.ContentType == null || !req.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))
{
// Incorrect Content-Type, bad request
return(req.BadRequest("Content-Type must be application/json"));
}
string subscriptionId = req.Headers[SubscriptionIdHeaderKey].ToString();
if (string.IsNullOrEmpty(subscriptionId))
{
return(req.BadRequest("Api-Subscription-Id header missing or invalid"));
}
Activity.Current?.AddTag("SubscriptionId", subscriptionId);
try
{
(bool Success, IActionResult? Error) = await req.TryValidateEntries(JsonSerializer.DeserializeAsyncEnumerable <PwnedPasswordsIngestionValue>(req.Body));
if (Success)
{
// Now insert the data
req.Body.Seek(0, System.IO.SeekOrigin.Begin);
PwnedPasswordsTransaction?transaction = await _tableStorage.InsertAppendDataAsync(subscriptionId).ConfigureAwait(false);
await _fileStorage.StoreIngestionFileAsync(transaction.TransactionId, req.Body).ConfigureAwait(false);
return(new OkObjectResult(transaction));
}
#pragma warning disable CS8603 // Won't be null if Success=false.
return(Error);
#pragma warning restore CS8603 // Possible null reference return.
}
catch (JsonException e)
{
// Error occurred trying to deserialize the JSON payload.
_log.LogError(e, "Unable to parse JSON for subscription {SubscriptionId}", subscriptionId);
return(req.BadRequest($"Unable to parse JSON: {e.Message}"));
}
}
static async Task <IAsyncEnumerable <UbiUser> > GetData()
{
while (true)
{
try
{
HttpClient httpClient = new();
var response = await httpClient.GetStreamAsync($"https://ubi.vtech.cf/all_user_data?key={UBIKey}");
return(JsonSerializer.DeserializeAsyncEnumerable <UbiUser>(response));
}
catch (HttpRequestException)
{
Console.WriteLine("Jacob did a stupid! ubi.vtech.cf is down!");
await Task.Delay(60000);
continue;
}
}
}
public static async Task DeserializeAsyncEnumerable_ReadSimpleObjectAsync(int count, int bufferSize)
{
JsonSerializerOptions options = new JsonSerializerOptions
{
DefaultBufferSize = bufferSize
};
using var stream = new MemoryStream(GenerateJsonArray(count));
int callbackCount = 0;
await foreach (SimpleTestClass item in JsonSerializer.DeserializeAsyncEnumerable <SimpleTestClass>(stream, options))
{
Assert.Equal(callbackCount, item.MyInt32);
item.MyInt32 = 2; // Put correct value back for Verify()
item.Verify();
callbackCount++;
}
Assert.Equal(count, callbackCount);
public static async Task <IAsyncEnumerable <T> > GetIAsyncEnumerableFromJson <T>(this HttpClient httpClient, string url)
{
var response = await httpClient.GetStreamAsync(url);
return(JsonSerializer.DeserializeAsyncEnumerable <T>(response));
}
public async Task <IAsyncEnumerable <UbiUser> > GetAllAsyncEnumerable() => JsonSerializer.DeserializeAsyncEnumerable <UbiUser>(await GetAllUserStream());
public async Task <IAsyncEnumerable <UbiUser> > GetTop10() =>
JsonSerializer.DeserializeAsyncEnumerable <UbiUser>(await _httpClient.GetStreamAsync("https://ubi.vtech.cf/api/leaderboard"));
