Shouldn't the result of the c# typeof() operator be considered "const"?

[SetTrend]

Currently, it's not possible to use a typeof(T) expression for switch statements and expressions because the result of the typeof operator is not considered a constant value.

Are there any cases where typeof(T) isn't a constant value? And if not, shouldn't the result be considered a const?

On the other hand, if cases exist where the result of typeof(T) cannot be determined at compile time, still if the result is clearly a constant value, like, e.g., typeof(XDocument), shouldn't these cases then be considered constant values, and so be made available for switch cases?

---

Example

using System.Xml.Linq;

void f(Type t)
{
  switch (t)
  {
    case typeof(XText):
      break;

    case typeof(XComment):
      break;
  }
}

[RikkiGibson]

dotnet/csharplang#356 proposes to allow switching on a System.Type.

[SetTrend]

Yes, I could split the switch statement into separate switch expressions.

Yet, sometimes it would be nicer (and perhaps cleaner?) to execute a block of code at a single place of truth, i.e. a single case block.

[SetTrend]

This is like what I had before replacing the switch statement with two switch expressions:

switch (type.Name)
{
  case nameof(XText):
  case nameof(XCData):
    text = ((XText)node).Value;
    break;

  case nameof(XComment):
    text = ((XComment)node).Value;
    break;

  case nameof(XDocumentType):
  {
    XDocumentType docType = (XDocumentType)node;

    text = docType.Name;
    toolTip = $"{nameof(XDocumentType.PublicId)} = \"{docType.PublicId}\", {nameof(XDocumentType.SystemId)} = \"{docType.SystemId}\", {nameof(XDocumentType.InternalSubset)} = \"{docType.InternalSubset}\", ";

    break;
  }

  case nameof(XProcessingInstruction):
  {
    XProcessingInstruction pi = (XProcessingInstruction)node;

    text = pi.Target;
    toolTip = pi.Data;

    break;
  }
}