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