HashSet<KeyValuePair<T, T>>

HashSet<KeyValuePair<T, T>> equivalenceRelation = new HashSet<KeyValuePair<T,T>>(new SymmetricEqualityComparer<T>());

public class EquivalenceRelationEqualityComparer<T> : IEqualityComparer<T>
{
    private readonly HashSet<KeyValuePair<T, T>> mEquivalenceRelation;
    public EquivalenceRelationEqualityComparer(HashSet<KeyValuePair<T, T>> equivalenceRelation)
    {
        mEquivalenceRelation = equivalenceRelation;
    }
    public bool Equals(T x, T y)
    {
        if (ReferenceEquals(x, y))
        {
            return true;
        }
        return mEquivalenceRelation.Contains(new KeyValuePair<T, T>(x, y));
    }
    public int GetHashCode(T obj)
    {
        return 0;
    }
}

var pairs =
    from first in candidate
    from second in candidate
    select new {first, second};
return pairs.All(x =>
    candidate.Contains(x.first.Union(x.second), comparer) &&
    candidate.Contains(x.first.Intersect(x.second), comparer));

public class SymmetricEqualityComparer<TSource> : IEqualityComparer<KeyValuePair<TSource, TSource>>
{
    public bool Equals(KeyValuePair<TSource, TSource> x, KeyValuePair<TSource, TSource> y)
    {
        return(EqualityComparer<TSource>.Default.Equals(x.Key, y.Key) &&
               EqualityComparer<TSource>.Default.Equals(x.Value, y.Value)) ||
              (EqualityComparer<TSource>.Default.Equals(x.Key, y.Value) &&
               EqualityComparer<TSource>.Default.Equals(x.Value, y.Key));
    }
    public int GetHashCode(KeyValuePair<TSource, TSource> obj)
    {
        return EqualityComparer<TSource>.Default.GetHashCode(obj.Key) ^
               EqualityComparer<TSource>.Default.GetHashCode(obj.Value);
    }
}

SymmetricEqualityComparer<IEnumerable<T>> symmetricComparer =
    new SymmetricEqualityComparer<IEnumerable<T>>();
var pairs =
    (from first in candidate
     from second in candidate
     select newKeyValuePair<IEnumerable<T>,IEnumerable<T>>(first, second))
        .Distinct(symmetricComparer);
return pairs.All(x =>
    candidate.Contains(x.Key.Union(x.Value), comparer) &&
    candidate.Contains(x.Key.Intersect(x.Value), comparer));

public static IEnumerable<IEnumerable<IEnumerable<T>>> Topologies<T>(IEnumerable<T> world)
{
    IEnumerable<IEnumerable<T>> discreteTopology = GetPowerSet(world);
    IEnumerable<IEnumerable<IEnumerable<T>>> candidates = GetPowerSet(discreteTopology);
    return candidates.Where(x => IsTopology(x, world));
}

public static bool IsTopology<T>(IEnumerable<IEnumerable<T>> candidate, IEnumerable<T> world)
{
    SetComparer<T> comparer = new SetComparer<T>();
    if (!candidate.Contains(Enumerable.Empty<T>(), comparer) ||
        !candidate.Contains(world, comparer))
    {
        return false;
    }
    var pairs =
        from first in candidate
        from second in candidate
        select new {first, second};
    return pairs.All(x =>
        candidate.Contains(x.first.Union(x.second), comparer) &&
        candidate.Contains(x.first.Intersect(x.second), comparer));
}

public class SetComparer<T> : IEqualityComparer<IEnumerable<T>>
{
    public bool Equals(IEnumerable<T> x,IEnumerable<T> y)
    {
        return new HashSet<T>(x).SetEquals(y);
    }
    public int GetHashCode(IEnumerable<T> obj)
    {
        return 0;
    }
}

