Question

I have a class called DataStructures where I have a set of public static data structures that store objects. To add an object to a data structures is an involved process requiring a number of checks to be carried out, processes to be remembered and data to be rearranged. In another class called Foo, I need to add objects to the data structures.
I was thinking I can do this by making a method called ObjectFeed which would take an object and the object’s label as parameters. The label would tell the method which of the data structures the object should be added to. I would also have a method called addObject which would take the object to append and the appropriate target data structure as parameters:

Public Class DataStructures
{
    public static List<obj> object1Storage = new List<obj>();
    public static List<obj> object2Storage = new List<obj>();
    ...
}

Public Class Foo
{
    public void ObjectFeed(/* PARAMETERS */)
    {
      //Code that generates an object called inspectionObject
      //inspection object has an associated enum Type
        if(objectType == Type.Type1)
        {
             addObject(inspectionObject, DataStructures.object1Storage);
        }
        if(objectType == Type.Type2)
        {
             addObject(inspectionObject, DataStructures.object2Storage);
        }
        ...
    }

    private void addObject(obj inspectionObject, List<obj> objStorage)
    {
        objStorage.Add(inspectionObject);
        //And a lot more code
    }
}

Passing a public data structure as a parameter to a method that can just as well access that data structure directly doesn’t feel correct. Is there a more clever and less intuitive way of doing this?

Edit:

In the example I originally contrived, the ObjectFeed method served no apparent purpose. I rewrote the method to look more like a method from the real world.

Answer 1

As pointed out in other answers:

1. The public static Lists are bad practice
2. Since the addObject method is the same for every data structure, it should be implemented as a data structure accessor.

To this end, I moved the instantiation of the data structures into Foo and moved the addObject method from Foo to a new class called StorageLibrary that more accurately represents the data structure architecture.

private class StorageLibrary 
{
    private List<obj> storedObjects = new List<obj>();
    public void addObject(obj inspectionObject)
    {
        storedObjects.Add(inspectionObject);
        //And a lot more code
    }
}

public class Foo : StorageLibrary
{
    //Declaration of libraries
    public static StorageLibrary storage1 = new StorageLibrary();
    public static StorageLibrary storage2 = new StorageLibrary();
    ...

    private void ObjectFeed(/* PARAMATERS */)
    {
        //generate objects

        if (objectType == Type.Type1)
        {
            storage1.addObject(inspectionObject);
        }
        if (objectType == Type.Type2)
        {
            storage2.addObject(inspectionObject);
        }
        ...
    }
}