Question

我希望一个班级修改另一个班级的列表字段。我将两个列表字段都作为引用传递。问题是，最后修改了一个列表，而第二个则没有修改。我不明白为什么。我想用一个最小的可行示例来检验我的想法，在该示例中一切正常：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20190424_ref_list_del
{
    class Program
    {
        static void Main(string[] args)
        {
            ListManager testObj = new ListManager();
            testObj.startJob();
        }
    }

    class ListManager
    {
        private List<int> ListToExpand;
        private List<int> ListToShorten;

        public ListManager()
        {
            ListToExpand = new List<int>() { 1, 2, 3 };
            ListToShorten = new List<int>() { 1, 2, 3 };
        }

        public void startJob()
        {
            EditList editObj = new EditList(ref ListToExpand, ref ListToShorten);
            editObj.doJob();
            System.Diagnostics.Debug.Print("List to expand:");
            foreach (int x in ListToExpand)
            {
                System.Diagnostics.Debug.Print(x.ToString());
            }
            System.Diagnostics.Debug.Print("List to shorten:");
            foreach (int x in ListToShorten)
            {
                System.Diagnostics.Debug.Print(x.ToString());
            }

        }
    }

    class EditList
    {
        private List<int> ListToExpand;
        private List<int> ListToShorten;

        public EditList(ref List<int> listToExpand, ref List<int> listToShorten)
        {
            ListToExpand = listToExpand;
            ListToShorten = listToShorten;
        }

        public void doJob()
        {
            ListToExpand.Add(4);
            ListToShorten.RemoveAt(0);
        }
    }
}

主要思想是：

初始化两个列表
先展开，然后再缩短另一个。
检查在工人阶级之外是否存在影响名单的行为。

因此，我正在使用ref。但是在我的真实应用中，相同的方法失败了。我也有两个清单。一个要扩展，第二个要缩短。

让我解释一下我的代码的功能：有一个Modbus设备的示例列表。一些样本需要合并成更大的样本（因为某些值太大，以至于int32的值需要存储在两个int16寄存器中）。

我有一个使用Command设计模式的类，其工作方式如下：

创建一个包含以下内容的Command对象：
1. （ref）输入单个样本的列表
2. 要加入的样本列表
3. （ref）加入双样本的样本列表
构建双样本
删除已加入的单个样本

在测试时，将填充双重样本的列表，但不会缩短单个样本的列表。我不明白为什么，因为看起来我使用的方法与最小工作示例中的方法相同。你能告诉我怎么了吗？

测试用例：

namespace put_samples_into_dbTests.Unit.Commands
{
    [TestClass]
    public class GetDoubleSamples
    {
        List<Sample> SingleSamples;
        List<PatternSample32> SamplesPattern;
        List<Sample32> ResultSamples;
        int MaxSources = 2;
        int MaxObjects = 3;

        [TestInitialize]
        public void TestInit()
        {
            SingleSamples = new List<Sample>();
            SamplesPattern = new List<PatternSample32>();
            ResultSamples = new List<Sample32>();

            for (byte i = 1; i <= MaxSources; i++)
            {
                for (byte k = 2; k <= MaxObjects; k++)
                {
                    SamplesPattern.Add(new PatternSample32(i, k, 1, 2));
                }
            }
        }

        [TestMethod]
        public void BuildFrom1Set()
        {
            int howManySamples32 = MaxSources * (MaxObjects-1);
            int howManySamples = MaxSources* ((1 + MaxObjects) * MaxObjects / 2) - howManySamples32 *2;
            DateTime dateTime = DateTime.Now;


            for (byte i = 1; i <= MaxSources; i++)
            {
                for (byte k = 1; k <= MaxObjects; k++)
                {
                    for (byte l = 1; l <= k; l++)
                    {
                        SingleSamples.Add(new Sample(dateTime, i, k, l, 1, true));
                    }
                }
            }

            Command command = new GetDoubleSamples(ref SingleSamples, SamplesPattern , ref ResultSamples );
            command.Execute();

            Assert.AreEqual(howManySamples, SingleSamples.Count); // [!]
            Assert.AreEqual(howManySamples32, ResultSamples.Count);

        }

现在，看看我的GetDoubleSamples命令：

public class GetDoubleSamples : Command
    {
        private List<Sample> SingleSamples;
        private List<PatternSample32> DoubleSamplesPattern;
        private List<Sample32> ResultSamples;
        private List<Sample> ProcessedSamples;

        public GetDoubleSamples (ref List<Sample> singleSamples, List<PatternSamples32> doubleSamplesPattern, ref List<Sample32> resultSamples)
        {
            SingleSamples = singleSamples;
            doubleSamplesPattern = doubleSamplesPattern;
            ResultSamples = resultSamples;
            ProcessedSamples = new List<Sample>();
        }

        public void Execute()
        {
            SortSamples();
            foreach (List<Sample> samplesSet in GenerateSets())
            {
                ResultSamples.AddRange(BuildDoubles(samplesSet ));
            }
            DeleteProcessedSamples();
        }
         private void DeleteProcessedSamples()
        {
            SingleSamples = SingleSamples.Except(ProcessedSamples).ToList();
        }
}

问题是，当我检查创建的双样本的数量时-没关系。但是，相同的（我想）简单样品列表不会减少处理后的样品。当我调试代码时，我看到在类中提到的列表已被修改。但是一旦我脱离Execute方法并脱离Command类，就失去了修改后的列表，回到了原来的列表。就像我的清单没有作为参考传递。

您知道什么地方可能出问题吗？任何建议，以及有关重新安排我的测试方法的建议，将不胜感激！：-）

引用列表未在命令类之外进行修改

0 个答案: