3

我正在制作一个有几个类的游戏，每个类都执行某种特定的任务。

我对 OOP 完全陌生，我想知道我应该怎么做才能让我的类实例在彼此之间进行通信，而不会重复使用静态类、方法和属性，这似乎是一件可怕的事情。

我是自学成才的程序员，我意识到我做了很多不好的做法。到目前为止，我设法使这两个类都成为静态的，但我想知道我应该怎么做才能使我的代码尽可能好。

另外，如果您能向我推荐一些资源/书籍/文章，那将是很好的，这样我就可以阅读有关该主题的更多信息（实例之间的通信）。

这是一段代码，所以你明白我在说什么。

class Program
{
    static void Main(string[] args)
    {
        Class1 instance1 = new Class1();
        Class2 instance2 = new Class2();

        // infinite loop
        while (true)
        {
            instance1.UpdateMethod(someValue);
            instance2.UpdateMethod();
        }
    }
}

class Class1
{
    int Property;
    UpdateMethod(int argument)
    {
        Property += argument;
        if(Property == 3000)
        {
            // I should change the state of instance2
        }
    }
}

class Class2
{
    UpdateMethod()
    {
        if(Time.GetTime() == SomeTime)
        {
            // here I want to change the state of instance1
        }
    }
}
4

5 回答 5

2

对于常见设计模式的概述，我推荐

http://en.wikipedia.org/wiki/Category:Software_design_patterns

Class1如果和之间存在自然关系Class2，那么一个实例持有对另一个实例的引用是很常见的。例如，如果您有一个Player类，而玩家有一个Weapon，请像这样定义您的类：

public class Player
{
    public Weapon Weapon { get; set; }
    // Other properties
}

特别是在您的情况下，您似乎想Class1从Class2. 我建议您定义一个Class2包含 的相关实例的属性Class1，就像上面的示例一样。

这称为复合模式。

在软件工程中，复合模式是一种分区设计模式。复合模式描述了一组对象将以与对象的单个实例相同的方式处理。组合的目的是将对象“组合”成树结构以表示部分整体的层次结构。实现复合模式可以让客户统一处理单个对象和组合。

另一种经常用于作用于对象实例的模式是命令模式。

在面向对象的编程中，命令模式是一种设计模式，其中对象用于表示和封装以后调用方法所需的所有信息。此信息包括方法名称、拥有该方法的对象和方法参数的值。始终与命令模式相关的三个术语是客户端、调用者和接收者。客户端实例化命令对象并提供稍后调用该方法所需的信息。调用者决定何时调用该方法。接收者是包含方法代码的类的一个实例。使用命令对象可以更轻松地构建需要委托的通用组件，

于 2012-07-06T00:17:28.393 回答
0

我会建议你两个链接和他们的内容是免费阅读

http://msdn.microsoft.com/en-us/library/dd460654.aspx

更多关于模式更好的细节是http://www.codeproject.com/Articles/22769/Introduction-to-Object-Oriented-Programming-Concep

最后一个来自鲍勃叔叔对 OOD 原则的良好解释http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod

于 2012-07-06T00:17:40.533 回答
0

如果你需要从另一个类改变一个对象的状态，你需要一个对它的引用。常见的方法是通过构造函数：

public class Class2
{
    private readonly Class1 instance;

    public Class2(Class1 instance)
    {
        this.instance = instance;
    }

    public void UpdateMethod()
    {
        if(VisualStyleElement.TaskbarClock.Time.GetTime() == SomeTime)
        {
            // here I want to change the state of instance1
            this.instance.SomeProperty = "Some Value";
        }
    }
}

或通过传递给方法的参数

public class Class2
{
    public void UpdateMethod(Class1 instance)
    {
        if (VisualStyleElement.TaskbarClock.Time.GetTime() == SomeTime)
        {
            // here I want to change the state of instance1
            instance.SomeProperty = "Some Value";
        }
    }
}

在第一种情况下，您可以这样称呼它：

Class2 instance2 = new Class2(instance1);
instance2.UpdateMethod();

在第二种情况下，您可以这样称呼它：

Class2 instance2 = new Class2();
instance2.UpdateMethod(instance1);
于 2012-07-06T00:19:59.533 回答
0

欢迎来到 OOP 的世界！要理解的一件重要事情是继承的概念。继承与什么有关。孩子是人，母亲是人。

请看一下这个模型：

public class Person
    {
        protected string Name;

        public string WhatsYourName()
        {
            return this.Name;
        }
    }

    public class Mother: Person
    {
        public Mother(string personName)
        {
            this.Name = personName;
        }
    }

    public class Child : Person
    {
        public Mother MyMother { get; set; }

        public Child(string personName)
        {
            this.Name = personName;
        }

        public string WhoAreYou()
        {
            return string.Format("My name is {0} and my mom is {1}", this.Name, this.MyMother.WhatsYourName());
        }
    }

现在，对象如何相互交谈？有很多方法可以实现这一点，但都归结为一个简单的概念：引用。当您创建一个对象 (x = new ...) 时，您正在创建一个新实例，并且您有它的引用。

现在，看看这个：

static void Main(string[] args)
{
    Mother mary = new Mother("Mary");
    Child bobby = new Child("Bobby");

    bobby.MyMother = mary;

    Console.WriteLine(bobby.WhoAreYou());

    Console.ReadLine();
}

看看我们什么时候设置鲍比的妈妈？我们正在传递它的对象引用。

请看一下这段代码，我相信它会有所帮助。

此外，我强烈建议您阅读有关设计模式的内容。也许从这里开始：http: //www.dofactory.com/Patterns/Patterns.aspx/

希望这可以帮助。

于 2012-07-06T00:30:34.113 回答
0

这完全取决于什么Class1和Class2是什么以及它们是否需要耦合。如果他们做不相关的事情并且不需要相互了解，您可以使用事件来传达他们之间的变化：

class Program
{
    static void Main(string[] args)
    {
        Class1 instance1 = new Class1();
        Class2 instance2 = new Class2();

        instance1.CriticalValueReached += instance2.DoSomething;
        instance2.TimeoutElapsed += instance1.DoSomething;

        // infinite loop
        while (true)
        {
            instance1.UpdateMethod(someValue);
            instance2.UpdateMethod();
        }
    }
}

class Class1
{
    int Property;

    public event Action CriticalValueReached;

    public UpdateMethod(int argument)
    {
        Property += argument;
        if (Property == 3000)
            RaiseCriticalValueReached();
    }

    public void DoSomething()
    {
        // Whatever...
    }

    private void RaiseCriticalValueReached()
    {
        var handler = CriticalValueReached;
        if (handler != null)
            handler();
    }
}

class Class2
{
    public event Action TimeoutElapsed;

    public UpdateMethod()
    {
        if (Time.GetTime() == SomeTime)
            RaiseTimeoutElapsed();
    }

    public void DoSomething()
    {
        // ...
    }

    private void RaiseTimeoutElapsed()
    {
        var handler = TimeoutElapsed;
        if (handler != null)
            handler();
    }
}
于 2012-07-06T01:02:27.547 回答