internal static async Task CreateThumbnailAsync(StorageRepository repo, string fileName, TextWriter log) { using (var memStream = await repo.GetBlob(StorageConfig.PhotosBlobContainerName, fileName)) { MemoryStream thumbnail = null; try { thumbnail = PhotoEditor.ProcessImage(memStream); await repo.UploadBlobAsync(thumbnail, StorageConfig.ThumbnailsBlobContainerName, fileName); } catch (Exception oops) { await log.WriteAsync(oops.Message); throw oops; } finally { if (null != thumbnail) { thumbnail.Dispose(); } } } }
/// <summary> /// Handles retrieving of all patients. /// </summary> /// <param name="inputArguments">Parsed program input arguments</param> /// <param name="writer">Writer the serialized result will be written into</param> /// <returns>Represents an asynchronous operation</returns> private async Task HandleAllPatients(InputArguments inputArguments, TextWriter writer) { var query = mPatientInfoProvider.GetPatients(); if (inputArguments.UseCache) { query = query.LoadFromCache(); } await writer.WriteAsync(JsonConvert.SerializeObject(await query.ToListAsync())); }
public async Task Write(IApiNode apiNode, TextWriter file, CancellationToken cancellationToken, bool recurse = true) { if (recurse) file.WriteLine(); //Indentation is only correct after a newline (note: WriteLineAsync doesn't seem to do indentation at all) await file.WriteAsync($"{AccessibilityPrefix(apiNode)}{apiNode.Signature}"); if (recurse || ShouldWriteMembersInline(apiNode)) { var orderedMembers = MembersInCanonicalOrder(apiNode); await WriteMembers(apiNode, file, cancellationToken, orderedMembers); } }
private void write(string title, IList <Diagnostic> errors) { if (errors.Count > 0) { writer.WriteAsync(errors.Count.ToString()); } else { writer.WriteAsync("No"); } writer.WriteAsync(" error"); if (errors.Count > 1) { writer.WriteAsync('s'); } writer.WriteAsync(" in \""); writer.WriteAsync(title); if (errors.Count > 0) { writer.WriteLineAsync("\":"); foreach (var e in errors) { writer.WriteLine(e.ToString()); } } else { writer.WriteLineAsync("\"."); } }
static int WriteAsync(IntPtr L) { try { int count = LuaDLL.lua_gettop(L); if (count == 2 && TypeChecker.CheckTypes <char>(L, 2)) { System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1); char arg0 = (char)LuaDLL.lua_tonumber(L, 2); System.Threading.Tasks.Task o = obj.WriteAsync(arg0); ToLua.PushObject(L, o); return(1); } else if (count == 2 && TypeChecker.CheckTypes <string>(L, 2)) { System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1); string arg0 = ToLua.ToString(L, 2); System.Threading.Tasks.Task o = obj.WriteAsync(arg0); ToLua.PushObject(L, o); return(1); } else if (count == 2 && TypeChecker.CheckTypes <char[]>(L, 2)) { System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1); char[] arg0 = ToLua.CheckCharBuffer(L, 2); System.Threading.Tasks.Task o = obj.WriteAsync(arg0); ToLua.PushObject(L, o); return(1); } else if (count == 4) { System.IO.TextWriter obj = (System.IO.TextWriter)ToLua.CheckObject <System.IO.TextWriter>(L, 1); char[] arg0 = ToLua.CheckCharBuffer(L, 2); int arg1 = (int)LuaDLL.luaL_checknumber(L, 3); int arg2 = (int)LuaDLL.luaL_checknumber(L, 4); System.Threading.Tasks.Task o = obj.WriteAsync(arg0, arg1, arg2); ToLua.PushObject(L, o); return(1); } else { return(LuaDLL.luaL_throw(L, "invalid arguments to method: System.IO.TextWriter.WriteAsync")); } } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
public static Task CopyToAsync(this TextReader reader, TextWriter writer, bool leaveReaderOpen, bool leaveWriterOpen) { return reader.PipeAsync( async () => { var buffer = new char[Constants.CharBufferSize]; int charsRead; while ((charsRead = await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) > 0) { await writer.WriteAsync(buffer, 0, charsRead).ConfigureAwait(false); } }, leaveOpen: leaveReaderOpen, extraDisposeAction: leaveWriterOpen ? default(Action) : () => writer.Dispose() ); }
// This function will get triggered/executed when a new message is written // on an Azure Queue called queue. public static async Task ProcessQueueMessage( [QueueTrigger("uploadqueue")] string message, TextWriter log) { log.WriteLineAsync(message).Wait(); var m = message.Split(','); await log.WriteAsync("Message received: " + m); var model = new PhotoModel { ID = m[0], ServerFileName = m[1], StorageAccountName = m[2], Owner = m[3], OwnerName = m[4], BlobURL = m[5], OriginRegion = m[6] }; //Copy blob from source to destination await log.WriteAsync("Replicating blob..."); await Helpers.ReplicateBlobAsync(model, log); try { //Change the blob URL to point to the new location! await log.WriteAsync("Getting blob URIs"); string storageConnectionString = SettingsHelper.LocalStorageConnectionString; var repo = new StorageRepository(storageConnectionString); model.BlobURL = repo.GetBlobURI(model.ServerFileName, StorageConfig.PhotosBlobContainerName).ToString(); model.ThumbnailURL = repo.GetBlobURI(model.ServerFileName, StorageConfig.ThumbnailsBlobContainerName).ToString(); //Create thumbnail await log.WriteAsync("Creating thumbnail"); await Helpers.CreateThumbnailAsync(repo, model.ServerFileName, log); //Store in table storage await log.WriteAsync("Saving to table storage"); await Helpers.SaveToTableStorageAsync(model, log); //Add to Redis cache await log.WriteAsync("Saving to Redis"); await Helpers.SaveToRedisAsync(model, log); } catch (Exception oops) { await log.WriteLineAsync(oops.Message); } }
public virtual async Task RenderAsync(ViewContext context, TextWriter writer) { var contentBuilder = new StringBuilder(1024); using (var bodyWriter = new StringWriter(contentBuilder)) { Output = bodyWriter; Execute(); } string bodyContent = contentBuilder.ToString(); if (!String.IsNullOrEmpty(Layout)) { await RenderLayoutAsync(context, writer, bodyContent); } else { await writer.WriteAsync(bodyContent); } }
public static async Task ProcessMultipleParameterQueueMessage([QueueTrigger("emailcontainer")] Email emailInfo, TextWriter logger) { var storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ToString()); var blobClient = storageAccount.CreateCloudBlobClient(); var logBlobContainer = blobClient.GetContainerReference("emailinfos"); logBlobContainer.CreateIfNotExists(); CloudBlockBlob logBlob = logBlobContainer.GetBlockBlobReference("credentials.txt"); await logBlob.UploadTextAsync(emailInfo.ToString()); var mailMessage = new MailMessage(emailInfo.Sender, emailInfo.Receiver, emailInfo.Subject, emailInfo.Body); var netCred = new NetworkCredential(emailInfo.Sender, "pfG6u_TDlGvoHQAeyn3xBQ"); var smtpobj = new SmtpClient("smtp.mandrillapp.com", 587); smtpobj.EnableSsl = true; smtpobj.Credentials = netCred; smtpobj.Send(mailMessage); await logger.WriteAsync("Web jobs for sending email succedded"); }
private static async Task GenerujTrescFormularza(IHtmlHelper helper, string actionName, string controllerName, System.IO.TextWriter writer, object model, string akcjaAnuluj = null) { using (helper.BeginForm(actionName, controllerName, FormMethod.Post, new { enctype = "multipart/form-data" })) { helper.AntiForgeryToken(); await writer.WriteLineAsync("<div class=\"form-horizontal\">"); await writer.WriteLineAsync("<hr/>"); writer.WriteLine(helper.ValidationSummary(true, "", new { @class = "text-danger" })); helper.DopiszEdytoryDlaPropertiesow(model, writer); helper.GenerujPrzyciskiFormularza(akcjaAnuluj).WriteTo(writer, HtmlEncoder.Default); await writer.WriteAsync("</div>"); } }
/// <summary> /// Writes the buffered content to <paramref name="writer"/>. /// </summary> /// <param name="writer">The <see cref="TextWriter"/>.</param> /// <param name="encoder">The <see cref="HtmlEncoder"/>.</param> /// <returns>A <see cref="Task"/> which will complete once content has been written.</returns> public async Task WriteToAsync(TextWriter writer, HtmlEncoder encoder) { if (BufferSegments == null) { return; } var htmlTextWriter = writer as HtmlTextWriter; if (htmlTextWriter != null) { htmlTextWriter.Write(this); return; } for (var i = 0; i < BufferSegments.Count; i++) { var segment = BufferSegments[i]; var count = i == BufferSegments.Count - 1 ? CurrentCount : segment.Length; for (var j = 0; j < count; j++) { var value = segment[j]; var valueAsString = value.Value as string; if (valueAsString != null) { await writer.WriteAsync(valueAsString); continue; } var valueAsViewBuffer = value.Value as ViewBuffer; if (valueAsViewBuffer != null) { await valueAsViewBuffer.WriteToAsync(writer, encoder); continue; } var valueAsHtmlContent = value.Value as IHtmlContent; if (valueAsHtmlContent != null) { valueAsHtmlContent.WriteTo(writer, encoder); continue; } } } }
static async Task WriteStackItemAsync(System.IO.TextWriter writer, Neo.VM.Types.StackItem item, int indent = 1, string prefix = "") { switch (item) { case Neo.VM.Types.Boolean _: await WriteLineAsync(item.GetBoolean()? "true" : "false").ConfigureAwait(false); break; case Neo.VM.Types.Integer @int: await WriteLineAsync(@int.GetInteger().ToString()).ConfigureAwait(false); break; case Neo.VM.Types.Buffer buffer: await WriteLineAsync(Neo.Helper.ToHexString(buffer.GetSpan())).ConfigureAwait(false); break; case Neo.VM.Types.ByteString byteString: await WriteLineAsync(Neo.Helper.ToHexString(byteString.GetSpan())).ConfigureAwait(false); break; case Neo.VM.Types.Null _: await WriteLineAsync("<null>").ConfigureAwait(false); break; case Neo.VM.Types.Array array: await WriteLineAsync($"Array: ({array.Count})").ConfigureAwait(false); for (int i = 0; i < array.Count; i++) { await WriteStackItemAsync(writer, array[i], indent + 1).ConfigureAwait(false); } break; case Neo.VM.Types.Map map: await WriteLineAsync($"Map: ({map.Count})").ConfigureAwait(false); foreach (var m in map) { await WriteStackItemAsync(writer, m.Key, indent + 1, "key: ").ConfigureAwait(false); await WriteStackItemAsync(writer, m.Value, indent + 1, "value: ").ConfigureAwait(false); } break; } async Task WriteLineAsync(string value) { for (var i = 0; i < indent; i++) { await writer.WriteAsync(" ").ConfigureAwait(false); } if (!string.IsNullOrEmpty(prefix)) { await writer.WriteAsync(prefix).ConfigureAwait(false); } await writer.WriteLineAsync(value).ConfigureAwait(false); } }
private async Task WriteLineStart(IApiNodeComparison apiComparison, TextWriter file, int indentLevel) { file.WriteLine(); await file.WriteAsync(ChangeTypeIndicator(apiComparison) + new string(' ', indentLevel * 2 + 1)); }
public override Task WriteAsync(char value) { lock (this) { return(writer.WriteAsync(value)); } }
/// <summary> /// Append the NewLine string. /// </summary> public void AppendNewLine(TextWriter writer) { writer.WriteAsync(NewLine); ++Line; currentLineEmpty = true; Column = 0; }
/// <summary> /// Handles retrieving of multiple studies. /// </summary> /// <param name="inputArguments">Parsed program input arguments</param> /// <param name="writer">Writer the serialized result will be written into</param> /// <returns>Represents an asynchronous operation</returns> private async Task HandleMultipleStudies(InputArguments inputArguments, TextWriter writer) { IDicomQuery<StudyInfo> query; if (inputArguments.ParentIdentifier != null) { var patient = await mPatientInfoProvider.GetPatientByBirthNumberAsync(inputArguments.ParentIdentifier, inputArguments.UseCache); query = mStudyInfoProvider.GetStudiesForPatient(patient); } else { query = mStudyInfoProvider.GetStudies(); } if (inputArguments.UseCache) { query = query.LoadFromCache(); } await writer.WriteAsync(JsonConvert.SerializeObject(await query.ToListAsync())); }
private static async Task WriteParentAsync(TextWriter writer, TranslationSet parent, IComparer<CultureData> languageComparer) { var mostImportantTranslation = parent.Translations.Where(t => t.Words.Count > 0).OrderByDescending(t => t.Language, languageComparer).FirstOrDefault(); if (mostImportantTranslation == null) { return; } await writer.WriteAsync(Constants.ParentIndicator); await writer.WriteAsync(mostImportantTranslation.Language.Name); await writer.WriteAsync(Constants.LanguageSeparator); await writer.WriteLineAsync(string.Join(Constants.TermSeparator + " ", mostImportantTranslation.Words.First())); }
private async Task WriteAutogeneratedShortnamesInline(TextWriter file, CancellationToken cancellationToken, IOrderedEnumerable<IApiNode> orderedMembers) { var accessibleMembers = orderedMembers.Select(GetShortNameFromAutoGeneratedMember); var memberString = $" {{ {string.Join("; ", accessibleMembers)}; }}"; await file.WriteAsync(memberString); }
/// <summary> /// Handles retrieving of multiple series. /// </summary> /// <param name="inputArguments">Parsed program input arguments</param> /// <param name="writer">Writer the serialized result will be written into</param> /// <returns>Represents an asynchronous operation</returns> private async Task HandleMultipleSeries(InputArguments inputArguments, TextWriter writer) { IDicomQuery<SeriesInfo> query; if (inputArguments.ParentIdentifier != null) { var study = await mStudyInfoProvider.GetStudyByIDAsync(inputArguments.ParentIdentifier, inputArguments.UseCache); query = mSeriesInfoProvider.GetSeriesForStudy(study); } else { query = mSeriesInfoProvider.GetSeries(); } if (inputArguments.UseCache) { query = query.LoadFromCache(); } await writer.WriteAsync(JsonConvert.SerializeObject(await query.ToListAsync())); }
/// <summary> /// Handles retrieving of single series. /// </summary> /// <param name="inputArguments">Parsed program input arguments</param> /// <param name="writer">Writer the serialized result will be written into</param> /// <returns>Represents an asynchronous operation</returns> private async Task HandleSingleSeries(InputArguments inputArguments, TextWriter writer) { var series = await mSeriesInfoProvider.GetSeriesByIDAsync(inputArguments.Identifier, inputArguments.UseCache); await writer.WriteAsync(JsonConvert.SerializeObject(series)); }
public async Task WritePrivateAsync(TextWriter writer) { await writer.WriteAsync(PrivateDataAsJson()); }
public async virtual Task SayHello(TextWriter writer) { await writer.WriteAsync("Hello World!"); }
/// <summary> /// Handles retrieving of single study or downloading images for single study. /// </summary> /// <param name="inputArguments">Parsed program input arguments</param> /// <param name="writer">Writer the serialized result will be written into</param> /// <returns>Represents an asynchronous operation</returns> private async Task HandleSingleStudy(InputArguments inputArguments, TextWriter writer) { var study = await mStudyInfoProvider.GetStudyByIDAsync(inputArguments.Identifier, inputArguments.UseCache); if (inputArguments.Download) { await mStudyInfoProvider.DownloadImagesAsync(study); } else { await writer.WriteAsync(JsonConvert.SerializeObject(study)); } }
/// <summary> /// Handles retrieving of single patient or downloading images for single patient. /// </summary> /// <param name="inputArguments">Parsed program input arguments</param> /// <param name="writer">Writer the serialized result will be written into</param> /// <returns>Represents an asynchronous operation</returns> private async Task HandleSinglePatient(InputArguments inputArguments, TextWriter writer) { var patient = await mPatientInfoProvider.GetPatientByBirthNumberAsync(inputArguments.Identifier, inputArguments.UseCache); if (inputArguments.Download) { await mPatientInfoProvider.DownloadImagesAsync(patient); } else { await writer.WriteAsync(JsonConvert.SerializeObject(patient)); } }
private static async Task WriteListAsync(TextWriter writer, BufferEntryCollection values) { foreach (var value in values) { await writer.WriteAsync(value); } }
private static async Task WriteToAsync(TextWriter writer, string prefix, LanguageWordList wordList) { if (wordList.Words.Count == 0) { return; } if (!string.IsNullOrWhiteSpace(prefix)) { await writer.WriteAsync(prefix); await writer.WriteAsync(Constants.PrefixSeparator); } await writer.WriteAsync(wordList.Language.Name); await writer.WriteAsync(Constants.LanguageSeparator); await writer.WriteLineAsync(string.Join(Constants.TermSeparator + " ", wordList.Words)); }