GeorgeTsiokos

public static class DataThread
{
    public static Action<DataTable> UpdateDelegate { get; set; }

    public static void Execute(TimeSpan updateRate, TimeSpan sleepRate)
    {
        var key = int.MinValue;
        var dataTable = CreateDataTable();
        var columns = dataTable.Columns;
        var rows = dataTable.Rows;

GeorgeTsiokos

public static CancellationToken Timeout(this CancellationToken cancellationToken, TimeSpan timeout)
{
    if (!cancellationToken.CanBeCanceled)
        return new CancellationTokenSource(timeout).Token;

    var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
    cancellationTokenSource.CancelAfter(timeout);
    return cancellationTokenSource.Token;
}

GeorgeTsiokos

static void Flush(ConsoleLogger consoleLogger)
{
    var fieldInfo = typeof(ConsoleLogger).GetField("_queueProcessor", BindingFlags.Instance | BindingFlags.NonPublic);
    var consoleLoggerProcessor = (ConsoleLoggerProcessor)fieldInfo.GetValue(consoleLogger);
    consoleLoggerProcessor.Dispose();
}

GeorgeTsiokos

internal sealed class ReadOnlySequenceConsumer
{

    readonly List<string> _result = new List<string>();

    public IReadOnlyList<string> Result => _result;

    public void Consume(ReadOnlySequence<byte> message) => _result.Add(GetString(message));

    public string GetString(ReadOnlySequence<byte> message) => message.IsSingleSegment ? Encoding.ASCII.GetString(message.First.Span) : string.Create((int)message.Length, message, GetChars);

GeorgeTsiokos

public interface ISerializer
{

    bool TryDeserialize<T>([CanBeNull] byte[] value, [CanBeNull] out T result) where T : class;

    bool TrySerialize<T>([CanBeNull] T value, [NotNull] out byte[] result, bool compress = false) where T : class;

}

GeorgeTsiokos

"new byte[] {" + string.Join(", ", File.ReadAllBytes(@"C:\filename")) + "};"

GeorgeTsiokos

public static class DictionaryExtensions
{
    public static string ToXUnitAssertion<TKey, TValue>([NotNull] this IDictionary<TKey, TValue> dictionary, string variableName = "dictionary")
    {
        var isKeyString = typeof(TKey) == typeof(string);
        var isValueString = typeof(TValue) == typeof(string);
        string GetKey(TKey key) => isKeyString ? $"\"{key}\"" : key.ToString();
        string GetValue(TValue value) => isValueString ? $"\"{value}\"" : value.ToString();

        var stringBuilder = new StringBuilder();

GeorgeTsiokos

[PublicAPI]
public static partial class DictionaryExtensions
{
    /// <summary>
    ///     Adds a key/value pair to the <see cref="T:System.Collections.Generic.IDictionary`2" /> by using the specified
    ///     function, if the key does not already exist.
    /// </summary>
    /// <param name="dictionary">the dictionary to get or add from</param>
    /// <param name="key">The key of the element to add.</param>
    /// <param name="valueFactory">The function used to generate a value for the key</param>

GeorgeTsiokos

using System;

public static class ObservableExtensions
{
    public static IObservable<TResponse> IgnoreElements<TSource, TResponse>(this IObservable<TSource> sequence) => new IgnoreElementsObservable<TSource, TResponse>(sequence);

    sealed class IgnoreElementsObservable<TSource, TResult> : IObservable<TResult>
    {
        readonly IObservable<TSource> _sequence;

GeorgeTsiokos

public sealed class JsonLogger : IDisposable
{
    readonly string _fileName;

    readonly JsonSerializer _jsonSerializer = JsonSerializer.Create(new JsonSerializerSettings
    {
        NullValueHandling = NullValueHandling.Ignore,
        Formatting = Formatting.None,
        Converters = new JsonConverter[] {new StringEnumConverter()}
    });