Question

我有一个winform我正在努力，需要在达到特定阶段时更改标签，并在完成时更改相同的标签。我有一个接口设置和一个实现此接口的类。在类构造函数中，我正在尝试添加Action＆lt;＆gt;作为一个参数，但我无法处理我需要做的事情，以使其正确流动。

永远无法让它发挥作用：/

Answer 1

虽然你的例子我不能给出具体的例子，因为它让我感到困惑。我仍然可以回答一些问题。

这有帮助吗？

        private Action _methodOnProgress;
        public ChipLoadFirmware(Action method)
        {
            _methodOnProgress = method;
        }
        public bool LoadFirmWare()
        {
            (p) = > 
            {
                _methodOnProgress();
            }
        }

Answer 2

这里的事件模式可能更可靠。

首先添加一个

public event EventHandler Progress

到你的ChipLoadFirmware类，并在manager类中公开（假设它叫做Manager，ChiLoad实例叫做Loader）

因此，当您在添加

的表单中实例化经理时

Manager.Loader.Progress += (o, e) => { /* Change the label */  };

最后在（p）=＆gt; {}做

Progress(this, EventArgs.Empty);

编辑以下是您的代码及更改，请填写类Form是您的表单和labelToChange必须更改的标签;

/// <summary>
/// Represents an object that can load the firmware
/// </summary>
public interface ILoadFirmware
{
    /// <summary>
    /// Loads firmware on a device
    /// </summary>
    bool LoadFirmware();
    event EventHandler Progress;
    event EventHandler Status;
}

public class ChipLoadFirmware : ILoadFirmware
{
    private readonly log4net.ILog logger = Logging.Log4NetManager.GetLogger();
    private readonly ImageLoader imageLoader = new ImageLoader ();
    private bool abort = false;
    private string cmdText = string.Empty;
    private string errortext = string.Empty;
    private string isaIp;
    public event EventHandler Progress;
    public event EventHandler Status;

    /// <summary>
    /// Sets up an ImageLoader
    /// </summary>
    /// <param name="isaTargetIpAddress">The IP address of the ISA to load the firmware on</param>
    public ChipLoadFirmware (string isaTargetIpAddress)
    {
        this.isaIp = isaTargetIpAddress;
        imageLoader.EventHandler += (s, e) => { };
        logger.DebugFormat("Using IP Address {0}", isaTargetIpAddress);
    }

    /// <summary>
    /// Loads the firmware onto the device
    /// </summary>
    /// <returns>Returns true if successful</returns>
    public bool LoadFirmware()
    {
        bool result = imageLoader.Run(this.isaIp,
            false,
            Command.Command,
            string.Empty,
            CommandFlag.CommandFlag,
            2000,
            (p) => { Progress(this, EventArgs.Empty); },
            (s) => { Status(this, EventArgs.Empty); },
            ref this.abort,
            out this.cmdText,
            out this.errortext);

        if (!result)
        {
            result = false;
            throw new InvalidOperationException(
                string.Format(
                    "ImageLoader failed with message: {0}",
                    errortext));
        }

        return result;
    }
}

public class CalibrationManager : ICalibrationManager
{
    const uint startAddress = 0x00000000;
    const uint startAddress = 0x00000000;

    private readonly log4net.ILog logger;
    private readonly ISignalGenerator sigGenerator;
    public readonly ILoadFirmware loadFirmware;
    private readonly IReader reader;
    private readonly IValueParser valueParser;
    private readonly IRepository<CalibrationValue> calibrationRepository;
    private readonly IRepository<UIDList> uidRepository;

    private string uid;

    public CalibrationManager(ISignalGenerator sigGen, ILoadFirmware loadFirmware, IReader chipRreader, IValueParser chipValueParser, IRepository<UIDList> uidRepo, IRepository<CalibrationValue> calRepo)
    {
        if (sigGen == null ||
            loadFirmware == null ||
            chipReader == null ||
            chipValueParser == null ||
            calRepo == null ||
            uidRepo == null) throw new ArgumentNullException();

        logger = Logging.Log4NetManager.GetLogger();

        this.sigGenerator = sigGen;
        this.loadFirmware = loadFirmware;
        this.reader = chipReader;
        this.valueParser = chipValueParser;
        this.uidRepository = uidRepo;
        this.calibrationRepository = calRepo;
    }

    public void Calibrate(bool reuse)
    {
        int voltageG;
        int currentG;
        // Read uid from device
        this.uid = uidReader.ReadUid();
        logger.DebugFormat("Read UID {0}", this.uid);

        var possibleCalibrations = getCalibrationDataFromRepo();
        if (possibleCalibrations.Any() && reuse)
        {
            logger.Debug("Reusing existing values");
            var existingCalibration = possibleCalibrations.OrderByDescending(c => c.DateCalibrated).First();
            currentG = existingCalibration.CurrentGain;
            voltageG = existingCalibration.VoltageGain;
        }
        else
        {
            logger.Debug("Reading new values");

            // Set voltage and current for signal generator
            sigGenerator.SetOutput(187, 60);

            // Load firmware onto chip for CLI commands
            loadFirmware.LoadFirmware();
            UpdateStateChange(StateOfDevice.LoadFirmware);

            // Read voltage from device and calibrate
            voltageG = valueParser.ReadVoltageValue();
            UpdateStateChange(StateOfDevice.CalibrateVoltage);

            // Read current from device and calibrate
            sigGenerator.SetOutput(38, 60);
            currentG = valueParser.ReadCurrentValue();
            UpdateStateChange(StateOfDevice.CalibrateCurrent);

            // Insert values into table
            CalibrationValue cv = new CalibrationValue();
            cv.UidId = uidRepository.GetBy(e => e.UID.Equals(this.uid)).Id;
            cv.CurrentGain = currentG;
            cv.VoltageGain = voltageG;
            calibrationRepository.Insert(cv);
            calibrationRepository.Submit();
            UpdateStateChange(StateOfDevice.DatabaseInsert);
        }

        logger.DebugFormat("Updated database for current gain to {0} and voltage gain to {1}", currentG, voltageG);

        // Once here, device has passed all phases and device is calibrated
        UpdateStateChange(StateOfDevice.CalibrationComplete);
    }

    private IQueryable<CalibrationValue> getCalibrationDataFromRepo()
    {
        int uidId = uidRepository.GetBy(e => e.UID.Equals(this.uid)).Id;
        return calibrationRepository.SearchFor(c => c.UidId == uidId);
    }

    public bool CalibrationDataExists()
    {
        this.uid = uidReader.ReadUid();
        logger.DebugFormat("Read UID {0}", this.uid);

        return getCalibrationDataFromRepo().Any();
    }

    public event Action<StateOfDevice, string> StateChange;

    private void UpdateStateChange(StateOfDevice state, string message = "")
    {
        var sc = StateChange;
        if (sc != null)
        {
            StateChange(state, message);
        }
    }
}

public class Form
{
    Label labelToModify;

    void MagickButtonClick(object Source, EventArgs e)
    { 

        CalibrationManager manager = new CalibrationManager(.......);

        manager.loadFirmware.Progress += (o, e) => { labelToModify.Text = "Some progress achieved!!";  };

    }

}

将SystemAction委托为构造函数参数

2 个答案: