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)); }