Operation could destabilize the runtime?

Question

I'm having a little bit of trouble understanding what the problem is here. I have a bit of code that pulls records from a database using LINQ and puts them into an object which is cast into an interface. It looks a bit like this:

public IEnumerable<ISomeObject> query()
{
    return from a in dc.SomeTable
           select new SomeObject
           {
             //Assign various members here
           } as ISomeObject;
}

When I test this, I put the returned IEnumerable into a variable called results and run this line:

Assert.AreEqual(EXPECTED_COUNT, results.Count());

When this is run, I get a System.Security.VerificationException: "Operation could destabilize the runtime."

I found the solution here, which is this:

var results = from a in dc.SomeTable
              select new SomeObject
              {
                //Assign various members here
              } as ISomeTable;
return results.OfType<ISomeObject>();

This works, but I'm having trouble understanding what's happening here. Why did I get the exception in the first place and how did the lines of code above fix it? The MSDN documentation seems to suggest that this is an issue of type safety, but I'm not seeing where the previous code was type-unsafe.

UPDATE A little bit more information I found out. The first example works if I make the return type IQueryable. This sheds a little bit more light on what was going wrong, but I'm still confused about the why. Why didn't the compiler force me to cast the IEnumerable into an IQueryable?

Jairia

This happens regularily to me when using ANTS Performance Profiler with projects that make use of HtmlAgilityPack. The solution to this was to tell the profiler to exclude HtmlAgilityPack by adding <assemblyName>HtmlAgilityPack</assemblyName> to the file "C:\Users\YourUserName\AppData\Local\Red Gate\ANTS Performance Profiler 9\LineLevelBlacklist.xml" (Replace "YourUserName" by your actual user name). – Daily

Answer 1

I believe it is an issue of covariance or contravariance as noted by this forum post.

See Covariance and Contravariance in C#, Part Two: Array Covariance and the rest of the Covariance and Contravariance series at Eric Lippert's blog.

Although he is dealing with Arrays in the article I linked, I believe a similar problem presents itself here. With your first example, you are returning an IEnumerable that could contain objects that implement an interface that is larger than ISomeTable (i.e. - you could put a Turtle into an Animals IEnumerable when that IEnumerable can only contain Giraffes). I think the reason it works when you return IQueryable is because that is larger/wider than anything you could return, so you're guaranteed that what you return you will be able to handle(?).

In the second example, OfType is ensuring that what gets returned is an object that stores all the information necessary to return only those elements that can be cast to Giraffe.

I'm pretty sure it has something to do with the issues of type safety outlined above, but as Eric Lippert says Higher Order Functions Hurt My Brain and I am having trouble expressing precisely why this is a co/contravariant issue.

Indignity

This sounds right to me. I can see where you're coming from on not being able to express why this is. I'll wait a while and see if anyone has a more direct explanation, otherwise I'll accept this answer. – Jairia

Answer 2

I found this entry while looking for my own solution to "operation could destabilize the runtime". While the covariance/contra-variance advice above looks very interesting, in the end I found that I get the same error message by running my unit tests with code coverage turned on and the AllowPartiallyTrustedCallers assembly attribute set.

Removing the AllowPartiallyTrustedCallers attribute caused my tests to run fine. I could also turn off code coverage to make them run but that was not an acceptable solution.

Hopefully this helps someone else who makes it to this page trying to find a solution to this issue.

Jareb

This was the problem in my case, but it was that the AllowPartiallyTrustedCallers was set on an assembly that the assemly under test referenced. Microsoft definitely needs to address this as I need that flag on my assembly and why in the heck would a test cause the problem when code running in a normal context doesn't?! Whatever happened to 'test mimics real code calling it'?! Obviously test host is doing something special to cause the problem. – Attu

Just got the exact same error message, and this was indeed the issue. Removing the AllowPartiallyTrustedCallers attribute lets my tests run just fine. – Avar

This worked for me too. I switched to VS 2012 and suddenly my Tao Open GL library wouldn't work any more. This fixed it. – Quart

