Home/ Questions/Q 8586899
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-11T22:25:47+00:00

I’m building a HTTP-API wrapper for .NET, which has a bunch of methods to

  • 0

I’m building a HTTP-API wrapper for .NET, which has a bunch of methods to set data in an object, and then it serializes the data and sends it to my server. There are 6 datatypes allowed:

  • string
  • int
  • long
  • float
  • double
  • DateTime

My data attributes use generics:

SetAttribute<T>(string key, T value)

So there is only one generic method to set data. Since I cannot constrain the data types to the 6 mentioned, I use run-time checks and throw an exception when the wrong data type is used.

Now for my problem: I have two versions of SetAttribute, one that takes a single value (of type T) and one that takes multiple values (of type IEnumerable<T>). The problem is that when a programmer uses this wrapper and does not specify the type parameter, the runtime guesses which method to use, for instance:

SetAttribute("testkey","thing,anotherthing,athirdthing".Split(','))

This defaults to the single value method and T is String[] which of course makes my method cast an exception because String[] is not a valid type. If you specify:

SetAttribute<string>("testkey","thing,anotherThing,aThirdThing".Split(','))

The runtime chooses the correct method (multi-value) and no exception is cast because T is then string.

My question: how can I label my methods so that the type parameter is mandatory and must be explicitly defined? Or do I have to detect this at runtime and redirect to the multi-method myself?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Ok, this was originally a comment above since it doesn’t necessarily answer your original question but suggests an alternate approach;

    I would say using a public generic SetAttribute in this case isn’t necessarily a good idea.

    Since the types are so constrained, you should probably just write the overloads and move the errors from runtime to compile time. It would also allow you to take IEnumerable<string> etc. with another 6 overloads and eliminate the problem you’re having entirely.

    You can always implement SetAttribute with a private generic and just call that from each overload, that will remove some duplication.

    It will also more or less eliminate the need for runtime checks, since the types are already constrained by the compiler.

    • 0