private static void PrintXMLFileToScreen() { ITextReader textReader = new TextFileReaderModule(XMLFile); String text = textReader.Read(); output.Write(text); output.Write(Environment.NewLine); output.Write(Environment.NewLine); }
public static async Tasks.Task <bool> Join(this ITextWriter me, Generic.IEnumerator <string> items, string separator = null) { bool result = items.MoveNext() && await me.Write(items.Current); while (result && items.MoveNext()) { if (separator.NotNull()) { result &= await me.Write(separator); } result &= await me.Write(items.Current); } return(result); }
public void Handle(object model) { // Find the full path to the template file, // using current directory if argument isn't fully qualified string templatePath = GetTemplatePath(); DebugTrace.Trace(this, "Rendering:" + templatePath); DebugTrace.Trace(this, "Model:" + model.ToString()); var templateName = Path.GetFileName(templatePath); var templateDirPath = Path.GetDirectoryName(templatePath); SparkViewEngine engine = new SparkEngineFactory().GetSparkEngine <TView>(templateDirPath); try { // compile and instantiate the template string templateResult = ProcessViewTemplate(engine, templateName, model); _fileWriter.Write(templateResult); } catch (Exception ex) { throw new SparkReportGenerationException("An exception occurred:" + ex.GetType().Name + "\r\n" + ex.Message, ex); } }
private void WriteResultMessage(int correctResult, int userAnswer) { var wasUserAnswerCorrect = correctResult == userAnswer; var wasAnswerCorrectMessage = GetWasAnswerCorrectMessage(wasUserAnswerCorrect); var messageType = GetMessageType(wasUserAnswerCorrect); string message = $"Vaše odpověď \"{userAnswer}\" {wasAnswerCorrectMessage}"; textWriter.Write(message, messageType); }
private void WriteValueWithPadding( ITextWriter textWriter, MessageTemplate.ArgumentToken arg, string formatedValue) { if (arg.Alignment > 0) { int padLeft = arg.Alignment - formatedValue.Length; textWriter.Write(' ', padLeft); } textWriter.Write(formatedValue); if (arg.Alignment < 0) { int padRight = -arg.Alignment - formatedValue.Length; textWriter.Write(' ', padRight); } }
public async Task SendMessage(int projectId, int jobQueueId, string taskName, string message) { var group = GetGroupName(jobQueueId.ToString()); List <string> groups = new List <string>() { group }; await _textWriter.Write($"{JobQueueLog.FolderNamePrefix}_{projectId}_{jobQueueId}", taskName ?? "job", message); await Clients.Groups(groups).SendAsync("ReceiveMessage", taskName, message); }
/// <summary> /// Writes the hash file (hash.extension) from a text. /// </summary> /// <param name="text">The text, null is equal as an empty string.</param> /// <param name="writer">The textwriter for the output.</param> /// <exception cref="ArgumentNullException"><paramref name="writer"/>is null</exception> public void WriteHashFromString(string text, ITextWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } string hash = this.GetHashFromString(text); writer.Write(hash); }
/// <summary> /// Writes the hash value file (filename.extension) from the content of a File. /// </summary> /// <param name="reader">The reader for the input data.</param> /// <param name="writer">The textwriter for the output.</param> /// <exception cref="ArgumentNullException"><paramref name="reader"/>is null</exception> /// <exception cref="ArgumentNullException"><paramref name="writer"/>is null</exception> public void WriteHash(ITextReader reader, ITextWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } string hash = this.GetHashFromReader(reader); writer.Write(hash); }
static void Main(string[] args) { //initialize the Unity IoC Container and Dependency Injection Bootstrap.Init(); Initiator init = DependencyInjector.Retrieve <Initiator>(); //Instantiate the apireader and console writer objects _reader = init.GetReader(); _writer = init.GetWriter(); _reader.SetClient(uriAddress); //attempt to read from the Web API try { //Write out to the console Message 1 and 2 from the API _writer.Write(_reader.GetMessage(1).Result); _writer.Write("<Press any key to exit>"); Console.ReadLine(); _writer.Write(_reader.GetMessage(2).Result); //pause for 1 second and exit System.Threading.Thread.Sleep(1000); } //If an error occurs, print out teh error message and exit. catch (Exception ex) { _writer.Write(ex.InnerException.Message); _writer.Write("Please ensure the target API application is running, and the server is accessable"); _writer.Write("<Press any key to exit>"); Console.ReadLine(); } }
public void Flush() { char[] copy = _empty; lock (_synchro) { if (_buffer.Count > 0) { copy = _buffer.ToArray(); _buffer.Clear(); } } if (copy.Length > 0) { _writer.Write(copy); } }
private void PrintSuggestions() { var joined = " " + string.Join("\r\n", _suggestions.OrderBy(x => x).ToArray()).Replace("\r\n", "\r\n "); string classFormat = @" namespace Your.Namespace.Here {{ [StorEvil.Context] public class StubContextClass {{ {0} }} }}"; var classDefinition = string.Format(classFormat, joined); SuggestionWriter.Write(classDefinition); }
public void Write( MessageTemplate messageTemplate, IReadOnlyList <object> args, ITextWriter textWriter, IFormatProvider formatProvider = null) { if (messageTemplate == null) { throw new ArgumentNullException(nameof(messageTemplate)); } if (args == null) { throw new ArgumentNullException(nameof(args)); } if (textWriter == null) { throw new ArgumentNullException(nameof(textWriter)); } var formatter = GetFormatter(formatProvider); foreach (var token in messageTemplate.Tokens) { switch (token) { case MessageTemplate.TextToken text: textWriter.Write(text.Text); break; case MessageTemplate.ArgumentToken arg: var value = args[arg.Index]; string formatedValue = _valueFormatter.Format(value, arg.Format, formatProvider, formatter); WriteValueWithPadding(textWriter, arg, formatedValue); break; default: throw new FormatException($"Unknown format token `{token?.GetType().Name}`."); } } }
/// <summary> /// Run the program /// </summary> public void Run() { string result; // for each string that is read try { foreach (string inputString in reader.Read()) { try { // encode input string result = encoder.Encode(inputString); } catch (Exception e) { Console.WriteLine("Encoding error\r\n{0}", e.Message); break; } try { // write to output writer.Write(result); } catch (Exception e) { Console.WriteLine("Data output error\r\n{0}", e.Message); break; } } } catch (Exception e) { Console.WriteLine("Data input error\r\n{0}", e.Message); } }
public static Tasks.Task <bool> Write(this ITextWriter me, params char[] buffer) { return(me.Write((Generic.IEnumerable <char>)buffer)); }
protected void Write(string str) => _textWriter.Write(str);
private void Line(string text) { _w.Write(GetCurrentIndent()); _w.WriteLine(text); }
public async Task Acquire(Acquirable acquirable) { var result = await acquirable.Fetch(_httpClient); if (!result.IsSuccess) { return; } if (await CheckSdkExists(result.Version)) { _textWriter.WriteLine($"SDK version {result.Version} is already installed."); return; } using var channelResponse = await JsonDocument.ParseAsync(await _httpClient.GetStreamAsync(result.ChannelJson)); var file = channelResponse .RootElement.GetProperty("releases").EnumerateArray() .SelectMany(x => { IEnumerable <JsonElement> GetSdks() { yield return(x.GetProperty("sdk")); if (x.TryGetProperty("sdks", out var sdks)) { foreach (var y in sdks.EnumerateArray()) { yield return(y); } } } return(GetSdks()); }) .First(x => x.GetProperty("version").GetString() == result.Version) .GetProperty("files") .EnumerateArray() .First(FileFilter); var name = file.GetProperty("name").GetString(); var installerUrl = file.GetProperty("url").GetString(); var fileHash = file.GetProperty("hash").GetString(); var filePath = Path.Combine(Path.GetTempPath(), name); _textWriter.WriteLine($"Starting download of .NET Core SDK Version {result.Version}"); using (var installerStream = await _httpClient.GetStreamAsync(installerUrl)) { using var fileStream = new FileStream(filePath, FileMode.Create); var progress = new Progress <long>(); var lastReportedBytesMbs = 0; progress.ProgressChanged += (sender, totalBytes) => { var currentBytesMbs = (int)Math.Floor(totalBytes / Math.Pow(2, 20)); if (currentBytesMbs <= lastReportedBytesMbs) { return; } lastReportedBytesMbs = currentBytesMbs; _textWriter.SetCursorPosition(0, Console.CursorTop); _textWriter.Write($"Downloading: {currentBytesMbs}MB"); }; await CopyToWithProgress(installerStream, fileStream, progress); } CheckHash(filePath, fileHash); _installerLauncher.Launch(filePath); }
public void Handle(SessionFinished eventToHandle) { _fileWriter.Write(_doc.OuterXml); }
public static async Tasks.Task <bool> WriteLine(this ITextWriter me, Generic.IEnumerator <char> value) { return(await me.Write(value) && await me.WriteLine()); }
/// <summary> /// Decorate and passes to next writer /// </summary> /// <param name="data">output string, could be null</param> public void Write(string data) { writer.Write(Decorate(data)); }
public static Tasks.Task <bool> Write(this ITextWriter me, string format, params object[] arguments) { return(me.Write(string.Format(format, arguments))); }
public static Tasks.Task <bool> WriteLine(this ITextWriter me) { return(me.Write('\n')); // The newline characters are converted by bool Write(this ITextWriter me, Generic.IEnumerable<char> buffer) }
/// <summary> /// 容器起始标签 /// </summary> public IDisposable Begin() { _writer.Write(GetBeginResult()); return(new ContainerWrapper <T>(this)); }
public async Task Acquire(string version) { var channelVersion = ParseChannelVersion(version); var platform = _platformIdentifier.GetPlatform(); using var releasesResponse = await JsonDocument.ParseAsync(await _httpClient.GetStreamAsync(ReleaseIndex)); var channel = releasesResponse.RootElement.GetProperty("releases-index").EnumerateArray() .First(x => x.GetProperty("channel-version").GetString() == channelVersion); var channelJson = channel.GetProperty("releases.json").GetString(); using var channelResponse = await JsonDocument.ParseAsync(await _httpClient.GetStreamAsync(channelJson)); var file = channelResponse .RootElement.GetProperty("releases").EnumerateArray() .SelectMany(x => { IEnumerable <JsonElement> GetSdks() { yield return(x.GetProperty("sdk")); if (x.TryGetProperty("sdks", out var sdks)) { foreach (var y in sdks.EnumerateArray()) { yield return(y); } } } return(GetSdks()); }) .First(x => x.GetProperty("version").GetString() == version) .GetProperty("files") .EnumerateArray() .First(x => x.GetProperty("rid").GetString() == platform); var name = file.GetProperty("name").GetString(); var installerUrl = file.GetProperty("url").GetString(); var fileHash = file.GetProperty("hash").GetString(); var filePath = Path.Combine(Path.GetTempPath(), name); using var installerStream = await _httpClient.GetStreamAsync(installerUrl); using var fileStream = new FileStream(filePath, FileMode.Create); var progress = new Progress <long>(); var lastReportedBytesMbs = 0; progress.ProgressChanged += (sender, totalBytes) => { var currentBytesMbs = (int)Math.Floor(totalBytes / Math.Pow(2, 20)); if (currentBytesMbs <= lastReportedBytesMbs) { return; } lastReportedBytesMbs = currentBytesMbs; _textWriter.SetCursorPosition(0, Console.CursorTop); _textWriter.Write($"Downloading: {currentBytesMbs}MB"); }; await CopyToWithProgress(installerStream, fileStream, progress); CheckHash(filePath, fileHash); _installerLauncher.Launch(filePath); }
/// <summary> /// Writes the hash value file (filename.extension) from the content of a File. /// </summary> /// <param name="reader">The reader for the input data.</param> /// <param name="writer">The textwriter for the output.</param> /// <exception cref="ArgumentNullException"><paramref name="reader"/>is null</exception> /// <exception cref="ArgumentNullException"><paramref name="writer"/>is null</exception> public void WriteHash(ITextReader reader, ITextWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } string hash = this.GetHashFromReader(reader); writer.Write(hash); }
public static Tasks.Task <bool> Write(this ITextWriter me, Generic.IEnumerable <char> buffer) { return(me.Write(buffer?.GetEnumerator())); }
/// <summary> /// Writes the hash file (hash.extension) from a text. /// </summary> /// <param name="text">The text, null is equal as an empty string.</param> /// <param name="writer">The textwriter for the output.</param> /// <exception cref="ArgumentNullException"><paramref name="writer"/>is null</exception> public void WriteHashFromString(string text, ITextWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } string hash = this.GetHashFromString(text); writer.Write(hash); }
public void Write(string text) { writer.Write(text); }
public static async Tasks.Task <bool> Write(this ITextWriter me, string value) { return(value.IsEmpty() || await me.Write((Generic.IEnumerable <char>) value)); }
public async Task Add(string name, string value, CancellationToken cancellationToken = default(CancellationToken)) { var protectedValue = _protector.Protect(value); await _textWriter.Write(FolderName, name, protectedValue); }
public static Tasks.Task <bool> Write <T>(this ITextWriter me, T value) where T : IConvertible { return(me.Write(value.ToString((IFormatProvider)System.Globalization.CultureInfo.InvariantCulture.GetFormat(typeof(T))))); }