DEV Community: Kevin Griffin @ #Shedquarters

HttpContext Issues with Azure SignalR Service

Kevin Griffin @ #Shedquarters — Tue, 12 Dec 2023 08:00:00 +0000

This is my entry for this years CS Advent. Take a moment to go check out the other great entries!

Last week, the team and I were migrating an application built with ASP.NET Core and SignalR to use the Azure SignalR Service. The migration was pretty straight forward, but we ran into an issue with the HttpContext when using the Azure SignalR Service.

When a normal SignalR integration is running under an ASP.NET host, you will typically have access to the HttpContext for the SignalR request. This is best done by injecting IHttpContextAccessor into your Hub class.

We wrote a bit of code that needed to look at the HttpContext to pull some information from a cookie. In normal operation, this code worked fantastically and it served us well for YEARS.

public class SignalRHub : Hub
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    public SignalRHub(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;_
    }

    public async Task SendMessage(string message)
    {
        var httpContext = _httpContextAccessor.HttpContext;

        // look up cookie tzInformation
        var tzInformation = httpContext.Request.Cookies["tzInformation"];

        // do something with tzInformation
    }
}

There is a bit of problem now that we migrated this code to Azure SignalR Service. The IHttpContextAccessor is still injected into the Hub class, but it won't have the same information you'd have in a normal SignalR integration.

If you think about it for a moment, or read this Github issue from 2019, you'll realize that it makes sense. The HttpContext is from a connection between the client and the SignalR. When Azure SignalR Service is used, the hub is still on your server, but the connection is between the client and the Azure SignalR Service. The Azure SignalR Service then forwards the messages to your hub.

What's a better approach?

The primary mistake we made was assuming the state was available when it wasn't. The better approach is to pass the information you need from the client to the hub. In our case, we needed the timezone information from the client. We could have passed that information as a parameter to the SendMessage method.

public class SignalRHub : Hub
{
    public async Task SendMessage(string message, string tzInformation)
    {
        // do something with tzInformation
    }
}

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/signalr")
    .build();

async function sendMessage(message: string) {
    const tzInformation = "America/New_York";
    await connection.invoke("SendMessage", message, tzInformation);
}

async connection.start();

What about Identity?

One of the cool things that Azure SignalR Service will do for you is it will pass along any IPrincipal information that is set on the HttpContext. This is great if you are using Identity and want to know who the user is. You can use the Context.User property to get the user information.

public class SignalRHub : Hub
{
    public async Task SendMessage(string message)
    {
        var user = Context.User;
        // do something with user
    }
}

Conclusion

If you've found yourself here because of a Google search, I hope you have a little bit of resolve now. Maybe if you're looking for more SignalR information, take a look at my course, SignalR Mastery. It's a great way to learn SignalR and it's on sale for the holidays! If you're looking for more information on Azure SignalR Service, check out the Azure SignalR Service documentation.

Rapid Project Upgrades with the .NET Upgrade Assistant

Kevin Griffin @ #Shedquarters — Wed, 08 Dec 2021 08:00:00 +0000

This is my yearly submission for CS Advent 2021! Please take a moment to check out all the other great submissions from folks in the community.

Quick history

Let's rewind back a couple weeks. I was maintaining a .NET Core 3.1 Web Application. This particular app had been on quite the journey! It started life in .NET Framework 4.6 (after I dabbled with the idea of writing the app in node.js, whew I dodged a bullet with that one). Eventually, it was migrated to .NET Core 1.1. Then .NET Core 2.2. And then .NET Core 3.1 where it's been since about two weeks ago.

I had skipped the jump to .NET 5 partially out of laziness, but also out of concern. This application had grown a bit in complexity and moving pieces, so I was wary to put the effort into upgrading it to the latest bits. And .NET Core 3.1 was the LTS (long term service) version of .NET, so I wasn't in a huge hurry to move forward.

.NET 6 Launch

I knew that I wanted to move this application to .NET 6, as it would be the new LTS version, and I was foregoing several dependency updates. In particular, there was one dependency that was still based on .NET Framework that was giving me concern. It never made the jump to .NET Standard, so I worried about future compatibility.

