Tom DuPont .NET

Creating an IOC Container for ASP.NET Core

2017-04-27T08:01:00.000-07:00

I recently added support for ASP.NET Core to my Tact.NET IOC Container, and I thought that I would share some of the interesting requirements I discovered while doing so. I had originally expected the default ASP.NET Core container would follow the same rules as the official Microsoft Unity container, but that turned out not to be the case!

1) Register is first in win.

The Unity container was last in win, and it would completely disregard the original registration. With ASP.NET Core you need to preserve the original registration and then treat all subsequent registrations as addition registrations that will only be resolved when ResolveAll is invoked, similar to keyed registrations in Unity. Which brings us to our next difference...

public class RegisterIsFirstInWinTests

    [Fact]

    public void Unity()

        var log = new EmptyLog();

        using (var container = new TactContainer(log))

            container.RegisterSingleton<IExample, ExampleA>();

            container.RegisterSingleton<IExample, ExampleB>();

            var example = container.Resolve<IExample>();

            Assert.IsType<ExampleB>(example);

    [Fact]

    public void AspNetCore()

        var log = new EmptyLog();

        using (var container = new AspNetCoreContainer(log))

            container.RegisterSingleton<IExample, ExampleA>();

            container.RegisterSingleton<IExample, ExampleB>();

            var example = container.Resolve<IExample>();

            Assert.IsType<ExampleA>(example);

    public interface IExample

        string Name { get; }

    public class ExampleA : IExample

        public string Name => nameof(ExampleA);

    public class ExampleB : IExample

        public string Name => nameof(ExampleB);

2) ResolveAll includes single registrations.

Unity has the concept of keyed registrations, where you can register the same type multiple times with distinct keys (strings) and then resolve them individually by key or as an IEnumerable with ResolveAll. In ASP.NET Core there is no concept of keyed registration, and ResolveAll will return all registrations made for a given type. This means that registering a single type will cause ResolveAll to return an IEnumerable with one value.

public class ResolveAllIncludesSingleRegistrations

    [Fact]

    public void Unity()

        var log = new EmptyLog();

        using (var container = new TactContainer(log))

            container.RegisterSingleton<IExample, ExampleA>();

            container.RegisterSingleton<IExample, ExampleB>();

            var examples = container.ResolveAll<IExample>();

            Assert.Equal(0, examples.Count());

    [Fact]

    public void AspNetCore()

        var log = new EmptyLog();

        using (var container = new AspNetCoreContainer(log))

            container.RegisterSingleton<IExample, ExampleA>();

            container.RegisterSingleton<IExample, ExampleB>();

            var examples = container.ResolveAll<IExample>();

            Assert.Equal(2, examples.Count());

    public interface IExample

        string Name { get; }

    public class ExampleA : IExample

        public string Name => nameof(ExampleA);

    public class ExampleB : IExample

        public string Name => nameof(ExampleB);

3) Generic resolution is required.

This was a neat feature that I had not used before! You can register generic types without any generic parameters, and then the container will fill in the generic parameters based on the resolve request. So, for example, I could register IRepository<> to type DataRepository<>, and then when I call container.Resolve<IRepository<User>>, the IOC container will automatically try to construct a DataRepository<User>

public class TactContainerTests

    [Fact]

    public void GenericResolution()

        var log = new EmptyLog();

        using (var container = new TactContainer(log))

            container.RegisterSingleton(typeof(IRepository<>), typeof(Repository<>));

            var userRepository = container.Resolve<IRepository<User>>();

            Assert.IsType<Repository<User>>(userRepository);

    public interface IRepository<T>

        string ClassName { get; }

        string GenericName { get; }

    public class Repository<T> : IRepository<T>

        public string ClassName => nameof(Repository<T>);

        public string GenericName => typeof(T).Name;

    public class User

4) You have to convert IServiceCollection to your container.

I like how the new .NET separates their service registration from the container itself. In your ASP.NET Core wire up you will work with an IServiceCollection, which will then be converted into a container after you are done filling in your registrations. This means that if you want to create your own container, you will need to map the service collection into your container.

Enjoy,
Tom

How to make a dotnet CLI Tool

2017-04-16T09:31:00.000-07:00

Good news, everyone! It is remarkably easy to make a new dotnet CLI (Command Line Interface) tool! I recently created a CLI tool for one of my new projects, Tact.NET RPC, and in this post I will be referencing that project as my example.

The Basics

Step 1) Create your CLI Console App

All you have to do is...

Create a normal .NET Core Console App.
- NOTE: Currently, the dotnet CLI only supports netcoreapp1.0
Rename the assembly to be prefixed with "dotnet-"
dotnet pack the project and put the package in your local NuGet package source

...that is it! It is literally that easy to create your CLI tool!

Recommendation: use Microsoft.Extensions.Configuration to parse your command line arguments in a standard way.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>

    <OutputType>Exe</OutputType>

    <TargetFramework>netcoreapp1.0</TargetFramework>

    <AssemblyName>dotnet-tactrpcgen</AssemblyName>

    <PackageId>Tact.Rpc.Generator</PackageId>

    <Version>1.0.3</Version>

  </PropertyGroup>

  <ItemGroup>

    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="1.1.1" />

  </ItemGroup>

</Project>

Step 2) Consume your CLI Tool NuGet Package

Edit your csproj file and add a DotNetCliToolReference element that references your package.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>

    <TargetFramework>netstandard1.6</TargetFramework>

  </PropertyGroup>

  <ItemGroup>

    <DotNetCliToolReference Include="Tact.Rpc.Generator" Version="1.0.3" />

  </ItemGroup>

</Project>

Now you are able to invoke your console app via the dotnet command line whenever it is executed in the same path as the csproj.

That's it; it really is that easy!

Development Tips

Here is a simple way to automate the creation and consumption of your CLI tool NuGet package during development.

Create a local package directory

I recommend that you create a packages folder at the root of your solution along with a NuGet.config file; this will allow you to automatically build and consume NuGet packages from this location.

<configuration>

  <packageSources>

    <add key="LocalPackages" value="packages" />

  </packageSources>

</configuration>

Pack on post build

Go back and update your CLI tool's csproj to include a post build step that packs your project and places the output in your package folder. (There is a csproj GeneratePackageOnBuild setting, however at this time I do not believe that you can customize the output directory, so instead I recommend using a post build step.)

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>

    <OutputType>Exe</OutputType>

    <TargetFramework>netcoreapp1.0</TargetFramework>

    <AssemblyName>dotnet-tactrpcgen</AssemblyName>

    <PackageId>Tact.Rpc.Generator</PackageId>

    <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>

    <PostBuildEvent>

      dotnet pack $(SolutionDir)rpc\src\Tact.Rpc.Generator -o $(SolutionDir)packages --no-build

    </PostBuildEvent>

    <Version>1.0.3</Version>

  </PropertyGroup>

  <ItemGroup>

    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="1.1.1" />

  </ItemGroup>

</Project>

Execute on pre build

Obviously this is a completely optional step that should only be used when necessary; in the case of Tact.NET RPC, the active code generation is powered by the CLI tool, and thus it needs to run every build.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>

    <TargetFramework>netstandard1.6</TargetFramework>

    <PreBuildEvent>

      cd $(SolutionDir)rpc\demo\Demo.Rpc

      dotnet tactrpcgen

    </PreBuildEvent>

  </PropertyGroup>

  <ItemGroup>

    <DotNetCliToolReference Include="Tact.Rpc.Generator" Version="1.0.3" />

  </ItemGroup>

</Project>

Increment version to update

NOTE: Despite updating the your local package directory each build, the package will actually be cached in your global NuGet cache, and thus updates will not be picked up unless you increment the version number.

Enjoy,
Tom

C# String Interpolation Performance

2017-03-30T08:00:00.000-07:00

Time for a follow up to my String.Concat vs String.Format Performance post from back in 2014!

I recently found out that string interpolation is not nearly as efficient as I would have thought. I also suspected that it was just doing a string concatenation, but it is actually doing a string format. This leads to a pretty significant performance degradation; the following test runs one million iterations of each.

Number of Args	Interpolation Milliseconds	String.Format Milliseconds	String.Concat Milliseconds	String Add Milliseconds	StringBuilder Milliseconds
2	262	260	19	18	34
3	367	367	25	24	35
4	500	513	31	32	41
5	646	635	67	66	44
6	740	723	79	76	49
7	802	819	86	85	52
8	938	936	97	98	58

So, what's the lesson? Don't use string interpolation in high performance areas (such as your logger)!

Enjoy,
Tom

WebSocket Support for .NET Core

2017-02-28T08:00:00.000-08:00

Full WebSocket support is coming with .NET Standard 2.0, which has now been delayed until Q3. In the meantime, there are still a few options to work with...

Third Party
- Client - WebSocket4Net - Beta
- Server - Fleck - Pending PR
Microsoft
- Client - System.Net.WebSockets.Client - v4.3.0
- Server - Microsoft.AspNetCore.WebSockets.Server - v0.1.0

If you want to use Microsoft.AspNetCore.WebSockets.Server, I have added a middle ware wrapper that feel a lot more like Fleck:

Tact.AspNetCore.WebSockets.Server

public void Configure(IApplicationBuilder app)

    app.UseWebSockets();

    app.UseWebSocketHandler("test", connection =>

        // Register your listeners here

        connection.OnMessage = m =>

            if (m == "hi")

                connection.SendAsync("bye");

};

});

Enjoy,
Tom

Run .NET Core xUnit tests from ReSharper in VS2015

