C# 更新具有相同属性的不同对象

在我的代码中，我有三个（或更多…）不同的对象，它们都具有相同的属性（例如TrackingItemType、ReaderID等）

它们是从CounterBase派生的（CounterBase不具有所需的属性，但具有其他属性）

现在我想遍历这些对象的集合。在集合中，三个对象都可以出现。因此，目前我分别为每个对象实现了“更新”

问题：如何避免编写重复的代码？有吗 模式可用于更新具有相同属性的不同对象 财产

谢谢

利息计算方法：

    private void UpdateTrackingCounters(Reading readingData, TrackingItemType trackingItemType, string trackingCounterType)
    {
        try
        {
            foreach (CounterBase counter in this.TrackingCounters)
            {
                if (typeof(TrackingSimpleCounter).IsInstanceOfType(counter))
                {
                    TrackingSimpleCounter trackingCounter = (TrackingSimpleCounter)counter;

                    if (trackingCounter.TrackingCounterType == trackingCounterType)
                    {
                        if ((trackingCounter.ReaderID == 0
                            && trackingCounter.TrackingItemType == null)
                            || (trackingCounter.ReaderID == 0
                                && trackingCounter.TrackingItemType == trackingCounter.TrackingItemType)
                            || (trackingCounter.ReaderID == readingData.ReaderId
                                && trackingCounter.TrackingItemType == null)
                            || (trackingCounter.ReaderID == readingData.ReaderId
                                && trackingCounter.TrackingItemType == trackingCounter.TrackingItemType)
                            )
                        {
                            trackingCounter.IncreaseOne();
                        }
                    }
                }
                else if (typeof(TrackingIntervalBasedRollingCounter).IsInstanceOfType(counter))
                {
                    TrackingIntervalBasedRollingCounter trackingCounter = (TrackingIntervalBasedRollingCounter)counter;

                    if (trackingCounter.TrackingCounterType == trackingCounterType)
                    {
                        if ((trackingCounter.ReaderID == 0
                            && trackingCounter.TrackingItemType == null)
                            || (trackingCounter.ReaderID == 0
                                && trackingCounter.TrackingItemType == trackingCounter.TrackingItemType)
                            || (trackingCounter.ReaderID == readingData.ReaderId
                                && trackingCounter.TrackingItemType == null)
                            || (trackingCounter.ReaderID == readingData.ReaderId
                                && trackingCounter.TrackingItemType == trackingCounter.TrackingItemType)
                            )
                        {
                            trackingCounter.IncreaseOne();
                        }
                    }
                }
                else if (typeof(TrackingTriggerBasedRollingCounter).IsInstanceOfType(counter))
                {
                    TrackingTriggerBasedRollingCounter trackingCounter = (TrackingTriggerBasedRollingCounter)counter;

                    if (trackingCounter.TrackingCounterType == trackingCounterType)
                    {
                        if ((trackingCounter.ReaderID == 0
                            && trackingCounter.TrackingItemType == null)
                            || (trackingCounter.ReaderID == 0
                                && trackingCounter.TrackingItemType == trackingCounter.TrackingItemType)
                            || (trackingCounter.ReaderID == readingData.ReaderId
                                && trackingCounter.TrackingItemType == null)
                            || (trackingCounter.ReaderID == readingData.ReaderId
                                && trackingCounter.TrackingItemType == trackingCounter.TrackingItemType)
                            )
                        {
                            trackingCounter.IncreaseOne();
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            this.Trace.Error(ex);
        }
    }

因式分解 可以将公共属性提取到一个新的公共对象中，并使两个类都具有该对象的引用属性

---

这样，当您更新此对象时，两个原始对象将具有最新的值，而不会忘记更新其中一个属性。

定义一个包含所需属性和方法的界面：

interface ITrackable
{
    int ReaderID;
    string TrackingItemType;
    void IncreaseOne();
}

并将其添加到拥有它们的每个类的声明中：

class TrackingSimpleCounter : CounterBase, ITrackable

class TrackingIntervalBasedRollingCounter: CounterBase, ITrackable

class TrackingTriggerBasedRollingCounter : CounterBase, ITrackable

如果所有类都真正共享这些属性，那么就不必实现任何接口，因为它已经存在了

那么你所需要的就是

foreach (ITrackable counter in this.TrackingCounters)
{
    if ((counter.ReaderID == 0 && counter.TrackingItemType == null)
    || (counter.ReaderID == 0 && counter.TrackingItemType == counter.TrackingItemType)
    || (counter.ReaderID == readingData.ReaderId && counter.TrackingItemType == null)
    || (counter.ReaderID == readingData.ReaderId && counter.TrackingItemType == counter.TrackingItemType)
    )
    {
        counter.IncreaseOne();
    }
}

除非我误解了你的逻辑，否则你真正需要的是：

foreach (ITrackable counter in this.TrackingCounters)
{
    if (counter.ReaderID == 0 || counter.ReaderID == readingData.ReaderID)
    {
        counter.IncreaseOne();
    }
}

或者，如果要使用LINQ：

foreach (var counter in this.TrackingCounters.OfType<ITrackable>().Where(c => c.ReaderID == 0 || c.ReaderID = readingData.ReaderID))
{
    counter.IncreaseOne();
}

foreach（this.TrackingCounters.OfType（）中的var计数器，其中（c=>c.ReaderID==0 | | c.ReaderID=readingData.ReaderID））
{
counter.IncreaseOne（）；
}

首先，这听起来是一个很好的解决方案。不幸的是，C#接口可能不包含字段/属性，而只包含方法//编辑：当添加getter/setter时，它可以正常工作。我会试着给出反馈！！