It was during the amazing Visual Studio 2021 launch video, I saw mention of the dotnet upgrade assistant. Now - I feel like a fool because this tool has been around for a while, but it was getting an update to support .NET 6.

Maybe this was the tool that would help us go live with .NET 6?

Getting Started with Upgrade Assistant

All tools should be as straight forward to install as the .NET Upgrade Assistant. We'll assume you already have the .NET 6 SDK and Runtimes installed on your machine.

dotnet tool install -g upgrade-assistant

After a moment, you'll have all the tools and a new command upgrade-assistant.

Analysis

If you run the command upgrade-assistant analyze [.sln or .csproj], you will be provided with a guided path of what an upgrade would look like.

This involves a couple things:

What TFM (Target Framework) should be used for the project?
Do any of the project's dependencies need to be updated?
Are there significant code changes that need to be made to support the upgrade?
And more!

For my .NET 3.1 project, there were a couple small changes to some of my ASP.NET Core Controllers - but there wasn't a significant code change.

I had another test project that I had taken from .NET Framework 4.6 to .NET Core 6. This one was a concern, because things such as ASP.NET Identity had radically changed. You could not do the upgrade without breaking the code.

In all of these cases, the upgrade assistant will tell you what needs to be done and make as many changes it can.

Upgrade

If you do the analysis step, then the upgrade is basically the same thing except you're provided an option to skip the step or perform the action.

For example, the first step is to Backup all of the projects and code being worked on. Since I do all of my work in Git branches, I skipped this step because source control. I recommend you do the same.

There is also an option to provide more detail on each step. If you're not sure if the step will be expensive or cause a break your code, the upgrade assistant will tell you.

Go live time!

Here was the funny part - my upgrade process compiled perfectly the first time.

And that's scary.

We went through the proper motions for testing, and everything worked great. The application was a bit faster, and the memory usage decreased.

I was really not looking forward to upgrading the project, but the upgrade assistant made it a breeze!

Questions Answered

Does this handle solutions or just single projects?

When I ran the upgrade assistant against my primary project (with ~20 projects in it), the upgrade assistant asked for to designate the entrypoint for the application.

From there, the upgrade assistant looked at all the dependencies, their dependencies, and graphed the best way to tackle the upgrade.

I ended up repeating this process two more times because I had additional entrypoints for the solution (MVC application, an Azure Functions application, and a console service application).

What .NET langages does the Upgrade Assistant support?

C# and Visual Basic are fully supported!

What else can Upgrade Assistant help with?

I haven't played around with all of the configurations that the .NET Upgrade Assistant can help you with, but according to the website, the Upgrade Assistant can help with the following project types:

ASP.NET MVC
Windows Forms
Windows Presentation Foundation (WPF)
Console applications
Class Libraries

What about other types of projects?

You'll probably notice ASP.NET Web Forms is missing from the above list, and that's on the roadmap for the project along with many other features!

Conclusion

I wasn't looking forward to the upgrade path for my applications, mainly because I didn't want to have to edit all the project files and deal with incremental issues that might have popped up.

The .NET Upgrade Assistant was an amazing tool that helped us get our application into production with .NET 6 easily and quickly. I'm hoping if you're on the fence about making the upgrade, take the time to check out this tool!

Building a Twitch Badge For My Site

Kevin Griffin @ #Shedquarters — Thu, 28 May 2020 03:08:36 +0000

This article was originally first on my site, https://consultwithgriff.com - check it out!

On my stream, I wanted to play around with building out some tools that help me connect better with my readers and viewers.

First task on the list was an indicator on this site that would tell you if was currently online. Eventually, this will extend to other tools - but first things first.

Here are the steps I had to follow in order to build my Twitch badge:

Create an endpoint that would tell me if I was online
Generate a badge that said online or offline
Display the badge on my site

TwitchLib

When creating an endpoint that would tell me if I was online, I wanted to start with a solid base. Turns out there is already an amazing open-source library called TwitchLib which helps facilitate the connection to the Twitch APIs.

