C＃继承重写参数

Question

I have a "specific Manager" which inherits "Manager", I also have a "specific Object" which inherits "BaseClass"

What I try to code is dealing "BaseClass" properties with "Manager" and dealing "specific Object" properties with "specific Manager".

It might be messy now so I have a Class UML :

Here is the basic of the code:

class Program
{
    static void Main(string[] args)
    {
        SpecificManager ManagerFoo = new SpecificManager();
        SpecificManager2 ManagerBar = new SpecificManager2();
    }
}

public class Manager
{

    public void Manage()
    {
        // deal with BaseClass properties of the SpecificObject
        // myObject should be know as type of SpecificObject or SpecificObject2 depending of SpecificManager child
        myObject.isAlive = true;
    }
}

public class SpecificManager : Manager
{
    public SpecificObject myObjectSpec = new SpecificObject("Alfred");
    public void SpecificManage() 
    {
        // Manage Attributes of SpecificObject class
        myObjectSpec.level = 2;
        base.Manage();
    }
}
public class SpecificManager2 : Manager
{
    public SpecificObject2 myObjectSpec = new SpecificObject2("Alfred2");
    public void SpecificManage2()
    {
        // Manage Attributes of SpecificObject2 class
        myObjectSpec.description = "Foo";
        base.Manage();
    }
}

public class BaseClass
{
    public string gameObject;
    public bool isAlive;

    public BaseClass(string gameObjectStructure)
    {
        this.gameObject = gameObjectStructure;
    }
}

public class SpecificObject : BaseClass
{
    public int level = 1;
    public SpecificObject(string objectname) : base(objectname)
    {

    }
}

public class SpecificObject2 : BaseClass
{
    public string description = String.Empty;
    public SpecificObject2(string objectname) : base(objectname)
    {

    }
}

Maybe the way I want this to work is not the right way to do, so I'm really fine getting some suggestions !

Thank you, dear helper !

Answer 1

The quick answer you to your specific question on how does inheritance work is that you could put public int level into your base class object (which @Sriram Sakthivel pointed out is not a good name to use for your class since it is the most base object in c#) and then both child classes would be able to use it. So your code would at least compile and run at that point.

This would look like the following (Note I've changed your class name from Object to BaseClass which while a better name than Object still isn't terribly descriptive for what the class does and so I wouldn't use either)

public class BaseClass
{
    public string gameObject;
    public bool isAlive;
    public int level;

    public BaseClass(string gameObjectStructure)
    {
        this.gameObject = gameObjectStructure;
        level = 1;
    }
}

Another suggestion would be that you not get into the habit of using public members in the first place and instead use properties. This has several benefits but one of the main ones is that you can now override how the property is set. For example if SpecificObject1 needs to do something different with Level than SpecifictObject2 does.

This change would look like the following...

public class BaseClass
{
    private string gameObject;
    private bool isAlive;
    private int level;

    public BaseClass(string gameObjectStructure)
    {
        this.gameObject = gameObjectStructure;
        level = 1;
    }

    //don't include a set property to prevent anyone from changing the value
    public string GameObject { get { return gameObject; } }

    //"normal" property which includes a way to set and get the value
    public bool IsAlive { get { return isAlive; } set { isAlive = value; } }

    //Include virtual which allows the child classes to override the behavior
    public virtual Level { get { return level; } set { level = value; } }
}

public SpecificObject : BaseClass
{
    private string levelMessage;

    public SpecificObject(string objectname) : base(objectname)
    {
        //No need to call base.gameObject = objectName; because that is what
        //base(objectname) is doing for you.
        levelMessage = String.Empty;
    }

    //Contrived example showing overrides on a virtual method.
    public override Level 
    {
        get { return base.Level } 
        set { 
                base.Level = value;
                levelMessage = value.ToString();
            } 

    }
}

There are other things that you could do to improve your code but this should get you started in the right direction and explains your original question on inheritance.

Answer 2

I might have find a solution.

class Program
{
    static void Main(string[] args)
    {
        SpecificManager specificManager = new SpecificManager();
        SpecificManager2 specificManager2 = new SpecificManager2();
        //...
        specificManager.Manage();
        specificManager2.Manage();
    }
}

public class Manager
{
    dynamic myObject = null;
    public void ManagerInit (dynamic myObject)
    {
        this.myObject = myObject;
    }
    public void Manage()
    {
        if (myObject == null)
            return;
        // deal with BaseClass properties of the SpecificObject
        myObject.isAlive = true;
    }
}

public class SpecificManager : Manager
{
    public SpecificObject myObjectSpec = new SpecificObject("Alfred");
    public SpecificManager ()
    {
        base.ManagerInit(myObjectSpec);
    }
    public void SpecificManage()
    {
        // Manage Attributes of SpecificObject class
        myObjectSpec.level = 2;
        base.Manage();
    }
}
public class SpecificManager2 : Manager
{
    public SpecificObject2 myObjectSpec2 = new SpecificObject2("Alfred2");
    public SpecificManager2 ()
    {
        base.ManagerInit(myObjectSpec2);
    }
    public void SpecificManage2()
    {
        // Manage Attributes of SpecificObject2 class
        myObjectSpec2.description = "Foo";
        base.Manage();
    }
}

public class BaseClass
{
    public string gameObject;
    public bool isAlive;

    public BaseClass(string gameObjectStructure)
    {
        this.gameObject = gameObjectStructure;
    }
}

public class SpecificObject : BaseClass
{
    public int level = 0;
    public SpecificObject(string objectname) : base(objectname)
    {

    }
}

public class SpecificObject2 : BaseClass
{
    public string description = String.Empty;
    public SpecificObject2(string objectname) : base(objectname)
    {

    }
}

This compile and changes done under Manager are well seen under SpecificManagers. Terrible thing is that the code won't yell at build if I write stupids things under the Manage method...