Jekyll2026-03-29T17:28:14-07:00https://wforney.github.io/feed.xmlWilliam ForneyPersonal blog of William Forney — software engineer, architect, and developer. Writing about .NET, cloud, architecture, and more.Update on .NET Packages for Shared Code2025-02-23T00:00:00-08:002025-02-23T00:00:00-08:00https://wforney.github.io/2025/02/23/update-on-net-packages-for-shared-codeHello all, it’s been a while. I have fixed the build for my improvgroup/sharedcode on GitHub NuGet packages and pushed a new package update targeting .NET 9 primarily. It should still work with .NET 8 as well. I dropped support for 6 and 7 since they are also out of support from Microsoft at this point. The .NET Core releases are going out much faster than in the old days, so I’ll try to keep these libraries relevant and working in newer versions. I may split some functionality and release a .NET Standard package that could support older projects when I have some free time.

Contributions and suggestions are always welcome. I try to add functionality that complements what’s out there and remove things that I find are better left to other libraries or the framework itself.

That is all for now. Please feel free to leave me issues or feedback on improvgroup/sharedcode on GitHub.

]]>How to map an IDataRecord to an entity class object using expressions2020-09-27T00:00:00-07:002020-09-27T00:00:00-07:00https://wforney.github.io/2020/09/27/how-to-map-an-idatarecord-to-an-entity-class-object-without-using-reflectionRecently I had a need to map an IDataRecord to an entity class object in C#. Here is the code for reference… First, we need the method that generates a function to map the properties while handling DBNull.

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();
        }

Next we need the function that calls the above…

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);
        }

This does the job for a single row, but we want all the rows in the reader, right? For that we need this one…

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;  
        }

That’s it… It doesn’t use the async API of the data reader for the read… We might want an async version too…

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;  
        }

But what if we don’t want to pull the whole list all at once? Then you need this…

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;  
                }  
            }  
        }

Oh, but what if you want a blocking version of that?

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;  
                }  
            }  
        }

Hopefully, part of this will come in handy for someone as it was for me.

The code for this is available on improvgroup/sharedcode on GitHub and via SharedCode.Data on NuGet.

]]>STAThread async/await got you down?2020-09-27T00:00:00-07:002020-09-27T00:00:00-07:00https://wforney.github.io/2020/09/27/stathread-async-await-got-you-downWhen encountering issues with async/await while building a Windows Forms application recently I came across this helpful class that allows you to await returning to the initial (usually UI) thread…

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);
    }

It goes along with this extension method…

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);

And you use it like this…

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

This is a somewhat cleaner way to handle the multi-threading problem in async methods in a STAThread application.

]]>Using a wait cursor doesn’t have to be hard…2020-09-27T00:00:00-07:002020-09-27T00:00:00-07:00https://wforney.github.io/2020/09/27/using-a-wait-cursor-doesnt-have-to-be-hardHere is a simple disposable wait cursor class to simplify your mouse display needs…

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;
            }
        }
    }
]]>…and back to WordPress again…2020-09-12T00:00:00-07:002020-09-12T00:00:00-07:00https://wforney.github.io/2020/09/12/and-back-to-wordpress-againA while ago I swapped my blog to BlogEngine.NET, then to MiniBlog, then to Ghost, then back to MiniBlog. Now I’m going back to WordPress again after a decade or so. The other platforms were nice, and some were integrated well, but nobody has kept them up, or they were just side demo projects for people. At this point I wanted a platform that I can host that is relatively stable and is maintained actively. Some of the newer features are nice too.

]]>Update to ASP.NET Core2018-08-19T00:00:00-07:002018-08-19T00:00:00-07:00https://wforney.github.io/2018/08/19/update-to-asp-net-coreRecently I updated the blog to MiniBlog.Core on ASP.NET Core. So far it seems pretty fast. I’m working on a new engine for it in my spare time using Azure Functions and blob storage. More to come when I find some time to update this.

]]>Getting Started with Aurelia on ASP.NET Core2017-05-22T00:00:00-07:002017-05-22T00:00:00-07:00https://wforney.github.io/2017/05/22/getting-started-with-aurelia-on-asp-net-coreAurelia, one of the leading JavaScript client frameworks for single page applications (SPAs), has been around for a while now and there are a number of resources for getting started with it. Rather than try to make yet another demo, I thought it might be fun to create a site repository that could be used as a template with a few more bells and whistles already setup. It is my hope that this will be useful not just to me, but to anyone else who wants to start a project. We’re going to use the command line tools to do this, but you can use Visual Studio if you want as well.

