0

I'm trying to have some toolbox with each tool in that toolbox being something quite different in functionality. So every tool would require its own config to be created and passed at the start, or when you need to change params, while the base class would be just the general outline of what all the tools have in common, but I'm getting an error when trying to access a public member of some config from a generic method. I have something like this:

public abstract class Tool
{
    public abstract void Setup<T>(T setupParams);
}

public class SomeTool : Tool
{
    public class SomeConfig
    {
        public int counter;
        public float size;
        public SomeConfig(int _counter, float _size)
        {
            counter = _counter;
            size = _size;
        }
    }

    int m_counter;
    int m_size;

    public override void Setup<SomeConfig>(SomeConfig setupParams)
    {
        m_counter = setupParams.counter;
        //'SomeConfig' does not contain a definition for 'counter' and no accessible extension
        // method 'counter' accepting a first argument of type 'SomeConfig' could be found
        // (are you missing a using directive or an assembly reference?)
    }
}

Having a constructor, or non generic setup function works, but why am I getting an error with what I am doing here?

Trigger
  • 3
  • 1
  • 2
    In `Setup`, `SomeConfig` is not the `SomeConfig` class you defined. You're missing a type constraint if you want it to work on the `SomeConfig` class or anything derived from it. Is that what you were trying to do? – madreflection May 12 '22 at 21:30
  • 1
    I suggest renaming the type parameter to something starting with a `T`. For example, `TConfig`. – madreflection May 12 '22 at 21:37
  • This sort of thing would work with C++ templates, which are duck-typed. C++ has a complicated system of dependent names which don't get looked up until the specific type is known. C# generics do not use duck-typing. All name lookup is done based only on constraints. – Ben Voigt May 12 '22 at 22:03
  • Ok, I got why, thanks! Back to the drawing board... – Trigger May 13 '22 at 17:00

1 Answers1

3

When you do this:

public abstract void Setup<T>(T setupParams)

You are using <T> to define the type. That type doesn't exists. T isn't a class. You can put any name and compile:

public override void Setup<WhatEver>(WhatEver setupParams)

But WhatEver is a type that you define just there. It doesn't exists.

You can define the class in this form:

public abstract class Tool<T>
{
    public abstract void Setup(T setupParams);
}

public class SomeConfig
{
    public int counter;
    public float size;
    public SomeConfig(int _counter, float _size)
    {
        counter = _counter;
        size = _size;
    }
}

public class SomeTool : Tool<SomeConfig>
{

    int m_counter;
    int m_size;

    public override void Setup(SomeConfig setupParams)
    {
        m_counter = setupParams.counter;
    }
}
Victor
  • 2,313
  • 2
  • 5
  • 13