2

编辑：将在 SO 上公开生产代码！希望没有人窃取我的秘密！

我有一个控制器类，用于使用 Modbus 协议通过 TCP 与设备通信。我使用 NModbus 库。

以下是控制器类实现的接口：

public interface CoilReader
{
    bool[] Read(ushort startAddress, ushort numberOfCoils);
}

public interface CoilWriter
{
    void WriteSingle(ushort address, bool value);

    void WriteMultiple(ushort startAddress, bool[] values);
}

public interface HoldingRegisterReader
{
    ushort[] Read(ushort startAddress, ushort numberOfRegisters);
}

public interface HoldingRegisterWriter
{
    void WriteSingle(ushort address, ushort value);

    void WriteMultiple(ushort startAddress, ushort[] values);
}

public interface InputReader
{
    bool[] Read(ushort startAddress, ushort numberOfCoils);
}

public interface InputRegisterReader
{
    ushort[] Read(ushort startAddress, ushort numberOfRegisters);
}

public interface ConnectionInfo
{
    string IP { get; set; }
}

这是控制器类。

using System;
using System.Net.Sockets;
using System.Reflection;
using global::Modbus.Device;

public class Controller
    : ConnectionInfo,
      HoldingRegisterReader,
      InputRegisterReader,
      CoilReader,
      InputReader,
      CoilWriter,
      HoldingRegisterWriter
{
    static Controller()
    {
        AppDomain.CurrentDomain.AssemblyResolve += (sender, e) => loadEmbeddedAssembly(e.Name);
    }

    public virtual string IP
    {
        get
        {
            return this.ip;
        }

        set
        {
            this.ip = value;
        }
    }

    public virtual ushort[] ReadHoldingRegisters(ushort startAddress, ushort numberOfRegisters)
    {
        using (var connection = this.createDeviceConnection())
        {
            return connection.ReadHoldingRegisters(startAddress, numberOfRegisters);
        }
    }

    public virtual ushort[] ReadInputRegisters(ushort startAddress, ushort numberOfRegisters)
    {
        using (var connection = this.createDeviceConnection())
        {
            return connection.ReadInputRegisters(startAddress, numberOfRegisters);
        }
    }

    public virtual bool[] ReadCoils(ushort startAddress, ushort numberOfCoils)
    {
        using (var connection = this.createDeviceConnection())
        {
            return connection.ReadCoils(startAddress, numberOfCoils);
        }
    }

    public virtual bool[] ReadInputs(ushort startAddress, ushort numberOfInputs)
    {
        using (var connection = this.createDeviceConnection())
        {
            return connection.ReadInputs(startAddress, numberOfInputs);
        }
    }

    public virtual void WriteSingleCoil(ushort address, bool value)
    {
        using (var connection = this.createDeviceConnection())
        {
            connection.WriteSingleCoil(address, value);
        }
    }

    public virtual void WriteMultipleCoils(ushort startAddress, bool[] values)
    {
        using (var connection = this.createDeviceConnection())
        {
            connection.WriteMultipleCoils(startAddress, values);
        }
    }

    public virtual void WriteSingleHoldingRegister(ushort address, ushort value)
    {
        using (var connection = this.createDeviceConnection())
        {
            connection.WriteSingleRegister(address, value);
        }
    }

    public virtual void WriteMultipleHoldingRegisters(ushort startAddress, ushort[] values)
    {
        using (var connection = this.createDeviceConnection())
        {
            connection.WriteMultipleRegisters(startAddress, values);
        }
    }

    string ConnectionInfo.IP
    {
        get
        {
            return this.IP;
        }

        set
        {
            this.IP = value;
        }
    }

    ushort[] HoldingRegisterReader.Read(ushort startAddress, ushort numberOfRegisters)
    {
        return this.ReadHoldingRegisters(startAddress, numberOfRegisters);
    }

    ushort[] InputRegisterReader.Read(ushort startAddress, ushort numberOfRegisters)
    {
        return this.ReadInputRegisters(startAddress, numberOfRegisters);
    }

    bool[] CoilReader.Read(ushort startAddress, ushort numberOfCoils)
    {
        return this.ReadCoils(startAddress, numberOfCoils);
    }

    bool[] InputReader.Read(ushort startAddress, ushort numberOfInputs)
    {
        return this.ReadInputs(startAddress, numberOfInputs);
    }

    void CoilWriter.WriteSingle(ushort address, bool value)
    {
        this.WriteSingleCoil(address, value);
    }

    void CoilWriter.WriteMultiple(ushort startAddress, bool[] values)
    {
        this.WriteMultipleCoils(startAddress, values);
    }

    void HoldingRegisterWriter.WriteSingle(ushort address, ushort value)
    {
        this.WriteSingleHoldingRegister(address, value);
    }

    void HoldingRegisterWriter.WriteMultiple(ushort startAddress, ushort[] values)
    {
        this.WriteMultipleHoldingRegisters(startAddress, values);
    }

    private ModbusIpMaster createDeviceConnection()
    {
        const int port = 502;
        var client = new TcpClient();
        client.BeginConnect(this.ip, port, null, null).AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2));
        if (!client.Connected)
        {
            throw new Exception("Cannot connect to " + this.ip + ":" + port);
        }

        return ModbusIpMaster.CreateIp(client);
    }

    private static Assembly loadEmbeddedAssembly(string name)
    {
        if (name.EndsWith("Retargetable=Yes"))
        {
            return Assembly.Load(new AssemblyName(name));
        }

        var container = Assembly.GetExecutingAssembly();
        var path = new AssemblyName(name).Name + ".dll";

        using (var stream = container.GetManifestResourceStream(path))
        {
            if (stream == null)
            {
                return null;
            }

            var bytes = new byte[stream.Length];
            stream.Read(bytes, 0, bytes.Length);
            return Assembly.Load(bytes);
        }
    }

    private string ip;
}

