C# JsonResult在客户端和服务器上按相反的方向排序_C#_Asp.net Mvc

C# JsonResult在客户端和服务器上按相反的方向排序

c# asp.net-mvc

C# JsonResult在客户端和服务器上按相反的方向排序,c#,asp.net-mvc,C#,Asp.net Mvc,我查询数据库并将数据返回给客户机。当I console.log在客户端上记录数据时，数据按字母顺序排列： [ [{key='a',val=123},{key='a',val=666},{key='a',val=420}], [{key='b',val=999},{key='b',val=822},{key='b',val=314}], [{key='c',val=732},{key='c',val=444},{key='c',val=987}], ] 但是当我运行单元测试时，

我查询数据库并将数据返回给客户机。当I console.log在客户端上记录数据时，数据按字母顺序排列：

[
   [{key='a',val=123},{key='a',val=666},{key='a',val=420}],
   [{key='b',val=999},{key='b',val=822},{key='b',val=314}],
   [{key='c',val=732},{key='c',val=444},{key='c',val=987}],
]

但是当我运行单元测试时，数据是反向的

[
   [{key='c',val=732},{key='c',val=444},{key='c',val=987}],
   [{key='b',val=999},{key='b',val=822},{key='b',val=314}],
   [{key='a',val=123},{key='a',val=666},{key='a',val=420}],
]

也许我把物体投错了

JsonResult result = (JsonResult)target.GetStockHistory(new string[]{"ABCDEFG", "ZYXWVUT"});
IGrouping<string, StockRecord>[] allStocks = (IGrouping<string, StockRecord>[])result.Data;

JsonResult result=（JsonResult）target.GetStockHistory（新字符串[]{“ABCDEFG”，“ZYXWVUT”}）；
i分组[]所有股票=（i分组[]）结果数据；

我敢肯定，在控制台中排序并不是浏览器为我格式化的结果，因为浏览器无法知道排序依据的值。它只是解析JSON

这是我的操作方法（不确定排序或子查询是否是导致问题的原因）

公共操作结果GetStockHistory（字符串[]符号） { StockHistory股票=新股票历史（）； IEnumerable[]记录=repository.StockRecords .其中（r=>symbols.Contains（r.Symbol）） .GroupBy（r=>r.Symbol） .选择（g=> g、 OrderByDescending（g2=>g2.RecordDate） .Take（30） .OrderBy（g3=>g3.RecordDate）） .ToArray（）；返回Json（记录，JsonRequestBehavior.AllowGet）； } 这是测试方法

    [TestMethod]
    public void Can_Get_Stocks() 
    {
        // arrange
        Mock<IStockHistory> mock = new Mock<IStockHistory>();
        mock.Setup(m => m.StockRecords).Returns(new StockRecord[] {
            new StockRecord { 
                Symbol = "ABCDEFG", 
                RecordDate = new DateTime(2000, 1, 1),
                 LowValue = 1,
                 HighValue = 10,
                AdjustedCloseValue = 8,
                CloseValue = 9,
                OpenValue = 7, 
                Volume = 13245
            },
            new StockRecord { 
                Symbol = "LMNOP", 
                RecordDate = new DateTime(2005, 1, 1),
                LowValue = 1,
                HighValue = 5,
                AdjustedCloseValue = 6,
                CloseValue = 5,
                OpenValue = 4, 
                Volume = 23456
            },
            new StockRecord { 
                Symbol = "ZYXWVUT", 
                RecordDate = new DateTime(2010, 1, 1),
                LowValue = 6,
                HighValue = 60,
                AdjustedCloseValue = 10,
                CloseValue = 10,
                OpenValue = 7, 
                Volume = 67891
            }
        }.AsQueryable());
        CommonController target = new CommonController(mock.Object);

        // act
        JsonResult result = (JsonResult)target.GetStockHistory(new string[]{"ABCDEFG", "ZYXWVUT"});
        IGrouping<string, StockRecord>[] allStocks = (IGrouping<string, StockRecord>[])result.Data;
        // allStocks is backwards!?!?! cats and dogs are getting along! 

        // assert
        Assert.AreEqual(2, allStocks.Length);
        Assert.AreEqual("ZYXWVUT", allStocks[0].ToArray()[0].Symbol);
        Assert.AreEqual("ABCDEFG", allStocks[1].ToArray()[0].Symbol);
        Assert.AreEqual(10, allStocks[0].ToArray()[0].CloseValue);
        Assert.AreEqual(9, allStocks[1].ToArray()[0].CloseValue);
    }