using System;
namespace Quine
{
    public class Program
    {
        private const string PROGRAM =
            @"using System;
namespace Quine
{
    public class Program
    {
        private const string PROGRAM =
            @""#"";            
        private static void Main(string[] args)
        {
            string[] programLines =
                PROGRAM.Split(new[] {Environment.NewLine},
                              StringSplitOptions.None);
            
            foreach (string line in programLines) 
            {
                string lineToPrint = line;
                if (line.Contains(@""@""""#""""""))
                {
                    string programConstant =
                        PROGRAM.Replace(@"""""""", @"""""""""""");
                    lineToPrint =
                        lineToPrint.Replace(""#"", programConstant);
                }
                Console.WriteLine(lineToPrint);
            }
        }
    }
}";            
        private static void Main(string[] args)
        {
            string[] programLines =
                PROGRAM.Split(new[] {Environment.NewLine},
                              StringSplitOptions.None);
            
            foreach (string line in programLines) 
            {
                string lineToPrint = line;
                if (line.Contains(@"@""#"""))
                {
                    string programConstant =
                        PROGRAM.Replace(@"""", @"""""");
                    lineToPrint =
                        lineToPrint.Replace("#", programConstant);
                }
                Console.WriteLine(lineToPrint);
            }
        }
    }
}

private List<int> mTheNumbers =new List<int>() { 4, 8, 15, 16, 23, 42 };
public IEnumerable<int> GetTheNumbers()
{
    return mTheNumbers;
}

ICollection<int> numbers = (ICollection<int>)GetTheNumbers();
numbers.Add(108);

public class ReadOnlyEnumerable<T> : IEnumerable<T>
{
    private readonly IEnumerable<T> mSource;
    public ReadOnlyEnumerable(IEnumerable<T> source)
    {
        mSource = source;
    }
    public IEnumerator<T> GetEnumerator()
    {
        return mSource.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

public IEnumerable<int> GetTheNumbers()
{
    return new ReadOnlyEnumerable<int>(mTheNumbers);
}

public IEnumerable<int> GetTheNumbers()
{
    return mTheNumbers.Select(x => x);
}

public class Dog : IBarkable, IMoveable
{
}

public interface IBarkableProvider
{
    IBarkable Provide();
}
public interface IMoveableProvider
{
    IMoveable Provide();
}

public class Provider : IBarkableProvider, IMoveableProvider
{
    IBarkableIBarkableProvider.Provide()
    {
        // ...
    }
    IMoveableIMoveableProvider.Provide()
    {
        // ...
    }
}

public class Provider :IBarkableProvider, IMoveableProvider
{
    public Dog Provide()
    {
        // ...
    }
}

public class Provider
{
    public IBarkableProvider AsBarkableProvider()
    {
    }
    public IMoveableProvider AsMoveableProvider()
    {
    }
}

public class Provider
{
    private class BarkableProvider : IBarkableProvider
    {
        private readonly Provider mProvider;
        public BarkableProvider(Provider provider)
        {
            mProvider = provider;
        }
        public IBarkable Provide()
        {
            // ...
        }
    }
    private class MoveableProvider : IMoveableProvider
    {
        private readonly Provider mProvider;
        public MoveableProvider(Provider provider)
        {
            mProvider = provider;
        }
        public IMoveable Provide()
        {
            // ...
        }
    }
    public IBarkableProvider AsBarkableProvider()
    {
        return new BarkableProvider(this);
    }
    public IMoveableProvider AsMoveableProvider()
    {
        return new MoveableProvider(this);
    }
}

public class InvertibleDictionary<TKey, TValue>
    : IDictionary<TKey, TValue>,ILookup<TValue, TKey>
{
}

public class InvertibleDictionary<TKey, TValue>
    : IDictionary<TKey, TValue>, ILookup<TValue, TKey>
{
    private class KeyValuePairGrouping : IGrouping<TValue, TKey>
    {
        private readonly KeyValuePair<TValue, ICollection<TKey>> mPair;
        public KeyValuePairGrouping(KeyValuePair<TValue, ICollection<TKey>> pair)
        {
            mPair = pair;
        }
        public IEnumerator<TKey> GetEnumerator()
        {
            return mPair.Value.GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        public TValue Key
        {
            get
            {
                return mPair.Key;
            }
        }
    }
    private IDictionary<TKey, TValue> mKeyToValue = new Dictionary<TKey, TValue>();
    private IDictionary<TValue, ICollection<TKey>> mValueToKeys = new Dictionary<TValue, ICollection<TKey>>();
    IEnumerator<IGrouping<TValue, TKey>> IEnumerable<IGrouping<TValue, TKey>>.GetEnumerator()
    {
        return mValueToKeys
            .Select(x => new KeyValuePairGrouping(x))
            .Cast<IGrouping<TValue, TKey>>()
            .GetEnumerator();
    }
    public void Add(TKey key, TValue value)
    {
        mKeyToValue.Add(key, value);
        ICollection<TKey> valueToKeys;
        if (!mValueToKeys.TryGetValue(value, out valueToKeys))
        {
            valueToKeys = new List<TKey>();
            mValueToKeys[value] = valueToKeys;
        }
        valueToKeys.Add(key);
    }
    public bool Remove(KeyValuePair<TKey, TValue> item)
    {
        if (mKeyToValue.Remove(item.Key))
        {
            ICollection<TKey> valueToKey = mValueToKeys[item.Value];
            valueToKey.Remove(item.Key);
            if (!valueToKey.Any())
            {
                mValueToKeys.Remove(item.Value);
            }
            return true;
        }
        return false;
    }
    public bool Remove(TKey key)
    {
        TValue value;
        
        if (!mKeyToValue.TryGetValue(key, out value))
        {
            return false;
        }
        return Remove(new KeyValuePair<TKey, TValue>(key, value));
    }
    public TValue this[TKey key]
    {
        get
        {
            return mKeyToValue[key];
        }
        set
        {
            TValue keyValue;
            
            if (mKeyToValue.TryGetValue(key, out keyValue))
            {
                Remove(new KeyValuePair<TKey, TValue>(key, keyValue));
            }
            Add(key, value);
        }
    }
    #region Dummy Implementation
    public void Add(KeyValuePair<TKey, TValue> item)
    {
        Add(item.Key, item.Value);
    }
    public void Clear()
    {
        mKeyToValue.Clear();
        mValueToKeys.Clear();
    }
    public bool Contains(KeyValuePair<TKey, TValue> item)
    {
        return mKeyToValue.Contains(item);
    }
    public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        mKeyToValue.CopyTo(array, arrayIndex);
    }
    public bool Contains(TValue key)
    {
        return mValueToKeys.ContainsKey(key);
    }
    public bool ContainsKey(TKey key)
    {
        return mKeyToValue.ContainsKey(key);
    }
    int ILookup<TValue, TKey>.Count
    {
        get
        {
            return mValueToKeys.Count;
        }
    }
    IEnumerable<TKey> ILookup<TValue, TKey>.this[TValue key]
    {
        get
        {
            return mValueToKeys[key];
        }
    }
    int ICollection<KeyValuePair<TKey, TValue>>.Count
    {
        get
        {
            return mKeyToValue.Count;
        }
    }
    public IEnumerator GetEnumerator()
    {
        IDictionary<TKey, TValue> dictionary = this;
        return dictionary.GetEnumerator();
    }
    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }
    public bool TryGetValue(TKey key, out TValue value)
    {
        return mKeyToValue.TryGetValue(key, out value);
    }
    IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
    {
        return mKeyToValue.GetEnumerator();
    }
    public ICollection<TKey> Keys
    {
        get
        {
            return mKeyToValue.Keys;
        }
    }
    public ICollection<TValue> Values
    {
        get
        {
            return mValueToKeys.Keys;
        }
    }
    #endregion
}

IEnumerable<IGrouping<string,int>> invertibleEnumerable = invertible;
foreach (IGrouping<string, int> group in invertibleEnumerable)
{
    // ...
}

IConfiguration GetConfiguration();
IDbConnection CreateDbConnection(IConfiguration configuration);
IEnumerable<User> GetUsers(IDbConnection dbConnection);

private Lazy<IConfiguration> mConfiguration;
private Lazy<IDbConnection> mDbConnection;
private Lazy<IEnumerable<User>> mUsers;

mConfiguration = new Lazy<IConfiguration>(GetConfiguration);
mDbConnection = new Lazy<IDbConnection>(() => CreateDbConnection(mConfiguration.Value));
mUsers = new Lazy<IEnumerable<User>>(() => GetUsers(mDbConnection.Value));

ThreadPool.QueueUserWorkItem(x => { var nothing = mUsers.Value; });

public class TwoSideDictionary<TKey, TValue>
{
    private readonly IDictionary<TKey, TValue> mKeyToValue = new Dictionary<TKey, TValue>();
    private readonly IDictionary<TValue, TKey> mValueToKey = new Dictionary<TValue, TKey>();
    public void Map(TKey key, TValue value)
    {
        if (mKeyToValue.ContainsKey(key))
        {
            throw new ArgumentException("Key already mapped in dictionary", "key");
        }
        if (mValueToKey.ContainsKey(value))
        {
            throw new ArgumentException("Value already mapped in dictionary", "value");
        }
        mKeyToValue[key] = value;
        mValueToKey[value] = key;
    }
    public TValue GetByKey(TKey key)
    {
        return mKeyToValue[key];
    }
    public TKey GetByValue(TValue key)
    {
        return mValueToKey[key];
    }
    public bool ContainsKey(TKey key)
    {
        return mKeyToValue.ContainsKey(key);
    }
    public bool ContainsValue(TValue value)
    {
        return mValueToKey.ContainsKey(value);
    }
    public TValue this[TKey key]
    {
        get 
        {
            return GetByKey(key);
        }
        set
        {
            Map(key, value);
        }
    }
    public TKey this[TValue key]
    {
        get 
        {
            return GetByValue(key);
        }
        set
        {
            Map(value, key);
        }
    }
    public IEnumerable<KeyValuePair<TKey, TValue>> KeyToValue
    {
        get
        {
            return mKeyToValue;
        }
    }
    public IEnumerable<KeyValuePair<TKey, TValue>> ValueToKey
    {
        get
        {
            return mKeyToValue;
        }
    }
}

IDictionary<string,ICollection<int>> nameToIds =
    new Dictionary<string,ICollection<int>>();

public interface ILookup<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
{
    int Count { get; }
    IEnumerable<TElement> this[TKey key] { get; }
    bool Contains(TKey key);
}

ILookup<string, int> nameToIds =
    people.ToLookup(x => x.Name, x => x.Id);