C# Object-Oriented – Create New Object or Reset Properties

cconstructionobject-oriented

 public class MyClass
    {
        public object Prop1 { get; set; }

        public object Prop2 { get; set; }

        public object Prop3 { get; set; }
    }

Suppose I have an object myObject of MyClass and I need to reset its properties, is it better to create a new object or reassign each property? Assume I don't have any additional use with the old instance.

myObject = new MyClass();

myObject.Prop1 = null;
myObject.Prop2 = null;
myObject.Prop3 = null;

Best Answer

Instantiating a new object is always better, then you have 1 place to initialise the properties (the constructor) and can easily update it.

Imagine you add a new property to the class, you would rather update the constructor than add a new method that also re-initialises all properties.

Now, there are cases where you might want to re-use an object, one where a property is very expensive to re-initialise and you'd want to keep it. This would be more specialist however, and you'd have special methods to reinitialise all other properties. You'd still want to create a new object sometimes even for this situation.

Approach 1: Use a property in `bar`

Make commonlib a property in bar and declare getters and setters. Share that one instance of commonlib that you declared in main between foo1 and foo2.

abstract class bar {
    protected $commonlib;
    
    public function __get($property) {
        if (property_exists($this, $property)) {
            return $this->$property;
        }
    }

    public function __set($property, $value) {
        if (property_exists($this, $property)) {
            $this->$property = $value;
        }
        return $this;
    }
}


class foo1 extends bar{
    public function someMethod() {
        $this->commonlib->addQueries($fromSomeWhere);
    }
}

class foo2 extends bar{
    public function someMethod() {
        $this->commonlib->addQueries($fromSomeWhereElseAndInADifferentWay);
    }
}

class main {

    public $commonlib = new commonlib();

    public function start(){
        //goal is to share one instance of $this->commonlib between foo1 and foo2 
        //so that they can both add to the properites of $this->commonlib (global
        //between the two)
        $foo1 = new foo1();
        $foo1->commonlib = $commonlib;

        $foo2 = new foo2();
        $foo2->commonlib = $commonlib;

        $foo1->someMethod();
        $foo2->someMethod();

        //now execute all of the queries after foo1 and foo2 add their query
        $this->commonlib->RunQueries();

}

Edit:

Approach 2: Pass common lib as an argument and only put algos in foo1 and foo2

Thus,

class foo1 {
    public function addQueries($commonlib) {
        $commonlib->addQueries($fromSomeWhere);
    }
}

class foo2 {
    public function addQueries($commonlib) {
        $commonlib->addQueries($fromSomeWhereElseAndInADifferentWay);
    }
}

class main {

    public $commonlib = new commonlib();

    public function start(){
        //goal is to share one instance of $this->commonlib between foo1 and foo2 
        //so that they can both add to the properites of $this->commonlib (global
        //between the two)
        $foo1 = new foo1();
        $foo2 = new foo2();

        $foo1->someMethod($commonlib);
        $foo2->someMethod($commonlib);

        //now execute all of the queries after foo1 and foo2 add their query
        $this->commonlib->RunQueries();

}

Should Timeout Be a Public Static Property or a Parameter in C#

Is it reasonable to assume users won't be micromanaging timeouts for individual requests like that?

Well it really depends on the services being provided. Some operations might be very slow and he client might be able to anticipate that (for example, requesting all transactions on some account for the last 5 years) and the user is willing to wait. Other operations might not be so slow, or the user might prefer to fail/abort/skip them if they are too slow. I would think it's better to give them the option: maybe set a "global" default when they first create the client object, and allow them to override with an optional parameter, as in your example.

Best Answer

Related Solutions

PHP Object-Oriented Programming – Sharing Objects Between Classes

Approach 1: Use a property in bar

Approach 2: Pass common lib as an argument and only put algos in foo1 and foo2

Should Timeout Be a Public Static Property or a Parameter in C#

Related Topic

Approach 1: Use a property in `bar`