private static object[] GetTypeConvertersInternal(MemberInfo memberInfo) { if (memberInfo != null) { Type type; if (ChoType.TryGetMemberType(memberInfo, out type) && (type == null)) { return(EmptyTypeConverters); } if (_typeMemberTypeConverterCache.ContainsKey(memberInfo)) { if ((_typeMemberTypeConverterCache[memberInfo] == EmptyTypeConverters) && _typeTypeConverterCache.ContainsKey(type)) { return(_typeTypeConverterCache[type]); } return(_typeMemberTypeConverterCache[memberInfo]); } lock (_typeMemberTypeConverterCacheLockObject) { if (!_typeMemberTypeConverterCache.ContainsKey(memberInfo)) { _typeMemberTypeConverterCache[memberInfo] = EmptyTypeConverters; _typeMemberTypeConverterParamsCache[memberInfo] = EmptyParams; ChoPriorityQueue queue = new ChoPriorityQueue(); ChoPriorityQueue queue2 = new ChoPriorityQueue(); foreach (Attribute attribute in ChoType.GetMemberAttributesByBaseType(memberInfo, typeof(ChoTypeConverterAttribute))) { ChoTypeConverterAttribute attribute2 = (ChoTypeConverterAttribute)attribute; if (attribute2 != null) { queue.Enqueue(attribute2.Priority, attribute2.CreateInstance()); queue2.Enqueue(attribute2.Priority, attribute2.Parameters); } if (queue.Count > 0) { _typeMemberTypeConverterCache[memberInfo] = queue.ToArray(); _typeMemberTypeConverterParamsCache[memberInfo] = queue2.ToArray(); return(_typeMemberTypeConverterCache[memberInfo]); } } if ((queue.Count == 0) && !type.IsSimple()) { if (!_typeTypeConverterCache.ContainsKey(type)) { Register(type); } return(_typeTypeConverterCache[type]); } } return(_typeMemberTypeConverterCache.ContainsKey(memberInfo) ? _typeMemberTypeConverterCache[memberInfo] : ((object[])EmptyTypeConverters)); } } return(EmptyTypeConverters); }
private static void Build(MemberInfo memberInfo) { List <IChoSurrogateValidator> validators = new List <IChoSurrogateValidator>(); ChoCompositeValidator compositeValidator = new ChoAndCompositeValidator(); foreach (Attribute memberCallAttribute in ChoType.GetMemberAttributesByBaseType(memberInfo, typeof(Attribute))) { foreach (IChoValidationManager validationManager in ChoValidationManagerSettings.Me.ValidationManagers) { if (memberCallAttribute is ChoCompositeValidatorAttribute) { if (((ChoCompositeValidatorAttribute)memberCallAttribute).CompositionType == ChoCompositionType.Or) { if (validators.Count > 0) { compositeValidator.Add(validators.ToArray()); validators.Add(compositeValidator); validators.Clear(); } compositeValidator = new ChoOrCompositeValidator(); } } else if (validationManager.IsValid(memberCallAttribute)) { IChoSurrogateValidator validator = validationManager.CreateValidator(memberCallAttribute, ValidationScope.Before, ValidatorSource.Attribute); if (validator != null) { validators.Add(validator); } } } } if (validators.Count > 0) { compositeValidator.Add(validators.ToArray()); validators.Add(compositeValidator); } _objectMemberValidatorCache.Add(memberInfo, new ChoAndCompositeValidator(validators.ToArray())); }
private static void DoValidate(object target, ChoValidationResults validationResults) { bool canContinue = true; foreach (MethodInfo methodInfo in GetValidationRoutines(target.GetType())) { canContinue = false; canContinue = (bool)ChoType.InvokeMethod(target, methodInfo.Name, validationResults); if (!canContinue) { break; } } //Do built-in attribute validations if (canContinue) { MemberInfo[] memberInfos = ChoType.GetMembers(target.GetType()); foreach (MemberInfo memberInfo in memberInfos) { foreach (ChoMemberAttribute memberAttribute in ChoType.GetMemberAttributesByBaseType(memberInfo, typeof(ChoMemberAttribute))) { try { memberAttribute.Validate(ChoType.GetMemberValue(target, memberInfo.Name), false); } catch (Exception ex) { validationResults.AddResult(ex.Message); } } } } }
//private static void SetAsNotDisposed(IChoProfile profile, bool dispose) //{ // if (profile == null) // return; // if (profile is ChoBufferProfile) // ((ChoBufferProfile)profile).CanDispose = dispose; // else if (profile is ChoStreamProfile) // ((ChoStreamProfile)profile).CanDispose = dispose; //} private static string GetProfileName(string name, out MemberInfo memberInfo, out string typeProfileFileName, out ChoProfileAttribute memberProfileAttribute, out ChoProfileAttribute typeProfileAttribute) { typeProfileFileName = null; StackFrame stackFrame = ChoStackTrace.GetStackFrame(typeof(ChoProfile).Namespace); memberInfo = stackFrame.GetMethod(); memberProfileAttribute = null; foreach (ChoProfileAttribute profileAttribute in ChoType.GetMemberAttributesByBaseType <ChoProfileAttribute>(memberInfo)) { if (profileAttribute.Name == name) { memberProfileAttribute = profileAttribute; break; } } ChoProfileAttribute emptyTypeProfileAttribute = null; typeProfileAttribute = null; foreach (ChoProfileAttribute profileAttribute in ChoType.GetAttributes <ChoProfileAttribute>(memberInfo.ReflectedType)) { if (String.IsNullOrEmpty(profileAttribute.Name)) { emptyTypeProfileAttribute = profileAttribute; } if (profileAttribute.Name == name) { typeProfileAttribute = profileAttribute; break; } } if (typeProfileAttribute == null) { if (emptyTypeProfileAttribute == null) { typeProfileFileName = GLOBAL_PROFILE_NAME; } else { typeProfileFileName = "{0}_{1}_{2}_{3}".FormatString(name.IsNullOrEmpty() ? "Default" : name, "Type", ChoThreadLocalStorage.Target == null ? 0 : ChoThreadLocalStorage.Target.GetHashCode(), ChoPropertyManager.ExpandProperties(ChoThreadLocalStorage.Target, emptyTypeProfileAttribute.Name)); } } else { typeProfileFileName = "{0}_{1}_{2}_{3}".FormatString(name.IsNullOrEmpty() ? "Default" : name, "Type", ChoThreadLocalStorage.Target == null ? 0 : ChoThreadLocalStorage.Target.GetHashCode(), ChoPropertyManager.ExpandProperties(ChoThreadLocalStorage.Target, typeProfileAttribute.Name)); } if (memberProfileAttribute != null) { return("{0}_{1}_{2}_{3}".FormatString(name.IsNullOrEmpty() ? "Default" : name, memberInfo.Name, ChoThreadLocalStorage.Target == null ? 0 : ChoThreadLocalStorage.Target.GetHashCode(), ChoPropertyManager.ExpandProperties(ChoThreadLocalStorage.Target, memberProfileAttribute.Name))); } else { return(typeProfileFileName); } }
public static object[] GetTypeConverters(MemberInfo memberInfo) { if (memberInfo == null) { return(null); } Type memberType; if (!ChoType.TryGetMemberType(memberInfo, out memberType) || (memberType == null /*|| memberType.IsSimple() */)) { return(null); } if (_typeMemberTypeConverterCache.ContainsKey(memberInfo)) { if (_typeMemberTypeConverterCache[memberInfo] == EmptyTypeConverters) { if (_typeTypeConverterCache.ContainsKey(memberType)) { return(_typeTypeConverterCache[memberType]); } } return(_typeMemberTypeConverterCache[memberInfo]); } else { lock (_typeMemberTypeConverterCacheLockObject) { if (!_typeMemberTypeConverterCache.ContainsKey(memberInfo)) { Type typeConverterAttribute = typeof(ChoTypeConverterAttribute); _typeMemberTypeConverterCache[memberInfo] = EmptyTypeConverters; _typeMemberTypeConverterParamsCache[memberInfo] = EmptyParams; SortedList <int, object> queue = new SortedList <int, object>(); SortedList <int, object[]> paramsQueue = new SortedList <int, object[]>(); foreach (Attribute attribute in ChoType.GetMemberAttributesByBaseType(memberInfo, typeof(ChoTypeConverterAttribute))) { ChoTypeConverterAttribute converterAttribute = (ChoTypeConverterAttribute)attribute; if (converterAttribute != null) { queue.Add(converterAttribute.Priority, converterAttribute.CreateInstance()); paramsQueue.Add(converterAttribute.Priority, converterAttribute.Parameters); } if (queue.Count > 0) { _typeMemberTypeConverterCache[memberInfo] = queue.Values.ToArray(); _typeMemberTypeConverterParamsCache[memberInfo] = paramsQueue.Values.ToArray(); return(_typeMemberTypeConverterCache[memberInfo]); } } if (queue.Count == 0 && !memberType.IsSimple()) { if (!_typeTypeConverterCache.ContainsKey(memberType)) { ChoTypeConverterAttribute converterAttribute = memberType.GetCustomAttribute <ChoTypeConverterAttribute>(); if (converterAttribute != null /*&& converterAttribute.ConverterType == memberType*/) { _typeTypeConverterCache.Add(memberType, new object[] { converterAttribute.CreateInstance() }); _typeTypeConverterParamsCache.Add(memberType, new object[] { converterAttribute.Parameters }); return(_typeTypeConverterCache[memberType]); } //} TypeConverter converter = TypeDescriptor.GetConverter(memberType); if (converter != null) { _typeTypeConverterCache.Add(memberType, new object[] { converter }); } else { _typeTypeConverterCache.Add(memberType, EmptyTypeConverters); } _typeTypeConverterParamsCache.Add(memberType, EmptyParams); } return(_typeTypeConverterCache[memberType]); } } return(_typeMemberTypeConverterCache.ContainsKey(memberInfo) ? _typeMemberTypeConverterCache[memberInfo] : EmptyTypeConverters); } } }
private static void Build(MemberInfo memberInfo) { string validatorName = null; List <IChoSurrogateValidator> validators = new List <IChoSurrogateValidator>(); Dictionary <string, IChoSurrogateValidator> namedValidators = new Dictionary <string, IChoSurrogateValidator>(); List <ChoCompositeValidatorAttribute> compositeValidatorsAttrs = new List <ChoCompositeValidatorAttribute>(); ChoCompositeValidator topCompositeValidator = new ChoAndCompositeValidator(); ChoCompositeValidator compositeValidator = topCompositeValidator; Attribute[] attrs = ChoType.GetMemberAttributesByBaseType(memberInfo, typeof(Attribute)); //Lookup all non composite validators, build and cache them foreach (Attribute memberCallAttribute in attrs) { if (!(memberCallAttribute is ChoCompositeValidatorAttribute)) { foreach (IChoValidationManager validationManager in ChoValidationManagerSettings.Me.ValidationManagers) { if (validationManager.IsValid(memberCallAttribute, out validatorName)) { if (!validatorName.IsNullOrWhiteSpace() && namedValidators.ContainsKey(validatorName)) { continue; } IChoSurrogateValidator validator = validationManager.CreateValidator(memberCallAttribute, ValidationScope.Before, ValidatorSource.Attribute); if (validator != null) { if (validatorName.IsNullOrWhiteSpace()) { validators.Add(validator); } else { namedValidators.Add(validatorName, validator); } } break; } } } else if (memberCallAttribute is ChoCompositeValidatorAttribute) { compositeValidatorsAttrs.Add(memberCallAttribute as ChoCompositeValidatorAttribute); } } //Build and cache all the composite validators foreach (ChoCompositeValidatorAttribute memberCallAttribute in compositeValidatorsAttrs) { if (memberCallAttribute.Name.IsNullOrWhiteSpace()) { IChoSurrogateValidator validator = BuildCompositeValidator(memberCallAttribute as ChoCompositeValidatorAttribute, namedValidators, compositeValidatorsAttrs.ToArray()); if (validator != null) { validators.Add(validator); } } } _objectMemberValidatorCache.Add(memberInfo, new ChoAndCompositeValidator(validators.ToArray())); }
/// In the Invoke Method we do our interception work. public override IMessage Invoke(IMessage msg) { ///the MethodCallMessageWrapper provides read/write access to the method call arguments. MethodCallMessageWrapper methodCallMsg = new MethodCallMessageWrapper((IMethodCallMessage)msg); ///This is the reflected method base of the called method. MethodInfo methodInfo = (MethodInfo)methodCallMsg.MethodBase; ///This is the object we are proxying. MarshalByRefObject owner = GetUnwrappedServer(); ///Some basic initializations for later use IMethodReturnMessage returnMsg = null; if (owner != null) { ChoMemberInfo memberInfo = new ChoMemberInfo(owner, methodCallMsg); try { lock (this) { if (owner is ChoInterceptableObject && memberInfo.DirtyOperation && !((ChoInterceptableObject)owner).Silent) { ((ChoInterceptableObject)owner).SetDirty(memberInfo.DirtyOperation); } if (owner is ChoInterceptableObject) { ((ChoInterceptableObject)owner).PreInvoke(methodCallMsg, memberInfo); } if (memberInfo.Info != null) { foreach (IChoBeforeMemberCallAttribute beforeMemberCallAttribute in ChoType.GetMemberAttributesByBaseType(memberInfo.Info, typeof(IChoBeforeMemberCallAttribute))) { beforeMemberCallAttribute.Validate(memberInfo.Value, ((ChoInterceptableObject)owner).Silent); } } //outVal = methodInfo.Invoke(owner, methodCallMsg.Args); returnMsg = RemotingServices.ExecuteMessage(owner, methodCallMsg); if (memberInfo.Info != null) { memberInfo.MethodMsg = returnMsg; foreach (IChoAfterMemberCallAttribute afterMemberCallAttribute in ChoType.GetMemberAttributesByBaseType(memberInfo.Info, typeof(IChoAfterMemberCallAttribute))) { afterMemberCallAttribute.Validate(memberInfo.Value, ((ChoInterceptableObject)owner).Silent); } } if (owner is ChoInterceptableObject) { ((ChoInterceptableObject)owner).PostInvoke(methodCallMsg, memberInfo); } return(returnMsg); // new ReturnMessage(outVal, methodCallMsg.Args, methodCallMsg.Args.Length, methodCallMsg.LogicalCallContext, methodCallMsg); } } catch (TargetInvocationException ex) { return(new ReturnMessage(ex.InnerException, methodCallMsg)); } } throw new NullReferenceException("Missing target object."); }