如何在输入参数中传递加号？(How do I pass a plus sign in input parameter?)

 你正在与编译器作斗争; 你应该继续使用重载。 
 
 “我宁愿从普通类型'容器'中检测出类型。” 
 
 您的选择是变体或无类型指针。 您将不得不解压缩“Value”参数。 使用无类型指针，您将不得不完成所有工作; 使用变体，您将不得不完成大部分工作。 很乱。 
 
 “它们几乎完全相同的重复代码，除了微小的变化，取决于Value是Variant还是TObject。” 
 
 如果确实如此，那么你仍然应该继续使用重载，但是添加一个内部的“SetProp”方法，该方法采用“规范化”的数据来完成实际的工作。 您的“重复”代码是属性值的设置。 但是，您仍然需要编写特定的代码来破解传入的“Value”参数，无论您有一个接受“容器”类型的方法，还是多个重载方法，这些方法采用您想要接受的各种类型。 在one-method-container类型中，您将拥有一个（复杂的）if-then-else块，它会破坏Value。 在重载方法类型中没有if-testing; 你只需破解每个方法接受的类型的值。 主要优点是您的对象更好地记录：您可以看到“值”可接受的类型，更好的是，编译器可以帮助您，因为它“知道”可接受的类型。 使用单方法方法，编译器将无法帮助您强制执行“值”类型; 你正在做所有的工作。 
 
 此外，使用重载方法，我不会有一个接受变量（虽然下面的例子）。 对每个字符串，整数，双精度等都有一个单独的重载。 
 
type
   TNormalizedPropValue = record
   // ....
   end;


procedure TProps.internalSetProp(Value : TNormalizedPropValue);

begin
//
// Set the property value from the "Normalized" pieces and parts.
//
end;

procedure TProps.SetProp(Value : TObject);

var  
   NormalizedObjectPropValue : TNormalizedPropValue;

begin
   // Copy the pieces and parts from "Value" into NormalizedObjectPropValue
   //

   internalSetProp(NormalizedObjectPropValue);
end;

procedure TProps.SetProp(Value : variant);

var  
   NormalizedVariantPropValue : TNormalizedPropValue;

begin
   // Crack "Value" variant and copy the pieces and parts into NormalizedVariantPropValue
   //

   internalSetProp(NormalizedVariantPropValue);
end;

You are fighting the compiler; You should continue to use overloads.
 
"I would rather detect the type from a common type 'container'."
 
Your choices are variant or untyped pointer. You are going to have to unpack the "Value" parameter. With an untyped pointer you will have to do all the work; with a variant you will have to do most of the work. Very messy.
 
"They do pretty much the same repeating code except from minor variations depending on whether the Value is Variant or TObject."
 
If that is really true then you should still continue to use overloads but add an internal "SetProp" method that takes "normalized" data that does the actual work. Your "repeating" code is the setting of the property values. But you still have specific code to write to crack the incoming "Value" parameter whether you have one method that accepts a "container" type or multiple overloaded methods that take the various types you want to accept. In the one-method-container type you will have a (complex) if-then-else block that cracks the Value. In the overloaded-methods type there is no if-testing; you just crack the Value for the type that each method accepts. The major advantage is that your object is better documented: you can see what types are acceptable for "Value" and, better still, the compiler helps you because it "knows" what types are acceptable. With your one-method approach the compiler will not be able to help you enforce the type of "Value"; you are doing all the work.
 
Also, using the overloaded methods, I wouldn't have one that accepts variant (although the example below does). Have an separate overload for each of string, integer, double, etc.
 
type
   TNormalizedPropValue = record
   // ....
   end;


procedure TProps.internalSetProp(Value : TNormalizedPropValue);

begin
//
// Set the property value from the "Normalized" pieces and parts.
//
end;

procedure TProps.SetProp(Value : TObject);

var  
   NormalizedObjectPropValue : TNormalizedPropValue;

begin
   // Copy the pieces and parts from "Value" into NormalizedObjectPropValue
   //

   internalSetProp(NormalizedObjectPropValue);
end;

procedure TProps.SetProp(Value : variant);

var  
   NormalizedVariantPropValue : TNormalizedPropValue;

begin
   // Crack "Value" variant and copy the pieces and parts into NormalizedVariantPropValue
   //

   internalSetProp(NormalizedVariantPropValue);
end;