There is a great set of APIs available, and the exact method call I wanted was in the examples: BroadcasterOnlineAsync.

var user = await _api.V5.Users.GetUserByNameAsync(channelName);
var isOnline = await _api.V5.Streams.BroadcasterOnlineAsync(user.Matches.First().Id);

Turns out, I had to take an additional step of getting my channel ID instead of just using my channel name. If anyone knows another way of doing this that's easier/faster/better, please let me know.

Azure Functions

With my new ability to get channel status at the blink of an eye, I needed a way to query this whenever some came to my site.

Serverless was the answer.

I wrote a simple Azure Function for polling Twitch to see if I was online.

[FunctionName("IsChannelOnline")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req)
{
    var clientId = Environment.GetEnvironmentVariable("twitch:clientId");
    var accessToken = Environment.GetEnvironmentVariable("twitch:accessToken");

    var twitch = new Twitch(clientId, accessToken);

    string name = req.Query["channelName"];

    if (string.IsNullOrEmpty(name)) return new BadRequestObjectResult("Channel name was missing.");

    var isOnline = await twitch.IsChannelOnlineAsync(name);

    /* other code */
}

This method would let me call a HTTP endpoint, like https://myazurefunctions.com/api/IsChannelOnline?channelName=1kevgriff and it would return a response!

Note: The await twitch.IsChannelOnlineAsync(name) is a wrapper around the TwitchLib code I wrote above. Sorry if that was misleading!

Shields.io

With my new Azure Function deployed, I need to set up to show if it said online or offline.

My buddy, Mike Buckbee, had an amazing idea - why not make it look like build badges used on various GitHub pages. Another buddy, Calvin Allen, pointed out I could use Shields.io to build the badge automatically.

To that extent, I could give Shields.io my Azure Functions endpoint and it would build the badge for me.

My updated Azure Function to return the JSON necessary for Shields.io to build a badge.

public class ShieldBadge
{
    public int SchemaVersion { get; private set; } = 1;

    /// <summary>
    /// Left Text
    /// </summary>
    public string Label { get; set; }

    /// <summary>
    /// Right Text
    /// </summary>
    public string Message { get; set; }

    /// <summary>
    /// Right Color
    /// </summary>
    public string Color { get; set; }

    /// <summary>
    /// Left Color
    /// 
    /// </summary>
    public string LabelColor { get; set; }

    /// <summary>
    /// Style
    /// 
    /// Options: flat, plastic, flat-square, for-the-badge, social 
    /// </summary>
    public string Style { get; set; }
}

var badge = new ShieldBadge
{
    Label = "twitch.tv/1kevgriff",
    LabelColor = "lightgrey",
    Style = "flat",
    Message = isOnline ? "LIVE" : "OFFLINE",
    Color = isOnline ? "#2f855a" : "red"
};

Adding it to my site

This was the easiest step. On my site, I added an image tag pointing to the following URL.

<img
alt="Am I streaming?"
src="https://img.shields.io/endpoint?style=for-the-badge&url=https%3A%2F%2Fgriffin-twitch-functions.azurewebsites.net%2Fapi%2FIsChannelOnline%3Fcode%3DxCnE0Jr1XRSamEmyhLUYuJE%2FQ34ovvbST19kl3vOXbvnxIBKCBxzvw%3D%3D%26channelName%3D1kevgriff"
/>

Doing this will add the awesome little badge you see at the top:

Wrap up!

This was a fun little project that took me about 2 hours to figure out, start to finish. Full source code is available at https://github.com/1kevgriff/Griffin.TwitchBot..

Thanks for following along, and follow me on Twitch to see when I go live!

What is Dapper, and why you should consider it for your .NET projects

Kevin Griffin @ #Shedquarters — Mon, 18 May 2020 17:31:05 +0000

This post was originally hosted on my site, https://consultwithgriff.com - check it out!

On the speaking circuit, I've been doing a good number of presentations on Dapper. My talk is entitled Better Object Mapping in .NET with Dapper and this is an attempt to catch the eyes of developers who might have heard of object mapping from things like Entity Framework.

