Are options types good candidates for structs?

Question

Please consider the following immutable type:

public class/struct AServiceOptions {

    public AServiceOptions (Uri baseAddress, int workersCount, TimeSpan maxIdleTime) {
        BaseAddress = baseAddress;
        WorkersCount = workersCount;
        MaxIdleTime = maxIdleTime;
    }

    public Uri BaseAddress { get; }
    public int WorkersCount { get; }
    public TimeSpan MaxIdleTime { get; }
}

Used in the following manner:

public class AService {

    public AService (AServiceOptions options) {
        Options = options;
        Initialize();
    }

    AServiceOptions Options { get; }

    private void Initialize () {
        InitHttpClient(Options.BaseAddress);
        InitWorkers(Options.WorkersCount);
        InitTimer(Options.MaxIdleTime);
    }

    // Service implementation details
}

Is the AServiceOptions type a good candidate for a Struct? Why / Why not?

score 1 · Answer 1 · edited May 23 '17 at 12:14

1

No, because this kind of type instances are suitable for being shared during a call stack, and you know that structs are values so you're not sharing the same object when passing it as argument on methods but you're creating copies, unless you use the ref keyword.

In summary, it should be a class.

See this other Q&A to get further details about when to use structs: When to use struct?

edited May 23 '17 at 12:14

Community

1
1

answered Sep 09 '16 at 15:24

Matías Fidemraizer

63,804
18
124
206

score 1 · Answer 2 · answered Sep 09 '16 at 15:31

This is not a good candidate for a struct, because all your AService objects would be limited to using the same options implementation, without a possibility to inherit for subclass-specific options.

This is not possible with a struct:

public struct AServiceOptions {
}
public struct ADerivedServiceOptions : AServiceOptions { // Not possible
}
public class AService {
    public AService(AServiceOptions opt) ...
}
public class ADerivedService {
    public ADerivedService (ADerivedServiceOptions opt) ...
}

In addition, struct does not "buy" you anything: an immutable class would be just as good, and it would also avoid boxing/unboxing if you need to pass options as an object.

score 0 · Answer 3 · answered Sep 09 '16 at 15:25

I've designed and implemented an option system. I think the best way to approach this problem is to have a base class 'Option'. My argument on why it should be a class is because the options of most applications tend to grow with time. ( if you are extending the modules, writing new code etc..)

Are options types good candidates for structs?

3 Answers3