Excluding Types in the Generic Constraints (Possible?)

Question

Is possible to exclude specific types from the set of possible types, that can be used in a generic parameter? If so how.

For example

Foo<T>() : where T != bool

would mean any type except for the type bool.

Edit

Why?

The following code is my attempt to enforce the negative constraint.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
  class Program
  {
    static void Main(string[] args)
    {
      var x1=Lifted.Lift("A");
      var x2=Lifted.Lift(true);
    }
    static class Lifted
    {
      // This one is to "exclude" the inferred type variant of the parameter
      [Obsolete("The type bool can not be Lifted", true)]
      static public object Lift(bool value) { throw new NotSupportedException(); }
      // This one is to "exclude" the variant where the Generic type is specified.
      [Obsolete("The type bool can not be Lifted", true)]
      static public Lifted<T> Lift<T>(bool value) { throw new NotSupportedException(); }
      static public Lifted<T> Lift<T>(T value) { return new Lifted<T>(value); }
    }

    public class Lifted<T>
    {
      internal readonly T _Value;
      public T Value { get { return this._Value; } }
      public Lifted(T Value) { _Value = Value; }
    }
  }
}

As you can see it involves a bit of faith in the overload resolution being correct, and bit of @jonskeet -esque evil code.

Comment out the section with deals with the inferred type example and it doesn't work.

It would be so much better to have the excluded generic constraint.

Answer 1

Nope, you can't make one-off exclusions like that using type constraints. You can do it at runtime though:

public void Foo<T>()
{
     if (typeof(T) == typeof(bool))
     {
         //throw exception or handle appropriately.
     }
}