c# - 静态方法有没有办法访问类的所有非静态实例？

Question

这可能是一个愚蠢的问题，但无论如何我都会问它......我正在用 C#.NET 编程。我有一个包含非静态实例 EventHandler 的类。是否可以为静态方法中存在的每个类实例触发 EventHandler？我知道这是一个很长的镜头！

Answer 1

您可以这样做，但您需要创建所有对象的静态集合：

public class Thing
{
   public static List<Thing> _things = new List<Thing>();

   public Thing()
   {
       _things.Add(this);
   }

   public static void SomeEventHandler(object value, EventHandler e)
   {
      foreach (Thing thing in _things)
      {
           // do something.
      }
   }
}

您也需要注意积累“事物”。当您不再需要它们时，请确保将它们从列表中删除。

Answer 2

不，没有。基本上没有办法找到一个类的所有实例，除非你编写自己的代码来做到这一点。

编辑：对为什么这被否决感到好奇。无论如何，要添加更多细节：您应该避免这样做。你可以让你的类型实现IDisposable，然后在构造函数中注册一个静态事件处理程序，并在Dispose方法中取消注册。哎呀，你甚至可以有一个终结器来为你做这件事，这会降低你的性能，但如果你没有处理实例，至少不会泄漏。

然而，所有这些都是有些严峻的选择。尝试重新设计以避免要求会更好。也许您可以向我们提供有关您正在尝试做的事情的更多信息，我们可以想出一个解决方法？

Answer 3

你可以这样做：

    public class MyClass{
private static List<MyClass> Instances = new List<MyClass>();

    public MyClass(){
lock(typeof(MyClass)){
Instances.Add(this);
}

}}

在此之后，您可以使用实例做任何您想做的事情。

Answer 4

我理解你的意思可能是错误的，但它应该很简单......

这是主文件

using System;
using IdeaClass;

namespace TestIdeas
{
    class Program
    {
        static void Main(string[] args)
        {
            Ideas i = new Ideas();
            Ideas.triggerMany();
            Console.ReadLine();
        }
    }
}

然后是想法类：

using System;

namespace IdeaClass
{
    public class Ideas
    {
        static OtherClass oc = new OtherClass();
        public static void triggerMany()
        {
            oc.runThing("textual");
        }

        public Ideas()
        {
            Ideas.oc.ThingEvent += DoThingHandler;
        }

        public void DoThingHandler(string thing)
        {
            System.Console.WriteLine(thing);
        }
    }
}

然后是另一个班级。

using System;

namespace IdeaClass
{
    class OtherClass
    {
        public delegate void DoThing(string text);
        public event DoThing ThingEvent;

        public void runThing(string text)
        {
            if (ThingEvent != null)
            {
                ThingEvent(text);
            }
        }
    }
}

它确实会导致引发事件的类与具有静态调用的类之间发生不幸的耦合，但它似乎可以满足您的要求。