public IConstructorArgumentProperties GetConstructorArgumentProperties()
{
if (this.constructorArgumentProperties == null)
{
this.constructorArgumentProperties = PlatformTypeHelper.GetConstructorArgumentProperties(this);
}
return(this.constructorArgumentProperties);
}
public override bool Instantiate(IInstanceBuilderContext context, ViewNode viewNode)
{
IConstructorArgumentNodeCollection constructorArgumentNodeCollections;
if (viewNode.Instance == null)
{
DocumentCompositeNode documentNode = viewNode.DocumentNode as DocumentCompositeNode;
if (documentNode == null)
{
return(base.Instantiate(context, viewNode));
}
IType type = documentNode.Type;
IConstructor bestConstructor = documentNode.GetBestConstructor(out constructorArgumentNodeCollections);
if (bestConstructor == null)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
string instanceBuilderCannotInstantiateType = ExceptionStringTable.InstanceBuilderCannotInstantiateType;
object[] name = new object[] { type.Name };
throw new InstanceBuilderException(string.Format(currentCulture, instanceBuilderCannotInstantiateType, name), documentNode);
}
IConstructorArgumentProperties constructorArgumentProperties = type.GetConstructorArgumentProperties();
IPropertyId[] propertyIdArray = new IPropertyId[constructorArgumentNodeCollections.Count];
IPropertyId[] propertyIdArray1 = propertyIdArray;
propertyIdArray1 = propertyIdArray;
if (!context.IsSerializationScope)
{
object[] objArray = new object[constructorArgumentNodeCollections.Count];
for (int i = 0; i < constructorArgumentNodeCollections.Count; i++)
{
IParameter item = bestConstructor.Parameters[i];
IProperty property = constructorArgumentProperties[item.Name];
propertyIdArray1[i] = property;
objArray[i] = MarkupExtensionInstanceBuilderBase.InstantiateConstructorArgument(context, viewNode, item, property, constructorArgumentNodeCollections[i]);
}
try
{
viewNode.Instance = bestConstructor.Invoke(objArray);
}
catch (Exception exception1)
{
Exception exception = exception1;
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
string str = ExceptionStringTable.InstanceBuilderCannotInstantiateType;
object[] name1 = new object[] { type.Name };
throw new InstanceBuilderException(string.Format(cultureInfo, str, name1), exception, documentNode);
}
}
else
{
DocumentNode[] documentNodeArray = new DocumentNode[constructorArgumentNodeCollections.Count];
for (int j = 0; j < constructorArgumentNodeCollections.Count; j++)
{
IParameter parameter = bestConstructor.Parameters[j];
IProperty item1 = constructorArgumentProperties[parameter.Name];
propertyIdArray1[j] = item1;
documentNodeArray[j] = (DocumentNode)MarkupExtensionInstanceBuilderBase.InstantiateConstructorArgument(context, viewNode, parameter, item1, constructorArgumentNodeCollections[j]);
}
type = (IType)type.Clone(context.DocumentContext.TypeResolver);
DocumentCompositeNode documentCompositeNode = context.DocumentContext.CreateNode(type);
documentCompositeNode.SetConstructor(bestConstructor, documentNodeArray);
viewNode.Instance = documentCompositeNode;
}
if (viewNode.Instance != null)
{
List <DocumentNode> documentNodes = null;
foreach (IProperty property1 in context.GetProperties(viewNode))
{
if (Array.IndexOf <IPropertyId>(propertyIdArray1, property1) >= 0)
{
continue;
}
if (documentNodes == null)
{
documentNodes = new List <DocumentNode>();
}
documentNodes.Add(documentNode.Properties[property1]);
}
if (documentNodes != null)
{
documentNodes.Sort(MarkupExtensionInstanceBuilderBase.DocumentNodeComparer);
foreach (DocumentNode documentNode1 in documentNodes)
{
this.UpdateProperty(context, viewNode, documentNode1.SitePropertyKey, documentNode1);
}
}
}
}
viewNode.InstanceState = InstanceState.Valid;
return(true);
}
public bool Refresh()
{
ITypeId typeId = this.baseType;
IPropertyId propertyId = this.nameProperty;
IPropertyId propertyId1 = this.defaultContentProperty;
ITypeId typeId1 = this.itemType;
ITypeId typeId2 = this.nullableType;
System.ComponentModel.TypeConverter typeConverter = this.typeConverter;
IAssembly assembly = this.GetAssembly(this.typeResolver, this.assemblyName);
if (!assembly.IsLoaded)
{
return(true);
}
this.assembly = assembly;
this.type = this.GetRuntimeType();
this.typeConverter = null;
this.initializationException = null;
if (this.type != null)
{
this.lastResolvedType = this.type;
this.isBuilt = true;
}
this.Cache();
bool flag = true;
if (this.constructors != null)
{
foreach (Constructor constructor in this.constructors)
{
ICachedMemberInfo cachedMemberInfo = constructor;
if (cachedMemberInfo == null || cachedMemberInfo.Refresh())
{
continue;
}
flag = false;
}
if (flag && this.type != null)
{
int num = 0;
ConstructorInfo[] constructors = PlatformTypeHelper.GetConstructors(this.type);
if (constructors != null)
{
ConstructorInfo[] constructorInfoArray = constructors;
for (int i = 0; i < (int)constructorInfoArray.Length; i++)
{
if (PlatformTypeHelper.IsAccessibleConstructor(constructorInfoArray[i]))
{
num++;
}
}
}
if (num != this.constructors.Count)
{
flag = false;
}
}
}
if (!this.members.Refresh())
{
flag = false;
}
if (flag && (typeId != this.baseType || typeId1 != this.itemType || typeId2 != this.nullableType))
{
flag = false;
}
if (flag && (propertyId != this.nameProperty || propertyId1 != this.defaultContentProperty))
{
flag = false;
}
if (flag && ProjectContextType.GetTypeConverterId(typeConverter) != ProjectContextType.GetTypeConverterId(this.typeConverter))
{
flag = false;
}
if (flag && this.constructorArgumentProperties != null)
{
IConstructorArgumentProperties constructorArgumentProperties = PlatformTypeHelper.GetConstructorArgumentProperties(this);
if (constructorArgumentProperties.Count == this.constructorArgumentProperties.Count)
{
foreach (string constructorArgumentProperty in constructorArgumentProperties)
{
if (constructorArgumentProperties[constructorArgumentProperty] == this.constructorArgumentProperties[constructorArgumentProperty])
{
continue;
}
flag = false;
break;
}
}
else
{
flag = false;
}
}
return(flag);
}
private static DocumentNode ParseMarkupExtension(XamlParserContext parserContext, ITextLocation lineInformation, IDocumentNodeReference nodeReference, IXmlNamespaceResolver xmlNamespaceResolver, IType typeId, MarkupExtensionDescription description)
{
int count = description.PositionalArguments.Count;
DocumentCompositeNode node = parserContext.DocumentContext.CreateNode((ITypeId)typeId);
IDocumentNodeReference documentNodeReference = (IDocumentNodeReference) new DocumentCompositeNodeReference(nodeReference, node);
IConstructor constructor1 = (IConstructor)null;
if (typeId.IsResolvable)
{
IList <IConstructor> constructors = typeId.GetConstructors();
if (constructors.Count > 0)
{
int num = 0;
foreach (IConstructor constructor2 in (IEnumerable <IConstructor>)constructors)
{
if (constructor2.Parameters.Count == count)
{
if (num == 0)
{
constructor1 = constructor2;
}
++num;
}
}
if (num == 0)
{
parserContext.ReportError(XamlParseErrors.IncorrectNumberOfConstructorArguments(lineInformation, (ITypeId)typeId));
}
else if (num <= 1)
{
;
}
}
else
{
parserContext.ReportError(XamlParseErrors.NoAccessibleConstructor(lineInformation, (ITypeId)typeId));
}
}
DocumentNode[] documentNodeArray = constructor1 != null ? new DocumentNode[constructor1.Parameters.Count] : (DocumentNode[])null;
IConstructorArgumentProperties argumentProperties = typeId.GetConstructorArgumentProperties();
if (count > 0)
{
for (int index = 0; index < count; ++index)
{
string str = description.PositionalArguments[index];
bool flag = constructor1 != null && index < constructor1.Parameters.Count;
IType type = parserContext.TypeResolver.ResolveType(parserContext.TypeResolver.PlatformMetadata.KnownTypes.Object);
if (flag)
{
IParameter parameter = constructor1.Parameters[index];
type = parserContext.TypeResolver.ResolveType((ITypeId)parameter.ParameterType);
IProperty property = argumentProperties[parameter.Name];
if (property != null && !property.PropertyType.IsAssignableFrom((ITypeId)type))
{
flag = false;
parserContext.ReportError(XamlParseErrors.ConstructorArgumentDeclaredTypeDoesNotMatchProperty(lineInformation, (IPropertyId)property));
}
}
TypeConverter typeConverter = type.TypeConverter;
DocumentNode propertyValue = MarkupExtensionParser.GetPropertyValue(parserContext, lineInformation, documentNodeReference, xmlNamespaceResolver, typeConverter, type, str, true);
if (flag && propertyValue != null)
{
documentNodeArray[index] = XamlParser.CanAssignTo(parserContext, lineInformation, type, propertyValue) ? propertyValue : (DocumentNode)null;
}
}
}
node.SetConstructor(constructor1, (IList <DocumentNode>)documentNodeArray);
int num1 = 0;
foreach (KeyValuePair <string, string> keyValuePair in (IEnumerable <KeyValuePair <string, string> >)description.NamedArguments)
{
string key = keyValuePair.Key;
MemberType memberTypes = MemberType.LocalProperty | MemberType.AttachedProperty | MemberType.Field;
if (parserContext.TypeResolver.IsCapabilitySet(PlatformCapability.IncompleteAttachedPropertiesInMarkupExtensions))
{
memberTypes |= MemberType.IncompleteAttachedProperty;
}
IProperty propertyKey = XamlTypeHelper.GetPropertyKey(parserContext, lineInformation, xmlNamespaceResolver, key, (XmlNamespace)null, typeId, memberTypes, MemberType.LocalProperty, false);
if (propertyKey != null)
{
DocumentNode propertyValue = MarkupExtensionParser.GetPropertyValue(parserContext, lineInformation, documentNodeReference, xmlNamespaceResolver, propertyKey, keyValuePair.Value, true);
if (propertyValue != null && XamlParser.SetProperty(parserContext, lineInformation, new DocumentCompositeNodeReference(documentNodeReference, node), (XamlSourceContext)null, (IPropertyId)propertyKey, propertyValue))
{
propertyValue.ContainerSourceContext = (INodeSourceContext) new MarkupExtensionParser.MinimalSourceContext(num1++);
}
}
}
return((DocumentNode)node);
}
