c#数组复制，调整大小

我有一个数组：

static Array results = new[] { new { Id, RoomCount, Cover, Space, Floor,
                                    FloorCount, NameHouse, Price, NameStreet } };

然后我有第二个：

var res = (//.......//
select new { f.Id, f.RoomCount, f.Cover, f.Space, f.Floor, f.FloorCount,
             h.NameHouse, f.Price, s.NameStreet }).ToArray();

然后我想将res复制到结果：

var lres = res.Length;
res.CopyTo(results, lres);

res的长度是不同的，结果的长度是固定的，因为它只是声明的

我得到一个解释：dest数组的长度太短。 我还尝试调整dest数组的大小：

var lres = res.Length;
Array.Resize(results, lres);

也崩溃了：无法从用法推断方法

System.Array.Resize（ref T[]，int）

的类型参数。尝试显式指定类型参数

有什么建议吗

    public partial class Search : System.Web.UI.Page
    {
    public static int Id { get; set; }
    public static int RoomCount { get; set; }
    public static string Cover { get; set; }
    public static int Space { get; set; }
    public static int Floor { get; set; }
    public static int FloorCount { get; set; }
    public static string NameHouse { get; set; }
    public static decimal Price { get; set; }
    public static string NameStreet { get; set; }

    static Array results = new[] { new { Id, RoomCount, Cover, Space, Floor,      FloorCount, NameHouse, Price, NameStreet } };  
 private Array FormData()
    {

       //some code
        var lng = ht.Length;

        while (lng != 0)
        {
            //
            var var = ht[lng - 1];
            lng--;


            var res = (from f in db.FlatSet
                           .Where(x => x.RoomCount >= rMin && x.RoomCount <= rMax)
                           .Where(x => x.Space >= sMin && x.Space <= sMax)
                           .Where(x => x.Floor >= fMin && x.Floor <= fMax)
                           .Where(x => x.FloorCount >= fcMin && x.FloorCount <= fcMax)
                           .Where(x => x.HouseTypeId == var)// || x.HouseTypeId == 2)
                           .Where(x => x.Price >= pMin && x.Price <= pMax)
                           .Where(x => x.Rent == r)
                       join h in db.HouseTypeSet on f.HouseTypeId equals h.Id
                       join s in db.StreetSet on f.StreetId equals s.Id
                       select new { f.Id, f.RoomCount, f.Cover, f.Space, f.Floor, f.FloorCount, h.NameHouse, f.Price, s.NameStreet }).ToArray();

            var lres = res.Length;
            Array.Resize(ref results, lres);

            res.CopyTo(results, lres);

        }
        return results;
    }


FIXED:
public class result
{
    public int Id { get; set; }
    public int RoomCount { get; set; }
    public string Cover { get; set; }
    public int Space { get; set; }
    public int Floor { get; set; }
    public int FloorCount { get; set; }
    public string NameHouse { get; set; }
    public decimal Price { get; set; }
    public string NameStreet { get; set; }
}
public partial class Search : System.Web.UI.Page
{
    DB_9AB8FB_lisogorEntities db = new DB_9AB8FB_lisogorEntities();


    List<result[]> myList = new List<result[]>();
    List<result> NewMyList = new List<result>();
}
  //////some code
 private List<result[]> FormData()//
    {
 int[] ht = (int[])arr;
        var lng = ht.Length;

        while (lng != 0)
        {
            //some code
            var var = ht[lng - 1];
            lng--;

            myList.Add((from f in db.FlatSet
                           .Where(x => x.RoomCount >= rMin && x.RoomCount <= rMax)
                           .Where(x => x.Space >= sMin && x.Space <= sMax)
                           .Where(x => x.Floor >= fMin && x.Floor <= fMax)
                           .Where(x => x.FloorCount >= fcMin && x.FloorCount <= fcMax)
                           .Where(x => x.HouseTypeId == var)// || x.HouseTypeId == 2)
                           .Where(x => x.Price >= pMin && x.Price <= pMax)
                           .Where(x => x.Rent == r)
                       join h in db.HouseTypeSet on f.HouseTypeId equals h.Id
                       join s in db.StreetSet on f.StreetId equals s.Id
                       select new result{ Id = f.Id, RoomCount = f.RoomCount, Cover = f.Cover, Space = f.Space, Floor = f.Floor, 
                                          FloorCount = f.FloorCount, NameHouse = h.NameHouse, Price = f.Price, NameStreet=s.NameStreet }).ToArray());

        }
        return myList;
    }

    private void BindData()
    {
        var i = myList.Count;

        while (i != 0)
        {
            if (myList[i - 1].Length != 0)
            {
                var j = myList[i - 1].Length;
                while (j != 0)
                {
                    NewMyList.Add(myList[i - 1][j-1]);
                    j--;
                }
            }
            i--;
        }
        Results1.DataSource = NewMyList;
        Results1.DataBind();
    }
    }