在与包含此类及其接口的库相同的解决方案中的 Tests 项目中创建的测试中，我没有收到以下错误。但是，在使用该库的不同解决方案中的项目中，我得到以下信息：

------ Test started: Assembly: CareControls.IvisHmi.Tests.dll ------

Unknown .NET Framework Version: v4.5.1
Test 'CareControls.IvisHmi.Tests.Presenters.ModbusTcpTogglePresenterTests.FactMethodName' failed:     FakeItEasy.Core.FakeCreationException : 
Failed to create fake of type "CareControls.Modbus.Tcp.Controller".

Below is a list of reasons for failure per attempted constructor:
  No constructor arguments failed:
    No default constructor was found on the type CareControls.Modbus.Tcp.Controller.

If either the type or constructor is internal, try adding the following attribute to the assembly:
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]


at FakeItEasy.Core.DefaultExceptionThrower.ThrowFailedToGenerateProxyWithResolvedConstructors(Type typeOfFake, String reasonForFailureOfUnspecifiedConstructor, IEnumerable`1 resolvedConstructors)
at FakeItEasy.Creation.FakeObjectCreator.TryCreateFakeWithDummyArgumentsForConstructor(Type typeOfFake, FakeOptions fakeOptions, IDummyValueCreationSession session, String failReasonForDefaultConstructor, Boolean throwOnFailure)
at FakeItEasy.Creation.FakeObjectCreator.CreateFake(Type typeOfFake, FakeOptions fakeOptions, IDummyValueCreationSession session, Boolean throwOnFailure)
at FakeItEasy.Creation.DefaultFakeAndDummyManager.CreateFake(Type typeOfFake, FakeOptions options)
at FakeItEasy.Creation.DefaultFakeCreatorFacade.CreateFake[T](Action`1 options)
at FakeItEasy.A.Fake[T]()
Presenters\ModbusTcpTogglePresenterTests.cs(22,0): at CareControls.IvisHmi.Tests.Presenters.ModbusTcpTogglePresenterTests.FactMethodName()

