Be careful when using many HttpClient instances

Who knew? According to MSDN (emphasis added):

HttpClient is intended to be instantiated once and re-used throughout the life of an application. Instantiating an HttpClient class for every request will exhaust the number of sockets available under heavy loads.

See more here: Disposable, Finalizers, and HttpClient

Cool JSON and SQL-related links found on a Hacker News post

https://quicktype.io/ – Parses sample JSON and creates code to serialize/deserialize it in several different languages.

https://github.com/rspeele/Rezoom.SQL – Rezoom.SQL is an F# ORM for SQL databases using type providers, so it will automatically pick up the schema on build. A HN commenter claimed it has better type support than any other ORM, a statement perhaps to be taken with a grain of salt.

https://github.com/ReactiveX/IxJS – Interactive Extensions for JavaScript (IxJS). IxJS is a set of libraries to compose synchronous and asynchronous collections and Array#extras style composition in JavaScript

Git line endings revisited and .gitignore

Git-scm.com revised their line ending fix-up instructions in a way that seems to remove ignored files from the repository.

Here are the new instructions:

echo "* text=auto" >.gitattributes
git read-tree --empty   # Clean index, force re-scan of working directory
git add .
git status              # Show files that will be normalized
git commit -m "Introduce end-of-line normalization"
Copy

.NET IsAssignableFrom

For some reason I have a mental block remembering which way .NET's IsAssignableFrom() function works, so, using the excellent LINQPad and the following code snippet, I came up with the following results:

typeof(BaseClass).IsAssignableFrom(typeof(DerivedClass)) // true

typeof(DerivedClass).IsAssignableFrom(typeof(BaseClass)) // false

Code:

void Main()
{
 typeof(BaseClass).IsAssignableFrom(typeof(DerivedClass)).Dump("typeof(BaseClass).IsAssignableFrom(typeof(DerivedClass))");
 typeof(DerivedClass).IsAssignableFrom(typeof(BaseClass)).Dump("typeof(DerivedClass).IsAssignableFrom(typeof(BaseClass))");
}
    
class BaseClass { }
class DerivedClass : BaseClass { }
Copy

C# 6 String Interpolation Does Not Concatenate

Well, I learned something new today that's slightly disappointing. I had thought that C# 6 string interpolation concatenated strings or perhaps used the StringBuilder or some such under the hood. It turns out it merely creates a good, old-fashioned String.Format statement out of it.

Given this source code:

	void Main()
	{
	}
	string NormalConcat()
	{
	var x = "B";
	return "A" + x + "C";
	}
	string Interpolation()
	{
	var x = "B";
	return $"A{x}C";
	}

view raw CompareConcatWithInterpolation.cs hosted with ❤ by GitHub

The resulting IL (compiled) code is the following (obtained using LINQPad):

	NormalConcat:
	IL_0000: nop
	IL_0001: ldstr "B"
	IL_0006: stloc.0 // x
	IL_0007: ldstr "A"
	IL_000C: ldloc.0 // x
	IL_000D: ldstr "C"
	IL_0012: call System.String.Concat
	IL_0017: stloc.1
	IL_0018: br.s IL_001A
	IL_001A: ldloc.1
	IL_001B: ret
	Interpolation:
	IL_0000: nop
	IL_0001: ldstr "B"
	IL_0006: stloc.0 // x
	IL_0007: ldstr "A{0}C"
	IL_000C: ldloc.0 // x
	IL_000D: call System.String.Format
	IL_0012: stloc.1
	IL_0013: br.s IL_0015
	IL_0015: ldloc.1
	IL_0016: ret

view raw CompareConcatWithInterpolation.il hosted with ❤ by GitHub

Note the following two statements:

ldstr       "A{0}C"
call        System.String.Format

These indicate that String.Format is being called with the familiar-looking format string "A{0}C".


To compile the C# code and create IL code, I used Joe Albahari's excellent LINQPad program.

WebClient vs HttpClient vs HttpWebRequest

All the clients explained.

http://www.diogonunes.com/blog/webclient-vs-httpclient-vs-httpwebrequest/

To quote from the link:

• HttpWebRequest for control
• WebClient for simplicity and brevity
• RestSharp for both on non-.NET 4.5 environments
• HttpClient for both + async features on .NET 4.5 environments