公共部分类搜索：System.Web.UI.Page
{
公共静态int-Id{get；set；}
公共静态int RoomCount{get；set；}
公共静态字符串覆盖{get；set；}
公共静态int空间{get；set；}
公共静态整数层{get；set；}
公共静态int FloorCount{get；set；}
公共静态字符串NameHouse{get；set；}
公共静态十进制价格{get；set；}
公共静态字符串NameStreet{get；set；}
静态数组结果=new[]{new{Id，RoomCount，Cover，Space，Floor，FloorCount，NameHouse，Price，NameStreet}；
专用数组FormData（）
{
//一些代码
var lng=高温长度；
而（液化天然气！=0）
{
//
var=ht[lng-1]；
液化天然气；
var res=（从db.FlatSet中的f开始）
其中（x=>x.RoomCount>=rMin和x.RoomCount x.Space>=sMin和x.Space x.Floor>=fMin和x.Floor x.FloorCount>=fcMin和x.FloorCount x.HouseTypeId==var）/| | x.HouseTypeId==2）
其中（x=>x.价格>=pMin&x.价格x.租金==r）
在f.HouseTypeId等于h.Id的db.houseType中加入h
将s连接到db.StreetSet上的f.StreetId等于s.Id
选择新{f.Id、f.RoomCount、f.Cover、f.Space、f.Floor、f.FloorCount、h.NameHouse、f.Price、s.NameStreet}）。ToArray（）；
var lres=相对长度；
调整数组大小（参考结果，LRE）；
res.CopyTo（结果、LRE）；
}
返回结果；
}
固定的：
公开课成绩
{
公共int Id{get；set；}
public int RoomCount{get；set；}
公共字符串覆盖{get；set；}
公共int空间{get；set；}
公共整数层{get；set；}
public int FloorCount{get；set；}
公共字符串NameHouse{get；set；}
公共十进制价格{get；set；}
公共字符串名称树集{get；set；}
}
公共部分类搜索：System.Web.UI.Page
{
DB_9AB8FB_lisogorEntities DB=新的DB_9AB8FB_Lisogorenties（）；
List myList=新列表（）；
List NewMyList=newlist（）；
}
//////一些代码
私有列表FormData（）//
{
int[]ht=（int[]）arr；
var lng=高温长度；
而（液化天然气！=0）
{
//一些代码
var=ht[lng-1]；
液化天然气；
myList.Add（（从db.FlatSet中的f开始）
其中（x=>x.RoomCount>=rMin和x.RoomCount x.Space>=sMin和x.Space x.Floor>=fMin和x.Floor x.FloorCount>=fcMin和x.FloorCount x.HouseTypeId==var）/| | x.HouseTypeId==2）
其中（x=>x.价格>=pMin&x.价格x.租金==r）
在f.HouseTypeId等于h.Id的db.houseType中加入h
将s连接到db.StreetSet上的f.StreetId等于s.Id
选择新结果{Id=f.Id，RoomCount=f.RoomCount，Cover=f.Cover，Space=f.Space，Floor=f.Floor，
FloorCount=f.FloorCount，NameHouse=h.NameHouse，Price=f.Price，namestret=s.namestret}）；
}
返回myList；
}
私有void BindData（）
{
var i=myList.Count；
而（i！=0）
{
if（myList[i-1]。长度！=0）
{
var j=myList[i-1]。长度；
而（j！=0）
{
新增（myList[i-1][j-1]）；
j--；
}
}
我--；
}
结果1.DataSource=NewMyList；
结果1.DataBind（）；
}
}

您使用的是匿名类型，而编译器不知道如何推断两个数组的并集，因为编译器应该知道要为其创建实例的对象的类型 您将在上获得此异常

 Array.Resize<T> 

---

希望有此帮助

尝试将显式类型放入

数组。调整大小

：

索引是起始索引，从最后一个索引开始，这就是目标数组不够长的原因

或者使用

Array.Copy（）

：

---

如果您正在寻找当前代码的解决方案，请按此操作

var arguments=new object[] { results, results.Length + res.Length };
        var method= typeof(Array).GetMethod("Resize").MakeGenericMethod(res.GetType().GetElementType());
        method.Invoke(null,arguments );
        var lastIndex = results.Length;
        results = arguments[0] as Array;
        res.CopyTo(results, lastIndex);

---

但我强烈建议你不要这样做。但是创建一个具有所有这些属性的

类

，并使用

列表

来创建一个干净且可维护的代码。匿名类的泛型

Array

很快就会迫使您进行完全的重新分解。

可能不是好代码，但

results=results.Union（res）.ToArray（）

可能会有所帮助。arraysAdd没有方法联合：使用System.Linq；为什么不使用

列表
？@user2970104您是否尝试过我的解决方案；-）如果两个数组的长度相等，则一切正常。两个数组的类型相同。@user2970104在
数组中指定数据类型。是否调整大小
？请参阅上面的更新。我有匿名类型数组，可以使用吗？
Array.Resize<String>(ref results, lres);

res.CopyTo(results, 0);

Array.Copy(res, results, res.length);

var arguments=new object[] { results, results.Length + res.Length };
        var method= typeof(Array).GetMethod("Resize").MakeGenericMethod(res.GetType().GetElementType());
        method.Invoke(null,arguments );
        var lastIndex = results.Length;
        results = arguments[0] as Array;
        res.CopyTo(results, lastIndex);