One interesting issue that came up recently and not very obvious at first sight is the following:
We found a difference in behavior in .NET Compact Framework compared to the Full .NET Framework. Basically we found that calling the same function on .NET and .NET Compact Framework had a differing behavior. The reason this came to be was .NET had more overloads for the same function compared to .NET Compact Framework. So for example is .NET had overloads:
Foo(int bar);
Foo(object bar);
whereas .NET Compact Framework had only the overload:
This is pretty common since we try to subset the full .NET Framework to give most of the utility of the .NET with the least amount of code. However as this specific issue came about, we found that there can be subtle differences.
When the code such as the one below was compiled:
Main()
{
bool flag = true;
Foo(flag);
}
on .NET, this would call into the more specific function overload Foo(int) whereas since on .NET Compact Framework since we didn't have that overload would target Foo(object). In this case, any internal implementation differences between the 2 overloads would manifest itself as a difference in behavior between .NET and .NET Compact Framework.
The definitive way to determine if this is the cause of the difference in behavior is using ildasm to view the IL generated code and seeing which overload is being called.
This posting is provided "AS IS" with no warranties, and confers no rights.