2017-02-26T08:11:00.001-08:00

Visual Studio 2017 is literally only a few days away from release; so it might be a little late, but I finally figured out how to run .NET Core xUnit tests from ReSharper in VS2015! Good News: If you can't upgrade to VS2017 right away, then at least you can still run your unit tests!

Just make sure that the following is included in your project.json file (with the appropriate runtime):

  "testRunner": "xunit",

  "dependencies": {

    "dotnet-test-xunit": "2.2.0-preview2-build1029",

    "xunit": "2.2.0"

},

  "frameworks": {

    "netcoreapp1.0": {

      "imports": "dnxcore50"

},

  "runtimes": {

    "win10-x64": {}

Enjoy,
Tom

.NET Standard Adoption as of January 2017

2017-01-31T08:48:00.000-08:00

Updated 2/16 to include Elasticsearch

As should be obviously from my recently blog posts, I have really been enjoying working with .NET Core. Clearly I am not alone, as a significant number of libraries have been porting over to the .NET Standard.

Below is a list libraries that have added support for the .NET Standard, meaning that they should be able to run cross platform on both Windows and Linux.

While I have not yet had the opportunity to try all of the libraries listed below, I have had great luck with the ones that I have tested, and I am simply ecstatic to see this list growing as fast as it is.

Technology	NuGet Package	.NET Standard Support
Autofac	Autofac	Released for 1.1
Cassandra	DataStax C# Driver for Apache Cassandra	Released for 1.5
Couchbase	Couchbase SDK 2.0	Beta for 1.5
Elasticsearch	Elasticsearch.Net	Released for 1.3
Kafka	Confluent.Kafka	Preview for 1.3
log4net	Apache log4net	Released for 1.3
MongoDB	MongoDB.Driver	Released for 1.4
NLog	NLog	Beta for 1.3
RabbitMQ	RabbitMQ.Client	Released for 1.5
RavenDB	RavenDB Client	Released for 1.3
Redis	StackExchange.Redis	Released for 1.5
Sqlite	Microsoft.EntityFrameworkCore.Sqlite	Released for 1.3
WebSocket Client	WebSocket4Net	Released for 1.3

How have these libraries been working out for you? Is there a better option than what I have listed? Please leave a comment and let me know!

Enjoy,
Tom

.NET JsonContent for HttpClient

2017-01-29T16:06:00.000-08:00

.NET already comes with a nice collection of HttpContent serializers, but it lacks a JsonContent type. A common solution is to just serialize their payload to a JSON string and that insert that into an instance of StringContent. However, this means that you need to remember to set your headers, and it is a little bit inefficient because of how it creates multiple strings and buffers for each payload.

I have create a simple implementation of JsonContent that uses Json.NET and pooled memory streams. The result is between 2% and 10% faster, and causes ~50% fewer garbage collections.

Check out the implementation in Tact.NET:

Enjoy,
Tom

2016 Retrospective

2016-12-31T14:17:00.000-08:00

.NET

It has been a great year for .NET development! A Visual Studio Community is fully featured, .NET Core has arrived, and everything is open source. Regarding .NET Core, I am really enjoying working with it, and I simply cannot wait to get deeper into the Linux world.

Blog

I finally had to downgrade from three posts per month to only two posts per month. Unfortunately writing quality blog posts tasks time, and that was not something that I had in great abundance this year. Fortunately, I do think that the majority of posts this year were very high quality, especially when you look at the most recent ones. I have been working a lot with performance optimization, and have really been enjoying profiling and digging deep into code to see exactly what it is doing and why.

Tact.NET

I am very happy to have launched Tact.NET this year! I have always really enjoyed creating frameworks, so rather than continue to write one off posts on this blog I decide to put all of my extracurricular worth together under one repository. I am really enjoying making Tact, and I have every intention of continuing to grow it.

QQ Cast

Wow, the QQ Cast is back! We took a hiatus for the second half of 2015, but in 2016 we recorded 43 podcasts. Next week is actually going to be our 100th episode, be sure to check it out!

Happy new year,
Tom

Object Pooling and Memory Streams

2016-12-30T13:58:00.000-08:00

The theme of this year, which I will talk about in my 2016 retrospective, has been optimization. It's been a fun journey, and I have really enjoyed getting down and dirty with profiling garbage collection, using spin waits, and aggressive inlining.

I want to end this year on a fun note: object pooling.

A great use case for this would be making HTTP requests with serialized objects. When you serialize an object, and then place it in a HttpContent object, you are probable creating several buffers (byte arrays) each time. For example, if you are using Newtonsoft to serialize an object and then adding that to a string content object for your request, then you are probably using more memory than you need. But that is getting ahead of ourselves...

Come back next week for a blog post about efficient JSON Content serialization!

For now, let's focus on building an object pool. Really all that we need is a preallocated array to store unused objects in, and then a super efficient thread safe data structure to pool (get and set) those objects.

How does pooling memory streams help us?

When you create a MemoryStream, it creates a byte array. As that byte array grows, the memory stream resizes it by allocating a new larger array and then copying your bytes into it. This is inefficient not only because it creates new objects and throws the old ones away, but also because it has to do the leg work of copying the content each time it resizes.

How can we reuse memory streams? Just set the length to zero!

Internally this will just set an index and empty the array, but the internal data structures will be preserved for future use. Thus, by putting memory streams into an object pool, we can drastically increase our efficiency.

Here is a demo of using the Tact.NET ObjectPool to pool MemoryStreams...

[Fact]

public void MemoryStreamPoolDemo()

    using (var pool = new ObjectPool<MemoryStream>(100, () => new MemoryStream()))

        var memoryStream1 = pool.Acquire();

        memoryStream1.SetLength(0);

        Assert.Equal(0, memoryStream1.Capacity);

        memoryStream1.Write(new byte[] {1, 0, 1, 0, 1}, 0, 5);

        var array1 = memoryStream1.ToArray();

        Assert.Equal(5, array1.Length);

        Assert.Equal(1, array1.First());

        Assert.Equal(1, array1.First());

        pool.Release(memoryStream1);

        var memoryStream2 = pool.Acquire();

        Assert.Same(memoryStream1, memoryStream2);

        memoryStream2.SetLength(0);

        Assert.Equal(256, memoryStream2.Capacity);

        memoryStream2.Write(new byte[] { 0, 1, 0 }, 0, 3);

        var array2 = memoryStream2.ToArray();

        Assert.Equal(3, array2.Length);

        Assert.Equal(0, array2.First());

        Assert.Equal(0, array2.First());

Enjoy,
Tom

The Performance Cost of Boxing in .NET

2016-11-27T12:27:00.000-08:00

I recently had to do some performance optimizations against a sorted dictionary that yielded some interesting results...

Background: I am used to using Tuples a lot, simply because they are easy to use and normally quite efficient. Please remember that Tuples were changed from structs to classes back in .NET 4.0.

Problem: A struct decreased performance!

I had a SortedDictionary that was using a Tuple as a key, so I thought "hey, I'll just change that tuple to a struct and reduce the memory usage." ...bad news, that made performance WORSE!

Why would using a struct make performance worse? It's actually quite simple and obvious when you think about it: it was causing comparisons to repeatedly box the primitive data structure, thus allocating more memory on the heap and triggering more garbage collections.

Solution: Use a struct with an IComparer.

I then created a custom struct and used that; it was must faster, but it was still causing boxing because of the non-generic IComparable interface. So finally I added a generic IComparer and passed that into my dictionary constructor; my dictionary then ran fast and efficient, causing a total of ZERO garbage collections!

See for yourself:

The Moral of the Story

Try to be aware of what default implementations are doing, and always remember that boxing to object can add up fast. Also, pay attention to the Visual Studio Diagnostics Tools window; it can be very informative!

Here is how many lines of code it took to achieve a 5x performance increase:

private struct MyStruct

    public MyStruct(int i, string s) { I = i; S = s; }

    public readonly int I;

    public readonly string S;

private class MyStructComparer : IComparer<MyStruct>

    public int Compare(MyStruct x, MyStruct y)

        var c = x.I.CompareTo(y.I);

        return c != 0 ? c : StringComparer.Ordinal.Compare(x.S, y.S);

Test Program

I have written some detailed comments in the Main function about what each test is doing and how it will affect performance. Let's take a look...

public static class Program

    public static void Main(string[] args)

        // This is going to use the class implementation

        // of Tuple that was changed in .NET 4.0. It is

        // be inefficient for three reasons:

        // 1) It is allocating a new class on the heap

        //    for each and every key.

        // 2) It is using the default object comparer

        //    to check each item, causing inefficient

        //    comparisons and...

        // 3) Causing boxing of primitive values.

        ClassTupleAsKey();

        Reset();

        // DURATION: 8,479 miliseconds

        // This is going to use the struct implementation

        // of Tuple that was available from .NET 2.0

        // until 4.0. It is even less efficiente than the

        // class tuple for both reasons listed above, and

        // one new reason:

        // 4) The StructTuple itself will be boxed when

        //    being passed between comparers, causing

        //    even more garbage collections to occur!

        StructTupleAsKey();

        Reset();

        // DURATION: 8,880 miliseconds

        // Now we move to a custom struct implementation

        // for the dictionary key, but because we are using

        // a SortedDictionary we still need to implement

        // IComparable, which is not generic, and thus will

        // be slow for one reason:

        // 1) The struct itself will be boxed when being

        //    passed between comparers.

        MyStructAsKey();

        Reset();

        // DURATION: 2,896 miliseconds

        // This is pretty much as fast as we can get; no

        // heap allocations, no boxing, fast comparisons.

        MyStructAsKeyWithCompare();

        // DURATION: 1,442 miliseconds

    private static void Reset()

        GC.Collect();

        Thread.Sleep(500);

    private static void ClassTupleAsKey()

        var dictionary = new SortedDictionary<ClassTuple<int, string>, int>();

        var sw = Stopwatch.StartNew();

        for (var i = 0; i < 1000000; i++)

            var key = new ClassTuple<int, string>(i % 1000, i.ToString());

            dictionary.Add(key, i);

        sw.Stop();

        Console.WriteLine("ClassTupleAsKey: " + sw.ElapsedMilliseconds);

    private static void StructTupleAsKey()

        var dictionary = new SortedDictionary<StructTuple<int, string>, int>();

        var sw = Stopwatch.StartNew();

        for (var i = 0; i < 1000000; i++)

            var key = new StructTuple<int, string>(i % 1000, i.ToString());

            dictionary.Add(key, i);

        sw.Stop();

        Console.WriteLine("StructTupleAsKey: " + sw.ElapsedMilliseconds);

    private static void MyStructAsKey()

        var dictionary = new SortedDictionary<MyStructA, int>();

        var sw = Stopwatch.StartNew();

        for (var i = 0; i < 1000000; i++)

            var key = new MyStructA(i % 1000, i.ToString());

            dictionary.Add(key, i);

        sw.Stop();

        Console.WriteLine("StructAsKey: " + sw.ElapsedMilliseconds);

    private static void MyStructAsKeyWithCompare()

        var dictionary = new SortedDictionary<MyStructB, int>(MyStructBComparer.Instance);

        var sw = Stopwatch.StartNew();

        for (var i = 0; i < 1000000; i++)

            var key = new MyStructB(i % 1000, i.ToString());

            dictionary.Add(key, i);

        sw.Stop();

        Console.WriteLine("StructAsKeyWithCompare: " + sw.ElapsedMilliseconds);

    public class ClassTuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable

        private readonly T1 _item1;

        private readonly T2 _item2;

        public T1 Item1 => _item1;

        public T2 Item2 => _item2;

        public ClassTuple(T1 item1, T2 item2)

            _item1 = item1;

            _item2 = item2;

        public override bool Equals(object obj)

            return ((IStructuralEquatable) this).Equals(obj, EqualityComparer<object>.Default);

        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)

            var objTuple = other as ClassTuple<T1, T2>;

            if (objTuple == null) return false;

            return comparer.Equals(_item1, objTuple._item1) && comparer.Equals(_item2, objTuple._item2);

        int IComparable.CompareTo(object obj)

            return ((IStructuralComparable) this).CompareTo(obj, Comparer<object>.Default);

        int IStructuralComparable.CompareTo(object other, IComparer comparer)

            if (other == null) return 1;

            var objTuple = other as ClassTuple<T1, T2>;

            if (objTuple == null)

                throw new ArgumentException("ArgumentException_TupleIncorrectType", nameof(other));

            var c = comparer.Compare(_item1, objTuple._item1);

            return c != 0 ? c : comparer.Compare(_item2, objTuple._item2);

        public override int GetHashCode()

            return ((IStructuralEquatable) this).GetHashCode(EqualityComparer<object>.Default);

        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)

            return CombineHashCodes(comparer.GetHashCode(_item1), comparer.GetHashCode(_item2));

        private static int CombineHashCodes(int h1, int h2)

            return ((h1 << 5) + h1) ^ h2;

    public struct StructTuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable

        private readonly T1 _item1;

        private readonly T2 _item2;

        public T1 Item1 => _item1;

        public T2 Item2 => _item2;

        public StructTuple(T1 item1, T2 item2)

            _item1 = item1;

            _item2 = item2;

        public override bool Equals(object obj)

            return ((IStructuralEquatable) this).Equals(obj, EqualityComparer<object>.Default);

        bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)

            if (!(other is StructTuple<T1, T2>)) return false;

            var objTuple = (StructTuple<T1, T2>) other;

            return comparer.Equals(_item1, objTuple._item1) && comparer.Equals(_item2, objTuple._item2);

        int IComparable.CompareTo(object obj)

            return ((IStructuralComparable) this).CompareTo(obj, Comparer<object>.Default);

        int IStructuralComparable.CompareTo(object other, IComparer comparer)

            var objTuple = (StructTuple<T1, T2>) other;

            var c = comparer.Compare(_item1, objTuple._item1);

            return c != 0 ? c : comparer.Compare(_item2, objTuple._item2);

        public override int GetHashCode()

            return ((IStructuralEquatable) this).GetHashCode(EqualityComparer<object>.Default);

        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)

            return CombineHashCodes(comparer.GetHashCode(_item1), comparer.GetHashCode(_item2));

        private static int CombineHashCodes(int h1, int h2)

            return ((h1 << 5) + h1) ^ h2;

    private struct MyStructA : IComparable

        public MyStructA(int i, string s)

            I = i;

            S = s;

        public readonly int I;

        public readonly string S;

        public int CompareTo(object obj)

            var y = (MyStructA) obj;

            var c = I.CompareTo(y.I);

            return c != 0 ? c : StringComparer.Ordinal.Compare(S, y.S);

    private struct MyStructB

        public MyStructB(int i, string s)

            I = i;

            S = s;

        public readonly int I;

        public readonly string S;

    private class MyStructBComparer : IComparer<MyStructB>

        public static readonly MyStructBComparer Instance = new MyStructBComparer();

        public int Compare(MyStructB x, MyStructB y)

            var c = x.I.CompareTo(y.I);

            return c != 0 ? c : StringComparer.Ordinal.Compare(x.S, y.S);

