Instantiate any one of several derived classes (depending on an argument) within a static method of the abstract base class

Question

I have been trying to find an elegant way to avoid repeating code in all of my derived classes. At this point, I am unsure as to the best way to proceed.

I'd like to write a single method in the base class that will instantiate and use any of its derived classes without having to edit the method when I write new derived classes.

I have tried learning/using a generic method but started to think I might be heading down a dead end for this application. I understand that using reflection can be expensive, and since this method is meant to handle hundreds or even thousands of Elements, it seemed like a bad idea.

Now I'm thinking of trying to pass in the class itself as an argument somehow... maybe. That doesn't seem quite right to me either.

I'm willing to do the research, but would love any help pointing me in the right direction.

Here is an abridged version of what I have...

Base Class:

public abstract class Element
{
    public string ElementName { get; }
    public List<string> BadParameters { get; set; } = new List<string>();

    //Constructor
    public Element(string name)
    {
        ElementName = name;
    }

    //The method in question---
    public static List<string> GetBadParameters(//derived class to instantiate)
    {
        var elem = new //derived class();
        return elem.BadParameters;
    }

}

Derived Class 1:

public class Wall : Element
{
    public double Length { get; set; }
    public bool LoadBearing { get; set; }

    //Constructor
    public Wall(string name): base(name)
    {
        SetBadParameters();
    }

    public void SetBadParameters()
    {
        BadParameters = //A wall specific way of setting bad parameters
    }
}

Derived Class 2:

public class Floor : Element
{
    public double Area { get; set; }
    public double Slope { get; set; }

    //Constructor
    public Floor(string name): base(name)
    {
        SetBadParameters();
    }

    public void SetBadParameters()
    {
        BadParameters = //A floor specific way of setting bad parameters
    }
}

Implementation:

public class Implementation
{
    public List<string> GetAllBadElementParameters()
    {
        List<string> output = new List<string>;

        List<string> badWalls = GetBadParameters(//Wall class)
        List<string> badFloors = GetBadParameters(//Floor class)

        output = output.AddRange(badWalls).AddRange(badFloors);
        return output;
    }
}

EDIT - To clarify:

The actual content of

public List<string> BadParameters

does not matter. Bad parameters, how and why they are bad, are inconsequential.

What I'm trying to accomplish is avoid having the method "GetBadParameters()" defined in the derived class, since this method will be the exact same for all derived classes.

It is only the populating of the "BadParameter" base class property that changes from one derived class to another.

EDIT 2 - My attempt at a generic method in the base class:

I know this won't work, but it may convey what I'd like to have happen.

    public static List<string> GetAllBadParameters<T>(List<string> names) where T : ANY DERIVED CLASS, new()
    {
        List<string> output = new List<string>();

        foreach (string name in names)
        {
            var elem = new T(name);
            foreach (string badParameter in elem.BadParameters)
            { 
                output.Add(badParameter); 
            }
        }

        return output;
    }

Answer 1

Well … First of all, I am guessing that by "bad parameter" you mean the name of a property in an Element-derived class. For example I'm guessing that if the Length of a Wall is negative then "Length" would be a bad parameter of that particular Wall. Secondly I'm guessing that you are going to have a largish number of elements, e.g. a number of walls and floors (and other things) in a diagram or whatever.

Assuming that, then one way to do this would be to have an abstract method in the Element class that returns the bad parameters, and implement it in each derived class. Something like this:

public abstract class Element  
{
    public string Name { get; private set; }
    public abstract IList<string> GetBadParameters();
    public Element( string name) { this.Name = name; }
}

public class Wall 
{
    public Wall( string name): base(name) {}
    public double Length { get; set; }
    public bool IsLoadBearing { get; set; }

    public IList<string> GetBadParameters() {
         List<string> bad = new List<string>();
         if (this.Length <= 0) { bad.Add( this.Name + ": " + nameof( this.Length); }
         if (this.IsLoadBearing && this.Length > whatever) { bad.Add( this.Name + ": " + nameof( this.IsLoadBearing); }
         return bad;
    }
}

Then if you had a list of all the elements you could get all the bad parameters by

IList<string> allBadParemeters = elements.SelectMany( e => e.GetBadParameters() ); 

What I would say though is that this might not be such a great design. You would end up with a system in which a lot of elements contain bad parameters. Life could be a lot easier if you just prevent bad parameters from happening in the first place. You can do this by making the 'set' methods of all the parameter properties private and adding a method such as bool Wall.TrySetParameters( double length, bool isLoadBearing). If the parameters are bad then this would just return false and not assign the parameters to the wall. If you want to have TrySetParameters in the base class then you could do it with a more general signature such as

 public struct Parameter { 
     public Parameter( string name, object value) { … } 
     public string Name { get; private set; }
     public object Value { get; private set; }
 }

 abstract public class Element { 
    …
    abstract public bool TrySetParameters( params Parameter[] parameters); 
 }

Answer 2

I am assuming your BadParameter list content is same for all derived Classes. If this list is not common then there is no point in filling these list in Base Class. By that assumption I can suggest you following changes .

Your base class looks like this . There is no need of making GetBadParameters() as static

public abstract class Element
    {
        public string ElementName { get; }
        public List<string> BadParameters { get; set; } = new List<string>();

        //Constructor
        public Element(string name)
        {
            ElementName = name;
        }

        /// <summary>
        /// Tjis Method is common for alal derived classes. Assuming content is same for all dervied class
        /// </summary>
        /// <returns></returns>
        //The method in question---
        public List<string> GetBadParameters()
        {
            return new List<string>() { "1", "2" };
        }

    }

Your first derived class Wall, where it will call GetBadParameters from base .

 public class Wall : Element
    {
        public double Length { get; set; }
        public bool LoadBearing { get; set; }

        //Constructor
        public Wall(string name) : base(name)
        {
            SetBadParameters();
        }

        public void SetBadParameters()
        {
            BadParameters = GetBadParameters();//Calling base GetBadParameters
        }
    }

Same goes with second derived class "Floor"

 public class Floor : Element
    {
        public double Area { get; set; }
        public double Slope { get; set; }

        //Constructor
        public Floor(string name) : base(name)
        {
            SetBadParameters();
        }

        public void SetBadParameters()
        {
            BadParameters = GetBadParameters();//Calling base GetBadParameters
        }
    }

In your implementation class, you can create both wall and floor objects by keeping Element class as reference and call respective GetBadParameters

public class Implementation
    {
        public List<string> GetAllBadElements()
        {
            List<string> output = new List<string>;

            Element _wall = new Wall("wall");
            Element _floor = new Floor("floor");
            List<string> badWalls = _wall.GetBadParameters(); //Returns Wall bad Parameters
            List<string> badFloors = _floor.GetBadParameters(); //Returns Floor bad Parameters

            output = output.AddRange(badWalls).AddRange(badFloors);
            return output;
        }
    }