We also encountered this question while searching for answers to "operation could destabilize the runtime" ... This was probably the fix, but internal to framework dlls (Microsoft.VisualStudio.QualityTools.UnitTestFramework, etc). To help anybody else caught by this framework bug introduced by MS in the .Net 4.0 to 4.5 updates there is a hotfix available via Windows update (or specifically support.microsoft.com/kb/2748645) that corrects this (if your code was working pre-update) – Chimera

Answer 3

Just a guess, but the as operator may return a null - so it may have to do with the actual implementation of the new SomeObject { ... } code, since it's syntactic sugar. The return results.OfType<ISomeTable>(); filters based on type, so your method's return statement will only return that type (ensuring type safety). I've run into a similar issue with returning generic types.

P.S. I love the "Operation could destabilize the runtime." exception. That's almost like the "You might blow up the internet" exception.

Mononuclear

Good guess, but that's not it. If I do a C-style cast, it doesn't work either. – Jairia

Drats. I still think the problem is the set you are trying to return doesn't agree with the return type of the method. Hopefully someone else knows :) – Mononuclear

Answer 4

I came across this error with similar code;

IEnumerable<Table> records = (from t in db.Tables
                              where t.Id.Equals(1)
                              select t).ToList();

This seemingly harmless code was part of a UserControl method which was called from a Page. No problem in a .NET4 development environment, however, when the site was PreCompiled and deployed to the server on .NET3.5 I got this error.

I suspect this has something to do with the fact that the control was being compiled into a separate DLL combined with the security changes between the frameworks as described in this .NET security blog

My solution: run the live site on .NET4

Yasui

Answer 5

`I have added to web.config file in section then System.Security.VerificationException: "Operation could destabilize the runtime." not coming for me.

<system.Web>
<trust level="Full"/>

Defeasible

Answer 6

Does it still fail if you change this:

select new SomeObject { ... } as ISomeTable;

to this:

select (ISomeTable) new SomeObject { ... };

?

If so (as I see you've confirmed), perhaps this has to do with the fact that an interface implementation could be either a class or a struct? Does the problem still appear if you cast to an abstract class rather than an interface?

Atalayah

Answer 7

I found that OfType had some nasty side effects when using linq to sql. For example, parts of the linq that were previously evaluated after the query was run against the db were instead translated to SQL. This failed as those sections had no SQL equivalent. I ended up using .Cast instead which seems to solve the problem as well.

Rosinarosinante

Answer 8

In my case i had wrongly declared the Storage property in the Column attribute of a Linq2SQL class

    [Column(Storage = "_Alias", DbType = "NVarChar(50)")]
    public string UserAlias

Hildy

Answer 9

I had same problem, but with inheritance I defined a class in assembly A and a subclass in Assembly B after I added below attribute to assembly A, problem solved:

[assembly: SecurityRules(SecurityRuleSet.Level1, SkipVerificationInFullTrust = true)]

Teat

Answer 10

I ran into this error while using the "Dynamic data access framework" Passive library. The source of the error was line 100 in the DynamicDatabase.cs file.

databaseDetectors = (databaseDetectors ?? Enumerable.Empty<DatabaseDetector>()).DefaultIfEmpty(new DatabaseDetector());

I changed that line of code to:

databaseDetectors = (databaseDetectors ?? Enumerable.Empty<DatabaseDetector>()).DefaultIfEmpty(new DatabaseDetector()).OfType<IDatabaseDetector>();

Doing so resolved the problem. I went ahead and forked the project and submitted the change to the original author.

Thank you, Jason Baker, for pointing out the solution in your original question.

On a side note, the original library ran fine on my local machine and on a Rackspace VPS, but when I pushed the same code to a shared hosting environment (GoDaddy and Rackspace's Cloud Sites), I began getting the "Operation could destabilize the runtime" error.

Midwinter

Answer 11

I guess, Linq to Sql may not support casting when translate to sql statement.

Bickart

This simply isn't true. The example that works involves casting as well. – Jairia

My above answer means, it may not support using syntax casting. But it allows using OfType. Does the SomeObject implement interface ISomeObject? – Bickart