Enjoy,
Tom

10x faster than Delegate.DynamicInvoke

2016-11-26T18:40:00.001-08:00

This is a follow up to my previous blog posts, Optimizing Dynamic Method Invokes in .NET, and Dynamically Invoke Methods Quickly, with InvokeHelpers.EfficientInvoke. Basically, I have re-implemented this for Tact.NET in a way that makes it smaller, faster, and compatible with the .NET Standard.

So, how much faster is this new way of doing things? EfficientInvoker.Invoke is over 10x faster than Delegate.DynamicInvoke, and 10x faster than MethodInfo.Invoke.

Check out the source on GitHub:

Simple Explanation

Here is an example of a method and a class that we might want to invoke dynamically...

public class Tester

    public bool AreEqual(int a, int b)

        return a == b;

...and then here is the code that the EfficientInvoker will generate at runtime to call that method:

public static object GeneratedFunction(object target, object[] args)

    return (object)((Tester)target).AreEqual((int)args[0], (int)args[1]);

See, it's simple!

Sample Tests

public class EfficientInvokerTest

    public void DelegateInvoke()

        var del = (Delegate) new Func<int, int, bool>((a, b) => a == b);

        // Standard slow way

        var result1 = (bool)del.DynamicInvoke(1, 2);

        Assert.False(result1);

        // New 10x faster way

        var invoker = del.GetInvoker();

        var result2 = (bool)invoker.Invoke(del, 1, 2);

        Assert.False(result2);

    public void MethodInvoke()

        var tester = new Tester();

        var type = tester.GetType();

        // Standard slow way

        var methodInfo = type.GetTypeInfo().GetMethod("AreEqual");

        var result1 = (bool) methodInfo.Invoke(tester, new object[] {1, 2});

        Assert.False(result1);

        // New 10x faster way

        var invoker = type.GetMethodInvoker("AreEqual");

        var result2 = (bool) invoker.Invoke(tester, 1, 2);

        Assert.False(result2);

    private class Tester

        public bool AreEqual(int a, int b)

            return a == b;

Enjoy,
Tom

IOC Container for Tact.NET

2016-10-31T18:00:00.000-07:00

Autofac now supports .NET Core, but other IOC frameworks such as Ninject and Unity have yet to port over. While I was looking into IOC frameworks for .NET Core, I had a bad idea...I, for fun, wrote my own Container in Tact.NET!

So, why did I do this? Honestly, it was just a fun academic exercise! I do think that this is a pretty good container, and I intend to use it in some of my personal projects. Would I recommend that YOU use this? Probably not yet, but I would invite you take a look and offer feedback!

Container Design

I have broken the container into two interfaces: IContainer for registration, and IResolver for consumption. There is a abstract class, ContainerBase, that can be inherited to easily create a container that matches other frameworks; for example, I intend to create a IDependencyResolver for ASP.NET.

You may notice that the IContainer does not have any lifetime management methods, that is because ALL of them are implemented as extension methods...

Registrations

To create a new lifetime manager you have to implement the IRegistration interface. There are already implementations for quite a few:

Resolution Handlers

The last part of the container is the IResolutionHandler interface. These resolution handlers are used when an exact registration match is not found during dependency resolution. For example, the EnumerableResolutionHandler will use ResolveAll to get a collection of whatever type is being requested. Another very different example, the ThrowOnFailResolutionHandler will cause an exception to be thrown when no match can be found.

I think that is a pretty good start, but I am hoping that this will continue to grow with time.

Enjoy,
Tom

Introducing Tact.NET

2016-10-31T08:30:00.000-07:00

I have decided to create a project to consolidate all of the utilities that I have authored over the years on this blog...

Tact.NET - A tactful collection of utilities for .NET development.

I believe that this will give me the opportunity to update old code more often, as well as develop new utilities faster. For example, the there is already an ILog interface that optimizes (thank you, Jeremy) the Caller Information Extensions I wrote about about back in May.

