public override bool TryConvert(ConvertBinder binder, out object result)
{
// string へのキャストで、要素の値を取得。
if (binder.Type == typeof(string))
{
result = element.Value;
return true;
}
// int へのキャストで int.Parse。
// Parse できないときは例外丸投げ。
if (binder.Type == typeof(int))
{
result = int.Parse(element.Value);
return true;
}
// 要素単体に対して foreach やっちゃったときでもエラーにならないように、IEnumerable へのキャストを定義。
// これやっとかないと、元々複数要素あったのに XML を修正して要素が1個だけになった時に挙動おかしくなる。
if (binder.Type == typeof(System.Collections.IEnumerable))
{
result = new[] { this };
return true;
}
result = null;
return false;
}
protected static bool TryConvert( ConvertBinder binder, DynamicMetaObject instance, out DynamicMetaObject result )
{
if ( instance.HasValue &&
instance.RuntimeType.IsValueType )
{
result = instance.BindConvert( binder );
return true;
}
if ( binder.Type.IsInterface )
{
Expression expression = Convert( instance.Expression, binder.Type );
result = new DynamicMetaObject( expression, BindingRestrictions.Empty, instance.Value );
result = result.BindConvert( binder );
return true;
}
if ( typeof (IDynamicMetaObjectProvider).IsAssignableFrom( instance.RuntimeType ) )
{
result = instance.BindConvert( binder );
return true;
}
result = null;
return false;
}
internal DelegateInfo(LanguageContext context, Type returnType, ParameterInfo[] parameters) {
Assert.NotNull(returnType);
Assert.NotNullItems(parameters);
_returnType = returnType;
_parameters = parameters;
PerfTrack.NoteEvent(PerfTrack.Categories.DelegateCreate, ToString());
if (_returnType != typeof(void)) {
_convertBinder = context.CreateConvertBinder(_returnType, true);
}
_invokeBinder = context.CreateInvokeBinder(new CallInfo(_parameters.Length));
Type[] delegateParams = new Type[_parameters.Length];
for (int i = 0; i < _parameters.Length; i++) {
delegateParams[i] = _parameters[i].ParameterType;
}
// Create the method with a special name so the langauge compiler knows that method's stack frame is not visible
DynamicILGen cg = Snippets.Shared.CreateDynamicMethod("_Scripting_", _returnType, ArrayUtils.Insert(typeof(object[]), delegateParams), false);
// Emit the stub
_constants = EmitClrCallStub(cg);
_method = cg.Finish();
}
/// <summary>
/// Implements dynamic cast for JsonValue types.
/// </summary>
/// <param name="binder">An instance of the <see cref="ConvertBinder"/> that represents the details of the dynamic operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public override DynamicMetaObject BindConvert(ConvertBinder binder)
{
if (binder == null)
{
throw new ArgumentNullException("binder");
}
Expression expression = Expression;
bool implicitCastSupported =
binder.Type.IsAssignableFrom(LimitType) ||
binder.Type == typeof(IEnumerable<KeyValuePair<string, JsonValue>>) ||
binder.Type == typeof(IDynamicMetaObjectProvider) ||
binder.Type == typeof(object);
if (!implicitCastSupported)
{
if (JsonValue.IsSupportedExplicitCastType(binder.Type))
{
Expression instance = Expression.Convert(Expression, LimitType);
expression = Expression.Call(_castValueMethodInfo.MakeGenericMethod(binder.Type), new Expression[] { instance });
}
else
{
string exceptionMessage = RS.Format(Properties.Resources.CannotCastJsonValue, LimitType.FullName, binder.Type.FullName);
expression = Expression.Throw(Expression.Constant(new InvalidCastException(exceptionMessage)), typeof(object));
}
}
expression = Expression.Convert(expression, binder.Type);
return new DynamicMetaObject(expression, DefaultRestrictions);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.ReturnType == typeof(bool))
{
result = bool.Parse(_value);
}
else if (binder.ReturnType == typeof(int))
{
result = int.Parse(_value);
}
else if (binder.ReturnType == typeof(float))
{
result = float.Parse(_value);
}
else if (binder.ReturnType == typeof(string))
{
result = _value;
}
else if (binder.ReturnType == typeof(DateTime))
{
result = DateTime.Parse(_value);
}
else
{
throw new Exception("Cannot convert string to type " + binder.ReturnType);
}
return true;
}
/// <summary>
/// If you don't call a method that invokes content you will need to dispose HttpContent, for Json this is done for you
/// https://aspnetwebstack.codeplex.com/discussions/461495
/// </summary>
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (!_isRoot)
{
throw new InvalidOperationException("Sorry implict cast not supported on child objects yet!");
}
if (binder.Type == typeof(IEnumerable) && _currentObject is JArray)
{
result = Extensions.WrapJToken(_currentObject);
return true;
}
if (binder.Type == typeof(HttpResponseMessage))
{
result = _httpResponseMessage;
return true;
}
if (_isJson)
{
var isValid = ToString().TryParseJson(out result, binder.Type);
return isValid;
}
throw new InvalidOperationException("Can not cast to " + binder.Type.FullName + OutputErrorString());
}
public override DynamicMetaObject BindConvert(ConvertBinder action) {
if (action.Type.IsSubclassOf(typeof(Delegate))) {
return MakeDelegateTarget(action, action.Type, Restrict(typeof(Method)));
}
return base.BindConvert(action);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
var eng = GetEngine();
if (binder.Type == typeof(int))
{
result = eng.Converter.ToInt32(this);
return true;
}
else if (binder.Type == typeof(double))
{
result = eng.Converter.ToDouble(this);
return true;
}
else if (binder.Type == typeof(string))
{
result = eng.Converter.ToString(this);
return true;
}
else if (binder.Type == typeof(bool))
{
result = eng.Converter.ToBoolean(this);
return true;
}
return base.TryConvert(binder, out result);
}
/// <summary>
/// Tries to convert the current instance.
/// </summary>
/// <param name="binder">The binder.</param>
/// <param name="result">The result.</param>
/// <returns></returns>
public override bool TryConvert(System.Dynamic.ConvertBinder binder, out object result)
{
var targetType = binder.Type;
var isExplicit = binder.Explicit;
result = null;
object tempResult;
if (RemoteInvoke(new Invocation(InvocationKind.Convert, (isExplicit ? "op_Explicit" : "op_Implicit"), targetType, isExplicit), out tempResult))
{
if (tempResult.GetType() == targetType)
{ // Not wrapped, so most likely a primitive?
result = tempResult;
}
else
{
if (targetType.IsInterface)
{
result = Impromptu.DynamicActLike(tempResult, targetType);
}
else
{
// We can not present ourself as any class so we just try keep beeing dynamic.
result = tempResult;
}
}
return(true);
}
return(false);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (_converter.HasConverters && _converter.TryConversion(binder.Type, _dataDictionary, out result))
return true;
return base.TryConvert(binder, out result);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.ReturnType.IsValueType)
result = Activator.CreateInstance(binder.ReturnType);
else
result = null;
if (binder.ReturnType.IsValueType || binder.ReturnType == typeof(string))
{
try
{
result = System.Convert.ChangeType(dynamicNodes.Single().ToString(), binder.ReturnType);
}
catch
{
return false;
}
}
else if (binder.ReturnType.IsArray || typeof(System.Array).IsAssignableFrom(binder.ReturnType))
{
if (binder.ReturnType.GetElementType() == null)
result = dynamicNodes.ToArray();
else
{
var temp = dynamicNodes
.Select(node =>
{
object value = null;
if (binder.ReturnType.IsValueType)
value = Activator.CreateInstance(binder.ReturnType);
else
value = null;
try
{
value = System.Convert.ChangeType(node.ToString(), binder.ReturnType.GetElementType());
}
catch { }
return value;
})
.Where(value => value != null)
.ToArray();
var array = Array.CreateInstance(binder.ReturnType.GetElementType(), temp.Count());
temp.CopyTo(array, 0);
result = array;
}
}
else if (typeof(IEnumerable).IsAssignableFrom(binder.ReturnType))
{
result = this;
}
else
{
return false;
}
return true;
}
public override DynamicMetaObject/*!*/ BindConvert(ConvertBinder/*!*/ binder) {
var protocolConversion = ProtocolConversionAction.TryGetDefaultConversionAction(Context, binder.Type);
if (protocolConversion != null) {
return protocolConversion.Bind(this, DynamicMetaObject.EmptyMetaObjects);
} else {
return binder.FallbackConvert(this);
}
}
public override DynamicMetaObject/*!*/ BindConvert(ConvertBinder/*!*/ action) {
var result = RubyBinder.TryBindCovertToDelegate(action, this);
if (result != null) {
return result;
}
return base.BindConvert(action);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.Type == typeof(bool))
{
}
return base.TryConvert(binder, out result);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
result = binder.Type.IsEnum
? Enum.Parse(binder.Type, node.Value)
: Convert.ChangeType(node.Value, binder.Type, CultureInfo.InvariantCulture);
return true;
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
result = null;
if(binder.Type == typeof(IEnumerable) && IsArrayList)
{
result = ((ArrayList)obj).ToArray().Select(o => new JsonDynamicDocument(o));
}
return true;
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
//--- Debbuger Break --- //
if(System.Diagnostics.Debugger.IsAttached)
System.Diagnostics.Debugger.Break();
//--- Debbuger Break --- //
return base.TryConvert(binder, out result);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.ReturnType == typeof(string))
{
result = _elements[0].Value;
return true;
}
return base.TryConvert(binder, out result);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.Type == typeof(string))
result = m_value.ToString();
else
result = Convert.ChangeType(m_value, binder.Type);
return true;
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.ReturnType == Model.GetType())
{
result = Model;
return true;
}
return base.TryConvert(binder, out result);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
var mapper = typeMap.GetOrDefault(binder.Type);
if (mapper == null)
return base.TryConvert(binder, out result);
result = mapper(element);
return true;
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
Type targetType = binder.Type;
if (targetType == typeof(IEnumerable)) {
result = this;
return true;
}
return base.TryConvert(binder, out result);
}
/// <summary>
/// Provides implementation for type conversion operations. Classes derived from the <see cref="T:System.Dynamic.DynamicObject"/> class can override this method to specify dynamic behavior for operations that convert an object from one type to another.
/// </summary>
/// <param name="binder">Provides information about the conversion operation. The binder.Type property provides the type to which the object must be converted. For example, for the statement (String)sampleObject in C# (CType(sampleObject, Type) in Visual Basic), where sampleObject is an instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject"/> class, binder.Type returns the <see cref="T:System.String"/> type. The binder.Explicit property provides information about the kind of conversion that occurs. It returns true for explicit conversion and false for implicit conversion.</param>
/// <param name="result">The result of the type conversion operation.</param>
/// <returns>
/// true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
/// </returns>
public override bool TryConvert(ConvertBinder binder, out object result)
{
result = null;
if (_wrapped == null || !binder.Type.IsAssignableFrom(_wrapped.GetType()))
return false;
result = _wrapped;
return true;
}
public override bool TryConvert(System.Dynamic.ConvertBinder binder, out object?result)
{
if (!binder.Type.IsAssignableFrom(this.type))
{
return(base.TryConvert(binder, out result)); // let the base call throw the exception
}
result = this._obj;
return(true);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.ReturnType == typeof(string))
{
result = this.textResource[this.memberName, this.context];
return true;
}
throw new InvalidOperationException("Cannot cast dynamic member access to anything else than a string.");
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.Type == typeof(IEditableObject))
{
result = this;
return true;
}
else
return base.TryConvert(binder, out result);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.Type.IsAssignableFrom(this.value.GetType()))
{
result = this.value;
return true;
}
return base.TryConvert(binder, out result);
}
public override bool TryConvert(ConvertBinder binder, out object result) {
result = null;
if (binder.Type.IsAssignableFrom(_values.GetType())) {
result = _values;
}
else {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, HelpersResources.Json_UnableToConvertType, binder.Type));
}
return true;
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
result = null;
if (!binder.Type.IsAssignableFrom(_model.GetType()))
throw new InvalidOperationException(String.Format(@"Unable to convert to ""{0}"".", binder.Type));
result = _model;
return true;
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if(binder.ReturnType != typeof(String[])) {
result = null;
return false;
}
result = _data;
return true;
}
public override DynamicMetaObject BindConvert(ConvertBinder binder)
{
var value = this.HasValue
? (this.Value as ODataEntry).AsDictionary().ToObject(binder.Type)
: null;
return new DynamicMetaObject(
Expression.Constant(value),
BindingRestrictions.GetTypeRestriction(Expression, LimitType));
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (binder.Type == typeof(ClrType))
{
result = m_type;
return true;
}
return base.TryConvert(binder, out result);
}
/// <summary>
/// Forwards the convert operation.
/// </summary>
/// <param name="binder">the binder</param>
/// <param name="result">the result</param>
/// <returns>true when successfull</returns>
public override bool TryConvert(System.Dynamic.ConvertBinder binder, out object result)
{
result = null;
try
{
result = Impromptu.InvokeConvert(CallTarget, binder.Type, binder.Explicit);
return(true);
}
catch (RuntimeBinderException)
{
return(false);
}
}
public override bool TryConvert(System.Dynamic.ConvertBinder binder, out object result)
{
result = null;
if (binder.Type.IsInterface)
{
this._interfaceTypes.Insert(0, binder.Type);
result = Impromptu.DynamicActLike(this.Target, this._interfaceTypes.ToArray());
return(true);
}
if (binder.Type.IsInstanceOfType(this.Target))
{
result = this.Target;
}
return(false);
}
public virtual new System.Dynamic.DynamicMetaObject BindConvert(ConvertBinder binder)
{
Contract.Requires(binder != null);
return(default(System.Dynamic.DynamicMetaObject));
}
// // Summary: // Provides implementation for type conversion operations. Classes derived from // the System.Dynamic.DynamicObject class can override this method to specify dynamic // behavior for operations that convert an object from one type to another. // // Parameters: // binder: // Provides information about the conversion operation. The binder.Type property // provides the type to which the object must be converted. For example, for the // statement (String)sampleObject in C# (CType(sampleObject, Type) in Visual Basic), // where sampleObject is an instance of the class derived from the System.Dynamic.DynamicObject // class, binder.Type returns the System.String type. The binder.Explicit property // provides information about the kind of conversion that occurs. It returns true // for explicit conversion and false for implicit conversion. // // result: // The result of the type conversion operation. // // Returns: // true if the operation is successful; otherwise, false. If this method returns // false, the run-time binder of the language determines the behavior. (In most // cases, a language-specific run-time exception is thrown.) public virtual bool TryConvert(ConvertBinder binder, out object result);
public virtual DynamicMetaObject BindConvert(ConvertBinder binder)
{
throw new NotImplementedException();
}
public virtual bool TryConvert(ConvertBinder binder, out object result)
{
result = null;
return(false);
}
/// <summary>
/// Performs the binding of the dynamic conversion operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="ConvertBinder"/> that represents the details of the dynamic operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindConvert(ConvertBinder binder)
{
ArgumentNullException.ThrowIfNull(binder);
return(binder.FallbackConvert(this));
}
/// <summary>
/// Performs the binding of the dynamic conversion operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="ConvertBinder"/> that represents the details of the dynamic operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindConvert(ConvertBinder binder)
{
ContractUtils.RequiresNotNull(binder, "binder");
return(binder.FallbackConvert(this));
}
public override bool TryConvert(System.Dynamic.ConvertBinder binder, out object result)
{
result = this;
return(true);
}
public virtual bool TryConvert(ConvertBinder binder, ref object result)
{
throw new NotImplementedException();
}
public virtual new bool TryConvert(ConvertBinder binder, out Object result)
{
result = default(Object);
return(default(bool));
}
/// <summary>
/// Provides the implementation of converting the <see cref="DynamicObject" /> to another type.
/// Derived classes can override this method to customize behavior. When not overridden the
/// call site requesting the binder determines the behavior.
/// </summary>
/// <param name="binder">The binder provided by the call site.</param>
/// <param name="result">The result of the conversion.</param>
/// <returns>true if the operation is complete, false if the call site should determine behavior.</returns>
public virtual bool TryConvert(ConvertBinder binder, [NotNullWhen(true)] out object?result)
{
_ = binder;
result = null;
return(false);
}