Expressões que quebram código quando compiladas usando a Atualização 1 do VS2015
Depois de instalar o Visual Studio 2015 Update 1 na minha máquina, vi que alguns dos meus testes de unidade falharam. Depois de fazer alguma investigação, pude reduzir o problema a esta linha de código:
Expression<Func<GameObject, bool>> expression = t => t.X == 0 && t.Y == 0 && t.GameObjectType == GameObjectType.WindMill;
Ao passar o mouse sobre a variável de expressão, os resultados foram diferentes nas versões do Visual Studio:
A lógica que estava fazendo a comparação para as enumerações (em algum lugar no código ServiceStack.OrmLite) agora agia de maneira diferente, o que acabou resultando na enum não sendo reconhecida como enumeração, resultando na falha do teste de unidade.
Consegui reproduzir o problema usando o seguinte código:
class Program
{
static void Main(string[] args)
{
var gameObjects = new List<GameObject> {
new GameObject { X = 0, Y = 0, GameObjectType = GameObjectType.WindMill },
new GameObject { X = 0, Y = 1, GameObjectType = GameObjectType.Pipe },
new GameObject { X = 0, Y = 2, GameObjectType = GameObjectType.Factory }
};
var gameObjectsQueryable = gameObjects.AsQueryable();
Expression<Func<GameObject, bool>> expression = t => t.X == 0 && t.Y == 0 && t.GameObjectType == GameObjectType.WindMill;
var result = gameObjectsQueryable.Where(expression);
var resultAsList = result.ToList();
foreach (var item in resultAsList)
{
Console.WriteLine(item);
}
//Obtain the t.GameObjectType == GameObjectType.WindMill part
var binaryExpression = expression.Body as BinaryExpression;
var right = binaryExpression.Right;
var binaryExpression2 = right as BinaryExpression;
var right2 = binaryExpression2.Right;
if (right2 is UnaryExpression)
{
Console.WriteLine("Found UnaryExpression (This happens when the solution is build with VS2015)...");
var right2Unary = binaryExpression2.Right as UnaryExpression;
var right2Constant = right2Unary.Operand as ConstantExpression;
CheckIfConsantIsAsExpected(right2Constant);
}
else
{
Console.WriteLine("Found ConstantExpression (This happens when the solution is build with VS2015 Update 1)...");
var right2Constant = binaryExpression2.Right as ConstantExpression;
CheckIfConsantIsAsExpected(right2Constant);
}
Console.ReadKey();
}
public static void CheckIfConsantIsAsExpected(ConstantExpression expression)
{
if (expression.Value.Equals(GameObjectType.WindMill))
{
Console.WriteLine($"The value is the enum we expected :), : {expression.Value}");
}
else
{
Console.WriteLine($"The value is not the enum we expected :(, : {expression.Value}");
}
}
}
public class GameObject
{
public int X { get; set; }
public int Y { get; set; }
public GameObjectType GameObjectType { get; set; }
public override string ToString()
{
return $"{X},{Y}: {GameObjectType}";
}
}
public enum GameObjectType
{
WindMill = 100,
Pipe = 200,
Factory = 300
}
No VS 2015, ele entrará no caminho da UnaryExpression e, no VS 2015, atualização 1, entrará no caminho do ConstantExpression.
Se você compilar a solução no VS 2015 e copiar o arquivo .exe compilado em um sistema do VS 2015 Update 1, ele será executado da mesma forma que a versão do VS 2015 (também o caminho da UnaryExpression). Isso sugere que não está relacionado ao JIT, mas sim relacionado à construção.
Minha pergunta seria se isso é pretendido? (Como ele pode quebrar o código existente ao simplesmente recompilar a solução)