C#

public interface IWTF
{
    string SomeString { set; get; }
}

public static class WTF<T> where T : IWTF
{
    public static string WTFMethod(IWTF i1, IWTF i2)
    {
        return i1.SomeString + i2.SomeString;
    }
}

WTF.WTFMethod(null, null); // this will compile, the WTF method is called !

public static string WTFMethod(IWTF i1, IWTF i2)
{
    if (!(i1 is IWTF) || !(i2 is IWTF)) throw new ArgumentException("You Suck !");
    
    return i1.SomeString + i2.SomeString;
}

using System;
using System.Collections.Generic;

namespace InterfaceImplementations
{
    // example #1 expose a Dictionary : explicit interface implementation
    public interface IRequire1
    {
        Dictionary<string, int> RequiredDictionary { get; }
    }

    // implement Dictionary so it is not publicly exposed
    // using explicit interface implementation
    public class Example1 : IRequire1
    {
        private Dictionary<string, int> internalDictionary { set; get; }

        // explicit implementation of IRequire
        Dictionary<string, int> IRequire1.RequiredDictionary
        {
            get { return this.internalDictionary; }
        }

        public Example1()
        {
            internalDictionary = new Dictionary<string, int>();
        }

        public void AddEntry(string str, int i)
        {
            internalDictionary.Add(str, i);
        }

        public void RemoveEntry(string key)
        {
            internalDictionary.Remove(key);
        }
    }

    // example #2 : expose methods that operate on the (implicit) Dictionary
    public interface IRequire2
    {
        void AddEntry(string key, int value );
        void RemoveEntry(string key);
    }

    public class Example2 : IRequire2
    {
        private Dictionary<string, int> internalDictionary { set; get; }

        public Example2()
        {
            internalDictionary = new Dictionary<string, int>();
        }

        public void AddEntry(string key, int value)
        {
            internalDictionary.Add(key, value);
        }

        public void RemoveEntry(string key)
        {
            internalDictionary.Remove(key);
        }
    }

    // example #3 : use two interfaces to distinguish between the Dictionary object
    // and the methods that can operate on that object
    public interface IRequire3Dictionary
    {
        Dictionary<string, int> RequiredDictionary { get; }
    }

    public interface IRequire3Methods
    {
        void AddEntry(string key, int value);
        void RemoveEntry(string key);
    }

    public class Example3 : IRequire3Dictionary, IRequire3Methods
    {
        private Dictionary<string, int> internalDictionary { set; get; }

        public Example3()
        {
            internalDictionary = new Dictionary<string, int>();
        }

        // explicit implementation of IRequire3Dictionary
        Dictionary<string, int> IRequire3Dictionary.RequiredDictionary
        {
            get { return this.internalDictionary; }
        }

        // implicit implementation of Methods of IRequire3Methods
        public void AddEntry(string key, int value)
        {
            internalDictionary.Add(key, value);
        }

        public void RemoveEntry(string key)
        {
            internalDictionary.Remove(key);
        }
    }

    // example #4 use a generic custom Class that inherits from Dictionary
    public interface IRequire4<T1,T2>
    {
        CustomDictionary<T1, T2> CustomDictionary { get; }
    }

    public class CustomDictionary<T1, T2> : Dictionary<T1, T2>
    {
        public void AddEntry(T1 key, T2 value)
        {
            base.Add(key, value);
        }

        public void RemoveEntry(T1 key)
        {
            base.Remove(key);
        }
    }

    public class Example4 : IRequire4<string, int>
    {
        private CustomDictionary<string, int> internalDictionary { set; get; }

        // explicit implementation
        CustomDictionary<string, int> IRequire4<string, int>.CustomDictionary
        {
            get { return internalDictionary; }
        }

        public Example4()
        {
            internalDictionary = new CustomDictionary<string, int>();
        }

        public void AddEntry(string key, int value)
        {
            internalDictionary.Add(key, value);
        }

        public void RemoveEntry(string key)
        {
            internalDictionary.Remove(key);
        }
    }
}

// put this you know where
Example1 example1 = new Example1();

example1.AddEntry("hello", 100);

Example2 example2 = new Example2();

example2.AddEntry("goodbye", 200);

// example1.RemoveEntry("hello");

Example3 example3 = new Example3();

example3.AddEntry("ex 4", 999);

Example4 example4 = new Example4();

example4.AddEntry("ex 4", 2222);