Everything that I add to this project will be build for the .NET Standard Library, and should support .NET Core on all platforms. Expect to see NuGet packages soon, and hopefully many more blog posts to come.

Enjoy,
Tom

Host HTTP and WebSockets on the Same Port in ASP.NET

2016-09-30T09:06:00.000-07:00

How do you support WebSocket connections on the same port as your HTTP server in .NET? It turns out that this is not that hard, and you even have several choices to do so...

Option 1: TCP Proxy

You could use a TCP proxy port to divide traffic between the two targets. For example, all traffic would come in to port 80, but then HTTP traffic would be routed internally to 8001 and WS traffic to 8002. This is useful because it would allow you to use multiple technologies (in the example on their site, both NancyFX and Fleck) to host your web servers.

github.com/lifeemotions/websocketproxy

Option 2: SignalR

SignalR is great because of all the backwards compatibility that it supports for both the server and client. However, it is not the most lightweight framework. If you choose to use it, then it will absolutely support both HTTP and WS.

asp.net/signalr

Option 3: Owin.WebSocket My Favorite

Owin supports WebSockets, and that is exactly what SignalR uses to host its WS connections. The awesome Mr. Bryce Godfrey extracted the Owin code from SignalR into a much smaller library called Owin.WebSocket.

The ONLY thing that I did not like about this implementation was that is uses inheritance to define endpoints, whereas I much prefer the ability to use delegates and lambdas. Because of this, I created Owin.WebSocket.Fleck, which allows you to use the Fleck API to map your WebSockets to an Owin context. A pull request is open to merge this into the main repository.

github.com/bryceg/Owin.WebSocket

Enjoy,
Tom

.NET Asynchronous Parallel Batch Processor

2016-09-25T11:05:00.001-07:00

Last year, I wrote about how to handle dynamically sized batches of data in an asynchronous manner. That original implementation used an abstract base class, and only supported a single background processing thread. I recently updated that implementation to support lambdas rather than requiring inheritance, and support a dynamic number of background threads.

...basically, this is a ConcurrentQueue that supports taking a lambda and thread count to asynchronously process enqueued items.

Unit Tests

public class ParallelProcessorTests

    [Fact]

    public async Task NoDisposeTimeout()

        var results = new ConcurrentQueue<int>();

        using (var processor = new ParallelProcessor<int>(2, async (i, token) =>

            await Task.Delay(200, token).ConfigureAwait(false);

            results.Enqueue(i);

        }, disposeTimeoutMs: 0))

            processor.Enqueue(1);

            processor.Enqueue(2);

            processor.Enqueue(3);

            processor.Enqueue(4);

            processor.Enqueue(5);

            await Task.Delay(300).ConfigureAwait(false);

        Assert.Equal(2, results.Count);

    [Fact]

    public void MaxParallelizationLimit()

        const int parallelism = 3;

        var results = new ConcurrentQueue<Tuple<int, int>>();

        var active = 0;

        using (var processor = new ParallelProcessor<int>(parallelism, async (i, token) =>

            Interlocked.Increment(ref active);

            await Task.Delay(200, token).ConfigureAwait(false);

            var currentActive = Interlocked.Decrement(ref active) + 1;

            var tuple = Tuple.Create(currentActive, i);

            results.Enqueue(tuple);

}))

            processor.Enqueue(1);

            processor.Enqueue(2);

            processor.Enqueue(3);

            processor.Enqueue(4);

            processor.Enqueue(5);

        Assert.Equal(5, results.Count);

        var maxParallelism = results.Max(t => t.Item1);

        Assert.Equal(parallelism, maxParallelism);

    [Fact]

    public void BatchProcessor()

        var results = new List<Tuple<long, List<int>>>();

        var sw = Stopwatch.StartNew();

        using (var processor = new BatchParallelProcessor<int>(1, 2, async (ints, token) =>

            await Task.Delay(100, token).ConfigureAwait(false);

            var tuple = Tuple.Create(sw.ElapsedMilliseconds, ints);

            results.Add(tuple);

}))

            processor.Enqueue(1);

            processor.Enqueue(2);

            processor.Enqueue(3);

            processor.Enqueue(4);

            processor.Enqueue(5);

        Assert.Equal(3, results.Count);

        Assert.Equal(2, results[0].Item2.Count);

        Assert.Equal(1, results[0].Item2[0]);

        Assert.Equal(2, results[0].Item2[1]);

        Assert.True(results[0].Item1 < results[1].Item1);

        Assert.Equal(2, results[1].Item2.Count);

        Assert.Equal(3, results[1].Item2[0]);

        Assert.Equal(4, results[1].Item2[1]);

        Assert.True(results[1].Item1 < results[2].Item1);

        Assert.Equal(1, results[2].Item2.Count);

        Assert.Equal(5, results[2].Item2[0]);

ParallelProcessor

public sealed class ParallelProcessor<T> : ProcessorBase<T>

    private readonly Func<T, CancellationToken, Task> _processHandler;

    private readonly Action<T, Exception> _exceptionHandler;

    public ParallelProcessor(

        int maxParallelization,

        Func<T, CancellationToken, Task> processHandler,

        Action<T, Exception> exceptionHandler = null,

        int disposeTimeoutMs = 30000,

        int? maxQueueSize = null)

        : base(maxParallelization, disposeTimeoutMs, maxQueueSize)

        if (maxParallelization < 1)

            throw new ArgumentException(

                $"{nameof(maxParallelization)} is required",

                nameof(maxParallelization));

        _processHandler = processHandler;

        _exceptionHandler = exceptionHandler;

    protected override async Task ProcessLoopAsync()

        T item;

        while (!CancelSource.IsCancellationRequested && Queue.TryDequeue(out item))

try

                await _processHandler(item, CancelSource.Token).ConfigureAwait(false);

            catch (TaskCanceledException) when (CancelSource.IsCancellationRequested)

                // Cancellation was requested, ignore and exit.

                return;

            catch (Exception ex)

                _exceptionHandler?.Invoke(item, ex);

BatchParallelProcessor

public sealed class BatchParallelProcessor<T> : ProcessorBase<T>

    private readonly int _batchSize;

    private readonly Func<List<T>, CancellationToken, Task> _processHandler;

    private readonly Action<List<T>, Exception> _exceptionHandler;

    public BatchParallelProcessor(

        int maxParallelization,

        int batchSize,

        Func<List<T>, CancellationToken, Task> processHandler,

        Action<List<T>, Exception> exceptionHandler = null,

        int disposeTimeoutMs = 30000,

        int? maxQueueSize = null)

        : base(maxParallelization, disposeTimeoutMs, maxQueueSize)

        if (batchSize < 1)

            throw new ArgumentException(

                $"{nameof(batchSize)} is required",

                nameof(batchSize));

        _batchSize = batchSize;

        _processHandler = processHandler;

        _exceptionHandler = exceptionHandler;

    protected override async Task ProcessLoopAsync()

        while (!CancelSource.IsCancellationRequested)

            var count = Math.Min(_batchSize, Queue.Count + 1);

            var list = new List<T>(count);

            T item;

            while (list.Count < _batchSize && Queue.TryDequeue(out item))

                list.Add(item);

            if (list.Count == 0)

                return;

try

                await _processHandler(list, CancelSource.Token).ConfigureAwait(false);

            catch (TaskCanceledException) when (CancelSource.IsCancellationRequested)

                // Cancellation was requested, ignore and exit.

                return;

            catch (Exception ex)

                _exceptionHandler?.Invoke(list, ex);

ProcessorBase

public abstract class ProcessorBase<T> : IDisposable

    protected readonly ConcurrentQueue<T> Queue = new ConcurrentQueue<T>();

    protected readonly CancellationTokenSource CancelSource = new CancellationTokenSource();

    private readonly object _lock = new object();

    private readonly Task[] _tasks;

    private readonly int _disposeTimeoutMs;

    private readonly int? _maxQueueSize;

    private bool _isDisposed;

    protected ProcessorBase(int maxParallelization, int disposeTimeoutMs, int? maxQueueSize)

        _tasks = new Task[maxParallelization];

        _disposeTimeoutMs = disposeTimeoutMs;

        _maxQueueSize = maxQueueSize;

    public void Dispose()

        if (_isDisposed)

            return;

        _isDisposed = true;

        if (_disposeTimeoutMs > 0)

            var tasks = _tasks.Where(t => t != null).ToArray();

            var allTask = Task.WhenAll(tasks);

            var delayTask = Task.Delay(_disposeTimeoutMs);

            Task.WaitAny(allTask, delayTask);

        CancelSource.Cancel();

    public void Enqueue(T item)

        if (_isDisposed)

            throw new InvalidOperationException("Cancellation has been requested");

        if (_maxQueueSize.HasValue && Queue.Count >= _maxQueueSize)

            throw new InvalidOperationException("Queue is full");

        Queue.Enqueue(item);

        TryStartProcessLoop();

    public bool TryEnqueue(T item)

        if (_isDisposed)

            return false;

        if (_maxQueueSize.HasValue && Queue.Count >= _maxQueueSize)

            return false;

        Queue.Enqueue(item);

        TryStartProcessLoop();

        return true;

    protected abstract Task ProcessLoopAsync();

    private void TryStartProcessLoop()

        // Another thread is in the lock, bail out.

        if (!Monitor.TryEnter(_lock))

            return;

        // Create task outside of lock to ensure that we attach the

        // continue without while another thread can be in the block.

        Task task;