[TestMethod]
公开作废可以获得股票（）
{
//安排
Mock Mock=新Mock（）；
mock.Setup（m=>m.StockRecords）.返回（newstockrecord[]{
新股票记录{
Symbol=“ABCDEFG”，
RecordDate=新的日期时间（2000,1,1），
低值=1，
高值=10，
调整后的关闭值=8，
CloseValue=9，
OpenValue=7，
体积=13245
},
新股票记录{
Symbol=“LMNOP”，
RecordDate=新的日期时间（2005,1,1），
低值=1，
高值=5，
调整后的关闭值=6，
CloseValue=5，
OpenValue=4，
体积=23456
},
新股票记录{
Symbol=“ZYXWVUT”，
RecordDate=新的日期时间（2010,1,1），
低值=6，
高值=60，
调整后的关闭值=10，
闭合值=10，
OpenValue=7，
体积=67891
}
}.AsQueryable（））；
CommonController目标=新的CommonController（mock.Object）；
//表演
JsonResult=（JsonResult）target.GetStockHistory（新字符串[]{“ABCDEFG”，“ZYXWVUT”}）；
i分组[]所有股票=（i分组[]）结果数据；
//所有股票都在倒退！？！？！猫和狗相处得很好！
//断言
断言.AreEqual（2，所有股票.长度）；
Assert.AreEqual（“ZYXWVUT”，所有股票[0].ToArray（）[0].Symbol）；
Assert.AreEqual（“ABCDEFG”，所有股票[1].ToArray（）[0].Symbol）；
Assert.AreEqual（10，所有股票[0].ToArray（）[0].CloseValue）；
Assert.AreEqual（9，所有股票[1].ToArray（）[0].CloseValue）；
}

1.据我所知，按键分组的库存记录应按键降序排列。至少您已经设置了单元测试期望。但在您的操作方法查询中，我没有看到按键降序。您需要添加它：

IEnumerable<StockRecord>[] records = repository.StockRecords
    .Where(r => symbols.Contains(r.Symbol))
    .GroupBy(r => r.Symbol)
    .OrderByDescending(p => p.Key)              
    .Select(g => g.OrderByDescending(g2 => g2.RecordDate).Take(30).OrderBy(p => p.RecordDate))                          
    .ToArray();
return Json(records, JsonRequestBehavior.AllowGet);

IEnumerable[]记录=repository.StockRecords
.其中（r=>symbols.Contains（r.Symbol））
.GroupBy（r=>r.Symbol）
.OrderByDescending（p=>p.Key）
.Select（g=>g.OrderByDescending（g2=>g2.RecordDate）。Take（30）。OrderBy（p=>p.RecordDate））
.ToArray（）；
返回Json（记录，JsonRequestBehavior.AllowGet）；

2.这样的强制转换

