Sunday, January 21, 2018

Git 2.16 and line endings

Git 2.16 introduces two new interesting options for dealing with line endings.

The first is the new --ignore-cr-at-eol option to git diff, which ignores changes in line endings in a diff, which otherwise sometimes lead to it appear that the entire file has changed (which, in a sense, it has).
git diff --cached --ignore-cr-at-eol
The second is the new --renormalize option to git add.
git add --renormalize .
To quote the man pages, git add --renormalize "is a new and safer way to record the fact that you are correcting the end-of-line convention and other "convert_to_git()" glitches in the in-repository data." So the way to normalize line endings in a repository has been revised to the following:
echo "* text=auto" >.gitattributes
git add --renormalize .
git status        # Show files that will be normalized
git commit -m "Introduce end-of-line normalization"
Note that the old way:
git read-tree --empty   # Clean index, force re-scan of working directory
git add .
will cause Git to delete files from the repository that are included in .gitignore. That might be a good thing for certain "undisciplined" repositories.

Friday, January 05, 2018

Easily building query strings in .NET

Instead of reinventing the wheel, try the following:
NameValueCollection queryString = System.Web.HttpUtility.ParseQueryString(string.Empty);

queryString["key1"] = "value1";
queryString["key2"] = "value2";

return queryString.ToString(); // Returns "key1=value1&key2=value2", all URL-encoded

Saturday, December 30, 2017

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

Wednesday, December 13, 2017

Cool JSON and SQL-related links found on a Hacker News post – Parses sample JSON and creates code to serialize/deserialize it in several different languages. – 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. – Interactive Extensions for JavaScript (IxJS). IxJS is a set of libraries to compose synchronous and asynchronous collections and Array#extras style composition in JavaScript

Wednesday, November 22, 2017

Git line endings revisited and .gitignore 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"

Wednesday, September 20, 2017

.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
void Main()
class BaseClass { }
class DerivedClass : BaseClass { }

Thursday, June 08, 2017

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:

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

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.