try

            // If cancellation has been requested, do not start.

            if (CancelSource.IsCancellationRequested)

                return;

            // If the queue is empty, do not start.

            if (Queue.Count == 0)

                return;

            var freeIndex = 0;

            var activeCount = 0;

            // Find last free index

            for (var i = 0; i < _tasks.Length; i++)

                if (_tasks[i] == null || _tasks[i].IsCompleted)

                    freeIndex = i;

                else

                    activeCount++;

            // All tasks are active, do not start.

            if (activeCount == _tasks.Length)

                return;

            // Only one in queue, at least one thread is active, do not start additional thread.

            if (activeCount > 0 && Queue.Count <= 1)

                return;

            // Start a new task to process the queue.

            task = _tasks[freeIndex] = Task.Run(ProcessLoopAsync, CancelSource.Token);

        finally

            Monitor.Exit(_lock);

        // When the process queue task completes, check to see if

        // the queue has been populated again and needs to restart.

        task.ContinueWith(t => TryStartProcessLoop());

Enjoy,
Tom

Dynamically Invoke Methods Quickly, with InvokeHelpers.EfficientInvoke

2016-08-21T12:28:00.000-07:00

In my previous blog post, I talked about Optimizing Dynamic Method Invokes in .NET. In this post, we will use that information to create a static helper method that is twice as fast as MethodInfo.Invoke.

Basically, we create and cache a delegate in a concurrent dictionary, and then cast both it and it's arguments to dynamics and invoke them directly. The concurrent dictionary introduces overhead, but it still more than twice as fast as calling MethodInfo.Invoke. Please note that this method is highly optimized to reduce the use of hash code look ups, property getters, closure allocations, and if checks.

let's take a look at the code...

InvokeHelpers.EfficientInvoke

public static class InvokeHelpers

    private const string TooManyArgsMessage = "Invokes for more than 10 args are not yet implemented";

    private static readonly Type VoidType = typeof(void);

    private static readonly ConcurrentDictionary<Tuple<string, object>, DelegatePair> DelegateMap

        = new ConcurrentDictionary<Tuple<string, object>, DelegatePair>();

    public static object EfficientInvoke(object obj, string methodName, params object[] args)

        var key = Tuple.Create(methodName, obj);

        var delPair = DelegateMap.GetOrAdd(key, CreateDelegate);

        if (delPair.HasReturnValue)

            switch (delPair.ArgumentCount)

                case 0: return delPair.Delegate();

                case 1: return delPair.Delegate((dynamic)args[0]);

                case 2: return delPair.Delegate((dynamic)args[0], (dynamic)args[1]);

                case 3: return delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2]);

                case 4: return delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3]);

                case 5: return delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4]);

                case 6: return delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5]);

                case 7: return delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5], (dynamic)args[6]);

                case 8: return delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5], (dynamic)args[6], (dynamic)args[7]);

                case 9: return delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5], (dynamic)args[6], (dynamic)args[7], (dynamic)args[8]);

                case 10: return delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5], (dynamic)args[6], (dynamic)args[7], (dynamic)args[8], (dynamic)args[9]);

                default: throw new NotImplementedException(TooManyArgsMessage);

        switch (delPair.ArgumentCount)

            case 0: delPair.Delegate(); break;

            case 1: delPair.Delegate((dynamic)args[0]); break;

            case 2: delPair.Delegate((dynamic)args[0], (dynamic)args[1]); break;

            case 3: delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2]); break;

            case 4: delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3]); break;

            case 5: delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4]); break;

            case 6: delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5]); break;

            case 7: delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5], (dynamic)args[6]); break;

            case 8: delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5], (dynamic)args[6], (dynamic)args[7]); break;

            case 9: delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5], (dynamic)args[6], (dynamic)args[7], (dynamic)args[8]); break;

            case 10: delPair.Delegate((dynamic)args[0], (dynamic)args[1], (dynamic)args[2], (dynamic)args[3], (dynamic)args[4], (dynamic)args[5], (dynamic)args[6], (dynamic)args[7], (dynamic)args[8], (dynamic)args[9]); break;

            default: throw new NotImplementedException(TooManyArgsMessage);

        return null;

    private static DelegatePair CreateDelegate(Tuple<string, object> key)

        var method = key.Item2

            .GetType()

            .GetMethod(key.Item1);

        var argTypes = method

            .GetParameters()

            .Select(p => p.ParameterType)

            .Concat(new[] { method.ReturnType })

            .ToArray();

        var newDelType = Expression.GetDelegateType(argTypes);

        var newDel = Delegate.CreateDelegate(newDelType, key.Item2, method);

        return new DelegatePair(newDel, argTypes.Length - 1, method.ReturnType != VoidType);

    private class DelegatePair

        public DelegatePair(dynamic del, int argumentCount, bool hasReturnValue)

            Delegate = del;

            ArgumentCount = argumentCount;

            HasReturnValue = hasReturnValue;

        public readonly dynamic Delegate;

        public readonly int ArgumentCount;

        public readonly bool HasReturnValue;

Now let's take a look at some performance tests...

Unit Tests

public class InvokeHelpersTests

    public const int Iterations = 1000000;

    private static readonly TestClass Obj = new TestClass();

    private static readonly object[] Args = { 1, true };

    private readonly ITestOutputHelper _output;

    public InvokeHelpersTests(ITestOutputHelper output)

        _output = output;

    /// <summary>

    /// This is not realistic, because our million invokes do not simulate

    /// the cost of looking up the MethodInfo. However, for the sake of

    /// argument, this takes 930,136 ticks for one million iterations.

    /// </summary>

    [Fact]

    public void MethodInfoInvoke()

        var methodInfo = Obj.GetType().GetMethod("TestMethod");

        var sw0 = Stopwatch.StartNew();

        methodInfo.Invoke(Obj, Args);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            methodInfo.Invoke(Obj, Args);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    /// <summary>

    /// This use case is more realistic, where we look up the MethodInfo

    /// each iteration. This takes 1,370,052 ticks for one million iterations.

    /// </summary>

    [Fact]

    public void GetMethodInfoInvoke()

        var sw0 = Stopwatch.StartNew();

        Obj.GetType().GetMethod("TestMethod").Invoke(Obj, Args);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            Obj.GetType().GetMethod("TestMethod").Invoke(Obj, Args);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    /// <summary>

    /// This is an apples to apples comparision of using a ConcurrentDictionary to cache

    /// the MethodInfo lookup. This takes 1,300,751 ticks for one million iterations.

    /// </summary>

    [Fact]

    public void MappedMethodInfoInvoke()

        var sw0 = Stopwatch.StartNew();

        MappedMethodInvokeHelpers.EfficientInvoke(Obj, "TestMethod", Args);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            MappedMethodInvokeHelpers.EfficientInvoke(Obj, "TestMethod", Args);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    /// <summary>

    /// Here is our custom optimized solution, which beats ALL of the previous iterations by

    /// more than a factor of 2! This only takes 467,158 ticks for one million iterations.

    /// </summary>

    [Fact]

    public void EfficientInvoke()

        var sw0 = Stopwatch.StartNew();

        InvokeHelpers.EfficientInvoke(Obj, "TestMethod", Args);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            InvokeHelpers.EfficientInvoke(Obj, "TestMethod", Args);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    public class TestClass

        public int TestMethod(int i, bool b)

            return i + (b ? 1 : 2);

    public static class MappedMethodInvokeHelpers

        private static readonly ConcurrentDictionary<Tuple<string, object>, MethodInfo> DelegateMap

            = new ConcurrentDictionary<Tuple<string, object>, MethodInfo>();

        public static object EfficientInvoke(object obj, string methodName, params object[] args)

            var key = Tuple.Create(methodName, obj);

            var methodInfo = DelegateMap.GetOrAdd(key, GetMethodInfo);

            return methodInfo.Invoke(obj, args);

        private static MethodInfo GetMethodInfo(Tuple<string, object> key)

            return key.Item2.GetType().GetMethod(key.Item1);

Enjoy,
Tom

Optimizing Dynamic Method Invokes in .NET

2016-08-21T12:05:00.002-07:00

I recently had a lot of fun helping to optimize some RPC code that was using reflection to dynamically invoke methods in a C# application. Below are a list of implementations that we experimented with, and their performance.

Directly Invoking the Method
Using MethodInfo.Invoke
Using Delegate.DynamicInvoke
Casting to a Func
Casting a Delegate to Dynamic

Spoilers: Here are the results. (The tests for this can be see below.)

Name	First Call (Ticks)	Next Million Calls	Invoke Comparison
Invoke	1	39795	-
MethodInfo.Invoke	12	967523	x24
Delegate.DynamicInvoke	32	1580086	x39
Func Invoke	731	41331	x1
Dynamic Cast	1126896	85495	x2

Conclusion: Invoking a method or delegate directly is always fastest, but when you need to execute code dynamically, then (after the first invoke) the dynamic invoke of a delegate is significantly faster than using reflection.

Let's take a look at the test code...

Unit Tests