i分组[]所有股票=（i分组[]）结果。数据将不会编译。您可以将其替换为IEnumerable[]allStocks=（IEnumerable[]）result.Data
然后，它将根据您在单元测试中定义的表达式进行操作。集合（如SQL SELECT查询）不保证按任何特定顺序排列，这意味着可以对结果进行排序
根据我的经验，任何.To\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu。因此，当您的代码在.OrderBy（g3=>g3.RecordDate）
之后调用.ToArray（）
时，它会重置任何排序。结果在客户机上排序这一事实很可能只是一个侥幸
解决方法是在链的前面调用.ToArray（）
，稍后调用.OrderBy（）
，或者在转换为数组后再次调用.OrderBy（）
。
我只是太傻了。它将转到另一个查询，并以这种方式进行排序。这就是我的结局：
行动方法
    public ActionResult GetStockHistory(string[] symbols, int maxRows = Int32.MaxValue)
    {
        IEnumerable<IEnumerable<StockRecord>> records;

        records = repository.StockRecords
            .Where(r => symbols.Contains(r.Symbol))
            .GroupBy(r => r.Symbol)
            .Select(g => g
                .OrderByDescending(g2 => g2.RecordDate)
                .Take(maxRows)
                .OrderBy(g3 => g3.RecordDate));

        return Json(records, JsonRequestBehavior.AllowGet); 
    }

public ActionResult GetStockHistory（字符串[]符号，int-maxRows=Int32.MaxValue）
{
可数记录；
records=repository.StockRecords
.其中（r=>symbols.Contains（r.Symbol））
.GroupBy（r=>r.Symbol）
.选择（g=>g
.OrderByDescending（g2=>g2.RecordDate）
.Take（maxRows）
.OrderBy（g3=>g3.RecordDate））；
返回Json（记录，JsonRequestBehavior.AllowGet）；
}

单元测试
    [TestMethod]
    public void Can_Get_Stock()
    {
        // arrange
        Mock<IStockHistory> mock = new Mock<IStockHistory>();
        mock.Setup(m => m.StockRecords).Returns(new StockRecord[] {
            new StockRecord { 
                Symbol = "ABCDEFG", 
                RecordDate = new DateTime(2000, 1, 1)
            }
        }.AsQueryable());
        CommonController target = new CommonController(mock.Object);

        // act
        JsonResult result = (JsonResult)target.GetStockHistory(new string[] { "ABCDEFG" });
        IEnumerable<IEnumerable<StockRecord>> allStocks = (IEnumerable<IEnumerable<StockRecord>>)result.Data;

        // assert
        Assert.AreEqual(1, allStocks.Count());
        StockRecord[] record1 = allStocks.ElementAt(0).ToArray();
        StockRecord record1_row1 = record1[0];

        Assert.AreEqual("ABCDEFG", record1_row1.Symbol);
    }

[TestMethod]
公开作废可以获得股票（）
{
//安排
Mock Mock=新Mock（）；
mock.Setup（m=>m.StockRecords）.返回（newstockrecord[]{
新股票记录{
Symbol=“ABCDEFG”，
RecordDate=新的日期时间（2000,1,1）
}
}.AsQueryable（））；
CommonController目标=新的CommonController（mock.Object）；
//表演
JsonResult=（JsonResult）target.GetStockHistory（新字符串[]{“ABCDEFG”}）；
IEnumerable allStocks=（IEnumerable）re
    [TestMethod]
    public void Can_Get_Stock()
    {
        // arrange
        Mock<IStockHistory> mock = new Mock<IStockHistory>();
        mock.Setup(m => m.StockRecords).Returns(new StockRecord[] {
            new StockRecord { 
                Symbol = "ABCDEFG", 
                RecordDate = new DateTime(2000, 1, 1)
            }
        }.AsQueryable());
        CommonController target = new CommonController(mock.Object);

        // act
        JsonResult result = (JsonResult)target.GetStockHistory(new string[] { "ABCDEFG" });
        IEnumerable<IEnumerable<StockRecord>> allStocks = (IEnumerable<IEnumerable<StockRecord>>)result.Data;

        // assert
        Assert.AreEqual(1, allStocks.Count());
        StockRecord[] record1 = allStocks.ElementAt(0).ToArray();
        StockRecord record1_row1 = record1[0];

        Assert.AreEqual("ABCDEFG", record1_row1.Symbol);
    }