public virtual XmlQualifiedName GetXmlQualifiedName(Type type, out string prefix)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
string typeNamespace = type.Namespace ?? String.Empty;
string assemblyName = (type.Assembly != null && type.Assembly != this.localAssembly) ? type.Assembly.FullName : String.Empty;
int key = typeNamespace.GetHashCode() ^ assemblyName.GetHashCode();
if (!this.clrNamespaceBasedMappings.TryGetValue(key, out WorkflowMarkupSerializerMapping mappingForType))
{
WorkflowMarkupSerializerMapping.GetMappingFromType(this, type, out mappingForType, out IList <WorkflowMarkupSerializerMapping> collectedMappings);
AddMappings(new List <WorkflowMarkupSerializerMapping>(new WorkflowMarkupSerializerMapping[] { mappingForType }));
AddMappings(collectedMappings);
}
string typeName = WorkflowMarkupSerializer.EnsureMarkupExtensionTypeName(type);
//Make sure that while writting the workflow namespaces will always be the default
prefix = (mappingForType.Prefix.Equals(StandardXomlKeys.WorkflowPrefix, StringComparison.Ordinal)) ? String.Empty : mappingForType.Prefix;
return(new XmlQualifiedName(typeName, mappingForType.XmlNamespace));
}
static WorkflowMarkupSerializerMapping()
{
WorkflowMarkupSerializerMapping.wellKnownTypes = new Dictionary <string, Type>();
//I am hard coding the well known mappings here instead of going through the assemblies as we want the mappings to be in
//a specific order for performance optimization when searching for type
WorkflowMarkupSerializerMapping.wellKnownMappings = new List <WorkflowMarkupSerializerMapping>();
WorkflowMarkupSerializerMapping.Serialization = new WorkflowMarkupSerializerMapping(StandardXomlKeys.Definitions_XmlNs_Prefix, StandardXomlKeys.Definitions_XmlNs, "LogicBuilder.Workflow.ComponentModel.Serialization", Assembly.GetExecutingAssembly().FullName);
WorkflowMarkupSerializerMapping.wellKnownMappings.Add(WorkflowMarkupSerializerMapping.Serialization);
WorkflowMarkupSerializerMapping.Rules = new WorkflowMarkupSerializerMapping(StandardXomlKeys.WorkflowPrefix, StandardXomlKeys.WorkflowXmlNs, "LogicBuilder.Workflow.Activities.Rules", AssemblyRef.ActivitiesAssemblyRef);
WorkflowMarkupSerializerMapping.wellKnownMappings.Add(WorkflowMarkupSerializerMapping.Rules);
//Possibly need this to work with a designer.
WorkflowMarkupSerializerMapping.wellKnownMappings.Add(new WorkflowMarkupSerializerMapping(StandardXomlKeys.WorkflowPrefix, StandardXomlKeys.WorkflowXmlNs, "LogicBuilder.Workflow.Activities.Rules.Design", AssemblyRef.DialogAssemblyRef));
}
public override bool Equals(object value)
{
WorkflowMarkupSerializerMapping mapping = value as WorkflowMarkupSerializerMapping;
if (mapping == null)
{
return(false);
}
//
// This class is intended to make MT scenarios easier by holding both the target and the unified (current)
// assembly names. They both represent the same type in this container and thus the both need to match to be equal.
// This makes it easier to make this classes default (static constructor) work better with MT in the rest of the codebase.
if (this.clrns == mapping.clrns &&
this.targetAssemblyName == mapping.targetAssemblyName &&
this.unifiedAssemblyName == mapping.unifiedAssemblyName)
{
return(true);
}
return(false);
}
internal static void GetMappingFromType(WorkflowMarkupSerializationManager manager, Type type, out WorkflowMarkupSerializerMapping matchingMapping, out IList <WorkflowMarkupSerializerMapping> collectedMappings)
{
matchingMapping = null;
collectedMappings = new List <WorkflowMarkupSerializerMapping>();
string clrNamespace = type.Namespace ?? String.Empty;
string xmlNamespace = String.Empty;
string assemblyName = String.Empty;
string prefix = String.Empty;
assemblyName = GetAssemblyName(type, manager);
if (type.Assembly.FullName.Equals(AssemblyRef.ActivitiesAssemblyRef, StringComparison.Ordinal))
{
xmlNamespace = StandardXomlKeys.WorkflowXmlNs;
prefix = StandardXomlKeys.WorkflowPrefix;
}
else if (type.Assembly.FullName.Equals(AssemblyRef.DialogAssemblyRef, StringComparison.Ordinal))
{
xmlNamespace = StandardXomlKeys.WorkflowXmlNs;
prefix = StandardXomlKeys.WorkflowPrefix;
}
else if (type.Assembly == Assembly.GetExecutingAssembly())
{
xmlNamespace = StandardXomlKeys.WorkflowXmlNs;
prefix = StandardXomlKeys.WorkflowPrefix;
}
if (xmlNamespace.Length == 0)
{
//First lookup the type's assembly for XmlNsDefinitionAttribute
object[] xmlnsDefinitions = type.Assembly.GetCustomAttributes(typeof(XmlnsDefinitionAttribute), true);
foreach (XmlnsDefinitionAttribute xmlnsDefinition in xmlnsDefinitions)
{
xmlNamespace = xmlnsDefinition.XmlNamespace;
assemblyName = xmlnsDefinition.AssemblyName;
if (type.Assembly == manager.LocalAssembly)
{
assemblyName = String.Empty;
}
else if (String.IsNullOrEmpty(assemblyName))
{
assemblyName = GetAssemblyName(type, manager);
}
if (String.IsNullOrEmpty(xmlNamespace))
{
xmlNamespace = GetFormatedXmlNamespace(clrNamespace, assemblyName);
}
prefix = GetPrefix(manager, type.Assembly, xmlNamespace);
WorkflowMarkupSerializerMapping mapping = new WorkflowMarkupSerializerMapping(prefix, xmlNamespace, clrNamespace, assemblyName, type.Assembly.FullName);
if (xmlnsDefinition.ClrNamespace.Equals(clrNamespace, StringComparison.Ordinal) && matchingMapping == null)
{
matchingMapping = mapping;
}
else
{
collectedMappings.Add(mapping);
}
}
}
if (matchingMapping == null)
{
if (type.Assembly == manager.LocalAssembly)
{
assemblyName = String.Empty;
}
else if (String.IsNullOrEmpty(assemblyName))
{
assemblyName = GetAssemblyName(type, manager);
}
xmlNamespace = GetFormatedXmlNamespace(clrNamespace, assemblyName);
if (String.IsNullOrEmpty(prefix))
{
prefix = GetPrefix(manager, type.Assembly, xmlNamespace);
}
matchingMapping = new WorkflowMarkupSerializerMapping(prefix, xmlNamespace, clrNamespace, assemblyName, type.Assembly.FullName);
}
}
public virtual Type GetType(XmlQualifiedName xmlQualifiedName)
{
if (xmlQualifiedName == null)
{
throw new ArgumentNullException("xmlQualifiedName");
}
string xmlns = xmlQualifiedName.Namespace;
string typeName = WorkflowMarkupSerializer.EnsureMarkupExtensionTypeName(xmlQualifiedName);
// first check our cache
cachedXmlQualifiedNameTypes.TryGetValue(xmlQualifiedName, out Type resolvedType);
if (resolvedType == null)
{
// lookup in well known types
resolvedType = WorkflowMarkupSerializerMapping.ResolveWellKnownTypes(this, xmlns, typeName);
}
if (resolvedType == null)
{
//Lookup existing mapping
if (!this.xmlNamespaceBasedMappings.TryGetValue(xmlns, out List <WorkflowMarkupSerializerMapping> xmlnsMappings))
{
WorkflowMarkupSerializerMapping.GetMappingsFromXmlNamespace(this, xmlns, out IList <WorkflowMarkupSerializerMapping> matchingMappings, out IList <WorkflowMarkupSerializerMapping> collectedMappings);
AddMappings(matchingMappings);
AddMappings(collectedMappings);
xmlnsMappings = new List <WorkflowMarkupSerializerMapping>(matchingMappings);
}
foreach (WorkflowMarkupSerializerMapping xmlnsMapping in xmlnsMappings)
{
string assemblyName = xmlnsMapping.AssemblyName;
string clrNamespace = xmlnsMapping.ClrNamespace;
// append dot net namespace name
string fullTypeName = xmlQualifiedName.Name;
if (clrNamespace.Length > 0)
{
fullTypeName = clrNamespace + "." + xmlQualifiedName.Name;
}
// Work around for component model assembly
if (assemblyName.Equals(Assembly.GetExecutingAssembly().FullName, StringComparison.Ordinal))
{
resolvedType = Assembly.GetExecutingAssembly().GetType(fullTypeName);
}
else if (assemblyName.Length == 0)
{
if (this.localAssembly != null)
{
resolvedType = this.localAssembly.GetType(fullTypeName);
}
}
else
{
string assemblyQualifiedName = fullTypeName;
if (assemblyName.Length > 0)
{
assemblyQualifiedName += (", " + assemblyName);
}
// now grab the actual type
try
{
resolvedType = GetType(assemblyQualifiedName);
}
catch
{
//
}
if (resolvedType == null)
{
resolvedType = GetType(fullTypeName);
if (resolvedType != null && !resolvedType.AssemblyQualifiedName.Equals(assemblyQualifiedName, StringComparison.Ordinal))
{
resolvedType = null;
}
}
}
//We found the type
if (resolvedType != null)
{
cachedXmlQualifiedNameTypes[xmlQualifiedName] = resolvedType;
break;
}
}
}
return(resolvedType);
}
