internal static TOut?SafeGet <TIn, TOut>(this TIn?input, Func <TIn, TOut?> converter) where TIn : struct where TOut : struct { return(input.HasValue ? converter(input.Value) : default(TOut?)); }
public static TOut SelectOrDefault <TIn, TOut>(this TIn?value, Func <TIn, TOut> resultIfNotNull, Func <TOut> resultIfNull = null) where TIn : struct { if (value.HasValue) { return(resultIfNotNull(value.Value)); } return(resultIfNull != null?resultIfNull() : default(TOut)); }
public static void TryConsume <TIn>(this TIn?instance, [NotNull] Action <TIn> action) where TIn : struct { if (action == null) { throw new ArgumentNullException(nameof(action)); } if (instance.HasValue) { action(instance.Value); } }
public static TOut?Adapt <TIn, TOut>(this IAdapter <TIn, TOut> adapter, TIn?input) where TIn : struct where TOut : struct { if (adapter == null) { throw new ArgumentNullException(nameof(adapter)); } return(input.HasValue ? adapter.Adapt(input.Value) : new TOut?()); }
public static TOut?TryTransform <TIn, TOut>(this TIn?instance, [NotNull] Func <TIn, TOut> transform, TOut?elseValue = null) where TIn : struct where TOut : struct { if (transform == null) { throw new ArgumentNullException(nameof(transform)); } if (instance == null) { return(elseValue); } return(transform(instance.Value)); }
private static byte[] Pack <TIn, TOut>(TIn?inVal, TOut?outVal) where TIn : struct where TOut : struct { using (var ms = new MemoryStream()) using (var wtr = new BinaryWriter(ms)) { wtr.Write(inVal.HasValue ? Marshal.SizeOf(typeof(TIn)) : 0); wtr.Write(outVal.HasValue ? Marshal.SizeOf(typeof(TOut)) : 0); if (inVal.HasValue) { wtr.Write(inVal.Value); } if (outVal.HasValue) { wtr.Write(outVal.Value); } return(ms.ToArray()); } }
internal static string ToParameterValue <TIn>(this TIn?input, Func <TIn, string> convert, string defaultValue = null) where TIn : struct { return(input.HasValue ? convert(input.Value) : defaultValue); }
/// <summary> /// Asynchronously maps input nullable value to an output <see cref="Maybe{T}" />. /// </summary> /// <typeparam name="TIn">Type of input nullable.</typeparam> /// <typeparam name="TOut">Type of output <see cref="Maybe{T}" />.</typeparam> /// <param name="self">Input nullable value to map.</param> /// <param name="f">Asynchronous mapping.</param> /// <returns>A task of the output <see cref="Maybe{T}" />.</returns> public static async Task <Maybe <TOut> > SelectAsync <TIn, TOut>(this TIn?self, Func <TIn, Task <TOut> > f) where TIn : struct where TOut : class => self.HasValue ? await f(self.Value).ConfigureAwait(false) : Maybe <TOut> .None;
public static TOut?Select <TIn, TOut>(this TIn?nullable, Func <TIn, TOut> selector) where TIn : struct where TOut : struct { return(nullable.HasValue ? selector(nullable.Value) : (TOut?)null); }
/// <summary> /// Sends a control code directly to a specified device driver, causing the corresponding device to perform the corresponding operation. /// </summary> /// <typeparam name="TIn">The type of the <paramref name="inVal"/>.</typeparam> /// <typeparam name="TOut">The type of the return value.</typeparam> /// <param name="hDevice"> /// A handle to the device on which the operation is to be performed. The device is typically a volume, directory, file, or stream. /// To retrieve a device handle, use the CreateFile function. For more information, see Remarks. /// </param> /// <param name="ioControlCode"> /// The control code for the operation. This value identifies the specific operation to be performed and the type of device on which /// to perform it. /// </param> /// <param name="inVal"> /// The input value required to perform the operation. The type of this data depends on the value of the <paramref /// name="ioControlCode"/> parameter. /// </param> /// <returns>An asynchronous result containing the populated data supplied by <typeparamref name="TOut"/>.</returns> /// <remarks> /// <para> /// To retrieve a handle to the device, you must call the CreateFile function with either the name of a device or the name of the /// driver associated with a device. To specify a device name, use the following format: /// </para> /// <para>\\.\DeviceName</para> /// <para> /// DeviceIoControl can accept a handle to a specific device. For example, to open a handle to the logical drive /// A: with CreateFile, specify \\.\a:. Alternatively, you can use the names \\.\PhysicalDrive0, \\.\PhysicalDrive1, and so on, to /// open handles to the physical drives on a system. /// </para> /// <para> /// You should specify the FILE_SHARE_READ and FILE_SHARE_WRITE access flags when calling CreateFile to open a handle to a device /// driver. However, when you open a communications resource, such as a serial port, you must specify exclusive access. Use the other /// CreateFile parameters as follows when opening a device handle: /// </para> /// <list type="bullet"> /// <item> /// <description>The fdwCreate parameter must specify OPEN_EXISTING.</description> /// </item> /// <item> /// <description>The hTemplateFile parameter must be NULL.</description> /// </item> /// <item> /// <description> /// The fdwAttrsAndFlags parameter can specify FILE_FLAG_OVERLAPPED to indicate that the returned handle can be used in overlapped /// (asynchronous) I/O operations. /// </description> /// </item> /// </list> /// </remarks> public static Task <TOut?> DeviceIoControlAsync <TIn, TOut>(HFILE hDevice, uint ioControlCode, TIn?inVal) where TIn : struct where TOut : struct { TOut?outValue = default(TOut); var buf = Pack(inVal, outValue); return(Task.Factory.FromAsync(BeginDeviceIoControl <TIn, TOut>, EndDeviceIoControl <TIn, TOut>, hDevice, ioControlCode, buf, null)); }
public static TOut?Bind <TIn, TOut>(this TIn?m, Func <TIn, TOut> map) where TIn : struct where TOut : struct { return(m.HasValue ? map(m.Value) : default(TOut?)); }
public static Option <TOut> ToOption <TIn, TOut>(this TIn?value, Func <TIn, TOut> map) where TIn : struct { return(value.HasValue ? Option.Some(map(value.Value)) : Option.None()); }
[DebuggerStepThrough] //Can get rid of this when upgraded to c# 6.0. It has Null Reference opertaor as part of the language internal static TReturn IfNotNull <TIn, TReturn>(this TIn?value, Func <TIn?, TReturn> then, TReturn @else = default(TReturn)) where TIn : struct => value.HasValue ? then(value) : @else;
public static IAsyncResult BeginDeviceIoControl <TIn, TOut>(SafeFileHandle hDevice, uint dwIoControlCode, TIn?inVal, TOut?outVal, AsyncCallback userCallback) where TIn : struct where TOut : struct { var buffer = Pack(inVal, outVal); return(BeginDeviceIoControl <TIn, TOut>(hDevice, dwIoControlCode, buffer, userCallback, null)); }
public static IResult <Maybe <TResult>, NonEmptyString> ToMaybe <TResult, TIn>(this TIn?value, NonEmptyString field, Func <TIn?, NonEmptyString, IResult <TResult, NonEmptyString> > creatorFunc) where TResult : class where TIn : struct { if (value == null) { return(((Maybe <TResult>)null).GetOkMessage()); } var result = creatorFunc(value, field); return(result.IsFailure ? result.Error.GetFailResult <Maybe <TResult> >() : ((Maybe <TResult>)result.Value).GetOkMessage()); }
/// <summary> /// Sends a control code directly to a specified device driver, causing the corresponding device to perform the corresponding operation. /// </summary> /// <typeparam name="TIn">The type of the <paramref name="inVal"/>.</typeparam> /// <typeparam name="TOut">The type of the <paramref name="outVal"/>.</typeparam> /// <param name="hDevice">A handle to the device on which the operation is to be performed. The device is typically a volume, directory, file, or stream. To retrieve a device /// handle, use the CreateFile function. For more information, see Remarks.</param> /// <param name="ioControlCode">The control code for the operation. This value identifies the specific operation to be performed and the type of device on which to perform it.</param> /// <param name="inVal">The input value required to perform the operation. The type of this data depends on the value of the <paramref name="ioControlCode"/> parameter.</param> /// <param name="outVal">The output value that is to receive the data returned by the operation. The type of this data depends on the value of the dwIoControlCode parameter.</param> /// <returns>An asynchronous result containing the populated data supplied by <paramref name="outVal"/>.</returns> /// <remarks> /// <para> /// To retrieve a handle to the device, you must call the CreateFile function with either the name of a device or the name of the driver associated with /// a device. To specify a device name, use the following format: /// </para> /// <para>\\.\DeviceName</para> /// <para> /// DeviceIoControl can accept a handle to a specific device. For example, to open a handle to the logical drive /// A: with CreateFile, specify \\.\a:. Alternatively, you can use the names \\.\PhysicalDrive0, \\.\PhysicalDrive1, and so on, to open handles to the /// physical drives on a system. /// </para> /// <para> /// You should specify the FILE_SHARE_READ and FILE_SHARE_WRITE access flags when calling CreateFile to open a handle to a device driver. However, when /// you open a communications resource, such as a serial port, you must specify exclusive access. Use the other CreateFile parameters as follows when /// opening a device handle: /// </para> /// <list type="bullet"> /// <item> /// <description>The fdwCreate parameter must specify OPEN_EXISTING.</description> /// </item> /// <item> /// <description>The hTemplateFile parameter must be NULL.</description> /// </item> /// <item> /// <description>The fdwAttrsAndFlags parameter can specify FILE_FLAG_OVERLAPPED to indicate that the returned handle can be used in overlapped (asynchronous) I/O operations.</description> /// </item> /// </list> /// </remarks> public static Task <TOut?> DeviceIoControlAsync <TIn, TOut>(HFILE hDevice, uint ioControlCode, TIn?inVal, TOut?outVal) where TIn : struct where TOut : struct { var buf = Pack(inVal, outVal); return(new TaskFactory().FromAsync(BeginDeviceIoControl <TIn, TOut>, EndDeviceIoControl <TIn, TOut>, hDevice, ioControlCode, buf, null)); }
private static unsafe Task <TOut?> ExplicitDeviceIoControlAsync <TIn, TOut>(HFILE hDevice, uint ioControlCode, TIn?inVal, TOut?outVal) where TIn : struct where TOut : struct { #pragma warning disable CS0618 // Type or member is obsolete ThreadPool.BindHandle((IntPtr)hDevice); #pragma warning restore CS0618 // Type or member is obsolete var tcs = new TaskCompletionSource <TOut?>(); var buffer = Pack(inVal, outVal); var nativeOverlapped = new Overlapped().Pack((code, bytes, overlap) => { try { switch (code) { case Win32Error.ERROR_SUCCESS: outVal = Unpack <TIn, TOut>(buffer).Item2; tcs.TrySetResult(outVal); break; case Win32Error.ERROR_OPERATION_ABORTED: tcs.TrySetCanceled(); break; default: tcs.TrySetException(new Win32Exception((int)code)); break; } } finally { Overlapped.Unpack(overlap); Overlapped.Free(overlap); } }, buffer); var unpack = true; try { var inSz = Marshal.SizeOf(typeof(TIn)); fixed(byte *pIn = buffer, pOut = &buffer[inSz]) { uint bRet; var ret = DeviceIoControl(hDevice, ioControlCode, pIn, (uint)inSz, pOut, (uint)(buffer.Length - inSz), out bRet, nativeOverlapped); if (ret) { outVal = Unpack <TIn, TOut>(buffer).Item2; tcs.SetResult(outVal); return(tcs.Task); } } var lastWin32Error = Marshal.GetLastWin32Error(); if (lastWin32Error != Win32Error.ERROR_IO_PENDING && lastWin32Error != Win32Error.ERROR_SUCCESS) { throw new Win32Exception(lastWin32Error); } unpack = false; return(tcs.Task); } finally { if (unpack) { Overlapped.Unpack(nativeOverlapped); Overlapped.Free(nativeOverlapped); } } }
public static TOut IfNotNull <TIn, TOut>(this TIn?value, Func <TIn, TOut> innerProperty, TOut otherwise) where TIn : struct { return(value.HasValue ? innerProperty(value.Value) : otherwise); }
/// <inheritdoc /> public abstract void Execute(object?executor, TIn?data);
public static TOut?IfNotNull <TIn, TOut>(this TIn?value, Func <TIn, TOut?> innerProperty) where TIn : struct where TOut : struct { return(value.HasValue ? innerProperty(value.Value) : null); }