0 passed, 1 failed, 0 skipped, took 0.93 seconds (xUnit.net 1.9.2 build 1705).

这是测试：

namespace CareControls.IvisHmi.Tests.Presenters
{
    using CareControls.IvisHmi.Framework;
    using CareControls.IvisHmi.Presenters;
    using CareControls.IvisHmi.UI;
    using CareControls.Modbus.Tcp;
    using FakeItEasy;
    using Ploeh.AutoFixture;
    using Xunit;

    public class ModbusTcpTogglePresenterTests
    {
        [Fact]
        public void FactMethodName()
        {
            A.Fake<Controller>();
        }
    }
}

为什么 FakeItEasy 不认为类上有默认构造函数？

很抱歉，我发布了大量帖子，但有人要求我包含代码。

编辑：如果我new Controller()在该A.Fake<Controller>()行之前添加，则测试通过：

namespace CareControls.IvisHmi.Tests.Presenters
{
    using CareControls.IvisHmi.Framework;
    using CareControls.IvisHmi.Presenters;
    using CareControls.IvisHmi.UI;
    using CareControls.Modbus.Tcp;
    using FakeItEasy;
    using Ploeh.AutoFixture;
    using Xunit;

    public class ModbusTcpTogglePresenterTests
    {
        [Fact]
        public void FactMethodName()
        {
            new Controller();
            A.Fake<Controller>();
        }
    }
}
4

4 回答 4

2

根据这个：

伪造/模拟接口会给出“没有默认构造函数”错误，这怎么可能？

有一个错误可以给出错误的异常消息。他们说，在那种情况下，仍然应该有一些东西导致异常被抛出。

我建议的事情：

  • 添加显式默认构造函数有帮助吗？
  • 能否正常成功实例化类？
  • 您可以使用反射或成功实例化该类Activator.CreateInstance吗？
于 2014-03-14T19:59:23.437 回答
1

为了总结 Sam Pearson 使用 FakeItEasy 1.18.0 以及 MSDN 文档收集的信息，问题是由Modbus无法加载程序集时引发的异常引起的。这很有趣，因为Controller的静态构造函数包含处理此故障的代码，因此它一定没有被执行。调用静态构造函数

…在创建第一个实例或引用任何静态成员之前自动初始化类。1

然而，FakeItEasy 并没有刻意做这两件事。似乎 DynamicProxy 也没有。

我的猜测是访问该类以便可以伪造它会触发 Modbus 程序集加载，而不会触发静态构造函数。

但是，FakeItEasy 的程序集扫描可能会触发程序集加载。
这可以通过添加一个伪造其他东西的测试来检查，比如ICollection，然后运行它。
如果错误仍然存​​在，那么就是目录扫描正在执行此操作。在这种情况下，您可以使用 FakeItEasy 1.18.0 中添加的新引导程序来禁用目录扫描。我们还没有官方文档，因为正在讨论稍微改变扫描机制，但我确实发布了关于如何禁用磁盘程序集扫描的帖子。如果FakeItEasy 的扫描会触发加载，禁用扫描会将程序集加载延迟到调用静态构造函数之后，这可能是最简单的事情。

其他可能的解决方法：

  1. 实例化第Controller一个是一种解决方法（如前所述）
  2. 伪造实现的许多接口中的一个（或全部）Controller而不是伪造Controller（我个人的偏好是伪造接口，而不是类，但有时需要）
  3. 如果可能的话，也许最好的办法是解决程序集加载失败的原因，但我敢打赌，如果这是一个选项，静态构造函数不会包含它所做的代码。
于 2014-03-16T00:10:38.667 回答
1

静态构造函数与公共构造函数不同。您确定在定义静态构造函数时编译器会生成默认的公共构造函数吗？我不会想到你会得到两个。如果您使用ILDASM对装配进行逆向工程，它会出现吗？

