/// <summary>Begins an asynchronous write operation.</summary>
/// <returns>An <see cref="T:System.IAsyncResult" /> object that represents the asynchronous write, which could still be pending.</returns>
/// <param name="array">The buffer to write data from.</param>
/// <param name="offset">The byte offset in <paramref name="buffer" /> to begin writing from.</param>
/// <param name="count">The maximum number of bytes to write.</param>
/// <param name="asyncCallback">An optional asynchronous callback, to be called when the write is complete.</param>
/// <param name="asyncState">A user-provided object that distinguishes this particular asynchronous write request from other requests.</param>
/// <exception cref="T:System.IO.IOException">An asynchronous write past the end of the stream was attempted, or a disk error occurred.</exception>
/// <exception cref="T:System.ArgumentException">One or more of the arguments is invalid.</exception>
/// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed.</exception>
/// <exception cref="T:System.NotSupportedException">The current <see cref="T:System.IO.Compression.DeflateStream" /> implementation does not support the write operation.</exception>
/// <exception cref="T:System.InvalidOperationException">The write operation cannot be performed because the stream is closed.</exception>
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback cback, object state)
{
if (disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (!CanWrite)
{
throw new InvalidOperationException("This stream does not support writing");
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count", "Must be >= 0");
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException("offset", "Must be >= 0");
}
if (count + offset > buffer.Length)
{
throw new ArgumentException("Buffer too small. count/offset wrong.");
}
WriteMethod writeMethod = WriteInternal;
return(writeMethod.BeginInvoke(buffer, offset, count, cback, state));
}
private string Write(string content, IEnumerable <NextResult> executionPath, WriteMethod writeMethod = WriteMethod.UseStreamWriter)
{
foreach (NextResult next in executionPath)
{
switch (writeMethod)
{
case WriteMethod.UseStreamWriter:
{
StreamWriter writer = next.Value.FileHandle.CreateStreamWriter();
writer.Write(content);
writer.Flush();
return(content);
}
case WriteMethod.AppendProperty:
{
next.Value.FileHandle.Append = content;
return(content);
}
case WriteMethod.AppendLineProperty:
{
next.Value.FileHandle.AppendLine = content;
return(content + Environment.NewLine);
}
}
}
return(null);
}
/// <summary>
/// Writes the specified matches to <see cref="OutputFile" />.
/// </summary>
/// <param name="matches">The collection of matches to write.</param>
private void WriteMatches(MatchCollection matches)
{
WriteMethod writeMethod = new WriteMethod(this.WriteXml);
using (StreamWriter writer = new StreamWriter(OutputFile.FullName)) {
writeMethod(matches, writer);
}
}
public string Run(Method method)
{
WriteMethod writeMethod = provider.GetRequiredService <WriteMethod>();
StringWriter writer = new StringWriter();
writer.Run(writeMethod, method);
return(writer.ToString().RemoveCarriageReturn());
}
private AccountingPolicy CreateAccountingPolicyItem(Warehouse warehouse, WriteMethod writeMethod)
{
var accountingPolicy = new AccountingPolicy();
accountingPolicy.Warehouse = warehouse;
accountingPolicy.WriteMethod = writeMethod;
return(accountingPolicy);
}
public void Run(Method method, string expected)
{
WriteMethod writeMethod = host.Provider.GetRequiredService <WriteMethod>();
StringWriter writer = new StringWriter();
writer.Run(writeMethod, method);
string actual = writer.ToString().RemoveCarriageReturn();
Assert.Equal(expected, actual);
}
public void TestFileDoesExistAndOverwriteFile([Values(WriteMethod.UseStreamWriter, WriteMethod.AppendProperty, WriteMethod.AppendLineProperty)] WriteMethod writeMethod)
{
Directory.CreateDirectory(defaultFolderPath);
System.IO.File.WriteAllText(defaultFilePath, "!@#", Encoding.UTF7);
var result = Execute(defaultFilePath, DoesNotExistOptions.CreateFile, ExistOptions.OverwriteFile, codepage: TextCodepage.UTF7);
Assert.AreEqual(defaultFilePath, result.Value);
AssertExecutionPath(defaultFilePath, result.ExecutionPathResult);
string expectedOutput = Write("↨ₐᾗ", result.ExecutionPathResult, writeMethod);
Assert.AreEqual(expectedOutput, System.IO.File.ReadAllText(defaultFilePath, Encoding.UTF7));
}
public void EX2_1()
{
WriteMethod methodCall = SendToFile;
if (methodCall())
{
Console.WriteLine("Success!");
}
else
{
Console.WriteLine("File write operation failed.");
}
}
public static void Main()
{
OutputTarget output = new OutputTarget();
WriteMethod methodCall = output.SendToFile;
if (methodCall())
{
Console.WriteLine("Success!");
}
else
{
Console.WriteLine("File write operation failed.");
}
}
public static void WriteToTarget()
{
WriteMethod methodCall = OutputTarget.WriteToConsole;
if (methodCall())
{
Console.WriteLine("success");
}
Func <bool> func = (() => OutputTarget.WriteToConsole());
if (func())
{
Console.WriteLine("success");
}
}
/// <summary>Ends an asynchronous write operation.</summary>
/// <param name="asyncResult">A reference to the outstanding asynchronous I/O request.</param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="asyncResult" /> is null.</exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="asyncResult" /> did not originate from a <see cref="M:System.IO.Compression.DeflateStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)" /> method on the current stream.</exception>
/// <exception cref="T:System.Exception">An exception was thrown during a call to <see cref="M:System.Threading.WaitHandle.WaitOne" />.</exception>
/// <exception cref="T:System.InvalidOperationException">The stream is null.</exception>
/// <exception cref="T:System.InvalidOperationException">The end write call is invalid.</exception>
public override void EndWrite(IAsyncResult async_result)
{
if (async_result == null)
{
throw new ArgumentNullException("async_result");
}
AsyncResult asyncResult = async_result as AsyncResult;
if (asyncResult == null)
{
throw new ArgumentException("Invalid IAsyncResult", "async_result");
}
WriteMethod writeMethod = asyncResult.AsyncDelegate as WriteMethod;
if (writeMethod == null)
{
throw new ArgumentException("Invalid IAsyncResult", "async_result");
}
writeMethod.EndInvoke(async_result);
}
public GZipper(string sourceFileName, string destinationFileName, WorkMode mode, bool needProcessInfo = false)
: base(sourceFileName, destinationFileName, needProcessInfo)
{
lastWritedBlockId = 0;
this.mode = mode;
this.modeMessage = mode.ToString();
if (mode == WorkMode.Compress)
{
this.reader = new CompressReader(sourceFileName, blockSize);
work = CompressWork;
write = CompressWrite;
}
else if (mode == WorkMode.Decompress)
{
this.reader = new DecompressReader(sourceFileName, blockSize);
work = DecompressWork;
write = DecompressWrite;
}
else
{
throw new InvalidOperationException("Unknown work mode");
}
}
public override void EndWrite(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
AsyncResult ares = asyncResult as AsyncResult;
if (ares == null)
{
throw new ArgumentException("Invalid IAsyncResult", "asyncResult");
}
WriteMethod w = ares.AsyncDelegate as WriteMethod;
if (w == null)
{
throw new ArgumentException("Invalid IAsyncResult", "asyncResult");
}
w.EndInvoke(asyncResult);
return;
}
public override IAsyncResult BeginWrite (byte [] buffer, int offset, int count,
AsyncCallback cback, object state)
{
if (disposed)
throw new ObjectDisposedException (GetType ().FullName);
if (!CanWrite)
throw new InvalidOperationException ("This stream does not support writing");
if (buffer == null)
throw new ArgumentNullException ("buffer");
if (count < 0)
throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
if (count + offset > buffer.Length)
throw new ArgumentException ("Buffer too small. count/offset wrong.");
WriteMethod w = new WriteMethod (WriteInternal);
return w.BeginInvoke (buffer, offset, count, cback, state);
}
/// <summary>
/// Sets the mode.
/// </summary>
/// <param name="mode">The mode.</param>
/// <returns></returns>
public bool SetMode(byte mode)
{
switch (mode)
{
case 4: { WriteSettings(VGA320x200x4); width = 320; height = 200; colors = 4; writeMethod = WriteMethod.Pixel2; return(true); }
case 5: { WriteSettings(VGA320x200x4); width = 320; height = 200; colors = 4; writeMethod = WriteMethod.Pixel2; return(true); }
//case 11: { WriteSettings(VGA640x480x2); width = 640; height = 480; colors = 2; writeMethod = WriteMethod.xxx; return true; }
//case 12: { WriteSettings(VGA640x480x16); width = 640; height = 480; colors = 16; writeMethod = WriteMethod.xxx; return true; }
case 13: { WriteSettings(VGA320x200x256); width = 320; height = 200; colors = 256; writeMethod = WriteMethod.Pixel8; return(true); }
// Custom Standard Modes:
//case 99: { WriteSettings(VGA720x480x16); width = 720; height = 480; colors = 16; writeMethod = WriteMethod.xxx; return true; }
default: { return(false); }
}
}
/// <summary>
/// Writes the specified matches to <see cref="OutputFile" />.
/// </summary>
/// <param name="matches">The collection of matches to write.</param>
private void WriteMatches(MatchCollection matches) {
WriteMethod writeMethod = new WriteMethod(this.WriteXml);
using (StreamWriter writer = new StreamWriter(OutputFile.FullName)) {
writeMethod(matches, writer);
}
}
public void Write(WriteMethod method, int pin, int value)
{
var message = new byte[] { MESSAGE, (byte)method, (byte)pin, (byte)value };
_port.Write(message, 0, message.Length);
}
/// <summary>
/// Sets the mode.
/// </summary>
/// <param name="mode">The mode.</param>
/// <returns></returns>
public bool SetMode(byte mode)
{
switch (mode) {
case 4: { WriteSettings(VGA320x200x4); width = 320; height = 200; colors = 4; writeMethod = WriteMethod.Pixel2; return true; }
case 5: { WriteSettings(VGA320x200x4); width = 320; height = 200; colors = 4; writeMethod = WriteMethod.Pixel2; return true; }
//case 11: { WriteSettings(VGA640x480x2); width = 640; height = 480; colors = 2; writeMethod = WriteMethod.xxx; return true; }
//case 12: { WriteSettings(VGA640x480x16); width = 640; height = 480; colors = 16; writeMethod = WriteMethod.xxx; return true; }
case 13: { WriteSettings(VGA320x200x256); width = 320; height = 200; colors = 256; writeMethod = WriteMethod.Pixel8; return true; }
// Custom Standard Modes:
//case 99: { WriteSettings(VGA720x480x16); width = 720; height = 480; colors = 16; writeMethod = WriteMethod.xxx; return true; }
default: { return false; }
}
}