What is Dapper?

Dapper is a Micro-ORM or Micro Object Relational Mapper.

Maybe it's better to start at the beginning. If you're using a relational database, such as SQL Server, MySql, or PostgreSQL, you probably have had to deal with the problem of "how do I turn a result set into an object I can actually do work with?"

There are a ton of ways to do this currently:

Write your own mapping from a result set.

This process is really tedious, and I've written my fair share of code that gets the string from ordinal position 0 and the long from ordinal position 52.

~~I'm not even going to show demo code, because I don't want you to write it. Use Dapper.~~

EDIT: Ok - here's how'd you write it.

Imagine you have a (relational) database table called Users. It has columns in it.

Column	type
Id	bigint
FirstName	nvarchar(50)
LastName	nvarchar(50)
EmailAddress	nvarchar(255)
DateOfBirth	datetime

If you wanted to query that content, you could simply write the following SQL:

SELECT Id, FirstName, LastName, EmailAddress, DateOfBirth
FROM [dbo].[Users]

And if you wanted to get that data into an object that is actually useful... you'd... well..

public class ApplicationUser
{
    public long Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string EmailAddress { get; set; }
    public DateTime DateOfBirth { get; set; }
}

Yeah! Write a DataReader...

var sql = @"SELECT Id, FirstName, LastName, EmailAddress, DateOfBirth
        FROM [dbo].[Users]";
using (var connection = new SqlConnection(CONNECTION_STRING))
{
    await connection.OpenAsync();
    using (var reader = await connection.ExecuteReaderAsync(sql))
    {
        var applicationUsers = new List<ApplicationUser>();
        while (await reader.ReadAsync())
        {
            applicationUsers.Add(new ApplicationUser()
            {
                Id = reader.GetInt64(0), // ordinal position
                FirstName = reader.GetString(1),
                LastName = reader.GetString(2),
                EmailAddress = reader.GetString(3),
                DateOfBirth = reader.GetDateTime(4)
            });
        }
        return applicationUsers;
    }
}

Not bad, right? Maybe not, until you're trying to retrieve a 10+ column result set.

Also, what if you want to change the order of your parameters? You need to reorder the ordinal positions of your readers.

Yes, you can get the ordinal by calling reader.GetOrdinal("EmailAddress");. Please don't do that in the .ReadAsync() loop though. Call it once outside of the loop and cache the results. Calling GetOrdinal for each column on each row read is expensive and will slow down your application.
And the more obvious detail, you need to know the data types for the columsn you're retrieving! Is it a string? Or a datetime? Or an Int16, Int32, or Int64?? Wowza.

Data Tables

The first .NET project I worked on back in 2007 used DataTables exclusively for all data access. This was to the extent where I believed DataTables were the ONLY way to get the results of a SQL Query.

And DataTables aren't too bad. The biggest downside to them is that they're memory hogs, and using them with larger datasets can imped performance.

Example:

var sql = @"SELECT Id, FirstName, LastName, EmailAddress, DateOfBirth
        FROM [dbo].[Users]";

using (var connection = new SqlConnection(CONNECTION_STRING))
{
    await connection.OpenAsync();
    using (var reader = await connection.ExecuteReaderAsync(sql))
    {
        DataTable table = new DataTable();
        table.Load(reader);
        var emailAddress = table.Rows[0]["EmailAddress"];
    }
}

Again - not bad! This approach is more accessible (in my opinion) than the DataReader.

Entity Framework

EF is the 6,000-pound gorilla in the room. It's what Microsoft recommends using for data access. And I have a lot of opinions on why I don't like Entity Framework for data access, but I don't feel this is the place nor the time.

By the way, it's great for demos.

Other ORMS options

Here are some other ORMs that are interesting to look at:

What makes Dapper special?

At its core, Dapper is simply a collection of extension methods off of a SqlConnnection object.

Here is an example of using Dapper to query the database and return a list of objects.

Remember our object?

public class ApplicationUser
{
    public long Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string EmailAddress { get; set; }
    public DateTime DateOfBirth { get; set; }
}

Here's the Dapper approach to Querying and Mapping the results to an object (or in our case, a collection of objects).

using (var connection = new SqlConnection(CONNECTION_STRING))
{
    var sql = "SELECT Id, FirstName, LastName, EmailAddress, DateOfBirth From [dbo].[Users]";

    var results = await connection
        .QueryAsync<ApplicationUser>(sql);
}

That's it. No need to .Open the connection. Just create it and call the Query or QueryAsync method.

What about parameters? How do I avoid SQL injection?

That's a great question. Let's go back to the DataReader example and see how it was done there:

var sql = @"SELECT Id, FirstName, LastName, EmailAddress, DateOfBirth
                    FROM [dbo].[Users] WHERE FirstName = @firstName";
using (var connection = new SqlConnection(CONNECTION_STRING))
{
    await connection.OpenAsync();
    using (var command = connection.CreateCommand())
    {
        command.CommandText = sql;
        command.Parameters.AddWithValue("firstName", "Kevin");
        using (var reader = await command.ExecuteReaderAsync())
        {
            var applicationUsers = new List<ApplicationUser>();
            while (await reader.ReadAsync())
            {
                applicationUsers.Add(new ApplicationUser()
                {
                    Id = reader.GetInt64(0), // ordinal position
                    FirstName = reader.GetString(1),
                    LastName = reader.GetString(2),
                    EmailAddress = reader.GetString(3),
                    DateOfBirth = reader.GetDateTime(4)
                });
            }
            return applicationUsers;
        }
    }
}

What's the difference? First, the SQL statement has a WHERE clause in it. I've added a parameter with the @firstName identifier.

Note: Please please please parameterize your SQL queries. This is one of the easiest things you can do to protect your databases.

In order for the query to work, you need to pass the parameter value to the data reader. I had to take an extra step by creating a full SqlCommand instead of just executing a reader. Not a big deal - but it's necessary to add parameters.

command.Parameters.AddWithValue("firstName", "Kevin"); tells the command which parameter I want to map to and the value to use for it.

Now! Let's do the same with Dapper.

var sql = @"SELECT Id, FirstName, LastName, EmailAddress, DateOfBirth
        FROM [dbo].[Users] WHERE FirstName = @firstName";
using (var connection = new SqlConnection(CONNECTION_STRING))
{
    var results = await connection
        .QueryAsync<ApplicationUser>(sql, new { firstName = "Kevin" });
}

The next parameter of QueryAsync (or many other Dapper methods) is a parameter object.

I'm passing an anonymous object for my parameters, and Dapper will assist with telling the database that I want @firstName to map to Kevin. I don't need to worry about any of that work.

It seems like you're over-simplifying?

I totally am. But my goal here is to tell you what Dapper is meant to do.

Most database operations you need to make: SELECT, UPDATE, INSERT, DELETE are supported with a couple of lines of code. I'm planning several follow up posts that cover scenarios around these topics, but I felt this article would become more reference than "hey, this is a tool I like and you should check it out."

Rob made a great point earlier, I'm not really diving deep enough into mapping. There is a rabbit hole of use-cases where Dapper can be combined with other awesome libraries, like AutoMapper. I'm not diving in deep here, but it seems like a great idea for future posts.

Use Stored Procedures? No problem

I also use Dapper in every single application I scaffold out. It's that critical to my project success.

Is it open-source?

Yes! And even better, it's built by the good folks over at StackOverflow. Maybe you've heard of it. It's one of the most frequented websites on the internet, and they do not play around when it comes to performance.

Dapper was created by their team in order to make mapping data to objects as painless as possible while being fast. Check out their performance benchmarks

Give it a try!

If you're jumping into Dapper for the first time, take it easy! There are a lot of great examples in the GitHub repo for getting started.

If you run into problems, feel free to ask me on Twitter. I'm happy to research your questions and write some detailed explanations on more complex use-cases.

Also - if you made it this far, follow me on Twitch. I do a daily stream where I work on random projects. I'd love to chat with you!