静态构造函数很可能被称为“懒惰”，因此当 FakeItEasy 试图通过反射类型来创建假时，静态构造函数尚未被调用。这可以解释为什么在创建假之前实例化类型时它会起作用。

于 2014-03-14T20:46:56.730 回答
0

我通过将createDeviceConnection()方法变成NModbusDeviceConnection一次性类解决了这个问题。在 的静态构造函数中是订阅事件的NModbusDeviceConnection地方。现在我可以在不触发装配负载AssemblyResolve的情况下创建假货。ControllerModbus

有关详细信息，请参阅以下NModbusDeviceConnection课程：

// ---------------------------------------------------------------------------------------------------------------------
// <copyright file="NModbusDeviceConnection.cs" company="Care Controls">
//   Copyright (c) Care Controls Inc. All rights reserved.
// </copyright>
// ---------------------------------------------------------------------------------------------------------------------

namespace CareControls.Modbus.Tcp.Internal
{
    using System;
    using System.Net.Sockets;
    using System.Reflection;
    using global::Modbus.Device;

    internal sealed class NModbusDeviceConnection : IDisposable
    {
        static NModbusDeviceConnection()
        {
            AppDomain.CurrentDomain.AssemblyResolve += (sender, e) => loadEmbeddedAssembly(e.Name);
        }

        public NModbusDeviceConnection(string ip)
        {
            const int port = 502;
            var client = new TcpClient();
            client.BeginConnect(ip, port, null, null).AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2));
            if (!client.Connected)
            {
                throw new Exception("Cannot connect to " + ip + ":" + port);
            }

            this.connection = ModbusIpMaster.CreateIp(client);
        }

        public ushort[] ReadHoldingRegisters(ushort startAddress, ushort numberOfRegisters)
        {
            return this.connection.ReadHoldingRegisters(startAddress, numberOfRegisters);
        }

        public ushort[] ReadInputRegisters(ushort startAddress, ushort numberOfRegisters)
        {
            return this.connection.ReadInputRegisters(startAddress, numberOfRegisters);
        }

        public bool[] ReadCoils(ushort startAddress, ushort numberOfCoils)
        {
            return this.connection.ReadCoils(startAddress, numberOfCoils);
        }

        public bool[] ReadInputs(ushort startAddress, ushort numberOfInputs)
        {
            return this.connection.ReadInputs(startAddress, numberOfInputs);
        }

        public void WriteSingleCoil(ushort address, bool value)
        {
            this.connection.WriteSingleCoil(address, value);
        }

        public void WriteMultipleCoils(ushort startAddress, bool[] values)
        {
            this.connection.WriteMultipleCoils(startAddress, values);
        }

        public void WriteSingleHoldingRegister(ushort address, ushort value)
        {
            this.connection.WriteSingleRegister(address, value);
        }

        public void WriteMultipleHoldingRegisters(ushort address, ushort[] values)
        {
            this.connection.WriteMultipleRegisters(address, values);
        }

        public void Dispose()
        {
            if (this.connection != null)
            {
                this.connection.Dispose();
            }
        }

        private static Assembly loadEmbeddedAssembly(string name)
        {
            if (name.EndsWith("Retargetable=Yes"))
            {
                return Assembly.Load(new AssemblyName(name));
            }

            var container = Assembly.GetExecutingAssembly();
            var path = new AssemblyName(name).Name + ".dll";

            using (var stream = container.GetManifestResourceStream(path))
            {
                if (stream == null)
                {
                    return null;
                }

                var bytes = new byte[stream.Length];
                stream.Read(bytes, 0, bytes.Length);
                return Assembly.Load(bytes);
            }
        }

        private readonly ModbusIpMaster connection;
    }
}

这是修改后的Controller类：

// ---------------------------------------------------------------------------------------------------------------------
// <copyright file="Controller.cs" company="Care Controls">
//   Copyright (c) Care Controls Inc. All rights reserved.
// </copyright>
// ---------------------------------------------------------------------------------------------------------------------

