private static T New <T>(Type objType, IChoCustomObjectFactory customObjectFactory)
{
if (customObjectFactory == null)
{
return((T)ChoType.CreateInstance(objType));
}
//return (T)ChoRealProxy.GetProxy(ChoType.CreateInstance(objType));
else
{
return((T)customObjectFactory.CreateInstance(objType));
}
}
public static object CreateInstance(Type configObjType)
{
if (configObjType == null)
{
throw new ArgumentNullException("configObjType");
}
lock (_cacheLockObj)
{
if (_globalConfigurationsCache.ContainsKey(configObjType))
{
return(_globalConfigurationsCache[configObjType]);
}
else
{
object configObject = ChoType.CreateInstance(configObjType);
object owner = configObject;
if (ChoType.IsInterceptableObject(configObjType))
{
configObject = ChoInterceptingProxy.Instance(configObject);
}
//Load config file and assign values to object memebers
ChoConfigurationElementMapAttribute configurationElementMap = ChoType.GetAttribute(configObjType, typeof(ChoConfigurationElementMapAttribute)) as ChoConfigurationElementMapAttribute;
if (configurationElementMap == null)
{
throw new NullReferenceException(String.Format(CultureInfo.InvariantCulture, Resources.ES1001, configObjType.Name));
}
if (ChoType.IsConfigurableObject(configObjType))
{
((ChoConfigurableObject)owner).ReadOnly = configurationElementMap.ReadOnly;
}
_globalConfigurationsCache[configObjType] = configObject;
configurationElementMap.Construct(configObject);
return(configObject);
}
}
}
public virtual object CreateInstance()
{
if (ConverterType == null)
{
return(null);
}
if (ChoGuard.IsArgumentNotNullOrEmpty(Parameters) && ChoType.HasConstructor(ConverterType, Parameters))
{
return(ChoType.CreateInstance(ConverterType, Parameters));
}
else if (ChoType.HasConstructor(ConverterType, new object[] { String.Empty }))
{
return(ChoType.CreateInstance(ConverterType, new object[] { Parameters != null && Parameters.Length > 0 ? Parameters[0] : String.Empty }));
}
else
{
return(Activator.CreateInstance(ConverterType));
}
}
internal static object GetConfig(Type configObjectType, string configSectionPath, Type defaultConfigSectionHandlerType,
ChoBaseConfigurationElement configElement)
{
if (_configuration == null)
{
return(null);
}
ChoConfigurationSection configurationSection = ChoConfigurationManager.GetConfigSection(configSectionPath);
XmlNode[] restOfXmlElements = null;
Type configSectionHandlerType = defaultConfigSectionHandlerType;
if (configurationSection != null)
{
restOfXmlElements = configurationSection.RestOfXmlElements;
if (!configurationSection.Type.IsNullOrWhiteSpace())
{
configSectionHandlerType = ChoType.GetType(configurationSection.Type);
}
}
configElement.ConfigSectionHandlerType = configSectionHandlerType;
if (!typeof(IChoConfigurationSectionHandler).IsAssignableFrom(configSectionHandlerType))
{
throw new ChoConfigurationException("Configuration section handler type should be of IChoConfigurationSectionHandler type.");
}
if (typeof(IChoNullConfigurationSectionableHandler).IsAssignableFrom(configSectionHandlerType))
{
return(ChoType.CreateInstance <IChoConfigurationSectionHandler>(configSectionHandlerType).Create(configObjectType, null, restOfXmlElements, configElement));
}
else
{
XmlNode node = ChoXmlDocument.GetXmlNode(configSectionPath, _configuration.RestOfXmlDocumentElements);
//if (node != null)
return(ChoType.CreateInstance <IChoConfigurationSectionHandler>(configSectionHandlerType).Create(configObjectType, node, restOfXmlElements, configElement));
}
//return new ChoDefaultApplicationConfigSection(configObjectType);
}
/// <summary>
/// Method to create or get the instance of the class T.
/// </summary>
/// <param name="args">Constructor parameters, if any</param>
/// <returns>Instance of the class.</returns>
internal T Instance(bool strict, object[] args)
{
T _instance = default(T);
VerifySingtonType(strict);
if (IsCustomSingleType())
{
ConstructorInfo constructorInfo = GetSingletonContructor();
if (constructorInfo != null)
{
try
{
_instance = constructorInfo.Invoke(args) as T;
}
catch (Exception innerEx)
{
throw new ChoSingletonException(String.Format("Failed to invoke constructor [{0}] in `{1}` type due mismatch parametes.",
constructorInfo, typeof(T).FullName), innerEx);
}
}
else
{
_instance = CreateInstance(args);
}
}
else
{
_instance = ChoType.CreateInstance(typeof(T), args) as T;
}
if (_instance == null)
{
throw new ChoSingletonException("Instance object is null.");
}
return(_instance);
}
public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
{
ICustomTypeDescriptor defaultDescriptor = base.GetTypeDescriptor(objectType, instance);
ChoTypeProviderAttribute typeProviderAttribute = ChoType.GetAttribute <ChoTypeProviderAttribute>(GetType());
if (typeProviderAttribute != null)
{
if (ChoGuard.IsArgumentNotNullOrEmpty(typeProviderAttribute.AdditionalConstructorParameters))
{
return(ChoType.CreateInstance(typeProviderAttribute.Type,
ChoArray.Combine <object>(new object[] { this, defaultDescriptor, objectType, instance }, typeProviderAttribute.AdditionalConstructorParameters))
as ICustomTypeDescriptor);
}
else
{
return(ChoType.CreateInstance(typeProviderAttribute.Type,
new object[] { this, defaultDescriptor, objectType, instance }) as ICustomTypeDescriptor);
}
//return instance == null ? defaultDescriptor : new FieldsToPropertiesTypeDescriptor(this, defaultDescriptor, objectType);
}
return(defaultDescriptor);
}
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;
ChoPriorityQueue queue = new ChoPriorityQueue();
ChoPriorityQueue paramsQueue = new ChoPriorityQueue();
foreach (Attribute attribute in ChoType.GetAttributes(memberInfo, typeof(ChoTypeConverterAttribute), false))
{
ChoTypeConverterAttribute converterAttribute = (ChoTypeConverterAttribute)attribute;
if (converterAttribute != null)
{
queue.Enqueue(converterAttribute.Priority, converterAttribute.CreateInstance());
paramsQueue.Enqueue(converterAttribute.Priority, converterAttribute.Parameters);
}
if (queue.Count > 0)
{
_typeMemberTypeConverterCache[memberInfo] = queue.ToArray();
_typeMemberTypeConverterParamsCache[memberInfo] = paramsQueue.ToArray();
return(_typeMemberTypeConverterCache[memberInfo]);
}
}
if (queue.Count == 0 && !memberType.IsSimple())
{
if (!_typeTypeConverterCache.ContainsKey(memberType))
{
foreach (Type type in ChoType.GetTypes <ChoTypeConverterAttribute>())
{
ChoTypeConverterAttribute converterAttribute = type.GetCustomAttribute <ChoTypeConverterAttribute>();
if (converterAttribute != null && converterAttribute.ConverterType == memberType)
{
_typeTypeConverterCache.Add(memberType, new object[] { ChoType.CreateInstance(type) });
_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);
}
}
}
