A simple way to get the IP of the server running your GitHub Actions
I recently had the need to determine the IP address of the server running my GitHib Action. Knowing this may be useful to matchup individual workflow runs with specific entries in log files, or temporarily whitelisting the action runner’s IP during testing.
I found that a cURL request to ipify.org can achieve this simply:
on:
workflow_dispatch:
push:
jobs:
ci:
runson: ubuntulatest
steps:
 name: ðŸ›’ Checkout
uses: actions/checkout@v2
 name: ðŸ”Ž Check IP
run: curl https://api.ipify.org
There are published/shared Actions which do something similar (e.g., haythem/publicip) but whenever possible I avoid these because they are a potential vector for supply chain attacks (a compromised action could access secrets in environment variables).
 The GitHub meta endpoint shows all IP ranges used by GitHub Actions runners and may be useful for whitelisting purposes.
How to perform math on generic types in C# with .NET 6
Generic types are great, but it has traditionally been difficult to do math with them. Consider the simple task where you want to accept a generic array and return its sum. With .NET 6 (and features currently still in preview), this got much easier!
public static T Sum<T>(T[] values) where T : INumber<T>
{
T sum = T.Zero;
for (int i = 0; i < values.Length; i++)
sum += values[i];
return sum;
}
To use this feature today you must:
 Install the System.Runtime.Experimental NuGet package
 Add these lines to the
PropertyGroup
in your csproj file:
<langversion>preview</langversion>
<EnablePreviewFeatures>true</EnablePreviewFeatures>
Note that the generic math function above is equivalent in speed to one that accepts and returns double[]
, while a method which accepts a generic but calls Convert.ToDouble()
every time is about 3x slower than both options:
// this code works on older versions of .NET but is about 3x slower
public static double SumGenericToDouble<T>(T[] values)
{
double sum = 0;
for (int i = 0; i < values.Length; i++)
sum += Convert.ToDouble(values[i]);
return sum;
}
How to determine if a point is inside a rotated rectangle with C#
I recently had the need to determine if a point is inside a rotated rectangle. This need arose when I wanted to make a rotated rectangular textbox draggable, but I wanted to determine if the mouse was over the rectangle. I know the rectangle’s location, size, and rotation, and the position of the mouse cursor, and my goal is to tell if the mouse is inside the rotated rectangle. In this example I’ll use Maui.Graphics
to render a test image in a Windows Forms application (with SkiaSharp and OpenGL), but the same could be achieved with System.Drawing
or other similar 2D graphics libraries.
I started just knowing the width and height of my rectangle. I created an array of points representing its corners.
float rectWidth = 300;
float rectHeight = 150;
PointF[] rectCorners =
{
new(0, 0),
new(rectWidth, 0),
new(rectWidth, rectHeight),
new(0, rectHeight),
};
I then rotated the rectangle around an origin point by applying a rotation transformation to each corner.
PointF origin = new(200, 300); // center of rotation
double angleRadians = 1.234;
PointF[] rotatedCorners = rectCorners.Select(x => Rotate(origin, x, angleRadians)).ToArray();
private PointF Rotate(PointF origin, PointF point, double radians)
{
double dx = point.X * Math.Cos(radians)  point.Y * Math.Sin(radians);
double dy = point.X * Math.Sin(radians) + point.Y * Math.Cos(radians);
return new PointF(origin.X + (float)dx, origin.Y + (float)dy);
}
To determine if a given point is inside the rotated rectangle I called this method which accepts the point of interest and an array containing the four corners of the rotated rectangle.
public bool IsPointInsideRectangle(PointF pt, PointF[] rectCorners)
{
double x1 = rectCorners[0].X;
double x2 = rectCorners[1].X;
double x3 = rectCorners[2].X;
double x4 = rectCorners[3].X;
double y1 = rectCorners[0].Y;
double y2 = rectCorners[1].Y;
double y3 = rectCorners[2].Y;
double y4 = rectCorners[3].Y;
double a1 = Math.Sqrt((x1  x2) * (x1  x2) + (y1  y2) * (y1  y2));
double a2 = Math.Sqrt((x2  x3) * (x2  x3) + (y2  y3) * (y2  y3));
double a3 = Math.Sqrt((x3  x4) * (x3  x4) + (y3  y4) * (y3  y4));
double a4 = Math.Sqrt((x4  x1) * (x4  x1) + (y4  y1) * (y4  y1));
double b1 = Math.Sqrt((x1  pt.X) * (x1  pt.X) + (y1  pt.Y) * (y1  pt.Y));
double b2 = Math.Sqrt((x2  pt.X) * (x2  pt.X) + (y2  pt.Y) * (y2  pt.Y));
double b3 = Math.Sqrt((x3  pt.X) * (x3  pt.X) + (y3  pt.Y) * (y3  pt.Y));
double b4 = Math.Sqrt((x4  pt.X) * (x4  pt.X) + (y4  pt.Y) * (y4  pt.Y));
double u1 = (a1 + b1 + b2) / 2;
double u2 = (a2 + b2 + b3) / 2;
double u3 = (a3 + b3 + b4) / 2;
double u4 = (a4 + b4 + b1) / 2;
double A1 = Math.Sqrt(u1 * (u1  a1) * (u1  b1) * (u1  b2));
double A2 = Math.Sqrt(u2 * (u2  a2) * (u2  b2) * (u2  b3));
double A3 = Math.Sqrt(u3 * (u3  a3) * (u3  b3) * (u3  b4));
double A4 = Math.Sqrt(u4 * (u4  a4) * (u4  b4) * (u4  b1));
double difference = A1 + A2 + A3 + A4  a1 * a2;
return difference < 1;
}
Consider 4 triangles formed by lines between the point and the 4 corners…
If the point is inside the rectangle, the area of the four triangles will equal the area of the rectangle.
If the point is outside the rectangle, the area of the four triangles will be greater than the area of the rectangle.
The code above calculates the area of the 4 rectangles and returns true
if it is approximately equal to the area of the rectangle.