Setting up the ASP.NET Core Project

Prerequisites

Steps

  1. Create a folder for your project.
  2. Open a command prompt (cmd) in that folder.

  3. Install the SPA templates with the following command:

    1

    dotnet new --install Microsoft.AspNetCore.SpaTemplates::*

screenshot

  1. Create the Aurelia project like this:

    1

    dotnet new Aurelia 

screenshot

  1. Prepare the environment to run using these commands, ignoring any warnings from npm as they are expected…

    1
2
3

    dotnet restore
npm install
setx ASPNETCORE_ENVIRONMENT "Development"

screenshot screenshot screenshot

  1. Restart your command prompt to ensure that the environment change takes effect.

  2. Run your new app with the command line

    1

    dotnet run

screenshot

These steps should give you a bare bones ASP.NET Core site with a basic Aurelia setup that looks like this…

screenshot

Publishing to a Host

Now that you have a working site you’ll want to publish it to an actual server somewhere. To do that you’ll perform a publish. You can do this by running this command:

1

dotnet publish -c Release

This command compiles the server side C# code and runs a webpack production build on the TypeScript and client assets. You can then find the files to upload to your host in the bin\Release\netcoreapp1.1\publish folder.

Exploring the Template

This template takes care of a lot of things that you would have to setup manually and makes a good starting point for adding more functionality, such as logging with Application Insights or another logging provider, fleshing out an administration interface for user management and authentication/authorization using IdentityServer, or any number of other useful additions that are widely available.

To get started understanding what we’ve got here, you’ll want to take a look into the files in your new project. You’ll notice that in Startup.cs we have setup a fallback route that allows anything not dealt with by a static file or MVC route to be sent to the Home Index view. This is the secret sauce that lets all your links work even though they aren’t configured individually.

1
2
3

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

To be continued…

]]>Aurelia with TypeScript on ASP.NET Core2016-03-08T00:00:00-08:002016-03-08T00:00:00-08:00https://wforney.github.io/2016/03/08/aurelia-with-typescript-on-asp-net-coreI’ve been tracking the ASP.NET betas and release candidates over the past year or more and it’s coming along nicely. I like the separation of client side and server side in the new folder structure and the unification of the ASP.NET MVC and WebAPI controllers. For the past few years I’ve used jsViews, Kendo UI, Angular, Durandal, Knockout, and Aurelia for front end JavaScript development.

A while ago I was using TypeScript with these to help with intellisense and typing issues across the libraries and sites I worked on. I often find myself introducing whatever team I’m on to these technologies in one way or another. I’ve been working with the combination of ASP.NET Core, formerly ASP.NET 5, and Aurelia with TypeScript and Web Components.

I start with the yoeman generator for ASP.NET and add the pieces as I go. I use ASP.NET MVC for the API and plain old HTML and TypeScript for the UI. The client tool chain consists of the usual npm, jspm, and gulp. When the new ASP.NET bits are done I’ll make a template for all this and post it to github. In the meantime I’m considering doing a short video or slide deck walking through the setup if anyone is interested.

]]>Something different, something new, something blue2015-11-08T00:00:00-08:002015-11-08T00:00:00-08:00https://wforney.github.io/2015/11/08/something-different-something-new-something-blueAmusingly today I’m looking at new cars, hence the blue and new, but that’s not all that’s going on. Today I am starting something new that will change hopefully not just my perception of the world, but others as well. It’s time for change. Let’s do this.

]]>How to open a “new window” in a Windows 10 Universal App2015-08-13T00:00:00-07:002015-08-13T00:00:00-07:00https://wforney.github.io/2015/08/13/how-to-open-a-new-window-in-a-windows-10-universal-appI had to dig a little bit to find this. Since not all form factors support multiple windows and tablet mode generally discourages floating windows this is probably buried for a reason, but I wanted to do it anyway so here it is:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

 var viewId = 0;

 var newView = CoreApplication.CreateNewView();
await newView.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
() =>
{
var frame = new Frame();
frame.Navigate(typeof(YourViewPageType), ViewModelDataOrNull);
Window.Current.Content = frame;




viewId = ApplicationView.GetForCurrentView().Id;

ApplicationView.GetForCurrentView().Consolidated += App.ViewConsolidated;

Window.Current.Activate();
});

var viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(viewId);

Hopefully that will save someone some digging.

]]>