namespace CareControls.Modbus.Tcp
{
    using System;
    using CareControls.Modbus.Tcp.Internal;

    public class Controller
        : ConnectionInfo,
          HoldingRegisterReader,
          InputRegisterReader,
          CoilReader,
          InputReader,
          CoilWriter,
          HoldingRegisterWriter
    {
        public Controller()
        {
            this.newDeviceConnection = () => new NModbusDeviceConnection(this.IP);
        }

        public virtual string IP { get; set; }

        public virtual ushort[] ReadHoldingRegisters(ushort startAddress, ushort numberOfRegisters)
        {
            using (var connection = this.newDeviceConnection())
            {
                return connection.ReadHoldingRegisters(startAddress, numberOfRegisters);
            }
        }

        public virtual ushort[] ReadInputRegisters(ushort startAddress, ushort numberOfRegisters)
        {
            using (var connection = this.newDeviceConnection())
            {
                return connection.ReadInputRegisters(startAddress, numberOfRegisters);
            }
        }

        public virtual bool[] ReadCoils(ushort startAddress, ushort numberOfCoils)
        {
            using (var connection = this.newDeviceConnection())
            {
                return connection.ReadCoils(startAddress, numberOfCoils);
            }
        }

        public virtual bool[] ReadInputs(ushort startAddress, ushort numberOfInputs)
        {
            using (var connection = this.newDeviceConnection())
            {
                return connection.ReadInputs(startAddress, numberOfInputs);
            }
        }

        public virtual void WriteSingleCoil(ushort address, bool value)
        {
            using (var connection = this.newDeviceConnection())
            {
                connection.WriteSingleCoil(address, value);
            }
        }

        public virtual void WriteMultipleCoils(ushort startAddress, bool[] values)
        {
            using (var connection = this.newDeviceConnection())
            {
                connection.WriteMultipleCoils(startAddress, values);
            }
        }

        public virtual void WriteSingleHoldingRegister(ushort address, ushort value)
        {
            using (var connection = this.newDeviceConnection())
            {
                connection.WriteSingleHoldingRegister(address, value);
            }
        }

        public virtual void WriteMultipleHoldingRegisters(ushort startAddress, ushort[] values)
        {
            using (var connection = this.newDeviceConnection())
            {
                connection.WriteMultipleHoldingRegisters(startAddress, values);
            }
        }

        string ConnectionInfo.IP
        {
            get
            {
                return this.IP;
            }

            set
            {
                this.IP = value;
            }
        }

        ushort[] HoldingRegisterReader.Read(ushort startAddress, ushort numberOfRegisters)
        {
            return this.ReadHoldingRegisters(startAddress, numberOfRegisters);
        }

        ushort[] InputRegisterReader.Read(ushort startAddress, ushort numberOfRegisters)
        {
            return this.ReadInputRegisters(startAddress, numberOfRegisters);
        }

        bool[] CoilReader.Read(ushort startAddress, ushort numberOfCoils)
        {
            return this.ReadCoils(startAddress, numberOfCoils);
        }

        bool[] InputReader.Read(ushort startAddress, ushort numberOfInputs)
        {
            return this.ReadInputs(startAddress, numberOfInputs);
        }

        void CoilWriter.WriteSingle(ushort address, bool value)
        {
            this.WriteSingleCoil(address, value);
        }

        void CoilWriter.WriteMultiple(ushort startAddress, bool[] values)
        {
            this.WriteMultipleCoils(startAddress, values);
        }

        void HoldingRegisterWriter.WriteSingle(ushort address, ushort value)
        {
            this.WriteSingleHoldingRegister(address, value);
        }

        void HoldingRegisterWriter.WriteMultiple(ushort startAddress, ushort[] values)
        {
            this.WriteMultipleHoldingRegisters(startAddress, values);
        }

        private readonly Func<NModbusDeviceConnection> newDeviceConnection;
    }
}
于 2014-03-20T16:15:45.957 回答