In practice you’ll probably want to use a more intelligent data structure than a 4element Pointf[]
when calling these functions.

The points in the array are clockwise, but I assume this method will work regardless of the order of the points in the array.

At the very end of IsPointInsideRectangle()
the final decision is made based on a distance being less than a given value. It’s true that the cursor will be inside the rectangle if the distance is exactly zero, but with the possible accumulation of floatingpoint math errors this seemed like a safer option.
How to smooth X/Y data using spline interpolation in Csharp
I recently had the need to create a smoothed curve from a series of X/Y data points in a C# application. I achieved this using cubic spline interpolation. I prefer this strategy because I can control the exact number of points in the output curve, and the generated curve (given sufficient points) will pass through the original data making it excellent for data smoothing applications.
The code below is an adaptation of original work by Ryan Seghers (links below) that I modified to narrow its scope, support double
types, use modern language features, and operate statelessly in a functional style with all static
methods.

It targets .NET Standard 2.0
so it can be used in .NET Framework and .NET Core applications.

Input Xs
and Ys
must be the same length but do not need to be ordered.

The interpolated curve may have any number of points (not just even multiples of the input length), and may even have fewer points than the original data.

Users cannot define start or end slopes so the curve generated is a natural spline.
public static class Cubic
{
/// <summary>
/// Generate a smooth (interpolated) curve that follows the path of the given X/Y points
/// </summary>
public static (double[] xs, double[] ys) InterpolateXY(double[] xs, double[] ys, int count)
{
if (xs is null  ys is null  xs.Length != ys.Length)
throw new ArgumentException($"{nameof(xs)} and {nameof(ys)} must have same length");
int inputPointCount = xs.Length;
double[] inputDistances = new double[inputPointCount];
for (int i = 1; i < inputPointCount; i++)
{
double dx = xs[i]  xs[i  1];
double dy = ys[i]  ys[i  1];
double distance = Math.Sqrt(dx * dx + dy * dy);
inputDistances[i] = inputDistances[i  1] + distance;
}
double meanDistance = inputDistances.Last() / (count  1);
double[] evenDistances = Enumerable.Range(0, count).Select(x => x * meanDistance).ToArray();
double[] xsOut = Interpolate(inputDistances, xs, evenDistances);
double[] ysOut = Interpolate(inputDistances, ys, evenDistances);
return (xsOut, ysOut);
}
private static double[] Interpolate(double[] xOrig, double[] yOrig, double[] xInterp)
{
(double[] a, double[] b) = FitMatrix(xOrig, yOrig);
double[] yInterp = new double[xInterp.Length];
for (int i = 0; i < yInterp.Length; i++)
{
int j;
for (j = 0; j < xOrig.Length  2; j++)
if (xInterp[i] <= xOrig[j + 1])
break;
double dx = xOrig[j + 1]  xOrig[j];
double t = (xInterp[i]  xOrig[j]) / dx;
double y = (1  t) * yOrig[j] + t * yOrig[j + 1] +
t * (1  t) * (a[j] * (1  t) + b[j] * t);
yInterp[i] = y;
}
return yInterp;
}
private static (double[] a, double[] b) FitMatrix(double[] x, double[] y)
{
int n = x.Length;
double[] a = new double[n  1];
double[] b = new double[n  1];
double[] r = new double[n];
double[] A = new double[n];
double[] B = new double[n];
double[] C = new double[n];
double dx1, dx2, dy1, dy2;
dx1 = x[1]  x[0];
C[0] = 1.0f / dx1;
B[0] = 2.0f * C[0];
r[0] = 3 * (y[1]  y[0]) / (dx1 * dx1);
for (int i = 1; i < n  1; i++)
{
dx1 = x[i]  x[i  1];
dx2 = x[i + 1]  x[i];
A[i] = 1.0f / dx1;
C[i] = 1.0f / dx2;
B[i] = 2.0f * (A[i] + C[i]);
dy1 = y[i]  y[i  1];
dy2 = y[i + 1]  y[i];
r[i] = 3 * (dy1 / (dx1 * dx1) + dy2 / (dx2 * dx2));
}
dx1 = x[n  1]  x[n  2];
dy1 = y[n  1]  y[n  2];
A[n  1] = 1.0f / dx1;
B[n  1] = 2.0f * A[n  1];
r[n  1] = 3 * (dy1 / (dx1 * dx1));
double[] cPrime = new double[n];
cPrime[0] = C[0] / B[0];
for (int i = 1; i < n; i++)
cPrime[i] = C[i] / (B[i]  cPrime[i  1] * A[i]);
double[] dPrime = new double[n];
dPrime[0] = r[0] / B[0];
for (int i = 1; i < n; i++)
dPrime[i] = (r[i]  dPrime[i  1] * A[i]) / (B[i]  cPrime[i  1] * A[i]);
double[] k = new double[n];
k[n  1] = dPrime[n  1];
for (int i = n  2; i >= 0; i)
k[i] = dPrime[i]  cPrime[i] * k[i + 1];
for (int i = 1; i < n; i++)
{
dx1 = x[i]  x[i  1];
dy1 = y[i]  y[i  1];
a[i  1] = k[i  1] * dx1  dy1;
b[i  1] = k[i] * dx1 + dy1;
}
return (a, b);
}
}
This sample .NET 6 console application uses the class above to create a smoothed (interpolated) curve from a set of random X/Y points. It then plots the original data and the interpolated curve using ScottPlot.
// generate sample data using a random walk
Random rand = new(1268);
int pointCount = 20;
double[] xs1 = new double[pointCount];
double[] ys1 = new double[pointCount];
for (int i = 1; i < pointCount; i++)
{
xs1[i] = xs1[i  1] + rand.NextDouble()  .5;
ys1[i] = ys1[i  1] + rand.NextDouble()  .5;
}
// Use cubic interpolation to smooth the original data
(double[] xs2, double[] ys2) = Cubic.InterpolateXY(xs1, ys1, 200);
// Plot the original vs. interpolated data
var plt = new ScottPlot.Plot(600, 400);
plt.AddScatter(xs1, ys1, label: "original", markerSize: 7);
plt.AddScatter(xs2, ys2, label: "interpolated", markerSize: 3);
plt.Legend();
plt.SaveFig("interpolation.png");
There are many different methods that can smooth data. Common methods include BÃ©zier splines, CatmullRom splines, cornercutting Chaikin curves, and Cubic splines. I recently implemented these strageies to include with ScottPlot (a MITlicensed 2D plotting library for .NET). Visit ScottPlot.net to find the source code for that project and search for the Interpolation
namespace.
A set of X/Y points can be interpolated such that they are evenly spaced on the X axis. This 1D interpolation can be used to change the sampling rate of time series data. For more information about 1D interpolation see my other blog post: Resample Time Series Data using Cubic Spline Interpolation
How I used C# and Maui.Graphics to generate status badges for NDepend static analysis metrics
Many project websites and readmes have status badges that display build status, project details, or code metrics. badgen.net and shields.io are popular services for dynamically generating status badges as SVG files using HTTP requests. This article demonstrates how I use C# and Microsoft.Maui.Graphics
to build status badges from NDepend static analysis reports. Source code for this project is available on GitHub.
NDepend can analyze a code base at different points in time and display code metric trends. See NDepend: Trend Monitoring for a full description. These metrics are stored in an XML file available in the HTML build folder.
The XML file contains many Root/MetricIndex/Metric
elements that describe each metric and its units. This can be parsed to obtain the Name
and Unit
for each metric.
<Root>
<MetricIndex>
<Metric Name="# New Issues since Baseline" Unit="issues" />
<Metric Name="# Issues Fixed since Baseline" Unit="issues" />
<Metric Name="# Issues Worsened since Baseline" Unit="issues" />
<Metric Name="# Issues with severity Blocker" Unit="issues" />
<Metric Name="# Issues with severity Critical" Unit="issues" />
<Metric Name="# Issues with severity High" Unit="issues" />
<Metric Name="# Issues with severity Medium" Unit="issues" />
...
</MetricIndex>
</Root>
The XML file contains multiple Root/M/R
elements that contain the value of each metric at a distinct time point. Numerical metrics have been converted to strings separated by the 
character. Metric values for each time point are in the same order as the metric index.
<Root>
<M>
<R D="10/16/2021 11:58:04 AM" V="000015982177...19133" />
<R D="10/03/2021 04:15:24 PM" V="000015932160...19132" />
...
</M>
</Root>
To read timestamped metrics from the NDepend XML I started by creating a C# record to hold an individual timestamped metric:
public record Metric
{
public DateTime DateTime { get; init; }
public string Name { get; init; }
public string Unit { get; init; }
public string Value { get; init; }
}
I then reached for using System.Xml.Linq
and using System.Xml.XPath
to extract a big list of timestamped metrics from the NDepend XML file:
Metric[] GetMetricsFromXML(string xmlFilePath)
{
XDocument doc = XDocument.Load(xmlFilePath);
List<Metric> baseMetrics = new();
foreach (var el in doc.XPathSelectElement("/Root/MetricIndex").Elements())
{
string name = el.Attribute("Name").Value;
string unit = el.Attribute("Unit").Value;
baseMetrics.Add(new Metric() { Name = name, Unit = unit });
}
List<Metric> allMetrics = new();
foreach (var runElement in doc.XPathSelectElement("/Root/M").Elements())
{
DateTime runDateTime = DateTime.Parse(runElement.Attribute("D").Value);
string[] values = runElement.Attribute("V").Value.Split("");
List<Metric> runMetrics = new();
for (int i = 0; i < baseMetrics.Count; i++)
runMetrics.Add(baseMetrics[i] with { DateTime = runDateTime, Value = values[i] });
allMetrics.AddRange(runMetrics);
}
return allMetrics.ToArray();
}
I found it convenient to make a helper function to get only the latest metrics:
Metric[] GetLatestMetrics(Metric[] metrics)
{
DateTime latestDateTime = metrics.Select(x => x.DateTime).Distinct().OrderBy(x => x).Last();
return metrics.Where(x => x.DateTime == latestDateTime).ToArray();
}
I’ve already written how to make status badges with C# and Maui.Graphics, but that strategy only generates PNG files. For this project I also chose to generate SVG files. Rather than discuss that in detail, I’ll just show to the source code for an example SVG file.
It is important to note that in order to know the image width I must measure the string width. In HTML environments this could be done with vanilla Javascript, but in a C# environment I reached for Microsoft.Maui.Graphics
(see how to MeasureString() with Maui.Graphics).
<svg xmlns='http://www.w3.org/2000/svg'
xmlns:xlink='http://www.w3.org/1999/xlink' width='237' height='20' role='img' arialabel='languages: 5'>
<title>Average # Lines of Code for Types: 25.96</title>
<linearGradient id='s' x2='0' y2='100%'>
<! linear gradient to use for the background shadow >
<stop offset='0' stopcolor='#bbb' stopopacity='.1'/>
<stop offset='1' stopopacity='.1'/>
</linearGradient>
<clipPath id='r'>
<! clip to a rectangle with rounded edges >
<rect width='237' height='20' rx='3' fill='#fff'/>
</clipPath>
<g clippath='url(#r)'>
<! left background >
<rect width='195' height='20' fill='#555'/>
<! right background >
<rect x='195' width='42' height='20' fill='#007ec6'/>
<! background shadow >
<rect width='237' height='20' fill='url(#s)'/>
</g>
<g fill='#FFF' textanchor='center' fontfamily='Verdana,Geneva,DejaVu Sans,sansserif' textrendering='geometricPrecision' fontsize='110'>
<! left text semitransparent shadow then white text >
<text ariahidden='true' x='40' y='150' fill='#010101' fillopacity='.3' transform='scale(.1)' textLength='1854'>Average # Lines of Code for Types</text>
<text x='40' y='140' transform='scale(.1)' fill='#FFF' textLength='1854'>Average # Lines of Code for Types</text>
<! right text semitransparent shadow then white text >
<text ariahidden='true' x='1994' y='150' fill='#010101' fillopacity='.3' transform='scale(.1)' textLength='300'>25.96</text>
<text x='1994' y='140' transform='scale(.1)' fill='#FFF' textLength='300'>25.96</text>
</g>
</svg>
One day Maui.Graphics may offer SVG export support (issue #103) but for now generating these files discretely isn’t too bad.
After putting it all together these are the badges generated by analyzing the current ScottPlot code base: