如何，从静态方法；访问静态方法中使用的静态属性的唯一值

Question

我想在同一线程上运行的其他静态方法中访问静态字段的值。下面的代码中有一个例子：

这个脚本中的第一个类是ClassA。 ClassA 的工作是比较两个 Rect 值，如果两个比较的 Rect 值之间存在不等式，则将公共布尔值设置为 true；

在 classA 中，IsRectChanged 是一个 bool 方法，它接受 Rect 类型的参数对象并将其与 StoredRect 进行比较，Rect。当storedRect 与IsRectChanged 的Rect 值不匹配时，该方法返回true。

    public class ClassA
    {
        private Rect storedRect;

        public ClassA() { }

        public bool IsRectChanged(Rect rect)
        {
            bool isChanged = !rect.Equals(storedRect);
            if(isChanged)
            {
                storedRect = rect;
            }

            return isChanged;
        }
    }

这是ClassB 我们在ClassB 中创建一个名为isRectChanged 的ClassA 静态字段。 请勿更改 ClassB 中 MethodB 的结构。考虑静态和非静态类中的 50 种其他方法必须使用 ClassA 字段这一事实。需要更改ClassB 的结构以使代码正常工作会适得其反。

    public static class ClassB
    {
        private static ClassA RectHelper = new ClassA();

        public static void MethodB(Rect yourRect)
        {
           if(RectHelper.IsRectChanged(yourRect))
           {
               Debug.Log("Changes were made");
           }
        }
    }

ClassC、ClassD和ClassE在同一个线程上运行。它们都调用ClassB.MethodB并在MethodB的参数中分配一个new Rect。

因为ClassC,ClassD和ClassE被调用ClassB.MethodB并在MethodB的参数中分配一个new Rect。它们各自覆盖静态字段ClassA RectHelper 的storedRect 值。

因此，ClassA RectHelper.IsRectChanged 将永远为真。

如何解决这个问题而不必使ClassB 的ClassA 和ClassE 的MethodB 成为非静态的？**

    public class ClassC
    {
        public void UpdateEverFrame()
        {
            ClassB.MethodB(new Rect(0, 0, 20, 20));
        }
    }
    public class ClassD
    {
        public void UpdateEverFrame()
        {
            ClassB.MethodB(new Rect(100, 100, 10, 10));
        }
    }

这里在ClassE ClassB.MthodB 中被两个UpdateEverFrame 方法调用，其中一个接受一个int 参数。如果同时调用它们，它们会相互覆盖，因此系统会认为IsRectChanged 为真，并且始终返回真。这是个大问题。

我们不希望IsRectChanged 被覆盖，我们希望ClassB.MethodB 的每个调用都被视为不是静态的，因此IsRectChanged 永远不会被覆盖

    public class ClassE
    {
        public void UpdateEverFrame()
        {
            ClassB.MethodB(new Rect(0, 0, 20, 20));
        }

        public void UpdateEverFrame(int i)
        {
            ClassB.MethodB(new Rect(100, 100, 10, 10));
        }
    }

在我的问题中，当我说“访问静态属性的唯一值”时，我指的是ClassB.RectHelper。

我知道 ClassB.RectHelper 是 STATIC，因此无论何时调用 MethodB，该值都将在 ClassC、ClassD 和 ClassE 类之间共享。但是我们能否解决这个问题，以便 ClassC 和 ClassD 不覆盖 ClassA 中的 storedRect 值？

Answer 1

我没有达到目的，但您是否考虑过将ClassB 设为通用？类似的东西：

    public class ClassB<T>
    {
        private static ClassA if_rect_Changed = new ClassA();

        public static void MethodB(Rect yourRect)
        {
            if (if_rect_Changed.RectChanged(yourRect))
            {
                Debug.Log("Changes were made");
            }
        }

    }

并像这样使用它：ClassB<ClassC>.MethodB(rect)，这样每个班级都将拥有“更改跟踪器”的“副本”，您将能够保持 MethodB 静态。

Answer 2

您为什么不跳过静态类 B 并在您的类 C 和 D 中创建类 A 的静态属性。您构建代码的方式对我来说似乎一团糟。我处理这个问题的另一种方法是做类似的事情：

public class ClassA
{
    protected Rect storedRect;

    public ClassA() { }

    public virtual void UpdateEverFrame();

    protected bool IsRectChanged(Rect rect)
    {
        bool isChanged = !rect.Equals(StoredRect);
        if(isChanged)
        {
            storedRect = rect;
        }

        return isChanged;
    }
}

public class ClassC : ClassA
{
    public override void UpdateEverFrame()
    {
        if(IsRectChanged(new Rect(0, 0, 20, 20)))
        {
             Debug.Log("Changes were made class C");
        }
    }
}
public class ClassD : ClassA
{
    public override void UpdateEverFrame()
    {
        if(IsRectChanged(new Rect(100, 100, 10, 10)))
        {
             Debug.Log("Changes were made class D");
        }
    }
}

Answer 3

首先进行一些澄清。我假设您使用的是 System.Windows.Rect，对吗？更多说明...

我们在 ClassB 中有一个 ClassA 的静态属性，名为 isRectChanged

不，您在 ClassB 中有一个 ClassA 类型的静态字段，名为 RectHelper。 IsRectChanged 是 ClassA 的非静态方法。

我们希望在同一线程上运行的其他静态方法中访问静态属性的值。

由于它们在同一线程上，因此您不可能同时调用您的静态方法。到目前为止，没问题。

它们都调用 ClassB.MethodB 并覆盖 MethodB 的 Rect 参数的值。两个类都使用ClassB.MethodB 的相同实例...

它们不会覆盖 Rect 参数，而是各自提供一个Rect 对象。 ClassB 是实例，而不是 ClassB.MethodB。

...永远是真的。

不是这样，尝试运行下面的代码，你会看到只有第一个调用返回true。

ClassC c = new ClassC();
c.UpdateEverFrame();
c.UpdateEverFrame();
c.UpdateEverFrame();

但是如果你通过 ClassD 在行之间插入调用，是的，IsRectChanged 将返回 true 因为它是真的，Rect实际上是不同的。但是，这就是 static 的用途，即，它适用于 Singleton 类型的操作。

如果您想要每个类 静态变量，则将静态变量放入每个类中。如果这需要您复制代码，请使用 模板。不必花哨，例如，只需将 ClassB 和对 ClassB 的方法的调用更改如下...

public class ClassB<TClass> // the rest of the class is the same
...
/* in ClassC */ ClassB<ClassC>.MethodB(new Rect(...));
...
/* in ClassD */ ClassB<ClassD>.MethodB(new Rect(...));

通过将ClassB制作成模板，每个ClassB都是一个不同的静态对象，每个都有自己的静态变量副本。现在，除了第一次调用 ClassC 和 ClassD 之外，以下代码将返回 false。

        ClassC c = new ClassC();
        c.UpdateEverFrame();
        c.UpdateEverFrame();
        c.UpdateEverFrame();
        ClassD d = new ClassD();
        d.UpdateEverFrame();
        d.UpdateEverFrame();
        c.UpdateEverFrame();
        d.UpdateEverFrame();

这是课程...

public static class ClassB<TClass>
{
    private static ClassA RectHelper = new ClassA();

    public static void MethodB(Rect yourRect)
    {
        if (RectHelper.IsRectChanged(yourRect))
        {
            Debug.WriteLine("Changes were made");
        }
    }
}

public class ClassC
{
    public void UpdateEverFrame()
    {
        ClassB<ClassC>.MethodB(new Rect(0, 0, 20, 20));
    }
}
public class ClassD
{
    public void UpdateEverFrame()
    {
        ClassB<ClassD>.MethodB(new Rect(100, 100, 10, 10));
    }
}