jnm2

MIT License

Copyright (c) 2021 Joseph Musser

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

jnm2

declare @schemaName sysname = 'dbo'
declare @tableName sysname = 'ItemPrices'
declare @rowCondition nvarchar(max) = 'PriceCode in (''SEEDS'', ''YEAREND'')'


declare @builder nvarchar(max);
select @builder = coalesce(@builder + '

', '') + 'if exists(
    select *' + QueryWithoutSelect + ')

jnm2

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;

public sealed class ExpressionComparer : IEqualityComparer<Expression>
{
    public NameComparison CompareLambdaNames { get; set; }
    public NameComparison CompareParameterNames { get; set; }

jnm2

using System;
using System.Diagnostics;
using System.Numerics;

#if NETCOREAPP2_1_OR_GREATER
using System.Buffers.Binary;
#endif

#nullable enable

jnm2

Open types in nameof

[TODO: follow standard sections, add examples, flesh everything out]

Motivation

This is a small feature that removes a common frustration: why do I have to pick a generic type argument when the choice has no effect on the evaluation of the expression? It's very odd to require something to be specified within an operand when it has no impact on the result. Notably, typeof does not suffer from this limitation.

It's not just about code that better expresses itself. Once some arbitrary type argument has been chosen in a nameof expression, such as object?, changing a constraint on a type parameter can break uses of nameof unnecessarily. Insult becomes added to injury in this scenario. Satisfying the type parameter requires declaring a dummy class to implement an interface which is constraining the type parameter. Now there's unused metadata and a strange name invented, all for the purpose of adding a type argument to the nameof expression, a type argument which `na

jnm2

flowchart
    ICollection --- IEnumerable
    IList --- ICollection
    IEnumerableT[IEnumerable<T>] --- IEnumerable
    ICollectionT[ICollection<T>] --- IEnumerableT
    IListT[IList<T>] --- ICollectionT
    IReadOnlyCollectionT[IReadOnlyCollection<T>] --- IEnumerableT
    IReadOnlyListT[IReadOnlyList<T>] --- IReadOnlyCollectionT

jnm2

// MIT license, copyright 2015 Joseph N. Musser II

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

namespace jnm2
{
    public struct WeakDelegate<TDelegate> : IEquatable<WeakDelegate<TDelegate>> where TDelegate : class

jnm2

/// <summary>
/// Tracks how many references there are to a disposable object, and disposes it when there are none remaining.
/// </summary>
public sealed class RefCountingDisposer
{
    private readonly IDisposable disposable;
    private uint refCount = 1;
    private readonly object lockObject = new();

    /// <summary>

jnm2

using System;
using System.Threading;

internal sealed class DeferredAction
{
    private static readonly Action SentinelNextSetShouldPost = () => { };

    private readonly SynchronizationContext synchronizationContext;
    private Action scheduledAction = SentinelNextSetShouldPost;

jnm2

using System;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;

public static class TaskTupleExtensions
{
    #region (Task<T1>)

    public static TaskAwaiter<T1> GetAwaiter<T1>(this ValueTuple<Task<T1>> tasks)
    {