How the .NET Runtime Loads a Type

    var x = DoubleIt<NumInt, int>(Int32.MaxValue);  // 20

    var a = Int32.MaxValue;
    var b = Int32.MaxValue;
    var c = a + b;

And then you can do for example:

    var validators = GetAllValidators<EntityBase>();

:)

An example is:

For some reason or another you've written a thread dispatcher that will dynamically spin up threads and route the outputs of these threads into new threads. (e.g. https://github.com/bilus/pipes )

Obviously this library will need to do run-time casting of types already as C# makes it too difficult to orchestrate these threads without some shared type. (Here is an example of Microsoft following this pattern. https://msdn.microsoft.com/en-us/library/dd321424(v=vs.110).... )

Now you need to hook validation into this existing dispatching library by assosciating validators with the outputs of particular threads. Without a shared type you cannot invoke the validator, but it sure is convenient to write the validator using generics.

Another example is:

You have two interfaces, "ISerializable" and "IEquatable", and two validators, "Validator<ISerizable>" and Validator<IEquatable>", and these validators apply to multiple classes. To run all of these validators against a given class you have three (un)reasonable choices:

* Create a boilerplate wrapper class for each of these validators for each class that they apply to, and store them against that class somehow. The disadvantage of this is that you lose track of which validators are shared between classes which may be important for some optimisation.

* Create a non-genic type "IValidator" or "Validator" that all validators share and put these in a collection. (i.e. as mentioned by the grandparent of this post).

* Bite the bullet: The code that calls these validators has to be duplicated. (This is the incorrect choice though because some day you may need to add a spin-up/teardown before running the validators and now you don't have a centralized location to do this)

Another example is:

You are writing validators for types from a 3rd party library. You may not modify the source code of this library, because it's WinForms. You've been tasked with a set of arbitrary validation tasks for your multi-million line codebase. Maybe you need to add a spell checker for all user-editable text? Maybe any control that is bound to a particular property needs an orange background.

Suddenly you have a case where you really do need to do casting and reflection to figure out which validators to run, as you perform the unfortunate evil of a recursive search through the entire control tree to hook up your validation, rather than re-writing a few thousand files.

Thats the point. You need an `IValidator` interface.

The point is that in some cases you want to be able to pass a more general interface while getting some Type-checking and convenience of generics.

In this case we want to hold on to PopProtocolSender and perhaps use it as a variable somewhere. When we use it we need to acccess it's specific IPopProtocol Protocol Property. But we also want to be able to treat it as a general IProtocolSender that has a IProtocol Property, so it can be sent to other classes that takes that interface.

These kinds of situations mainly arise when you have a more complicated architecture. If there's a better way to have your cake and eat it too I'd be glad to know it :)

    public interface IPopProtocol : IProtocol
    {
        void SomeUniqueMetod();
    }

    public interface IProtocol
    {
    }

    public interface IProtocolManager
    {
        void SendMessage(IProtocol protocol, string message);
    }

    public interface IProtocolSender
    {
        IProtocol Protocol
        {
            get;
        }
    }

    public class PopProtocol : IPopProtocol
    {
        public void SomeUniqueMetod()
        {
        }
    }

    public class Program
    {
        public void DoStuff()
        {
            var sender = new PopProtocolSender ();
            var manager = new ProtocolManager();
            manager.SendMessage(sender.Protocol, "Testing");
            sender.Protocol.SomeUniqueMethod();
        }
    }

    public class ProtocolManager : IProtocolManager
    {
        public void SendMessage(IProtocol protocol, string message)
        {
        }
    }

    public class ProtocolSender : IProtocolSender
    {
        protected readonly IProtocol _protocol;

        public ProtocolSender(IProtocol protocol)
        {
            _protocol = protocol;
        }

        public IProtocol Protool => _protocol;
    }

    public class PopProtocolSender : ProtocolSender<IPopProtocol>
    {
        public PopProtocolSender() : base(new PopProtocol)
        {
        }
    }

    public class ProtocolSender<T> : ProtocolSender where T : IProtocol
    {
        public ProtocolSender(T protocol) : base(protocol)
        {
        }

        public new T Protocol => (T)_protocol;
    }