public class InvokePerformance

    public const int Iterations = 1000000;

    public static readonly object[] Args = {1, true};

    public static readonly TestClass Obj = new TestClass();

    public static readonly Type Type = typeof(TestClass);

    public static readonly MethodInfo Method = Type.GetMethod("TestMethod");

    private readonly ITestOutputHelper _output;

    public InvokePerformance(ITestOutputHelper output)

        _output = output;

    [Fact]

    public void Invoke()

        var arg0 = (int) Args[0];

        var arg1 = (bool) Args[1];

        var sw0 = Stopwatch.StartNew();

        Method.Invoke(Obj, Args);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            Obj.TestMethod(arg0, arg1);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    [Fact]

    public void MethodInfoInvoke()

        var sw0 = Stopwatch.StartNew();

        Method.Invoke(Obj, Args);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            Method.Invoke(Obj, Args);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    [Fact]

    public void DelegateDynamicInvoke()

        var delType = Expression.GetDelegateType(typeof(int), typeof(bool), typeof(int));

        var del = Delegate.CreateDelegate(delType, Obj, Method);

        var sw0 = Stopwatch.StartNew();

        del.DynamicInvoke(Args);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            del.DynamicInvoke(Args);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    [Fact]

    public void FuncInvoke()

        var delType = Expression.GetDelegateType(typeof(int), typeof(bool), typeof(int));

        var del = (Func<int, bool, int>) Delegate.CreateDelegate(delType, Obj, Method);

        var arg0 = (int) Args[0];

        var arg1 = (bool) Args[1];

        var sw0 = Stopwatch.StartNew();

        del(arg0, arg1);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            del(arg0, arg1);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    [Fact]

    public void DynamicCast()

        var delType = Expression.GetDelegateType(typeof(int), typeof(bool), typeof(int));

        dynamic del = Delegate.CreateDelegate(delType, Obj, Method);

        dynamic arg0 = Args[0];

        dynamic arg1 = Args[1];

        var sw0 = Stopwatch.StartNew();

        del(arg0, arg1);

        sw0.Stop();

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < Iterations; i++)

            del(arg0, arg1);

        sw1.Stop();

        _output.WriteLine(sw0.ElapsedTicks.ToString());

        _output.WriteLine(sw1.ElapsedTicks.ToString());

    public class TestClass

        public int TestMethod(int i, bool b)

            return i + (b ? 1 : 2);

Enjoy,
Tom

Can I port my application to .NET Core?

2016-07-31T12:00:00.000-07:00

I am very excited about .NET Core, and I am looking forward to porting my projects to it. Generally porting your own code is a straight forward task, but updating all of your dependencies can be quite daunting. Good news: the guys over at Octopus have built an awesome little site that helps you determine the state of your dependencies!

I Can Has .NET Core

Enjoy,
Tom

Make your NuGet Server use NLog

2016-07-24T12:34:00.000-07:00

The latest version of NuGet.Server is fast, stable, and super simple to setup. As for most .NET tools, Scott Hanselman already create a great write up about how to use it.

However, I was very disappointed at how unintuitive it was to get wire up a custom logger!

You need to take several steps to make the official NuGet server write to something like NLog:

Create a log wrapper.
Implement NuGet.Server.Logging.ILogger.
Implement NuGet.ILogger...
...which also makes you implement NuGet.IFileConflictResolver!
Implement your own NuGet.Server.IServiceResolver
When instantiating ServerPackageRepository...
...pass in the ILogger...
...AND set the Logger property!

Still confused? Pull the code here, or take a look below!

NLogLogger

public class NLogLogger : Logging.ILogger, ILogger

    private readonly global::NLog.ILogger _logger;

    public NLogLogger(global::NLog.ILogger logger)

        _logger = logger;

    public void Log(LogLevel level, string message, params object[] args)

        switch (level)

            case LogLevel.Verbose:

                _logger.Trace(message, args);

                break;

            case LogLevel.Info:

                _logger.Info(message, args);

                break;

            case LogLevel.Warning:

                _logger.Warn(message, args);

                break;

            case LogLevel.Error:

                _logger.Error(message, args);

                break;

            default:

                throw new ArgumentOutOfRangeException(nameof(level), level, null);

    public FileConflictResolution ResolveFileConflict(string message)

        _logger.Warn(message);

        // This is what the default NullLogger returns.

        return FileConflictResolution.Ignore;

    public void Log(MessageLevel level, string message, params object[] args)

        switch (level)

            case MessageLevel.Info:

                _logger.Info(message, args);

                break;

            case MessageLevel.Warning:

                _logger.Warn(message, args);

                break;

            case MessageLevel.Debug:

                _logger.Debug(message, args);

                break;

            case MessageLevel.Error:

                _logger.Error(message, args);

                break;

            default:

                throw new ArgumentOutOfRangeException(nameof(level), level, null);

NLogServiceResolver

public class NLogServiceResolver : IServiceResolver

    private readonly IHashProvider _hashProvider;

    private readonly IServerPackageRepository _packageRepository;

    private readonly IPackageAuthenticationService _packageAuthenticationService;

    private readonly IPackageService _packageService;

    private readonly ILogger _logger;

    private readonly Logging.ILogger _loggingLogger;

    public NLogServiceResolver()

        var logger = LogManager.GetCurrentClassLogger();

        logger.Info("Initializing NLogServiceResolver");

        var nlogLogger = new NLogLogger(logger);

        _logger = nlogLogger;

        _loggingLogger = nlogLogger;

        _hashProvider = new CryptoHashProvider("SHA512");

        _packageRepository = new ServerPackageRepository(

            PackageUtility.PackagePhysicalPath,

            _hashProvider,

            _loggingLogger)

            // The base class has a separate logger that you have to set.

            Logger = _logger

};

        _packageAuthenticationService = new PackageAuthenticationService();

        _packageService = new PackageService(_packageRepository, _packageAuthenticationService);

    public object Resolve(Type type)

        if (type == typeof(IHashProvider))

            return _hashProvider;

        if (type == typeof(IServerPackageRepository))

            return _packageRepository;

        if (type == typeof(IPackageAuthenticationService))

            return _packageAuthenticationService;

        if (type == typeof(IPackageService))

            return _packageService;

        if (type == typeof(ILogger))

            return _logger;

        if (type == typeof(Logging.ILogger))

            return _loggingLogger;

        return null;

Enjoy,
Tom

Should you open source your software?

2016-07-17T22:02:00.001-07:00

Every Tuesday I help host the QQ Cast, where we fabricate answers to geek culture's most superfluous questions. For our 50th Quest, my good friend Matt Stevenson joined us to talk about open source software.

QQ Cast - Quest 50 - Should you open source your software?

00:00 - Mic Check and Introductions
05:30 - Is "Expand Enhance Extinguish" still alive and well?
19:40 - Can we build a sustainable infrastructure without open source software?
33:00 - How much structure do we like to see in our frameworks?
40:50 - What are some great open source projects?
47:15 - Was heartbleed a good thing or a bad thing?
54:30 - Does contributing to open source projects help your resume?
60:00 - Should you open source your software?
70:00 - Wrap up!

Please always remember that all views and opinions expressed on the podcast are representative solely of the person expressing them; not of their friends and family, not of their coworkers, and certainly not of their employers, past, present, or future.

Enjoy,
Tom

Updating Default Parameters in .NET Assemblies

2016-06-30T11:26:00.000-07:00

One of the things that I love about C# is how so many of it's features are just very conveniently designed compiler tricks. This means that, just like any other magic trick, once you know how the trick is performed you immediately realize that there really is nothing magical about it.

So, let's talk about default parameters. They are actually just constant values that get compiled into your code when you go to use a method that has them. Let's look at an example...

The Code

public enum Country

US,

CA

public static class SharedUtility

    public static bool CanDrink(

        int age,

        Country country = Country.CA)

        switch (country)

            case Country.US:

                return age >= 21;

            case Country.CA:

                return age >= 18;

            default:

                throw new ArgumentException(

                    "Invalid Country",

                    nameof(country));

public class SharedUtilityTests

    [Fact]

    public void CanDrink()

        var result = SharedUtility.CanDrink(20);

        // The line above will compile into the following:

        // var result = SharedUtility.CanDrink(20, Country.CA);

        // Thus, the Assert below will succeed!

        Assert.True(result, "The default was not US!");

So, now that you know how the trick is performed, how could this cause a problem for you? Specifically, what happens if you update a library that exposes methods with default parameters?

Nothing will change, until you recompile against the library!

If another library changes their default parameters, but you do not recompile your code against it, then your code will be using the old default values! Let's look back at the previous example and see why this could cause confusion...

The Change

public enum Country

US,

CA

public static class SharedUtility

    public static bool CanDrink(

        int age,

        // NOTE: We have changed the default value!

        Country country = Country.US)

        switch (country)

            case Country.US:

                return age >= 21;

            case Country.CA:

                return age >= 18;

            default:

                throw new ArgumentException(

                    "Invalid Country",

                    nameof(country));

public class SharedUtilityTests

    [Fact]

    public void CanDrink()

        var result = SharedUtility.CanDrink(20);

        // If you do NOT recompile and just replace the DLL,

        // then this test will still pass. However, as soon

        // as you recompile this test will start failing!

        Assert.True(result, "The default was not US!");

Don't take my word for it, here are screenshots of that code in action...

Enjoy,
Tom

MP3 Playlist for Chromecast

2016-06-26T18:57:00.000-07:00

Come to find out, I am a very retro guy when it comes to music. I have these old things that I like to use to play music, you may not have heard of them, they are called MP3s. They are kind of like 8-track tapes, but digital, not in the cloud, and not old enough to be cool yet.

How do you play MP3s via Chromecast?

The official answer is to use Google Play, but that implies that you want to both pay for that service and upload your files to the cloud. The unofficial answer is to drag and drop your MP3s into a Chrome tab and cast that tab, however this does not allow you to create a playlist.

Introducing Playlist for Chromecast

I have created a simple single page HTML 5 application that will act as a playlist for MP3s on your computer. Just download the project and open up release/playlist.html in Chrome, then drag and drop MP3s on to the page.

Development

