internal static void SetMember(IDynamicMetaObjectProvider o, string name, object value)
{
CallSite<Action<CallSite, object, object>> site;
if(!setSites.TryGetValue(name, out site)) {
site = CallSite<Action<CallSite, object, object>>.Create(new DoHelpersSetMemberBinder(name));
setSites.Add(name, site);
}
site.Target(site, o, value);
}
internal static void IDOIndexSet(IDynamicMetaObjectProvider Instance, object[] Arguments, string[] ArgumentNames)
{
SaveCopyBack back = new SaveCopyBack(null);
using (back)
{
object[] packedArgs = null;
CallInfo callInfo = null;
IDOUtils.PackArguments(1, ArgumentNames, Arguments, ref packedArgs, ref callInfo);
IDOUtils.CreateFuncCallSiteAndInvoke(new VBIndexSetBinder(callInfo), Instance, packedArgs);
}
}
internal bool TryGetMember(IDynamicMetaObjectProvider dynamicProvider, string name, out object value)
{
ValidationUtils.ArgumentNotNull(dynamicProvider, "dynamicProvider");
var callSite = _callSiteGetters.Get(name);
var result = callSite.Target(callSite, dynamicProvider);
if (!ReferenceEquals(result, NoThrowExpressionVisitor.ErrorResult))
{
value = result;
return true;
}
value = null;
return false;
}
// ExecuteFileInScope executes the file in the given module scope. This
// does NOT store the module scope on Globals. This function returns
// nothing.
//
public void ExecuteFileInScope(string filename,
IDynamicMetaObjectProvider moduleEO) {
var f = new StreamReader(filename);
// Simple way to convey script rundir for RuntimeHelpes.SymplImport
// to load .sympl files.
DynamicObjectHelpers.SetMember(moduleEO, "__file__",
Path.GetFullPath(filename));
try {
var moduleFun = ParseFileToLambda(filename, f);
var d = moduleFun.Compile();
d(this, moduleEO);
} finally {
f.Close();
}
}
public ForwardingMetaObject(
Expression expression,
BindingRestrictions restrictions,
object forwarder,
IDynamicMetaObjectProvider forwardee,
Func<Expression, Expression> forwardeeGetter
)
: base(expression, restrictions, forwarder)
{
// We'll use forwardee's meta-object to bind dynamic operations.
metaForwardee = forwardee.GetMetaObject(
forwardeeGetter(
Expression.Convert(expression, forwarder.GetType()) // [1]
)
);
}
internal static object IDOGet(IDynamicMetaObjectProvider Instance, string MemberName, object[] Arguments, string[] ArgumentNames, bool[] CopyBack)
{
object obj2;
SaveCopyBack back = new SaveCopyBack(CopyBack);
using (back)
{
object[] packedArgs = null;
CallInfo callInfo = null;
IDOUtils.PackArguments(0, ArgumentNames, Arguments, ref packedArgs, ref callInfo);
try
{
return IDOUtils.CreateRefCallSiteAndInvoke(new VBGetBinder(MemberName, callInfo), Instance, packedArgs);
}
finally
{
IDOUtils.CopyBackArguments(callInfo, packedArgs, Arguments);
}
}
return obj2;
}
private static IList <KeyValuePair <string, object> > QueryDynamicObject(object obj)
{
IDynamicMetaObjectProvider ido = obj as IDynamicMetaObjectProvider;
if (ido != null)
{
DynamicMetaObject mo = ido.GetMetaObject(parameter);
List <string> names = new List <string>(mo.GetDynamicMemberNames());
names.Sort();
if (names != null)
{
var result = new List <KeyValuePair <string, object> >();
foreach (string name in names)
{
object value;
if ((value = TryGetMemberValue(obj, name, true)) != null)
{
result.Add(new KeyValuePair <string, object>(name, value));
}
}
return(result);
}
}
#if !SILVERLIGHT
else if (IsComObject(obj))
{
var comExclusionList = new string[] { "MailEnvelope" }; //add any com names to be excluded from dynamic view here
IEnumerable <string> names = System.Dynamic.ComBinder.GetDynamicDataMemberNames(obj);
names = from name in names
where !comExclusionList.Contains(name)
select name;
var sortedNames = new List <string>(names);
sortedNames.Sort();
return(System.Dynamic.ComBinder.GetDynamicDataMembers(obj, sortedNames));
}
#endif
return(new KeyValuePair <string, object> [0]);
}
/// <summary>
/// Creates the action for a dynamic object.
/// </summary>
/// <param name="provider">The dynamic object.</param>
protected virtual void CreateActionForDynamic(IDynamicMetaObjectProvider provider)
{
var type = provider.GetType();
var parameterExpression = Expression.Parameter(typeof(object), "record");
var metaObject = provider.GetMetaObject(parameterExpression);
var propertyNames = metaObject.GetDynamicMemberNames();
var delegates = new List <Delegate>();
foreach (var propertyName in propertyNames)
{
var getMemberBinder = (GetMemberBinder)Microsoft.CSharp.RuntimeBinder.Binder.GetMember(0, propertyName, type, new[] { CSharpArgumentInfo.Create(0, null) });
var getMemberMetaObject = metaObject.BindGetMember(getMemberBinder);
var fieldExpression = Expression.Block(Expression.Label(CallSiteBinder.UpdateLabel), getMemberMetaObject.Expression);
var writeFieldMethodCall = Expression.Call(Expression.Constant(this), "WriteField", new[] { typeof(object) }, fieldExpression);
var lambda = Expression.Lambda(writeFieldMethodCall, parameterExpression);
delegates.Add(lambda.Compile());
}
typeActions[type] = CombineDelegates(delegates);
}
/// <summary>
/// 尝试获取动态对象中指定名称的属性值。
/// </summary>
/// <param name="dynamicProvider">一个动态对象。</param>
/// <param name="name">属性的名称。</param>
/// <param name="value">返回值。</param>
/// <returns></returns>
public bool TryGetMember(IDynamicMetaObjectProvider dynamicProvider, string name, out object value)
{
CallSite <Func <CallSite, object, object> > callSite;
if (!getCallSites.TryGetValue(name, out callSite))
{
callSite = CallSite <Func <CallSite, object, object> > .Create(new NoThrowGetBinderMember((GetMemberBinder)BinderWrapper.GetMember(name)));
}
var result = callSite.Target(callSite, dynamicProvider);
if (!ReferenceEquals(result, ErrorResult))
{
value = result;
return(true);
}
else
{
value = null;
return(false);
}
}
private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract)
{
contract.InvokeOnSerializing(value, Serializer.Context);
SerializeStack.Add(value);
writer.WriteStartObject();
foreach (string memberName in value.GetDynamicMemberNames())
{
object memberValue;
if (DynamicUtils.TryGetMember(value, memberName, out memberValue))
{
writer.WritePropertyName(memberName);
SerializeValue(writer, memberValue, GetContractSafe(memberValue), null, null);
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(value, Serializer.Context);
}
internal bool TryGetMember(
IDynamicMetaObjectProvider dynamicProvider,
string name,
out object?value
)
{
ValidationUtils.ArgumentNotNull(dynamicProvider, nameof(dynamicProvider));
CallSite <Func <CallSite, object, object> > callSite = _callSiteGetters.Get(name);
object result = callSite.Target(callSite, dynamicProvider);
if (!ReferenceEquals(result, NoThrowExpressionVisitor.ErrorResult))
{
value = result;
return(true);
}
else
{
value = null;
return(false);
}
}
public static T AsIf <T>(IDynamicMetaObjectProvider target) where T : class
{
//
// Get the thunk type.
//
var targetType = typeof(T);
string thunkTypeName = "<>__Thunks." + targetType.FullName;
//
// Don't regenerate the thunk type if it already exists for the specified target type.
//
Type thunkType = ModuleBuilder.GetType(thunkTypeName, false, false);
if (thunkType == null)
{
thunkType = BuildThunkType(targetType, thunkTypeName);
}
//
// Create and return the thunk instance.
//
return((T)Activator.CreateInstance(thunkType, target));
}
/// <summary>
/// Writes the header record for the given dynamic object.
/// </summary>
/// <param name="record">The dynamic record to write.</param>
public virtual void WriteDynamicHeader(IDynamicMetaObjectProvider record)
{
CheckDisposed();
if (record == null)
{
throw new ArgumentNullException(nameof(record));
}
if (!configuration.HasHeaderRecord)
{
throw new CsvWriterException("Configuration.HasHeaderRecord is false. This will need to be enabled to write the header.");
}
if (hasHeaderBeenWritten)
{
throw new CsvWriterException("The header record has already been written. You can't write it more than once.");
}
if (hasRecordBeenWritten)
{
throw new CsvWriterException("Records have already been written. You can't write the header after writing records has started.");
}
var provider = (IDynamicMetaObjectProvider)record;
var metaObject = provider.GetMetaObject(Expression.Constant(provider));
var names = metaObject.GetDynamicMemberNames();
foreach (var name in names)
{
WriteField(name);
}
NextRecord();
hasHeaderBeenWritten = true;
}
internal static void IDOSetComplex(IDynamicMetaObjectProvider Instance, string MemberName, object[] Arguments, string[] ArgumentNames, bool OptimisticSet, bool RValueBase)
{
SaveCopyBack back = new SaveCopyBack(null);
using (back)
{
if (Arguments.Length == 1)
{
IDOUtils.CreateFuncCallSiteAndInvoke(new VBSetComplexBinder(MemberName, OptimisticSet, RValueBase), Instance, Arguments);
}
else
{
object instance = IDOUtils.CreateFuncCallSiteAndInvoke(new VBGetMemberBinder(MemberName), Instance, Symbols.NoArguments);
if (instance == missingMemberSentinel)
{
NewLateBinding.ObjectLateSetComplex(Instance, null, MemberName, Arguments, ArgumentNames, Symbols.NoTypeArguments, OptimisticSet, RValueBase);
}
else
{
NewLateBinding.LateIndexSetComplex(instance, Arguments, ArgumentNames, OptimisticSet, RValueBase);
}
}
}
}
/// <summary>
/// Creates a delegate with a given signature that could be used to invoke this object from non-dynamic code (w/o code context).
/// A stub is created that makes appropriate conversions/boxing and calls the object.
/// The stub should be executed within a context of this object's language.
/// </summary>
/// <returns>The converted delegate.</returns>
/// <exception cref="T:Microsoft.Scripting.ArgumentTypeException">The object is either a subclass of Delegate but not the requested type or does not implement IDynamicMetaObjectProvider.</exception>
public Delegate GetDelegate(object callableObject, Type delegateType)
{
ContractUtils.RequiresNotNull(delegateType, "delegateType");
Delegate result = callableObject as Delegate;
if (result != null)
{
if (!delegateType.IsAssignableFrom(result.GetType()))
{
throw ScriptingRuntimeHelpers.SimpleTypeError(String.Format("Cannot cast {0} to {1}.", result.GetType(), delegateType));
}
return(result);
}
IDynamicMetaObjectProvider dynamicObject = callableObject as IDynamicMetaObjectProvider;
if (dynamicObject != null)
{
MethodInfo invoke;
if (!typeof(Delegate).IsAssignableFrom(delegateType) || (invoke = delegateType.GetMethod("Invoke")) == null)
{
throw ScriptingRuntimeHelpers.SimpleTypeError("A specific delegate type is required.");
}
result = GetOrCreateDelegateForDynamicObject(callableObject, delegateType, invoke);
if (result != null)
{
return(result);
}
}
throw ScriptingRuntimeHelpers.SimpleTypeError("Object is not callable.");
}
/// <inheritdoc/>
public virtual void WriteDynamicHeader(IDynamicMetaObjectProvider record)
{
if (record == null)
{
throw new ArgumentNullException(nameof(record));
}
var metaObject = record.GetMetaObject(Expression.Constant(record));
var names = metaObject.GetDynamicMemberNames().ToList();
if (dynamicPropertySort != null)
{
names = names.OrderBy(name => name, dynamicPropertySort).ToList();
}
HeaderRecord = names.ToArray();
foreach (var name in names)
{
WriteField(name);
}
hasHeaderBeenWritten = true;
}
/// <summary>
/// Writes the record to the CSV file.
/// </summary>
/// <typeparam name="T">The type of the record.</typeparam>
/// <param name="record">The record to write.</param>
public virtual void WriteRecord <T>(T record)
{
IDynamicMetaObjectProvider dynamicRecord = record as IDynamicMetaObjectProvider;
//if( record is IDynamicMetaObjectProvider dynamicRecord )
if (dynamicRecord != null)
{
if (context.WriterConfiguration.HasHeaderRecord && !context.HasHeaderBeenWritten)
{
WriteDynamicHeader(dynamicRecord);
NextRecord();
}
}
try
{
recordManager.Write(record);
context.HasHeaderBeenWritten = true;
}
catch (Exception ex)
{
throw ex as CsvHelperException ?? new WriterException(context, "An unexpected error occurred.", ex);
}
}
/// <summary>
/// Creates a meta-object for the specified object.
/// </summary>
/// <param name="value">The object to get a meta-object for.</param>
/// <param name="expression">The expression representing this <see cref="DynamicMetaObject"/> during the dynamic binding process.</param>
/// <returns>
/// If the given object implements <see cref="IDynamicMetaObjectProvider"/> and is not a remote object from outside the current AppDomain,
/// returns the object's specific meta-object returned by <see cref="IDynamicMetaObjectProvider.GetMetaObject"/>. Otherwise a plain new meta-object
/// with no restrictions is created and returned.
/// </returns>
public static DynamicMetaObject Create(object value, Expression expression)
{
ContractUtils.RequiresNotNull(expression, nameof(expression));
IDynamicMetaObjectProvider ido = value as IDynamicMetaObjectProvider;
if (ido != null)
{
var idoMetaObject = ido.GetMetaObject(expression);
if (idoMetaObject == null ||
!idoMetaObject.HasValue ||
idoMetaObject.Value == null ||
(object)idoMetaObject.Expression != (object)expression)
{
throw System.Linq.Expressions.Error.InvalidMetaObjectCreated(ido.GetType());
}
return idoMetaObject;
}
else
{
return new DynamicMetaObject(expression, BindingRestrictions.Empty, value);
}
}
public ScriptScope CreateScope(string languageId, IDynamicMetaObjectProvider storage) {
return GetEngine(languageId).CreateScope(storage);
}
private static void ApplyPropertyValueModels(
IDynamicMetaObjectProvider deviceProperties,
IEnumerable<DevicePropertyValueModel> devicePropertyValueModels)
{
Dictionary<string, DevicePropertyMetadata> devicePropertyIndex;
HashSet<string> dynamicProperties;
DevicePropertyMetadata propMetadata;
Debug.Assert(
deviceProperties != null,
"deviceProperties is a null reference.");
Debug.Assert(
devicePropertyValueModels != null,
"devicePropertyValueModels is a null reference.");
devicePropertyIndex =
GetDevicePropertyConfiguration().ToDictionary(t => t.Name);
dynamicProperties =
new HashSet<string>(
D.Dynamic.GetMemberNames(deviceProperties, true));
foreach (DevicePropertyValueModel propVal in devicePropertyValueModels)
{
if ((propVal == null) ||
string.IsNullOrEmpty(propVal.Name))
{
continue;
}
if (!dynamicProperties.Contains(propVal.Name))
{
continue;
}
// Pass through properties that don't have a specified
// configuration.
if (devicePropertyIndex.TryGetValue(propVal.Name, out propMetadata) && !propMetadata.IsEditable)
{
continue;
}
D.Dynamic.InvokeSet(
deviceProperties,
propVal.Name,
propVal.Value);
}
}
static void SerializeDynamicObject(IDynamicMetaObjectProvider dyn, TextWriter stream, Options opts, int depth)
{
var quoteColon = "\":";
if (opts.ShouldPrettyPrint)
{
quoteColon = "\": ";
}
stream.Write('{');
depth++;
var asJilDyn = dyn as Jil.DeserializeDynamic.JsonObject;
if (asJilDyn != null)
{
var first = true;
foreach (var memberName in asJilDyn.GetMemberNames())
{
var val = asJilDyn.GetMember(memberName);
if (val == null && opts.ShouldExcludeNulls)
{
continue;
}
if (!first)
{
stream.Write(',');
}
first = false;
if (opts.ShouldPrettyPrint)
{
LineBreakAndIndent(stream, depth);
}
stream.Write('"');
memberName.JsonEscapeFast(jsonp: opts.IsJSONP, output: stream);
stream.Write(quoteColon);
Serialize(stream, val, opts, depth + 1);
}
depth--;
if (opts.ShouldPrettyPrint)
{
LineBreakAndIndent(stream, depth);
}
}
else
{
var dynType = dyn.GetType();
var metaObj = dyn.GetMetaObject(CachedParameterExp);
var first = true;
foreach (var memberName in metaObj.GetDynamicMemberNames())
{
var getter = GetGetMember(dynType, memberName);
var val = getter(dyn);
if (val == null && opts.ShouldExcludeNulls)
{
continue;
}
if (!first)
{
stream.Write(',');
}
first = false;
if (opts.ShouldPrettyPrint)
{
LineBreakAndIndent(stream, depth);
}
stream.Write('"');
memberName.JsonEscapeFast(jsonp: opts.IsJSONP, output: stream);
stream.Write(quoteColon);
Serialize(stream, val, opts, depth + 1);
}
depth--;
if (opts.ShouldPrettyPrint)
{
LineBreakAndIndent(stream, depth);
}
}
stream.Write('}');
}
public Scope(IDictionary <string, object> dictionary)
{
_extensions = ScopeExtension.EmptyArray;
_storage = new StringDictionaryExpando(dictionary);
}
// VBScriptImport takes the runtime and module as context for the import.
// It takes a list of names, what, that either identify a (possibly dotted
// sequence) of names to fetch from Globals or a file name to load. Names
// is a list of names to fetch from the final object that what indicates
// and then set each name in module. Renames is a list of names to add to
// module instead of names. If names is empty, then the name set in
// module is the last name in what. If renames is not empty, it must have
// the same cardinality as names.
//
public static object VBScriptImport(VBScript runtime, IDynamicMetaObjectProvider module,
string[] what, string[] names,
string[] renames)
{
// Get object or file scope.
object value = null;
if (what.Length == 1)
{
string name = what[0];
if (DynamicObjectHelpers.HasMember(runtime.Globals, name))
{
value = DynamicObjectHelpers.GetMember(runtime.Globals, name);
// Since runtime.Globals has Sympl's reflection of namespaces and
// types, we pick those up first above and don't risk hitting a
// NamespaceTracker for assemblies added when we initialized Sympl.
// The next check will correctly look up case-INsensitively for
// globals the host adds to ScriptRuntime.Globals.
}
else if (DynamicObjectHelpers.HasMember(runtime.DlrGlobals, name))
{
value = DynamicObjectHelpers.GetMember(runtime.DlrGlobals, name);
}
else
{
throw new ArgumentException(
"Import: can't find name in globals -- " + name);
}
}
else
{
// What has more than one name, must be Globals access.
value = runtime.Globals;
// For more correctness and generality, shouldn't assume all
// globals are dynamic objects, or that a look up like foo.bar.baz
// cascades through all dynamic objects.
// Would need to manually create a CallSite here with Sympl's
// GetMemberBinder, and think about a caching strategy per name.
foreach (string name in what)
{
value = DynamicObjectHelpers.GetMember(
(IDynamicMetaObjectProvider)value, name);
}
}
// Assign variables in module.
if (names.Length == 0)
{
if (renames.Length == 0)
{
DynamicObjectHelpers.SetMember((IDynamicMetaObjectProvider)module,
what[what.Length - 1], value);
}
else
{
DynamicObjectHelpers.SetMember((IDynamicMetaObjectProvider)module,
renames[0], value);
}
}
else
{
if (renames.Length == 0)
{
renames = names;
}
for (int i = 0; i < names.Length; i++)
{
string name = names[i];
string rename = renames[i];
DynamicObjectHelpers.SetMember(
(IDynamicMetaObjectProvider)module, rename,
DynamicObjectHelpers.GetMember(
(IDynamicMetaObjectProvider)value, name));
}
}
return(null);
} // SymplImport
private ScopeExtension[] _extensions; // resizable
#endregion Fields
#region Constructors
/// <summary>
/// Creates a new scope with a new empty thread-safe dictionary.
/// </summary>
public Scope()
{
_extensions = ScopeExtension.EmptyArray;
_storage = new ScopeStorage();
}
private void _OnStartExecute(IDynamicMetaObjectProvider executingScope, SourceUnit sourceUnit)
{
ContractUtils.Requires(executingScope is Scope);
ExecutingScope = executingScope as Scope;
ExecutingScopeStorage = ExecutingScope.Storage;
//We should update the context under which this LuaTable is executing
//so that it resolves metamethod overrides correctly.
//TODO: Decide whether we should keep this if it is non-null, it may be that this is coming from a different
// CodeContext which has some metamethod stuff set particularly for this scope, or its contents, and we
// shouldn't change this.
if (ExecutingScopeStorage is LuaTable)
(ExecutingScopeStorage as LuaTable).Context = this;
_LoadedPackages.Clear();
_FunctionStacks.Clear();
_EnvironmentMappings.Clear(); //We clear this here as opposed to in OnFinishExecute in case the last execution failed
}
/// <summary>
/// Creates a new scope which is backed by an arbitrary object for it's storage.
/// </summary>
/// <param name="storage"></param>
public Scope(IDynamicMetaObjectProvider storage)
{
_extensions = ScopeExtension.EmptyArray;
_storage = storage;
}
public Scope(IDictionary<string, object> dictionary)
{
_extensions = ScopeExtension.EmptyArray;
_storage = new StringDictionaryExpando(dictionary);
}
internal static object UserDefinedConversion(IDynamicMetaObjectProvider Expression, Type TargetType)
{
return IDOUtils.CreateConvertCallSiteAndInvoke(new VBConversionBinder(TargetType), Expression);
}
internal static void IDOSetComplex(IDynamicMetaObjectProvider Instance, string MemberName, object[] Arguments, string[] ArgumentNames, bool OptimisticSet, bool RValueBase)
{
SaveCopyBack back = new SaveCopyBack(null);
using (back)
{
if (Arguments.Length == 1)
{
IDOUtils.CreateFuncCallSiteAndInvoke(new VBSetComplexBinder(MemberName, OptimisticSet, RValueBase), Instance, Arguments);
}
else
{
object instance = IDOUtils.CreateFuncCallSiteAndInvoke(new VBGetMemberBinder(MemberName), Instance, Symbols.NoArguments);
if (instance == missingMemberSentinel)
{
NewLateBinding.ObjectLateSetComplex(Instance, null, MemberName, Arguments, ArgumentNames, Symbols.NoTypeArguments, OptimisticSet, RValueBase);
}
else
{
NewLateBinding.LateIndexSetComplex(instance, Arguments, ArgumentNames, OptimisticSet, RValueBase);
}
}
}
}
private static IEnumerable<DevicePropertyValueModel> ExtractPropertyValueModels(
IDynamicMetaObjectProvider deviceProperties)
{
DevicePropertyValueModel currentData;
object currentValue;
Dictionary<string, DevicePropertyMetadata> devicePropertyIndex;
int editableOrdering;
bool isDisplayedRegistered;
bool isDisplayedUnregistered;
bool isEditable;
int nonediableOrdering;
DevicePropertyMetadata propertyMetadata;
PropertyType propertyType;
Debug.Assert(deviceProperties != null, "deviceProperties is a null reference.");
devicePropertyIndex = GetDevicePropertyConfiguration().ToDictionary(t => t.Name);
// For now, display r/o properties first.
editableOrdering = 1;
nonediableOrdering = int.MinValue;
foreach (string propertyName in D.Dynamic.GetMemberNames(deviceProperties, true))
{
if (devicePropertyIndex.TryGetValue(propertyName, out propertyMetadata))
{
isDisplayedRegistered = propertyMetadata.IsDisplayedForRegisteredDevices;
isDisplayedUnregistered = propertyMetadata.IsDisplayedForUnregisteredDevices;
isEditable = propertyMetadata.IsEditable;
propertyType = propertyMetadata.PropertyType;
}
else
{
isDisplayedRegistered = isEditable = true;
isDisplayedUnregistered = false;
propertyType = PropertyType.String;
}
if (!isDisplayedRegistered && !isDisplayedUnregistered)
{
continue;
}
currentData = new DevicePropertyValueModel()
{
Name = propertyName,
PropertyType = propertyType
};
if (isEditable)
{
currentData.IsEditable = true;
currentData.DisplayOrder = editableOrdering++;
}
else
{
currentData.IsEditable = false;
currentData.DisplayOrder = nonediableOrdering++;
}
currentData.IsIncludedWithUnregisteredDevices =
isDisplayedUnregistered;
currentValue = D.Dynamic.InvokeGet(deviceProperties, propertyName);
if (currentValue == null)
{
currentData.Value = string.Empty;
}
else
{
currentData.Value = string.Format(CultureInfo.InvariantCulture, "{0}", currentValue);
}
yield return currentData;
}
}
private static bool HasProperty(IDynamicMetaObjectProvider dynamicProvider, string name)
{
var defaultBinder = Binder.GetMember(CSharpBinderFlags.None, name, typeof(Program),
new[]
{
CSharpArgumentInfo.Create(
CSharpArgumentInfoFlags.None, null)
}) as GetMemberBinder;
var callSite = CallSite<Func<CallSite, object, object>>.Create(new NoThrowGetBinderMember(name, false, defaultBinder));
var result = callSite.Target(callSite, dynamicProvider);
if (Object.ReferenceEquals(result, NoThrowExpressionVisitor.DUMMY_RESULT))
{
return false;
}
return true;
}
public TheDude( IDynamicMetaObjectProvider module )
: base(module)
{
}
public DynamicWrapper(IDynamicMetaObjectProvider target)
{
this.target = target;
}
public ProtoTypalObjectWithMethods( IDynamicMetaObjectProvider prototype )
: base(prototype)
{
StaticMethodWithNoReturnValueOrParametersWasCalled = false;
}
/// <summary>
/// Creates a new scope with a new empty thread-safe dictionary.
/// </summary>
public Scope()
{
_extensions = ScopeExtension.EmptyArray;
_storage = new ScopeStorage();
}
/// <summary>
/// Gets the value of an IDynamicMetaObjectProvider
/// implementation's named property.
/// </summary>
/// <param name="item">
/// The IDynamicMetaObjectProvider implementation, from
/// which to extract a named property's value.
/// </param>
/// <param name="propertyName">
/// The name of the property.
/// </param>
/// <param name="usesCaseSensitivePropertyNameMatch">
/// A value indicating whether the property name match should be
/// case-sensitive.
/// </param>
/// <param name="exceptionThrownIfNoMatch">
/// A value indicating whether an exception should be thrown if
/// no matching property can be found.
/// </param>
/// <returns>
/// The value of the property named by propertyName on item,
/// or a null reference if exceptionThrownIfNoMatch is false and
/// propertyName does not name a property on item.
/// </returns>
private static object GetNamedPropertyValue(
IDynamicMetaObjectProvider item,
string propertyName,
bool usesCaseSensitivePropertyNameMatch,
bool exceptionThrownIfNoMatch)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (string.IsNullOrEmpty(propertyName))
{
throw new ArgumentException("propertyName is a null reference or empty string.", "propertyName");
}
if (!usesCaseSensitivePropertyNameMatch || exceptionThrownIfNoMatch)
{
StringComparison comparisonType = StringComparison.CurrentCultureIgnoreCase;
if (usesCaseSensitivePropertyNameMatch)
{
comparisonType = StringComparison.CurrentCulture;
}
propertyName = D.Dynamic.GetMemberNames(item, true).FirstOrDefault(
t => string.Equals(t, propertyName, comparisonType));
if (string.IsNullOrEmpty(propertyName))
{
if (exceptionThrownIfNoMatch)
{
throw new ArgumentException("propertyName does not name a property on item", "propertyName");
}
return null;
}
}
try
{
return D.Dynamic.InvokeGet(item, propertyName);
}
catch (RuntimeBinderException)
{
return null;
}
}
/// <summary>
/// Creates a new scope which is backed by an arbitrary object for it's storage.
/// </summary>
/// <param name="storage"></param>
public Scope(IDynamicMetaObjectProvider storage)
{
_extensions = ScopeExtension.EmptyArray;
_storage = storage;
}
/// <summary>
/// Writes the list of records to the CSV file.
/// </summary>
/// <typeparam name="T">Record type.</typeparam>
/// <param name="records">The list of records to write.</param>
public virtual void WriteRecords <T>(IEnumerable <T> records)
{
// Changes in this method require changes in method WriteRecords( IEnumerable records ) also.
try
{
// Write the header. If records is a List<dynamic>, the header won't be written.
// This is because typeof( T ) = Object.
var recordType = typeof(T);
var isPrimitive = recordType.GetTypeInfo().IsPrimitive;
if (context.WriterConfiguration.HasHeaderRecord && !context.HasHeaderBeenWritten && !isPrimitive && recordType != typeof(object))
{
WriteHeader(recordType);
if (context.HasHeaderBeenWritten)
{
NextRecord();
}
}
var getRecordType = recordType == typeof(object);
foreach (var record in records)
{
if (getRecordType)
{
recordType = record.GetType();
}
IDynamicMetaObjectProvider dynamicObject = record as IDynamicMetaObjectProvider;
//if( record is IDynamicMetaObjectProvider dynamicObject )
if (dynamicObject != null)
{
if (context.WriterConfiguration.HasHeaderRecord && !context.HasHeaderBeenWritten)
{
WriteDynamicHeader(dynamicObject);
NextRecord();
}
}
else
{
// If records is a List<dynamic>, the header hasn't been written yet.
// Write the header based on the record type.
isPrimitive = recordType.IsPrimitive;
//isPrimitive = recordType.GetTypeInfo().IsPrimitive;
if (context.WriterConfiguration.HasHeaderRecord && !context.HasHeaderBeenWritten && !isPrimitive)
{
WriteHeader(recordType);
NextRecord();
}
}
try
{
recordManager.Write(record);
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
NextRecord();
}
}
catch (Exception ex)
{
throw ex as CsvHelperException ?? new WriterException(context, "An unexpected error occurred.", ex);
}
}
private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
OnSerializing(writer, contract, value);
_serializeStack.Add(value);
WriteObjectStart(writer, value, contract, member, collectionContract, containerProperty);
int initialDepth = writer.Top;
for (int index = 0; index < contract.Properties.Count; index++)
{
JsonProperty property = contract.Properties[index];
// only write non-dynamic properties that have an explicit attribute
if (property.HasMemberAttribute)
{
try
{
object memberValue;
JsonContract memberContract;
if (!CalculatePropertyValues(writer, value, contract, member, property, out memberContract, out memberValue))
continue;
property.WritePropertyName(writer);
SerializeValue(writer, memberValue, memberContract, property, contract, member);
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, property.PropertyName, null, writer.ContainerPath, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
}
foreach (string memberName in value.GetDynamicMemberNames())
{
object memberValue;
if (contract.TryGetMember(value, memberName, out memberValue))
{
try
{
JsonContract valueContract = GetContractSafe(memberValue);
if (!ShouldWriteDynamicProperty(memberValue))
continue;
if (CheckForCircularReference(writer, memberValue, null, valueContract, contract, member))
{
string resolvedPropertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(memberName)
: memberName;
writer.WritePropertyName(resolvedPropertyName);
SerializeValue(writer, memberValue, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, memberName, null, writer.ContainerPath, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, value);
}
private static void Iterate(
ObjectEnumeratorBindingContext context,
IDynamicMetaObjectProvider target,
Action<TextWriter, object> template,
Action<TextWriter, object> ifEmpty)
{
if (HandlebarsUtils.IsTruthy(target))
{
context.Index = 0;
var meta = target.GetMetaObject(Expression.Constant(target));
foreach (var name in meta.GetDynamicMemberNames())
{
context.Key = name;
var value = GetProperty(target, name);
context.First = (context.Index == 0);
template(context.TextWriter, value);
context.Index++;
}
if (context.Index == 0)
{
ifEmpty(context.TextWriter, context.Value);
}
}
else
{
ifEmpty(context.TextWriter, context.Value);
}
}
private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
OnSerializing(writer, contract, value);
_serializeStack.Add(value);
WriteObjectStart(writer, value, contract, member, collectionContract, containerProperty);
int initialDepth = writer.Top;
for (int index = 0; index < contract.Properties.Count; index++)
{
JsonProperty property = contract.Properties[index];
// only write non-dynamic properties that have an explicit attribute
if (property.HasMemberAttribute)
{
try
{
object memberValue;
JsonContract memberContract;
if (!CalculatePropertyValues(writer, value, contract, member, property, out memberContract, out memberValue))
{
continue;
}
property.WritePropertyName(writer);
SerializeValue(writer, memberValue, memberContract, property, contract, member);
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, property.PropertyName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
}
foreach (string memberName in value.GetDynamicMemberNames())
{
object memberValue;
if (contract.TryGetMember(value, memberName, out memberValue))
{
try
{
JsonContract valueContract = GetContractSafe(memberValue);
if (!ShouldWriteDynamicProperty(memberValue))
{
continue;
}
if (CheckForCircularReference(writer, memberValue, null, valueContract, contract, member))
{
string resolvedPropertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(memberName)
: memberName;
writer.WritePropertyName(resolvedPropertyName);
SerializeValue(writer, memberValue, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, memberName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, value);
}
public ScriptScope CreateScope(string languageId, IDynamicMetaObjectProvider storage)
{
return(GetEngine(languageId).CreateScope(storage));
}
public override object Invoke(object obj, BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, CultureInfo culture)
{
parameters = parameters ?? Empty <object[]> .Value;
int args = parameters.Length;
InvokeMemberBinder dbinder;
bool named = false;
foreach (object arg in parameters)
{
if (arg is NamedArgument)
{
named = true;
}
break;
}
if (!named)
{
if (!cachebinder.TryGetValue(args, out dbinder))
{
CSharpArgumentInfo[] csargs = new CSharpArgumentInfo[parameters.Length + 1];
csargs[0] = CSharpArgumentInfo.Create(0, null);
for (int i = 0; i < args; i++)
{
csargs[i + 1] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.Constant | CSharpArgumentInfoFlags.UseCompileTimeType, null);
}
dbinder = (InvokeMemberBinder)Microsoft.CSharp.RuntimeBinder.Binder.InvokeMember(
0, name, null,
TypeOf <DynamicMethodInfo> .TypeID, csargs
);
cachebinder.Add(args, dbinder);
}
}
else
{
CSharpArgumentInfo[] csargs = new CSharpArgumentInfo[parameters.Length + 1];
csargs[0] = CSharpArgumentInfo.Create(0, null);
for (int i = 0; i < args; i++)
{
NamedArgument narg = parameters[i] as NamedArgument;
if (narg == null)
{
csargs[i + 1] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.Constant | CSharpArgumentInfoFlags.UseCompileTimeType, null);
}
else
{
csargs[i + 1] = CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.Constant | CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.NamedArgument, narg.Name);
}
}
dbinder = (InvokeMemberBinder)Microsoft.CSharp.RuntimeBinder.Binder.InvokeMember(
0, name, null,
TypeOf <DynamicMethodInfo> .TypeID, csargs
);
}
IDynamicMetaObjectProvider provider = obj as IDynamicMetaObjectProvider;
DynamicMetaObject mobj;
if (provider != null)
{
mobj = provider.GetMetaObject(Expression.Constant(obj));
}
else
{
mobj = new DynamicMetaObject(Expression.Constant(obj), BindingRestrictions.Empty, obj);
}
DynamicMetaObject[] margs = new DynamicMetaObject[parameters.Length];
for (int i = 0; i < args; i++)
{
NamedArgument narg = parameters[i] as NamedArgument;
if (narg == null)
{
margs[i] = new DynamicMetaObject(Expression.Constant(parameters[i]), BindingRestrictions.Empty, parameters[i]);
}
else
{
margs[i] = new DynamicMetaObject(Expression.Constant(narg.Value), BindingRestrictions.Empty, narg.Value);
}
}
DynamicMetaObject ret = mobj.BindInvokeMember(dbinder, margs);
BlockExpression final = Expression.Block(
Expression.Label(CallSiteBinder.UpdateLabel),
ret.Expression
);
Expression <Func <object> > lambda = Expression.Lambda <Func <object> >(final);
Func <object> del = lambda.Compile();
return(del.Invoke());
}
private static TableItem CreateFromDynamicMetaObject( IDynamicMetaObjectProvider entity, bool throwOnReservedPropertyName )
{
var properties = new Dictionary<string, Tuple<object, Type>>();
IEnumerable<string> memberNames = Dynamic.GetMemberNames( entity );
foreach ( var memberName in memberNames )
{
dynamic result = Dynamic.InvokeGet( entity, memberName );
properties[memberName] = new Tuple<object, Type>( (object) result, result.GetType() );
}
return new TableItem( properties, throwOnReservedPropertyName );
}
// Execute a single expression parsed from string in the provided module
// scope and returns the resulting value.
//
public object ExecuteExpr(string expr_str,
IDynamicMetaObjectProvider moduleEO) {
var moduleFun = ParseExprToLambda(new StringReader(expr_str));
var d = moduleFun.Compile();
return d(this, moduleEO);
}
/// <summary>
/// 尝试设置动态对象中指定名称的属性值。
/// </summary>
/// <param name="dynamicProvider">一个动态对象。</param>
/// <param name="name">属性的名称。</param>
/// <param name="value">设置值。</param>
/// <returns></returns>
public static bool TrySetMember(this IDynamicMetaObjectProvider dynamicProvider, string name, object value)
{
return(new DynamicManager().TrySetMember(dynamicProvider, name, value));
}
private void \u206D(\u005C8t9\u007E5r_\u007DCMvoQRqs\u007B\u007DP _param1, IDynamicMetaObjectProvider _param2, \u200E _param3, \u202E _param4, \u202E _param5, \u202E _param6)
{
// ISSUE: unable to decompile the method.
}
private static PropertyReader[] GetDynamicProperties(IDynamicMetaObjectProvider provider)
{
var metaObject = provider.GetMetaObject(Expression.Constant(provider));
var memberNames = metaObject.GetDynamicMemberNames(); // may return property names as well as method names, etc.
var result = new List<PropertyReader>();
foreach (var name in memberNames)
{
try
{
var argumentInfo = new[] {CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)};
var binder = Binder.GetMember(CSharpBinderFlags.None, name, provider.GetType(), argumentInfo);
var site = CallSite<Func<CallSite, object, object>>.Create(binder);
var value = site.Target(site, provider); // will throw if no valid property getter
result.Add(new PropertyReader
{
Name = name,
DeclaringType = provider.GetType(),
Read = o => value
});
}
catch (RuntimeBinderException)
{
}
}
return result.ToArray();
}
private static bool HasPropertyNaive(IDynamicMetaObjectProvider dynamicProvider, string name)
{
try
{
var callSite =
CallSite<Func<CallSite, object, object>>.Create(Binder.GetMember(CSharpBinderFlags.None, name, typeof(Program),
new[]
{
CSharpArgumentInfo.Create(
CSharpArgumentInfoFlags.None, null)
}));
callSite.Target(callSite, dynamicProvider);
return true;
}
catch (RuntimeBinderException)
{
return false;
}
}
/// <summary>
/// Serializes the dynamic.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="value">The value.</param>
/// <param name="contract">The contract.</param>
private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract)
{
contract.InvokeOnSerializing(value, Serializer.Context);
SerializeStack.Add(value);
writer.WriteStartObject();
foreach (string memberName in value.GetDynamicMemberNames())
{
object memberValue;
if (DynamicUtils.TryGetMember(value, memberName, out memberValue))
{
string resolvedPropertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(memberName)
: memberName;
writer.WritePropertyName(resolvedPropertyName);
SerializeValue(writer, memberValue, GetContractSafe(memberValue), null, null);
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(value, Serializer.Context);
}
public static IEnumerable <string> GetDynamicMemberNames(this IDynamicMetaObjectProvider dynamicProvider)
{
var metaObject = dynamicProvider.GetMetaObject(Expression.Constant(dynamicProvider));
return(metaObject.GetDynamicMemberNames());
}
public DelegatingMetaObject(IDynamicMetaObjectProvider innerProvider, Expression expr, BindingRestrictions restrictions, object value)
: base(expr, restrictions, value)
{
this.mProvider = innerProvider;
}
private object CreateDynamic(JsonReader reader, JsonDynamicContract contract, string id)
{
IDynamicMetaObjectProvider newObject = null;
if (contract.UnderlyingType.IsInterface || contract.UnderlyingType.IsAbstract)
{
throw new JsonSerializationException("Could not create an instance of type {0}. Type is an interface or abstract class and cannot be instantated.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
}
if (contract.DefaultCreator != null &&
(!contract.DefaultCreatorNonPublic || Serializer.ConstructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
{
newObject = (IDynamicMetaObjectProvider)contract.DefaultCreator();
}
if (id != null)
{
Serializer.ReferenceResolver.AddReference(id, newObject);
}
contract.InvokeOnDeserializing(newObject, Serializer.Context);
bool exit = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string memberName = reader.Value.ToString();
if (!reader.Read())
{
throw new JsonSerializationException("Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
}
// first attempt to find a settable property, otherwise fall back to a dynamic set without type
JsonProperty property = contract.Properties.GetClosestMatchProperty(memberName);
if (property != null && property.Writable && !property.Ignored)
{
SetPropertyValue(property, reader, newObject);
}
else
{
object value = (JsonReader.IsPrimitiveToken(reader.TokenType))
? reader.Value
: CreateObject(reader, typeof(IDynamicMetaObjectProvider), GetContractSafe(typeof(IDynamicMetaObjectProvider), null), null, null);
newObject.TrySetMember(memberName, value);
}
break;
case JsonToken.EndObject:
exit = true;
break;
default:
throw new JsonSerializationException("Unexpected token when deserializing object: " + reader.TokenType);
}
} while (!exit && reader.Read());
contract.InvokeOnDeserialized(newObject, Serializer.Context);
return(newObject);
}
public static PrototypalObject AsPrototypalObject( IDynamicMetaObjectProvider prototype )
{
if ( prototype == null )
{
return new PrototypalObject();
}
return prototype as PrototypalObject ?? new PrototypalObject( prototype );
}
private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
contract.InvokeOnSerializing(value, Serializer.Context);
_serializeStack.Add(value);
WriteObjectStart(writer, value, contract, member, collectionContract, containerProperty);
int initialDepth = writer.Top;
foreach (JsonProperty property in contract.Properties)
{
// only write non-dynamic properties that have an explicit attribute
if (property.HasMemberAttribute)
{
try
{
object memberValue;
JsonContract memberContract;
if (!CalculatePropertyValues(writer, value, contract, member, property, out memberContract, out memberValue))
continue;
writer.WritePropertyName(property.PropertyName);
SerializeValue(writer, memberValue, memberContract, property, contract, member);
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, property.PropertyName, writer.ContainerPath, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
}
foreach (string memberName in value.GetDynamicMemberNames())
{
object memberValue;
if (value.TryGetMember(memberName, out memberValue))
{
try
{
string resolvedPropertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(memberName)
: memberName;
writer.WritePropertyName(resolvedPropertyName);
SerializeValue(writer, memberValue, GetContractSafe(memberValue), null, null, member);
}
catch (Exception ex)
{
if (IsErrorHandled(value, contract, memberName, writer.ContainerPath, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
contract.InvokeOnSerialized(value, Serializer.Context);
}
public DynamicWrapper(IDynamicMetaObjectProvider target)
{
this.target = target;
}
public ScriptScope CreateScope(IDynamicMetaObjectProvider storage)
{
return(InvariantEngine.CreateScope(storage));
}
public override object Update(
DataManager dataManager,
string keyField,
IDynamicMetaObjectProvider data,
string tableName = null,
Query query = null,
object original = null)
{
IEnumerable <object> json = this.DataManager.Json;
string str1 = (string)null;
IDictionary <string, Type> columnType = DataUtil.GetColumnType((IEnumerable)json, false);
Type type = data.GetType();
bool flag = ((object)type != null ? type.BaseType : (Type)null) == typeof(DynamicObject);
if (flag)
{
str1 = DataUtil.GetDynamicValue(data as DynamicObject, keyField).ToString();
}
else
{
IDictionary <string, object> dictionary = (IDictionary <string, object>)data;
if (dictionary[keyField] != null)
{
str1 = dictionary[keyField].ToString();
}
}
foreach (object obj in (IEnumerable)json)
{
string str2 = (string)null;
if (flag)
{
str2 = DataUtil.GetDynamicValue(obj as DynamicObject, keyField).ToString();
}
else
{
IDictionary <string, object> dictionary = (IDictionary <string, object>)obj;
if (dictionary[keyField] != null)
{
str2 = dictionary[keyField].ToString();
}
}
if (str2 == str1)
{
if (flag)
{
foreach (string name in (data as DynamicObject).GetDynamicMemberNames().ToArray <string>())
{
if (name != keyField)
{
object dynamicValue1 = DataUtil.GetDynamicValue(data as DynamicObject, name);
object dynamicValue2 = DataUtil.GetDynamicValue(obj as DynamicObject, name);
if (dynamicValue1 != null && dynamicValue2 != null)
{
(obj as DynamicObject).TrySetMember((SetMemberBinder) new DataSetMemberBinder(name, false), SfBaseUtils.ChangeType(dynamicValue1, dynamicValue2.GetType()));
}
else
{
(obj as DynamicObject).TrySetMember((SetMemberBinder) new DataSetMemberBinder(name, false), dynamicValue1);
}
}
}
}
else
{
IDictionary <string, object> dictionary = (IDictionary <string, object>)data;
int count = dictionary.Keys.Count;
List <string> list = dictionary.Keys.ToList <string>();
for (int index = 0; index < count; ++index)
{
string key = list[index];
if (((IDictionary <string, object>)obj).ContainsKey(key))
{
if (dictionary[key] != null)
{
Type conversionType = ((IDictionary <string, object>)obj)[key] != null ? ((IDictionary <string, object>)obj)[key].GetType() : columnType[key];
if (conversionType == dictionary[key].GetType())
{
((IDictionary <string, object>)obj)[key] = dictionary[key];
}
else
{
((IDictionary <string, object>)obj)[key] = SfBaseUtils.ChangeType(dictionary[key], conversionType);
}
}
else
{
((IDictionary <string, object>)obj)[key] = dictionary[key];
}
}
else
{
((IDictionary <string, object>)obj).Add(key, dictionary[key]);
}
}
}
data = (IDynamicMetaObjectProvider)obj;
}
}
return((object)data);
}
internal bool TrySetMember(IDynamicMetaObjectProvider dynamicProvider, string name, object value)
{
ValidationUtils.ArgumentNotNull(dynamicProvider, "dynamicProvider");
CallSite<Func<CallSite, object, object, object>> callSite = _callSiteSetters.Get(name);
object result = callSite.Target(callSite, dynamicProvider, value);
return !ReferenceEquals(result, NoThrowExpressionVisitor.ErrorResult);
}
/// <summary>
/// Creates a new ScriptScope whose storage is an arbitrary object.
///
/// Accesses to the ScriptScope will turn into get, set, and delete members against the object.
/// </summary>
public virtual Scope CreateScope(IDynamicMetaObjectProvider storage)
{
return(new Scope(storage));
}
