internal ComInvokeBinder(
CallInfo callInfo,
DynamicMetaObject[] args,
bool[] isByRef,
BindingRestrictions restrictions,
Expression method,
Expression dispatch,
ComMethodDesc methodDesc
) {
Debug.Assert(callInfo != null, "arguments");
Debug.Assert(args != null, "args");
Debug.Assert(isByRef != null, "isByRef");
Debug.Assert(method != null, "method");
Debug.Assert(dispatch != null, "dispatch");
Debug.Assert(TypeUtils.AreReferenceAssignable(typeof(ComMethodDesc), method.Type), "method");
Debug.Assert(TypeUtils.AreReferenceAssignable(typeof(IDispatch), dispatch.Type), "dispatch");
_method = method;
_dispatch = dispatch;
_methodDesc = methodDesc;
_callInfo = callInfo;
_args = args;
_isByRef = isByRef;
_restrictions = restrictions;
// Set Instance to some value so that CallBinderHelper has the right number of parameters to work with
_instance = dispatch;
}
private DynamicMetaObject BindComInvoke(DynamicMetaObject[] args, ComMethodDesc method, IList<ArgumentInfo> arguments) {
return new ComInvokeBinder(
arguments,
args,
IDispatchRestriction(),
Expression.Constant(method),
Expression.Property(
Helpers.Convert(Expression, typeof(IDispatchComObject)),
typeof(IDispatchComObject).GetProperty("DispatchObject")
),
method
).Invoke();
}
private DynamicMetaObject BindComInvoke(DynamicMetaObject[] args, ComMethodDesc method, CallInfo callInfo, bool[] isByRef) {
return new ComInvokeBinder(
callInfo,
args,
isByRef,
IDispatchRestriction(),
Expression.Constant(method),
Expression.Property(
Helpers.Convert(Expression, typeof(IDispatchComObject)),
typeof(IDispatchComObject).GetProperty("DispatchObject")
),
method
).Invoke();
}
private DynamicMetaObject BindComInvoke(ComMethodDesc method, DynamicMetaObject[] indexes, IList<ArgumentInfo> argInfos) {
var callable = Expression;
var dispCall = Helpers.Convert(callable, typeof(DispCallable));
return new ComInvokeBinder(
argInfos,
indexes,
DispCallableRestrictions(),
Expression.Constant(method),
Expression.Property(
dispCall,
typeof(DispCallable).GetProperty("DispatchObject")
),
method
).Invoke();
}
private DynamicMetaObject BindComInvoke(ComMethodDesc method, DynamicMetaObject[] indexes, CallInfo callInfo, bool[] isByRef) {
var callable = Expression;
var dispCall = Helpers.Convert(callable, typeof(DispCallable));
return new ComInvokeBinder(
callInfo,
indexes,
isByRef,
DispCallableRestrictions(),
Expression.Constant(method),
Expression.Property(
dispCall,
typeof(DispCallable).GetProperty("DispatchObject")
),
method
).Invoke();
}
internal ComInvokeBinder(IList<ArgumentInfo> arguments, DynamicMetaObject[] args, BindingRestrictions restrictions, Expression method, Expression dispatch, ComMethodDesc methodDesc) {
ContractUtils.RequiresNotNull(arguments, "arguments");
ContractUtils.RequiresNotNull(args, "args");
ContractUtils.RequiresNotNull(method, "method");
ContractUtils.RequiresNotNull(dispatch, "dispatch");
ContractUtils.Requires(TypeUtils.AreReferenceAssignable(typeof(ComMethodDesc), method.Type), "method");
ContractUtils.Requires(TypeUtils.AreReferenceAssignable(typeof(IDispatch), dispatch.Type), "dispatch");
_method = method;
_dispatch = dispatch;
_methodDesc = methodDesc;
_arguments = arguments;
_args = args;
_restrictions = restrictions;
// Set Instance to some value so that CallBinderHelper has the right number of parameters to work with
_instance = dispatch;
}
private DynamicMetaObject BindGetMember(ComMethodDesc method, bool canReturnCallables) {
if (method.IsDataMember) {
if (method.ParamCount == 0) {
return BindComInvoke(DynamicMetaObject.EmptyMetaObjects, method, new CallInfo(0) , new bool[]{});
}
}
// ComGetMemberBinder does not expect callables. Try to call always.
if (!canReturnCallables) {
return BindComInvoke(DynamicMetaObject.EmptyMetaObjects, method, new CallInfo(0), new bool[0]);
}
return new DynamicMetaObject(
Expression.Call(
typeof(ComRuntimeHelpers).GetMethod("CreateDispCallable"),
Helpers.Convert(Expression, typeof(IDispatchComObject)),
Expression.Constant(method)
),
IDispatchRestriction()
);
}
internal bool TryGetPropertySetter(string name, out ComMethodDesc method, Type limitType, bool holdsNull) {
EnsureScanDefinedMethods();
if (ComBinderHelpers.PreferPut(limitType, holdsNull)) {
return _comTypeDesc.TryGetPut(name, out method) ||
_comTypeDesc.TryGetPutRef(name, out method);
} else {
return _comTypeDesc.TryGetPutRef(name, out method) ||
_comTypeDesc.TryGetPut(name, out method);
}
}
private DynamicMetaObject BindGetMember(ComMethodDesc method) {
if (method.IsDataMember) {
if (method.ParamCount == 0) {
return BindComInvoke(DynamicMetaObject.EmptyMetaObjects, method, new ArgumentInfo[0]);
}
}
return new DynamicMetaObject(
Expression.Call(
typeof(ComRuntimeHelpers).GetMethod("CreateDispCallable"),
Helpers.Convert(Expression, typeof(IDispatchComObject)),
Expression.Constant(method)
),
IDispatchRestriction()
);
}
internal void EnsureSetItem(ComMethodDesc candidate) {
Interlocked.CompareExchange(ref _setItem, candidate, null);
}
internal bool TryGetMemberMethodExplicit(string name, out ComMethodDesc method) {
EnsureScanDefinedMethods();
int dispId;
int hresult = GetIDsOfNames(_dispatchObject, name, out dispId);
if (hresult == ComHresults.S_OK) {
ComMethodDesc cmd = new ComMethodDesc(name, dispId, ComTypes.INVOKEKIND.INVOKE_FUNC);
_comTypeDesc.AddFunc(name, cmd);
method = cmd;
return true;
} else if (hresult == ComHresults.DISP_E_UNKNOWNNAME) {
method = null;
return false;
} else {
throw Error.CouldNotGetDispId(name, string.Format(CultureInfo.InvariantCulture, "0x{1:X})", hresult));
}
}
internal bool TryGetMemberMethod(string name, out ComMethodDesc method) {
EnsureScanDefinedMethods();
return _comTypeDesc.TryGetFunc(name, out method);
}
private bool SlowTryGetSetItem(out ComMethodDesc value) {
EnsureScanDefinedMethods();
ComMethodDesc methodDesc = _comTypeDesc.SetItem;
// Without type information, we really don't know whether or not we have a property setter.
if (methodDesc == null) {
string name = "[PROPERTYPUT, DISPID(0)]";
_comTypeDesc.EnsureSetItem(new ComMethodDesc(name, ComDispIds.DISPID_VALUE, ComTypes.INVOKEKIND.INVOKE_PROPERTYPUT));
methodDesc = _comTypeDesc.SetItem;
}
value = methodDesc;
return true;
}
internal bool TryGetSetItem(out ComMethodDesc value) {
ComMethodDesc methodDesc = _comTypeDesc.SetItem;
if (methodDesc != null) {
value = methodDesc;
return true;
}
return SlowTryGetSetItem(out value);
}
public static DispCallable CreateDispCallable(IDispatchComObject dispatch, ComMethodDesc method) {
return new DispCallable(dispatch, method.Name, method.DispId);
}
internal void AddPutRef(string name, ComMethodDesc method) {
name = name.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
lock (_putRefs) {
_putRefs[name] = method;
}
}
internal bool TryGetPropertySetterExplicit(string name, out ComMethodDesc method, Type limitType, bool holdsNull) {
EnsureScanDefinedMethods();
int dispId;
int hresult = GetIDsOfNames(_dispatchObject, name, out dispId);
if (hresult == ComHresults.S_OK) {
// we do not know whether we have put or putref here
// and we will not guess and pretend we found both.
ComMethodDesc put = new ComMethodDesc(name, dispId, ComTypes.INVOKEKIND.INVOKE_PROPERTYPUT);
_comTypeDesc.AddPut(name, put);
ComMethodDesc putref = new ComMethodDesc(name, dispId, ComTypes.INVOKEKIND.INVOKE_PROPERTYPUTREF);
_comTypeDesc.AddPutRef(name, putref);
if (ComBinderHelpers.PreferPut(limitType, holdsNull)) {
method = put;
} else {
method = putref;
}
return true;
} else if (hresult == ComHresults.DISP_E_UNKNOWNNAME) {
method = null;
return false;
} else {
throw Error.CouldNotGetDispId(name, string.Format(CultureInfo.InvariantCulture, "0x{1:X})", hresult));
}
}
internal bool TryGetFunc(string name, out ComMethodDesc method) {
name = name.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
if (_funcs.ContainsKey(name)) {
method = _funcs[name] as ComMethodDesc;
return true;
}
method = null;
return false;
}
private void EnsureScanDefinedMethods() {
if (_comTypeDesc != null && _comTypeDesc.Funcs != null) {
return;
}
ComTypes.ITypeInfo typeInfo = ComRuntimeHelpers.GetITypeInfoFromIDispatch(_dispatchObject, true);
if (typeInfo == null) {
_comTypeDesc = ComTypeDesc.CreateEmptyTypeDesc();
return;
}
ComTypes.TYPEATTR typeAttr = ComRuntimeHelpers.GetTypeAttrForTypeInfo(typeInfo);
if (_comTypeDesc == null) {
lock (_CacheComTypeDesc) {
if (_CacheComTypeDesc.TryGetValue(typeAttr.guid, out _comTypeDesc) == true &&
_comTypeDesc.Funcs != null) {
return;
}
}
}
ComTypeDesc typeDesc = ComTypeDesc.FromITypeInfo(typeInfo, typeAttr);
ComMethodDesc getItem = null;
ComMethodDesc setItem = null;
Hashtable funcs = new Hashtable(typeAttr.cFuncs);
Hashtable puts = new Hashtable();
Hashtable putrefs = new Hashtable();
for (int definedFuncIndex = 0; definedFuncIndex < typeAttr.cFuncs; definedFuncIndex++) {
IntPtr funcDescHandleToRelease = IntPtr.Zero;
try {
ComTypes.FUNCDESC funcDesc;
GetFuncDescForDescIndex(typeInfo, definedFuncIndex, out funcDesc, out funcDescHandleToRelease);
if ((funcDesc.wFuncFlags & (int)ComTypes.FUNCFLAGS.FUNCFLAG_FRESTRICTED) != 0) {
// This function is not meant for the script user to use.
continue;
}
ComMethodDesc method = new ComMethodDesc(typeInfo, funcDesc);
string name = method.Name.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
if ((funcDesc.invkind & ComTypes.INVOKEKIND.INVOKE_PROPERTYPUT) != 0) {
puts.Add(name, method);
// for the special dispId == 0, we need to store
// the method descriptor for the Do(SetItem) binder.
if (method.DispId == ComDispIds.DISPID_VALUE && setItem == null) {
setItem = method;
}
continue;
}
if ((funcDesc.invkind & ComTypes.INVOKEKIND.INVOKE_PROPERTYPUTREF) != 0) {
putrefs.Add(name, method);
// for the special dispId == 0, we need to store
// the method descriptor for the Do(SetItem) binder.
if (method.DispId == ComDispIds.DISPID_VALUE && setItem == null) {
setItem = method;
}
continue;
}
if (funcDesc.memid == ComDispIds.DISPID_NEWENUM) {
funcs.Add("GETENUMERATOR", method);
continue;
}
funcs.Add(name, method);
// for the special dispId == 0, we need to store the method descriptor
// for the Do(GetItem) binder.
if (funcDesc.memid == ComDispIds.DISPID_VALUE) {
getItem = method;
}
} finally {
if (funcDescHandleToRelease != IntPtr.Zero) {
typeInfo.ReleaseFuncDesc(funcDescHandleToRelease);
}
}
}
lock (_CacheComTypeDesc) {
ComTypeDesc cachedTypeDesc;
if (_CacheComTypeDesc.TryGetValue(typeAttr.guid, out cachedTypeDesc)) {
_comTypeDesc = cachedTypeDesc;
} else {
_comTypeDesc = typeDesc;
_CacheComTypeDesc.Add(typeAttr.guid, _comTypeDesc);
}
_comTypeDesc.Funcs = funcs;
_comTypeDesc.Puts = puts;
_comTypeDesc.PutRefs = putrefs;
_comTypeDesc.EnsureGetItem(getItem);
_comTypeDesc.EnsureSetItem(setItem);
}
}
