1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
        private static Func<IDataReader, T> GenerateMapFunction<T>(IDataReader dataReader)
        {
            if (dataReader is null)
            {
                throw new ArgumentNullException(nameof(dataReader));
            }

            var expressions = new List<Expression>();

            var dataReaderParameterExpression = Expression.Parameter(typeof(IDataRecord), "o7thDR");

            var targetExpression = Expression.Variable(typeof(T));

            expressions.Add(Expression.Assign(targetExpression, Expression.New(targetExpression.Type)));

            // does int based lookup
            var indexerInfo = typeof(IDataRecord).GetProperty("Item", new[] { typeof(int) });

            var columnNames = Enumerable.Range(0, dataReader.FieldCount)
                                        .Select(index => new { index, name = dataReader.GetName(index) });

            foreach (var column in columnNames)
            {
                var property = targetExpression.Type.GetProperty(
                    column.name,
                    BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
                if (property is null)
                {
                    continue;
                }

                // index
                var columnIndexExpression = Expression.Constant(column.index);

                // reader
                var readerPropertyExpression = Expression.MakeIndex(
                    dataReaderParameterExpression, indexerInfo, new[] { columnIndexExpression });

                // reader.IsDBNull(index);
                var isReaderDbNull = Expression.Call(
                    dataReaderParameterExpression, nameof(IDataReader.IsDBNull), null, columnIndexExpression);

                // reader as PropertyType;
                var safeCastExpression = Expression.TypeAs(
                    readerPropertyExpression,
                    property.PropertyType);

                // T.Property
                var targetPropertyExpression = Expression.Property(targetExpression, property);

                // T.Property = reader.IsDBNull(index) ? default(PropertyType) :
                // (PropertyType)reader as PropertyType;
                var assignmentBlock = Expression.Condition(
                    Expression.IsTrue(isReaderDbNull),
                    Expression.Assign(
                        targetPropertyExpression,
                        Expression.Default(property.PropertyType)),
                    Expression.Assign(
                        targetPropertyExpression,
                        Expression.Convert(safeCastExpression, property.PropertyType)));

                expressions.Add(assignmentBlock);
            }

            expressions.Add(targetExpression);

            return Expression.Lambda<Func<IDataReader, T>>(
                Expression.Block(
                    new[] { targetExpression },
                    expressions),
                dataReaderParameterExpression).Compile();
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
        public static T? Map<T>(this IDataReader dataReader) where T : class
        {
            if (dataReader is null)
            {
                return default;
            }

            //// Use the following loop for debugging field data types in your entity classes.
            //for (var i = 0; i < dataReader.FieldCount; i++)
            //{
            //    Trace.TraceInformation($"{i}:{dataReader.GetName(i)} = {dataReader.GetFieldType(i).Name}");
            //}

            var converter = GenerateMapFunction<T>(dataReader);
            return converter(dataReader);
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        public static List<T> ToList<T>(this IDataReader dataReader) where T : class  
        {  
            var list = new List<T>();  
  
            if (dataReader is not null)  
            {  
                while (dataReader.Read())  
                {  
                    var row = Map<T>(dataReader);  
                    if (row is not null)  
                    {  
                        list.Add(row);  
                    }  
                }  
            }  
  
            return list;  
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
        public static async Task<List<T>> ToListAsync<T>(  
            this DbDataReader dataReader,  
            CancellationToken cancellationToken = default) where T : class  
        {  
            var list = new List<T>();  
  
            if (dataReader is not null)  
            {  
                while (await dataReader.ReadAsync(cancellationToken).ConfigureAwait(false))  
                {  
                    var row = Map<T>(dataReader);  
                    if (row is not null)  
                    {  
                        list.Add(row);  
                    }  
                }  
            }  
  
            return list;  
        }  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        public static async IAsyncEnumerable<T> EnumerateAsync<T>(  
            this DbDataReader dataReader,  
             CancellationToken cancellationToken = default) where T : class  
        {  
            if (dataReader is null)  
            {  
                yield break;  
            }  
  
            while (await dataReader.ReadAsync(cancellationToken).ConfigureAwait(false))  
            {  
                var row = Map<T>(dataReader);  
                if (row is not null)  
                {  
                    yield return row;  
                }  
            }  
        }  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
        public static IEnumerable<T> Enumerate<T>(this DbDataReader dataReader) where T : class  
        {  
            if (dataReader is null)  
            {  
                yield break;  
            }  
  
            while (dataReader.Read())  
            {  
                var row = Map<T>(dataReader);  
                if (row is not null)  
                {  
                    yield return row;  
                }  
            }  
        }  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public struct SynchronizationContextAwaiter : INotifyCompletion, IEquatable<SynchronizationContextAwaiter>
    {
        private static readonly SendOrPostCallback postCallback = state => (state as Action)?.Invoke();

        private readonly SynchronizationContext context;

        public SynchronizationContextAwaiter(SynchronizationContext context) => this.context = context;

        public bool IsCompleted => context == SynchronizationContext.Current;

        public static bool operator !=(SynchronizationContextAwaiter left, SynchronizationContextAwaiter right) =>
            !(left == right);

        public static bool operator ==(SynchronizationContextAwaiter left, SynchronizationContextAwaiter right) =>
            left.Equals(right);

        public override bool Equals(object? obj) =>
            obj is SynchronizationContextAwaiter awaiter && this.Equals(awaiter);

        public bool Equals(SynchronizationContextAwaiter other) =>
            EqualityComparer<SynchronizationContext>.Default.Equals(this.context, other.context);

        public override int GetHashCode() => HashCode.Combine(this.context);

        [SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "Reviewed.")]
        public void GetResult()
        {
        }

        public void OnCompleted(Action continuation) => context.Post(postCallback, continuation);
    }

1
2
3
4
5
6
7
        /// <summary>
        /// Gets an awaiter for the specified synchronization context.
        /// </summary>
        /// <param name="context">The synchronization context.</param>
        /// <returns>The <see cref="SynchronizationContextAwaiter"/>.</returns>
        public static SynchronizationContextAwaiter GetAwaiter(this SynchronizationContext context) =>
            new SynchronizationContextAwaiter(context);

1
2
3
4
5
6
7
8
9
10
                var syncContext = SynchronizationContext.Current; // Grab UI thread

                // TODO: Do long running async stuff here

                if (syncContext != null)
                {
                    await syncContext;
                }

                // TODO: Do original/UI thread stuff here

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
    /// <summary>
    /// The WaitCursor class. Implements the <see cref="IDisposable" />
    /// </summary>
    /// <seealso cref="IDisposable" />
    public class WaitCursor : IDisposable
    {
        /// <summary>
        /// The previous cursor.
        /// </summary>
        private readonly Cursor previousCursor;

        /// <summary>
        /// A value indicating whether the class has been disposed.
        /// </summary>
        private bool disposedValue;

        /// <summary>
        /// Initializes a new instance of the <see cref="WaitCursor" /> class.
        /// </summary>
        public WaitCursor()
        {
            this.previousCursor = Cursor.Current;
            Cursor.Current = Cursors.WaitCursor;
        }

        /// <summary>
        /// Finalizes an instance of the <see cref="WaitCursor" /> class.
        /// </summary>
        ~WaitCursor()
        {
            this.Dispose(disposing: false);
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting
        /// unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            this.Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources.
        /// </summary>
        /// <param name="disposing">
        /// <c>true</c> to release both managed and unmanaged resources; <c>false</c> to release
        /// only unmanaged resources.
        /// </param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposedValue)
            {
                if (disposing)
                {
                }

                Cursor.Current = this.previousCursor;

                this.disposedValue = true;
            }
        }
    }

1
dotnet publish -c Release

1
2
3
routes.MapSpaFallbackRoute(
name: "spa-fallback",
defaults: new { controller = "Home", action = "Index" });