public void Setup([NotNull] FieldInfo setFieldInfo) { fieldInfo = setFieldInfo; #if ((UNITY_EDITOR || UNITY_STANDALONE) && !NET_STANDARD_2_0) && USE_IL_FOR_GET_AND_SET // Handle const values. if (setFieldInfo.IsLiteral && setFieldInfo.IsStatic) { var fieldType = setFieldInfo.FieldType; // FastReflection only supports following types when it comes to constants if (fieldType != Types.Bool && fieldType != Types.Int && fieldType != Types.Float && fieldType != Types.Double) { return; } } getValue = setFieldInfo.DelegateForGet(); #if UNITY_2018_1_OR_NEWER if (setFieldInfo.IsDefined(typeof(Unity.Collections.ReadOnlyAttribute), false)) { return; } #endif if (!setFieldInfo.IsInitOnly && !setFieldInfo.IsLiteral && !setFieldInfo.IsDefined(typeof(System.ComponentModel.ImmutableObjectAttribute), false) && !setFieldInfo.FieldType.IsDefined(typeof(System.ComponentModel.ReadOnlyAttribute), true)) { setValue = setFieldInfo.DelegateForSet(); #if DEV_MODE && DEBUG_CAN_WRITE Debug.Log(StringUtils.ToColorizedString(setFieldInfo.Name, ".CanWrite=", true, " with IsInitOnly=", setFieldInfo.IsInitOnly)); #endif } #endif }
private void Map(MemberGetter fromMember, MemberSetter toMember) { if (fromMember != null && toMember != null) { this.memberMaps.Add(new MemberMap(fromMember, toMember)); } }
public PropertyAccess(Type t, string n, MemberGetter g, MemberSetter s) { Type = t; Name = n; Getter = g; Setter = s; }
/// <summary> /// Executes the delegate on the specified target and value but only if it's not null /// </summary> public static void SafeInvoke <TTarget, TValue>(this MemberSetter <TTarget, TValue> setter, ref TTarget target, TValue value) { if (setter != null) { setter(ref target, value); } }
public void SetWithArg_stringToMemberOfType_expected <T>(string toSet, T expected) { FieldSample <T> sample = new FieldSample <T>(); MemberAttribute fieldAttr = new MemberAttribute(new NArgAttribute(), GetSingleMemberInfo(sample, "_field")); MemberSetter.SetArg(sample, fieldAttr, toSet); MemberAttribute propAttr = new MemberAttribute(new NArgAttribute(), GetSingleMemberInfo(sample, "TestProp")); MemberSetter.SetArg(sample, propAttr, toSet); MemberAttribute methodAttr = new MemberAttribute(new NArgAttribute(), GetSingleMemberInfo(sample, "TestMethod")); MemberSetter.SetArg(sample, methodAttr, toSet); MemberAttribute methodWithNoArgsAttr = new MemberAttribute(new NArgAttribute(), GetSingleMemberInfo(sample, "TestMethodWithNoArgs")); MemberSetter.SetArg(sample, methodWithNoArgsAttr, toSet); Assert.That(sample.FieldProp, Is.EqualTo(expected)); Assert.That(sample.TestProp, Is.EqualTo(expected)); Assert.That(sample.TestMethodProp, Is.EqualTo(expected)); Assert.That(sample.HasTestMethodWithNoArgsExecuted, Is.True); }
static InternalAccessor() { var type = typeof(List <T>); ArrayGetter = FastReflection.DelegateForGet <List <T>, T[]>(type.GetField("_items", BindingFlags.NonPublic | BindingFlags.Instance)); CountSetter = FastReflection.DelegateForSet <List <T>, int>(type.GetField("_size", BindingFlags.NonPublic | BindingFlags.Instance)); }
public static MemberSetter <TTarget, TValue> DelegateForSet <TTarget, TValue>(this PropertyInfo property) { if (!property.CanWrite) { throw new InvalidOperationException("Property is not writable " + property.Name); } int key = GetKey <TTarget, TValue>(property.GetHashCode(), kPropertySetterName); Delegate result; if (cache.TryGetValue(key, out result)) { return((MemberSetter <TTarget, TValue>)result); } #if HAS_EMIT return(GenDelegateForMember <MemberSetter <TTarget, TValue>, PropertyInfo>( property, key, kPropertySetterName, GenPropertySetter <TTarget>, typeof(void), typeof(TTarget).MakeByRefType(), typeof(TValue))); #else MemberSetter <TTarget, TValue> methodDelegate = (ref TTarget target, TValue value) => { MethodInfo setMethod = property.GetSetMethod(/*nonPublic:*/ true); if (setMethod != null) { setMethod.Invoke(target, new object[] { value }); } }; cache[key] = methodDelegate; return(methodDelegate); #endif }
public void Can_Get_Field_Setter() { var fieldInfo = typeof(TestObject).GetField("SomeField"); MemberSetter <object, object> setter = null; Assert.DoesNotThrow(() => { setter = fieldInfo.DelegateForSet(); }); Assert.IsNotNull(setter); }
public void Can_Get_Property_Setter() { var propertyInfo = typeof(TestObject).GetProperty("SomeProperty"); MemberSetter <object, object> setter = null; Assert.DoesNotThrow(() => { setter = propertyInfo.DelegateForSet(); }); Assert.IsNotNull(setter); }
public ReflectionSetterBenchmark() { _indexerEntity = new("hello word.", 1, 0.99M); var property = typeof(IndexerEntity).GetTypeInfo().GetProperty("Prop1"); _reflector = property.GetReflector(); _dotNextSetter = Type <IndexerEntity> .Property <string> .RequireSetter(nameof(IndexerEntity.Prop1)); }
public MemberSetter GetSetter(Type type, String Name) { if (type != null && !String.IsNullOrEmpty(Name)) { if (this.unsensitive) { Name = Name.ToUpper(); } Dictionary <String, MemberSetter> innerDict = null; if (!_cacheSetter.ContainsKey(type)) { lock (lck) { if (!_cacheSetter.ContainsKey(type)) { _cacheSetter[type] = innerDict = new Dictionary <String, MemberSetter>(); } } } innerDict = _cacheSetter[type]; if (!innerDict.ContainsKey(Name)) { lock (lck) { if (!innerDict.ContainsKey(Name)) { MemberSetter setter = null; PropertyInfo property = this.unsensitive ? type.GetProperties().FirstOrDefault(p => p.Name.ToUpper().Equals(Name)) : type.GetProperty(Name); FieldInfo field = this.unsensitive ? type.GetFields().FirstOrDefault(p => p.Name.ToUpper().Equals(Name)) : type.GetField(Name); if (property != null || field != null) { if (property != null) { setter = type.DelegateForSetPropertyValue(property.Name); } if (setter == null) { if (field != null) { setter = type.DelegateForSetFieldValue(field.Name); } } } innerDict[Name] = setter; } } } return(innerDict.ContainsKey(Name) ? innerDict[Name] : null); } return(null); }
public PropertyAccessor( PropertyInfo propertyInfo, MemberGetter publicGetter, MemberSetter publicSetter) { PropertyInfo = propertyInfo; PublicGetter = publicGetter; PublicSetter = publicSetter; }
private MemberSetter GetMemberSetter(Type type) { if (type != _memberSetterType) { _memberSetter = FasterflectManager.GetFieldSetter(type, info.Value.Name); _memberSetterType = type; } return(_memberSetter); }
public void SetRemainingArg_EmptyStringArrayToIEnumerableOfSring_DoesNotThrow() { var sample = new FieldSample <int>(); string[] empty = new string[] { }; MemberAttribute propAttr = new MemberAttribute(new NArgAttribute(), GetSingleMemberInfo(sample, "FooProp")); MemberSetter.SetRemainingArg(sample, propAttr, empty); }
public AssignmentEntry(string name, AssignmentMember @from, AssignmentMember to) { Name = name; From = @from; To = to; GetValueFn = From.CreateGetter(); SetValueFn = To.CreateSetter(); ConvertValueFn = TypeConverter.CreateTypeConverter(From.Type, To.Type); }
public StrongReflectiveSerializer(string member0, StrongWriter <TMember0> writer0, StrongReader <TMember0> reader0) { var flags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static; var member = typeof(TTarget).GetMemberFromAll(member0, flags); _setter0 = DelegateForSet <TTarget, TMember0>(member); _getter0 = DelegateForGet <TTarget, TMember0>(member); _writer0 = writer0; _reader0 = reader0; }
private Field(FieldInfo field) : base(field) { //TODO: Should be optimized when LINQ Expression will have a support for ref return provider = Lambda <Provider>(Call(typeof(Unsafe), nameof(Unsafe.AsRef), new[] { field.FieldType }, Field(null, field))).Compile(); const BindingFlags staticPrivate = BindingFlags.Static | BindingFlags.DeclaredOnly | BindingFlags.NonPublic; getter = GetType().GetMethod(nameof(GetValue), staticPrivate).CreateDelegate <MemberGetter <V> >(provider); setter = field.IsInitOnly ? null : GetType().GetMethod(nameof(SetValue), staticPrivate).CreateDelegate <MemberSetter <V> >(provider); }
public LightSerializationMember(SerializationMemberInfo memberInfo) { this.Getter = memberInfo.Getter; this.Setter = memberInfo.Setter; this.Serializer = memberInfo.Serializer; this.MemberInfo = memberInfo.MemberInfo; this.SerializedName = memberInfo.GetSerializedName(); this.SerializeAsCData = memberInfo.SerializeAsCData; this.XmlTreatAsNullIfEmpty = memberInfo.HasApplicableAttribute(typeof(XmlTreatAsNullIfEmptyAttribute)); this.LogicalType = memberInfo.LogicalType; }
public FieldAccessor( FieldInfo fieldInfo, MemberGetter publicGetter, MemberSetter publicSetter, MemberRefSetter publicSetterRef) { FieldInfo = fieldInfo; PublicGetter = publicGetter; PublicSetter = publicSetter; PublicSetterRef = publicSetterRef; }
public static void Main() { ConstructorInvoker ctor = Reflect.Constructor(typeof(long)); MemberGetter getValue = Reflect.Getter(typeof(long), "m_value"); MemberSetter setValue = Reflect.Setter(typeof(long), "m_value"); long integer = (long)ctor(); ValueTypeHolder holder = new ValueTypeHolder(integer); // IMPORTANT! setValue(holder, 8L); Console.WriteLine(getValue(holder)); Console.ReadLine(); }
public FastValueRegisterExecuter(object owner, string propertyName, Action <T> loadAction, Func <T> getPropertyOfTheObjectFunction) { PropertyName = propertyName; _owner = owner; var type = owner.GetType(); _propertyGetter = type.DelegateForGetPropertyValue(propertyName); _propertySetter = type.DelegateForSetPropertyValue(propertyName); _loadAction = loadAction; _getPropertyOfTheObjectFunction = getPropertyOfTheObjectFunction; }
protected override void Initialize() { string call = attribute.Call; string set = attribute.Set; if (!set.IsNullOrEmpty()) { try { var field = targetType.GetField(set, Flags.InstanceAnyVisibility); _setter = field.DelegateForSet(); } catch { try { var property = targetType.GetProperty(set, Flags.InstanceAnyVisibility); _setter = property.DelegateForSet(); } catch { throw new vMemberNotFound(targetType, set); } } } if (!call.IsNullOrEmpty()) { try { var methods = targetType.GetAllMembers(typeof(object)).OfType <MethodInfo>(); _onChanged = (from method in methods where method.Name == call where method.ReturnType == typeof(void) let args = method.GetParameters() where args.Length == 1 where args[0].ParameterType.IsAssignableFrom(memberType) select method).FirstOrDefault().DelegateForCall(); } catch { throw new vMemberNotFound(targetType, call); } } _previousValue = memberValue; if (member.CollectionCount != -1) { _previousCollectionCount = member.CollectionCount; } }
private void WriteCollectionSizeToField(TContainingType obj) { //We must first access the collection to get the size and then write it into the field //before we try to truly serialize it ICollection enumerable = CollectionGetter.Getter(obj) as ICollection; if (enumerable == null) { throw new InvalidOperationException($"Tried to read the size of collection in Type: {typeof(TContainingType).Name} but did not implement {nameof(ICollection)}."); } MemberSetter.Setter(obj, GenericMath.Convert <int, TSizeType>(enumerable.Count)); }
/// <inheritdoc /> public override async Task SetMemberAsync(TContainingType obj, IWireStreamReaderStrategyAsync source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } #if NET35 throw new NotImplementedException(); #else MemberSetter.Setter(obj, (TMemberType)await TypeSerializer.ReadAsync(source).ConfigureAwait(false)); #endif }
/// <inheritdoc/> public override void Dispose() { #if ((UNITY_EDITOR || UNITY_STANDALONE) && !NET_STANDARD_2_0) && USE_IL_FOR_GET_AND_SET getValue = null; setValue = null; #endif #if UNITY_EDITOR serializedProperty = null; #endif LinkedMemberInfoPool.Dispose(this); }
private Field(FieldInfo field) : base(field) { if (field.DeclaringType is null) { throw new ArgumentException(ExceptionMessages.ModuleMemberDetected(field), nameof(field)); } var instanceParam = Parameter(field.DeclaringType.MakeByRefType()); var valueParam = Parameter(field.FieldType); getter = Lambda <MemberGetter <T, V> >(Field(instanceParam, field), instanceParam).Compile(); setter = field.IsInitOnly ? null : Lambda <MemberSetter <T, V> >(Assign(Field(instanceParam, field), valueParam), instanceParam, valueParam).Compile(); }
/// <summary> /// Creates single key queries. /// </summary> /// <typeparam name="KeyType">The key type.</typeparam> /// <param name="threadSafety">Determines the thread safe access for the</param> internal void Create<KeyType>(LazyThreadSafetyMode threadSafety) { SqlQueries<T> queries = (SqlQueries<T>) Queries; MemberSetter setter = EqualityColumns[0].Setter; ObjectFromKey = (key) => { object result = System.Runtime.Serialization.FormatterServices.GetUninitializedObject(typeof(T)); setter(result, key); return (T) result; }; queries.LazyBulkDeleteKeys = new Lazy<DbKeysInt<T>>(() => CreateBulkDeleteKeys<KeyType>(), threadSafety); queries.LazyBulkGetKeys = new Lazy<DbKeysList<T>>(() => CreateBulkGetKeys<KeyType>(), threadSafety); queries.LazyGetKeysKeys = new Lazy<DbWhereKeys>(() => CreateGetKeysKeys<KeyType>(), threadSafety); queries.GetKey = CreateGetKey(); queries.DeleteKey = CreateDeleteKey(); }
public override void SetMember(TContainingType obj, [NotNull] IWireStreamReaderStrategy source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } try { MemberSetter.Setter(obj, (TMemberType)TypeSerializer.Read(source)); } catch (Exception e) { throw new InvalidOperationException($"Failed to set member {MemberInformation.Name} on Type: {MemberInformation.DeclaringType} for Type: {obj.GetType().Name} Exception: {e.Message}.", e); } }
public void SetValue(AssignableValue assignableValue, object destination) { Logger.Create(this).Debug("Setting value on '{0}' using assignable value:{1}{2}", destination, Environment.NewLine, assignableValue); MemberSetter setter = TryCacheSet(destination.GetType(), assignableValue.PropertyName); try { setter(destination, assignableValue.DestinationValue); } catch (Exception ex) { throw new DittoExecutionException(ex, "Failure while mapping '{0}'{1}{2}", assignableValue, Environment.NewLine, ex); } }
protected override void OnSingleInitialization() { string call = attribute.Call; string set = attribute.Set; if (!set.IsNullOrEmpty()) { try { var field = targetType.GetField(set, Flags.InstanceAnyVisibility); setter = field.DelegateForSet(); } catch { try { var property = targetType.GetProperty(set, Flags.InstanceAnyVisibility); setter = property.DelegateForSet(); } catch { throw new MemberNotFoundException("Failed to get a field or property to set with the name: " + set); } } } if (!call.IsNullOrEmpty()) { try { var methods = targetType.GetAllMembers(typeof(object)).OfType <MethodInfo>(); onChanged = (from method in methods where method.Name == call where method.ReturnType == typeof(void) let args = method.GetParameters() where args.Length == 1 where args[0].ParameterType.IsAssignableFrom(memberType) select method).FirstOrDefault().DelegateForCall(); } catch { throw new MemberNotFoundException(string.Format("Couldn't find an appropriate method to call with the name: {0} on target {1} when apply OnChanged on member {2}", call, rawTarget, member.Name)); } } previous = memberValue; }
/// <summary> /// Initializes a new instance of the <see cref="Field"/> class. /// </summary> /// <param name="prop">The prop.</param> /// <param name="entityType"></param> public Field(PropertyInfo prop, Type entityType) { _Prop = prop; setter = prop.DelegateForSetPropertyValue(); getter = prop.DelegateForGetPropertyValue(); }
private void PrecacheReflections(Type controllerType) { var defaultConstructor = controllerType.GetConstructors().FirstOrDefault(x => x.GetParameters().Length == 0); if (defaultConstructor == null) throw new ArgumentException("StatementHandler " + controllerType.Name + " does not have a default constructor"); activator = FastFlect.GetActivator(defaultConstructor); delegateForScopeSetter = controllerType.DelegateForSetPropertyValue("Scope"); delegateForContextSetter = controllerType.DelegateForSetPropertyValue("Context"); delegateForAttachmentsSetter = controllerType.DelegateForSetPropertyValue("Attachments"); delegateForTracerSetter = controllerType.DelegateForSetPropertyValue("Tracer"); delegateForInvokation = definition.MethodInfo.DelegateForCallMethod(); if (definition.TransformsScopeTo != null) { scopeConverter = StaticAnalysis.CreateConverter(definition.TransformsScopeTo); transformsToValueType = definition.TransformsScopeTo.IsValueType; } }
private static Action<Object, Object> MakeValueSetter(String fieldName, MemberSetter setter) { return (entity, value) => { try { setter(entity, value); } catch (Exception ex) { throw new UnableToSetTheFieldValueException(ex, fieldName, value); } }; }