I had a lot of fun making this, and I'm not done. I intend to use this project as a case study to talk about VSCode, TypeScript, SASS, HTML5 Audio, NPM, and unit testing. For now, I just wanted to start by getting this initial post up, but expect more to follow.

Source on GitHub

What's next?

Update project documentation.
Create unit tests.
Add theme support.
Write blog posts about development.
Maybe host it on a domain.
Maybe submit it as a Chrome application.

Enjoy,
Tom

Client Side Caching for jQuery

2016-06-18T11:07:00.000-07:00

Updates: 6/26/16

Fixed bug where triple equals null check would miss.
Added support for data driven cache key.
Removed let and const statements (some minifiers were having a hard time with them)

Original:

There is great question on Stack Overflow about caching a jquery ajax response in javascript/browser. Unfortunately, even thought it was a good solution, it did not do quite what I needed it to.

The application I was trying to optimize sometimes made redundant parallel requests, and I needed my caching solution to include a queuing system to prevent duplicate fetches.

Below is a simple solution that uses jQuery.ajaxPrefilter to check a local cache prior to making GET requests. Additionally, it will queue the callback if the request is already in flight. The cache stores the queue in both memory and local storage, ensuring that the cache will persist across page loads.

Implementation

(function ($) {

  "use strict";

  var timeout = 60000;

  var cache = {};

  $.ajaxPrefilter(onPrefilter);

  function onPrefilter(options, originalOptions) {

    if (options.cache !== true) {

      return;

    var callback = originalOptions.complete || $.noop;

    var cacheKey = getCacheKey(originalOptions);

    options.cache = false;

    options.beforeSend = onBeforeSend;

    options.complete = onComplete;

    function onBeforeSend() {

      var cachedItem = tryGet(cacheKey);

      if (!!cachedItem) {

        if (cachedItem.data === null) {

          cachedItem.queue.push(callback);

        } else {

          setTimeout(onCacheHit, 0);

        return false;

      cachedItem = createCachedItem();

      cachedItem.queue.push(callback);

      setCache(cacheKey, cachedItem);

      return true;

      function onCacheHit() {

        invoke(callback, cachedItem);

    function onComplete(data, textStatus) {

      var cachedItem = tryGet(cacheKey);

      if (!!cachedItem) {

        cachedItem.data = data;

        cachedItem.status = textStatus;

        setCache(cacheKey, cachedItem);

        var queuedCallback;

        while (!!(queuedCallback = cachedItem.queue.pop())) {

          invoke(queuedCallback, cachedItem);

        return;

      cachedItem = createCachedItem(data, textStatus);

      setCache(cacheKey, cachedItem);

      invoke(callback, cachedItem);

  function tryGet(cacheKey) {

    var cachedItem = cache[cacheKey];

    if (!!cachedItem) {

      var diff = new Date().getTime() - cachedItem.created;

      if (diff < timeout) {

        return cachedItem;

    var item = localStorage.getItem(cacheKey);

    if (!!item) {

      cachedItem = JSON.parse(item);

      var diff = new Date().getTime() - cachedItem.created;

      if (diff < timeout) {

        return cachedItem;

      localStorage.removeItem(cacheKey);

    return null;

  function setCache(cacheKey, cachedItem) {

    cache[cacheKey] = cachedItem;

    var clone = createCachedItem(cachedItem.data, cachedItem.status, cachedItem.created);

    var json = JSON.stringify(clone);

    localStorage.setItem(cacheKey, json);

  function createCachedItem(data, status, created) {

    return {

      data: data || null,

      status: status,

      created: created || new Date().getTime(),

      queue: []

};

  function invoke(callback, cachedItem) {

    if ($.isFunction(callback)) {

      callback(cachedItem.data, cachedItem.status);

  function getCacheKey(originalOptions) {

    if (!!originalOptions.data) {

      return originalOptions.url + "?" + JSON.stringify(originalOptions.data);

    return originalOptions.url;

})(jQuery);

Enjoy,
Tom

Word Boundaries Regex

2016-05-27T07:11:00.000-07:00

This is the second time this week where I have had to ask myself "how did I not know about this?"

There is a regex character to identify word boundaries: \b This is a zero length match, similar to the caret and dollar sign. It finds the boundaries between words, allowing you to search for a whole word match.

Below is a sample extension method that uses this to replace words in a string.

Implementation

public static class StringExtensions

    private static readonly Regex WordRegex = new Regex(@"\b\w+\b", RegexOptions.Compiled);

    public static string ReplaceWords(

        this string input,

        string find,

        string replace,

        StringComparison comparison = StringComparison.InvariantCulture)

        return WordRegex.Replace(input, m => m.Value.Equals(find, comparison)

            ? replace

            : m.Value);

Unit Test

public class StringExtensionsTests

    [Fact]

    public void ReplaceWords()

        Assert.Equal(

            "This island can has beautiful",

            "This island is beautiful".ReplaceWords("is", "can has"));

        Assert.Equal(

            "This island are beautiful",

            "This island is beautiful".ReplaceWords(

                "IS",

                "are",

                StringComparison.InvariantCultureIgnoreCase));

Enjoy,
Tom

Common Logging Extensions with Caller Information

2016-05-22T11:26:00.000-07:00

Update: Added the BreakParameter.

I have made it an (arguably bad) habit of manually adding the class and method name as a prefix to all my log lines. It is not that I enjoy typing out the same strings over and over, it's that I do not always trust things like the NLog callsite. Using the stack frame to identify a calling method always requires a bit of cleverness on the part of the author, as you never can be totally sure when you are dealing with a wrapper class or an async call stack.

I was recently introduced to the Caller Information attributes in C# 5, and now I think I am in love.

Disclaimer: I have not used this very much yet, but I intend to start! I think that these attributes are absolutely brilliant in their simplicity: a compiler trick to insert debug information directly into your code. That is freak'n sweet, and it's performant! I am not sure how this flew under my radar, but now that I know about it....

Below is a little T4 template that I wrote up to generate overloads for Common Logging that will include caller information. To customize this for your needs, just update the the GetFormat method at the bottom of the template.

Unit Tests

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using Common.Logging.Simple;

   4:  using Xunit;

5:

   6:  namespace Common.Logging.Tests

   7:  {

   8:      /// <summary>

   9:      /// Tests for Common Logging extensions that use Caller Information

  10:      /// https://msdn.microsoft.com/en-us/library/mt653988.aspx

  11:      /// </summary>

  12:      public class LogCallTests

  13:      {

  14:          [Fact]

  15:          public void LogFromMethod()

  16:          {

  17:              var log = new QueueSimpleLogger();

  18:              var ex = new Exception("Boom");

19:

  20:              log.Debug("Hello");

  21:              log.Debug("World", ex);

22:

  23:              log.DebugCall("Hello");

  24:              log.DebugCall("World", ex);

25:

  26:              log.WarnFormat("Hello - {0}", "Zero");

  27:              log.WarnFormat("World - {0}", ex, "Zero");

28:

  29:              log.WarnFormatCall("Hello - {0}", "Zero");

  30:              log.WarnFormatCall("World - {0}", ex, "Zero");

31:

  32:              Assert.Equal(8, log.Queue.Count);

33:

  34:              Assert.Equal("Hello", log.Queue.Dequeue());

  35:              Assert.Equal("World - Ex: Boom", log.Queue.Dequeue());

36:

  37:              Assert.Equal("LogCallTests.LogFromMethod(23) - Hello", log.Queue.Dequeue());

  38:              Assert.Equal("LogCallTests.LogFromMethod(24) - World - Ex: Boom", log.Queue.Dequeue());

39:

  40:              Assert.Equal("Hello - Zero", log.Queue.Dequeue());

  41:              Assert.Equal("World - Zero - Ex: Boom", log.Queue.Dequeue());

42:

  43:              Assert.Equal("LogCallTests.LogFromMethod(29) - Hello - Zero", log.Queue.Dequeue());

  44:              Assert.Equal("LogCallTests.LogFromMethod(30) - World - Zero - Ex: Boom", log.Queue.Dequeue());

  45:          }

46:

  47:          [Fact]

  48:          public void LogFromAction()

  49:          {

  50:              var log = new QueueSimpleLogger();

  51:              var ex = new Exception("Boom");

  52:              Action action = () =>

  53:              {

  54:                  log.Debug("Hello");

  55:                  log.Debug("World", ex);

56:

  57:                  log.DebugCall("Hello");

  58:                  log.DebugCall("World", ex);

59:

  60:                  log.WarnFormat("Hello - {0}", "Zero");

  61:                  log.WarnFormat("World - {0}", ex, "Zero");

62:

  63:                  log.WarnFormatCall("Hello - {0}", "Zero");

  64:                  log.WarnFormatCall("World - {0}", ex, "Zero");

  65:              };

66:

  67:              action();

68:

  69:              Assert.Equal(8, log.Queue.Count);

70:

  71:              Assert.Equal("Hello", log.Queue.Dequeue());

  72:              Assert.Equal("World - Ex: Boom", log.Queue.Dequeue());

73:

  74:              Assert.Equal("LogCallTests.LogFromAction(57) - Hello", log.Queue.Dequeue());

  75:              Assert.Equal("LogCallTests.LogFromAction(58) - World - Ex: Boom", log.Queue.Dequeue());

76:

  77:              Assert.Equal("Hello - Zero", log.Queue.Dequeue());

  78:              Assert.Equal("World - Zero - Ex: Boom", log.Queue.Dequeue());

79:

  80:              Assert.Equal("LogCallTests.LogFromAction(63) - Hello - Zero", log.Queue.Dequeue());

  81:              Assert.Equal("LogCallTests.LogFromAction(64) - World - Zero - Ex: Boom", log.Queue.Dequeue());

  82:          }

83:

  84:          private class QueueSimpleLogger : AbstractSimpleLogger

  85:          {

  86:              public readonly Queue<string> Queue = new Queue<string>();

87:

  88:              public QueueSimpleLogger()

  89:                  : base(string.Empty, LogLevel.All, true, true, true, string.Empty)

  90:              {

  91:              }

92:

  93:              protected override void WriteInternal(LogLevel level, object message, Exception exception)

  94:              {

  95:                  var s = message.ToString();

  96:                  if (exception != null) s += " - Ex: " + exception.Message;

  97:                  Queue.Enqueue(s);

  98:              }

  99:          }

 100:      }

 101:  }

LogExtension.cs (Part of a Generated File)

using System;

using System.Runtime.CompilerServices;

using System.Text.RegularExpressions;

// ReSharper disable once CheckNamespace

namespace Common.Logging

    public static class LogExtensions

        public static Regex ClassNameRegex = new Regex(@"([\w]+)\.[\w]+$", RegexOptions.Compiled);

        /* ... */

        public static void DebugCall(

            this ILog log,

            object message,

            BreakParameter breakParameter = default(BreakParameter),

            [CallerMemberName] string memberName = "",

            [CallerFilePath] string sourceFilePath = "",

            [CallerLineNumber] int sourceLineNumber = 0)

            if (!log.IsDebugEnabled) return;

            var newFormat = GetFormat(message.ToString(), memberName, sourceFilePath, sourceLineNumber);

            log.Debug(

                newFormat);

        public static void DebugCall(

            this ILog log,

            object message,

            Exception ex,

            BreakParameter breakParameter = default(BreakParameter),

            [CallerMemberName] string memberName = "",

            [CallerFilePath] string sourceFilePath = "",

            [CallerLineNumber] int sourceLineNumber = 0)

            if (!log.IsDebugEnabled) return;

            var newFormat = GetFormat(message.ToString(), memberName, sourceFilePath, sourceLineNumber);

            log.Debug(

                newFormat,

                ex);

        public static void DebugFormatCall(

            this ILog log,

            string format,

            object arg0,

            BreakParameter breakParameter = default(BreakParameter),

            [CallerMemberName] string memberName = "",

            [CallerFilePath] string sourceFilePath = "",

            [CallerLineNumber] int sourceLineNumber = 0)

            if (!log.IsDebugEnabled) return;

            var newFormat = GetFormat(format, memberName, sourceFilePath, sourceLineNumber);

            log.DebugFormat(

                newFormat,

                arg0);

        public static void DebugFormatCall(

            this ILog log,

            string format,

            Exception ex,

            object arg0,

            BreakParameter breakParameter = default(BreakParameter),

            [CallerMemberName] string memberName = "",

            [CallerFilePath] string sourceFilePath = "",

            [CallerLineNumber] int sourceLineNumber = 0)

            if (!log.IsDebugEnabled) return;

            var newFormat = GetFormat(format, memberName, sourceFilePath, sourceLineNumber);

            log.DebugFormat(

                newFormat,

ex,

                arg0);

        /* ... */

        [MethodImpl(MethodImplOptions.AggressiveInlining)]

        private static string GetFormat(string format, string memberName, string sourceFilePath, int sourceLineNumber)

            var m = ClassNameRegex.Match(sourceFilePath);

            return m.Success

                ? $"{m.Groups[1].Value}.{memberName}({sourceLineNumber}) - {format}"

                : format;

        public struct BreakParameter

LogExtension.tt (T4 Template)

<#@ template debug="false" hostspecific="false" language="C#" #>

<#@ assembly name="System.Core" #>

<#@ import namespace="System.Linq" #>

<#@ import namespace="System.Text" #>

<#@ import namespace="System.Collections.Generic" #>

<#@ output extension=".cs" #>

using System;

using System.Runtime.CompilerServices;

using System.Text.RegularExpressions;

// ReSharper disable once CheckNamespace

namespace Common.Logging

    public static class LogExtensions

        public static Regex ClassNameRegex = new Regex(@"([\w]+)\.[\w]+$", RegexOptions.Compiled);

<# foreach(var level in new [] { "Trace", "Debug", "Info", "Warn", "Error", "Fatal" }) { #>

<# for(var argCount = 0; argCount <= 8; argCount++) { #>

<# var suffix = argCount == 0 ? "" : "Format"; #>

<# var varType = argCount == 0 ? "object" : "string"; #>

<# var varName = argCount == 0 ? "message" : "format"; #>

<# var vartoString = argCount == 0 ? ".ToString()" : ""; #>

<# for(var hasException = 0; hasException < 2; hasException++) { #>

        public static void <#= level #><#= suffix #>Call(

            this ILog log,

            <#= varType #> <#= varName #>,

<# if (hasException == 1) { #>

            Exception ex,

<# } #>

<# for(var i = 0; i < argCount; i++) { #>

            object arg<#= i #>,

<# } #>

            BreakParameter breakParameter = default(BreakParameter),

            [CallerMemberName] string memberName = "",

            [CallerFilePath] string sourceFilePath = "",

            [CallerLineNumber] int sourceLineNumber = 0)

            if (!log.Is<#= level #>Enabled) return;

            var newFormat = GetFormat(<#= varName #><#= vartoString #>, memberName, sourceFilePath, sourceLineNumber);

            log.<#= level #><#= suffix #>(

                newFormat<# if (hasException == 1) { #>,

                ex<# } #><# for(var i = 0; i < argCount; i++) { #>,

                arg<#= i #><# } #>);

<# } #>

<# } #>

<# } #>

        [MethodImpl(MethodImplOptions.AggressiveInlining)]

        private static string GetFormat(string format, string memberName, string sourceFilePath, int sourceLineNumber)

            var m = ClassNameRegex.Match(sourceFilePath);

            return m.Success

                ? $"{m.Groups[1].Value}.{memberName}({sourceLineNumber}) - {format}"

                : format;

        public struct BreakParameter

Enjoy,
Tom

Number of Args	Interpolation Milliseconds	String.Format Milliseconds	String.Concat Milliseconds	String Add Milliseconds	StringBuilder Milliseconds
2	262	260	19	18	34
3	367	367	25	24	35
4	500	513	31	32	41
5	646	635	67	66	44
6	740	723	79	76	49
7	802	819	86	85	52
8	938	936	97	98	58

Number of Args	Interpolation Milliseconds	String.Format Milliseconds	String.Concat Milliseconds	String Add Milliseconds	StringBuilder Milliseconds
2	262	260	19	18	34
3	367	367	25	24	35
4	500	513	31	32	41
5	646	635	67	66	44
6	740	723	79	76	49
7	802	819	86	85	52
8	938	936	97	98	58

Tom DuPont .NET

Creating an IOC Container for ASP.NET Core

1) Register is first in win.

2) ResolveAll includes single registrations.

3) Generic resolution is required.

4) You have to convert IServiceCollection to your container.

How to make a dotnet CLI Tool

The Basics

Step 1) Create your CLI Console App

Step 2) Consume your CLI Tool NuGet Package

Development Tips

Create a local package directory

Pack on post build

Execute on pre build

Increment version to update

C# String Interpolation Performance

WebSocket Support for .NET Core

Run .NET Core xUnit tests from ReSharper in VS2015

.NET Standard Adoption as of January 2017

.NET JsonContent for HttpClient

2016 Retrospective

.NET

Blog

Tact.NET

QQ Cast

Object Pooling and Memory Streams

The Performance Cost of Boxing in .NET

Problem: A struct decreased performance!

Solution: Use a struct with an IComparer.

The Moral of the Story

Test Program

10x faster than Delegate.DynamicInvoke

Simple Explanation

Sample Tests

IOC Container for Tact.NET

Container Design

Registrations

Resolution Handlers

Introducing Tact.NET

Host HTTP and WebSockets on the Same Port in ASP.NET

Option 1: TCP Proxy

Option 2: SignalR

Option 3: Owin.WebSocket *My Favorite*

.NET Asynchronous Parallel Batch Processor

Unit Tests

ParallelProcessor

BatchParallelProcessor

ProcessorBase

Dynamically Invoke Methods Quickly, with InvokeHelpers.EfficientInvoke

InvokeHelpers.EfficientInvoke

Unit Tests

Optimizing Dynamic Method Invokes in .NET

Unit Tests

Can I port my application to .NET Core?

I Can Has .NET Core

Make your NuGet Server use NLog

NLogLogger

NLogServiceResolver

Should you open source your software?

Updating Default Parameters in .NET Assemblies

The Code

The Change

MP3 Playlist for Chromecast

How do you play MP3s via Chromecast?

Introducing Playlist for Chromecast

Development

What's next?

Client Side Caching for jQuery

Implementation

Word Boundaries Regex

Implementation

Unit Test

Common Logging Extensions with Caller Information

Unit Tests

LogExtension.cs (Part of a Generated File)

LogExtension.tt (T4 Template)

Option 3: Owin.WebSocket My Favorite

Number of Args	Interpolation Milliseconds	String.Format Milliseconds	String.Concat Milliseconds	String Add Milliseconds	StringBuilder Milliseconds
2	262	260	19	18	34
3	367	367	25	24	35
4	500	513	31	32	41
5	646	635	67	66	44
6	740	723	79	76	49
7	802	819	86	85	52
8	938	936	97	98	58