protected Resource ExtractValue(Entity cEntity, IValueInitInfo valInfo, Store rdfStore)
{
if (valInfo is RefValueInfo)
{
var compRef = ((RefValueInfo)valInfo).ComponentRef;
ExtractComponent(compRef, rdfStore);
// register dependency
var resEntity = GetCEntity(compRef);
rdfStore.Add(new Statement(cEntity, NS.NrDepFromEntity, resEntity));
return(resEntity);
}
else if (valInfo is ValueInitInfo)
{
var val = ((ValueInitInfo)valInfo).Value;
return(new Literal(Convert.ToString(val)));
}
else if (valInfo is ListValueInitInfo)
{
Entity bNode = new BNode();
rdfStore.Add(new Statement(
bNode, NS.Rdf.type, NS.Rdf.SeqEntity));
var values = ((ListValueInitInfo)valInfo).Values;
for (int i = 0; i < values.Length; i++)
{
var valEntity = ExtractValue(cEntity, values[i], rdfStore);
if (valEntity != null)
{
rdfStore.Add(new Statement(
bNode, NS.Rdf.BASE + "_" + (i + 1).ToString(), valEntity));
}
}
return(bNode);
}
return(null);
}
public object GetValue(IValueFactory factory, Type conversionType)
{
lock (cachedTypedArraysSyncObject)
{
// try to find in consts cache
if (isOnlyConstValues && cachedTypedArrays != null &&
conversionType.IsArray && cachedTypedArrays.ContainsKey(conversionType.GetElementType()))
{
return(cachedTypedArrays[conversionType.GetElementType()].Clone());
}
// try to create instance of desired type
Type elemType = typeof(object);
if (conversionType.IsArray)
{
elemType = conversionType.GetElementType();
}
Array listArray = Array.CreateInstance(elemType, Values.Length);
for (int i = 0; i < Values.Length; i++)
{
IValueInitInfo value = Values[i];
listArray.SetValue(value.GetValue(factory, elemType), i);
}
// store in consts cache
if (isOnlyConstValues && conversionType.IsArray)
{
if (cachedTypedArrays == null)
{
cachedTypedArrays = new Dictionary <Type, Array>();
}
cachedTypedArrays[elemType] = (Array)listArray.Clone();
}
if (conversionType.IsArray)
{
return(listArray); // nothing to convert
}
return(factory.GetInstance(listArray, conversionType));
}
}
public PropertyInfo(string name, IValueInitInfo value)
{
_Name = name;
_Value = value;
}
protected IValueInitInfo ResolveValueInfo(XPathNavigator objectDefinition, IXmlNamespaceResolver xmlNs, IDictionary <string, ComponentInitInfo> components)
{
// component definition ?
var componentNode = objectDefinition.SelectSingleNode("ioc:component", xmlNs);
if (componentNode != null)
{
// build nested component init info
ComponentInitInfo nestedComponentInfo = ReadComponentInitInfo(componentNode, xmlNs);
InitValues(nestedComponentInfo, componentNode, xmlNs, components);
return(new RefValueInfo(nestedComponentInfo));
}
// reference ?
var refNode = objectDefinition.SelectSingleNode("ioc:ref", xmlNs);
if (refNode != null)
{
string refName = refNode.GetAttribute("name", String.Empty);
if (!components.ContainsKey(refName))
{
throw new NullReferenceException("Reference to non-existent component: " + refName);
}
string methodName = refNode.GetAttribute("method", String.Empty);
if (methodName.Trim() == String.Empty)
{
methodName = null;
}
return(new RefValueInfo(components[refName], methodName));
}
// value ?
var valueNode = objectDefinition.SelectSingleNode("ioc:value", xmlNs);
if (valueNode != null)
{
return(new ValueInitInfo(valueNode.Value));
}
// xml ?
var xmlNode = objectDefinition.SelectSingleNode("ioc:xml", xmlNs);
if (xmlNode != null)
{
return(new ValueInitInfo(xmlNode.InnerXml));
}
// System.Type reference ?
var typeNode = objectDefinition.SelectSingleNode("ioc:type", xmlNs);
if (typeNode != null)
{
return(new TypeValueInitInfo(TypeResolver.ResolveType(typeNode.InnerXml)));
}
// list ?
var listNode = objectDefinition.SelectSingleNode("ioc:list", xmlNs);
if (listNode != null)
{
var entryNodes = listNode.Select("ioc:entry", xmlNs);
IValueInitInfo[] entries = new IValueInitInfo[entryNodes.Count];
int listEntryIdx = 0;
while (entryNodes.MoveNext())
{
entries[listEntryIdx++] = ResolveValueInfo(entryNodes.Current, xmlNs, components);
}
return(new ListValueInitInfo(entries));
}
// map ?
var mapNode = objectDefinition.SelectSingleNode("ioc:map", xmlNs);
if (mapNode != null)
{
var entryNodes = mapNode.Select("ioc:entry", xmlNs);
MapEntryInfo[] entries = new MapEntryInfo[entryNodes.Count];
int mapEntryIndex = 0;
while (entryNodes.MoveNext())
{
entries[mapEntryIndex++] = new MapEntryInfo(
entryNodes.Current.GetAttribute("key", String.Empty),
ResolveValueInfo(entryNodes.Current, xmlNs, components));
}
return(new MapValueInitInfo(entries));
}
// unknown object definition (???)
throw new XmlConfigurationException("Unknown object definition");
}
internal void SetObjectProperty(Type t, object o, string propName, IValueFactory factory, IValueInitInfo valueInfo)
{
if (ReflectionCacheEnabled)
{
ReflectionPropertyCacheKey cacheKey = new ReflectionPropertyCacheKey(t, propName);
ReflectionPropertyCacheValue cacheValue;
if (!propertyInfoCache.TryGetValue(cacheKey, out cacheValue))
{
System.Reflection.PropertyInfo propInfo = t.GetProperty(propName);
if (propInfo == null)
{
throw new MissingMethodException(t.ToString(), propName);
}
MethodInfo setMethodInfo = propInfo.GetSetMethod(false);
DynamicMethod setDynMethod = new DynamicMethod(String.Empty, typeof(void), new Type[] { typeof(object), typeof(object) }, t, true);
ILGenerator setGenerator = setDynMethod.GetILGenerator();
setGenerator.Emit(OpCodes.Ldarg_0);
setGenerator.Emit(OpCodes.Ldarg_1);
if (setMethodInfo.GetParameters()[0].ParameterType.IsValueType)
{
setGenerator.Emit(OpCodes.Unbox_Any, setMethodInfo.GetParameters()[0].ParameterType);
}
setGenerator.Emit(OpCodes.Call, setMethodInfo);
setGenerator.Emit(OpCodes.Ret);
cacheValue = new ReflectionPropertyCacheValue(
(PropertySetHandler)setDynMethod.CreateDelegate(typeof(PropertySetHandler)),
propInfo.PropertyType);
// despite the fact Dictionary is thread safe, for some reason sometimes exceptions are thrown without extra lock
lock (propertyInfoCache) {
propertyInfoCache[cacheKey] = cacheValue;
}
}
object value = valueInfo.GetValue(factory, cacheValue.PropertyType);
cacheValue.SetHandler(o, value);
}
else
{
System.Reflection.PropertyInfo propInfo = t.GetProperty(propName);
if (propInfo == null)
{
throw new MissingMethodException(t.ToString(), propName);
}
propInfo.SetValue(o, valueInfo.GetValue(factory, propInfo.PropertyType), null);
}
}
public MapEntryInfo(string key, IValueInitInfo value)
{
_Key = key;
_Value = value;
}
