डेल्फी

Question

में जेनेरिक से वेरिएंट में मैं कैसे परिवर्तित कर सकता हूं मेरे पास एक डेल्फी जेनेरिक क्लास है जो सामान्य प्रकार के तर्क के साथ एक फ़ंक्शन का खुलासा करती है। इस फ़ंक्शन के अंदर, मुझे सामान्य प्रकार का उदाहरण किसी अन्य ऑब्जेक्ट पर एक वेरिएंट प्रकार की अपेक्षा करने की आवश्यकता है। इसके समान:

type 
    IMyInterface = interface 
    DoStuff(Value: Variant); 
    end;  

    TMyClass<T> = class 
    FMyIntf: IMyInterface 
    procedure DoStuff(SomeValue: T); 
    end; 

[...] 

procedure MyClass<T>.DoStuff(SomeValue: T); 
begin 
    FMyIntf.DoStuff((*convert SomeValue to Variant here*)); 
end; 

मैंने Rtti.TValue.From (SomeValue) का उपयोग करने का प्रयास किया .सविरिएंट। यह अभिन्न प्रकार के लिए काम किया, लेकिन बूलियन के लिए उड़ा दिया। मुझे काफी नहीं लगता है, क्योंकि आम तौर पर मैं एक संस्करण में एक बूलियन मान असाइन करने में सक्षम होता हूं ...

क्या यह रूपांतरण करने का कोई बेहतर तरीका है? मुझे केवल सरल अंतर्निर्मित प्रकारों (गणनाओं और अभिलेखों को छोड़कर) के लिए काम करने की आवश्यकता है

Answer 1

मुझे लगता है कि जेनेरिक प्रकार को भिन्न रूप में परिवर्तित करने का कोई सीधा तरीका नहीं है क्योंकि संस्करण सभी संभावित प्रकारों को नहीं रख सकता है। आपको अपना विशिष्ट रूपांतरण दिनचर्या लिखना होगा। उदा .:

interface 
//... 
type 
    TDemo = class 
    public 
    class function GetAsVariant<T>(const AValue: T): Variant; 
    end; 
//... 
implementation 
uses 
    Rtti, 
    TypInfo; 
//... 

{ TDemo} 

class function TDemo.GetAsVariant<T>(const AValue: T): Variant; 
var 
    val: TValue; 
    bRes: Boolean; 
begin 
    val := TValue.From<T>(AValue); 
    case val.Kind of 
    tkInteger: Result := val.AsInteger; 
    tkInt64: Result := val.AsInt64; 
    tkEnumeration: 
    begin 
     if val.TryAsType<Boolean>(bRes) then 
     Result := bRes 
     else 
     Result := val.AsOrdinal; 
    end; 
    tkFloat: Result := val.AsExtended; 
    tkString, tkChar, tkWChar, tkLString, tkWString, tkUString: 
     Result := val.AsString; 
    tkVariant: Result := val.AsVariant 
    else 
    begin 
     raise Exception.Create('Unsupported type'); 
    end; 
    end; 
end; 

क्योंकि TValue.AsVariant प्रकार रूपांतरण आंतरिक रूप से ज्यादातर संभालती है, इस समारोह को सरल बनाया जा सकता है। मैं मामले में enumerations संभाल लेंगे आप उन्हें बाद में की जरूरत सकता है:

class function TDemo.GetAsVariant<T>(const AValue: T): Variant; 
var 
    val: TValue; 
begin 
    val := TValue.From<T>(AValue); 
    case val.Kind of 
    tkEnumeration: 
    begin 
     if val.TypeInfo = TypeInfo(Boolean) then 
     Result := val.AsBoolean 
     else 
     Result := val.AsOrdinal; 
    end 
    else 
    begin 
     Result := val.AsVariant; 
    end; 
    end; 

संभावित उपयोग:

var 
    vValue: Variant; 
begin 
    vValue := TDemo.GetAsVariant<Boolean>(True); 
    Assert(vValue = True); //now vValue is a correct Boolean 

Answer 2

एक और तरीका है (XE10 परीक्षण किया)

Var 
    old : variant; 
    val : TValue; 
Begin 
    val := TValue.FromVariant(old); 
End;