perhaps like this:

public class Program {

private static void Main() {

    CanThisHappen

<myfunnytype();

}


public static void CanThisHappen

<t() where T : class, new() {

    var instnace = new T();

    Debug.Assert(!instnace.Equals(null), "How did we break the CLR?");

    }

}

internal class MyFunnyType {

public override bool Equals(object obj) {

    return true;

}

}

Can we modify CanThisHappen method of program?

class MyFunnyTypeAttribute : ProxyAttribute {

public override MarshalByRefObject CreateInstance(Type serverType) { return null; }

}

[MyFunnyType] class MyFunnyType : ContextBoundObject{}

Do you mean to break

var instnace = new <whatever;

object.ReferenceEquals(instnace, null) == false?

Damn, thats a NASTY solution :S

I did not know that ProxyAttribute exists :)

It opens so many possibilities!!!

Indeed - pure evil; and definitely worthy of an update to my similar corner-case on stackoverflow: http://stackoverflow.com/questions/194484#194671

Apparently this will do the trick:

        public static bool operator !=(object left, MyFunnyType right)

        {

            return false;

        }

Right. When creating the object with new T() somehow the type is unknown and it won't call the != operator. Generics oddity...

@Reshef - it isn't that the T is unknown; it is that the operator can't be resolved via static analysis (which it must) to a single implementation. Similar to how +-*/ don't work (unless you cheat, like in MiscUtil's Operator class). I suspect there is some scenarios (involving subclassing and a constraint like T : SomeType) where it /would/ pick up the operator, but that ("T : SomeType") isn't in the question.

Looks like this would work.

public class InterceptionProxy : RealProxy

{

    public InterceptionProxy() : base(typeof(MyFunnyType)) { }


     public override IMessage Invoke(IMessage msg)

    {

         // Does not get here

          ....

    }


    public override object GetTransparentProxy()

    {

        return null;

    }

}

I've used a programming language in which you can return a value from a constructor, even null. Insanity :)

Cool post, I hate to say but I think you misspelled 'instance' as 'instnace' in your code example.

Peace!

Ooh, nice solution. I was thinking about this:

using MyFunnyType = System.Nullable <int;

As far as I recall, Nullable structs are not applicable for the "struct" constraint (which is actually defined as "non-nullable value type"), so I guess they might be applicable for the "class" constraint. I'm probably wrong, but it'd be a nice solution.