| public abstract TryResolveType ( System type, System declaredType, System knownTypeResolver, System &typeName, System &typeNamespace ) : bool | ||
| type | System | |
| declaredType | System | |
| knownTypeResolver | System | |
| typeName | System | |
| typeNamespace | System | |
| 리턴 | bool | |
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver,
out System.Xml.XmlDictionaryString typeName,
out System.Xml.XmlDictionaryString typeNamespace)
{
if (type == null)
throw new ArgumentNullException("type");
if (declaredType == null)
throw new ArgumentNullException("declaredType");
if (knownTypeResolver == null)
throw new ArgumentNullException("knownTypeResolver");
if (knownTypeResolver.TryResolveType(type, declaredType, knownTypeResolver, out typeName, out typeNamespace))
return true;
if (type.IsPrimitive && declaredType == typeof(object))
{
return knownTypeResolver.TryResolveType(type, type, knownTypeResolver, out typeName, out typeNamespace);
}
XmlDictionary dict = new XmlDictionary();
typeNamespace = dict.Add(xmlNamespace);
typeName = dict.Add(type.AssemblyQualifiedName);
return true;
}
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
var res = knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace);
if (res)
return res;
System.Reflection.Assembly asm = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(p => p == dataContractType.Assembly);
if (asm != null)
{
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add(dataContractType.Name);
typeNamespace = dictionary.Add("http://tempuri.com/" + asm.FullName);
return true;
}
foreach (IPlugin plugin in PluginHelper.plugins.Values)
{
if (plugin.GetType().Assembly == dataContractType.Assembly){
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add(dataContractType.Name);
typeNamespace = dictionary.Add("http://tempuri.com/"+ plugin.Name);
return true;
}
}
return false;
}
public override bool TryResolveType(
Type type, Type declaredType, DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
// bool r = false;
// if (declaredType.IsSubclassOf(typeof(System.Linq.IQueryable)))
// {
// typeName = _typeDictionary.Add(type.Name);
// typeNamespace = _typeDictionary.Add(type.Namespace);
// r = true;
// }
// else
// {
if (!type.IsPrimitive)
{
typeName = _typeDictionary.Add(GetTypeName(type));
typeNamespace = _typeDictionary.Add(type.Namespace);
// r = true;
// }
// if (r)
// {
string typeKey = typeName + "." + typeNamespace;
if (!_typeNames.ContainsKey(typeKey))
_typeNames.Add(typeKey, type);
return true;
}
else
return knownTypeResolver.TryResolveType(type, declaredType, knownTypeResolver, out typeName, out typeNamespace);
}
public override bool TryResolveType(Type type, Type declaredType,
DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
if (knownTypeResolver.TryResolveType(type, declaredType,
null, out typeName, out typeNamespace))
return true;
string typeNameString = null;
if (Resolver.IsCollection(type))
{
TryGetCollectionTypeName(type, knownTypeResolver, out typeNameString);
}
else if (Resolver.IsArray(type))
{
TryGetArrayTypeName(type, knownTypeResolver, out typeNameString);
}
if (typeNameString != null)
{
typeNamespace = new XmlDictionaryString(XmlDictionary.Empty, Namespaces.DEFAULT, 0);
typeName = new XmlDictionaryString(XmlDictionary.Empty, typeNameString, 0);
return true;
}
return false;
}
public override bool TryResolveType(
Type type,
Type declaredType,
DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName,
out XmlDictionaryString typeNamespace)
{
if (!MessageType.AllKnownTypes.Contains(type))
{
typeName = null;
typeNamespace = null;
return false;
}
knownTypeResolver.TryResolveType(
type, declaredType, knownTypeResolver, out typeName, out typeNamespace);
if (this.NamespaceShouldBeReplaced(typeNamespace))
{
typeName = new XmlDictionaryString(XmlDictionary.Empty, type.Name, 0);
typeNamespace = new XmlDictionaryString(XmlDictionary.Empty, type.Namespace, 0);
}
return true;
}
public override bool TryResolveType (Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
//Console.WriteLine ("TryResolveType: {0} {1}", type, declaredType);
if (knownTypeResolver.TryResolveType (type, declaredType, null, out typeName, out typeNamespace))
return true;
return SafeResolveType (type, out typeName, out typeNamespace);
}
/// <summary>
/// Override this method to map a data contract type to an xsi:type name and namespace during serialization.
/// </summary>
/// <param name="type">The type to map.</param>
/// <param name="declaredType">The type declared in the data contract.</param>
/// <param name="knownTypeResolver">The known type resolver.</param>
/// <param name="typeName">The xsi:type name.</param>
/// <param name="typeNamespace">The xsi:type namespace.</param>
/// <returns>
/// true if mapping succeeded; otherwise, false.
/// </returns>
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace)
{
if (type == typeof(Tag))
{
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add("Tag");
typeNamespace = dictionary.Add(uri);
return true;
}
else if (type == typeof(Entry))
{
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add("Entry");
typeNamespace = dictionary.Add(uri);
return true;
}
else if (type == typeof(LinkEntry))
{
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add("LinkEntry");
typeNamespace = dictionary.Add(uri);
return true;
}
else if (type == typeof(LinkItem))
{
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add("LinkItem");
typeNamespace = dictionary.Add(uri);
return true;
}
else
return knownTypeResolver.TryResolveType(type, declaredType, knownTypeResolver, out typeName, out typeNamespace);
}
// Serialization
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace)
{
Type[] genericTypes = type.GetGenericArguments();
string ns = string.Empty;
Type genericType = null;
foreach (Type genType in genericTypes)
{
if (typesByType.ContainsKey(genType) == true)
{
typesByType.TryGetValue(genType, out ns);
genericType = genType;
break;
}
}
if (string.IsNullOrEmpty(ns) == false)
{
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add(genericType.Name);
typeNamespace = dictionary.Add(ns);
return true;
}
else
{
return knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace);
}
}
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
var result = knownTypeResolver.TryResolveType(dataContractType, declaredType, knownTypeResolver, out typeName, out typeNamespace);
if (!result)
return true;
return result;
}
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
if (!knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace))
{
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add(dataContractType.FullName);
typeNamespace = dictionary.Add(dataContractType.Assembly.FullName);
}
return true;
}
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
if (!knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace))
{
typeName = new XmlDictionaryString(XmlDictionary.Empty, type.Name, 0);
typeNamespace = new XmlDictionaryString(XmlDictionary.Empty, type.Namespace, 0);
}
return true;
}
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
if (Identity.ContainsKey(dataContractType))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(Identity[dataContractType]);
typeNamespace = dictionary.Add(dataContractType.FullName);
return true;
}
// Defer to the known type resolver
return knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace);
}
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
if (type.Assembly.GetName().Name == DynamicTypeBuilder.AssemblyName)
{
XmlDictionary dic = new XmlDictionary();
typeName = dic.Add(type.Name);
typeNamespace = dic.Add(ResolverNamespace);
return true;
}
else
{
return knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace);
}
}
// These methods are necessary for standard .Net serialisation
// For JSon we use different means, have a look in JsonBinSerializer for its custom Json.NET handler.
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
if (TypeIdentity.Instance.ContainsKey(dataContractType))
{
XmlDictionary dictionary = new XmlDictionary();
typeName = dictionary.Add(TypeIdentity.Instance[dataContractType].Alias);
typeNamespace = dictionary.Add(dataContractType.FullName);
return true; // indicating that this resolver knows how to handle
}
else
{
// Defer to the known type resolver
return knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace);
}
}
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace)
{
Debug.WriteLine("TryResolveType ", type.Name);
var retVal = _typeToNames.ContainsKey(type);
if (retVal)
{
XmlDictionary dictionary = new XmlDictionary();
typeNamespace = dictionary.Add(_typeToNames[type].Item1);
typeName = dictionary.Add(_typeToNames[type].Item2);
}
else
{
retVal = knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace);
}
return retVal;
}
public override bool TryResolveType(Type type,
Type declaredType,
DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName,
out XmlDictionaryString typeNamespace)
{
var fullName = type.FullName;
if (_typeToAssemblyLookup.ContainsKey(fullName))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(fullName);
typeNamespace = dictionary.Add(_xmlNamespace);
return true;
}
return knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace);
}
public override bool TryResolveType(
Type type,
Type declaredType,
DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName,
out XmlDictionaryString typeNamespace)
{
if (type.FullName.Contains("DynamicProxies"))
{
var name = type.Name.Split('_').First();
var nameSpace = "myNamespace";
typeName = new XmlDictionaryString(XmlDictionary.Empty, name, 0);
typeNamespace = new XmlDictionaryString(XmlDictionary.Empty, nameSpace, 0);
return true;
}
return knownTypeResolver.TryResolveType(type, declaredType, knownTypeResolver, out typeName, out typeNamespace);
}
public override bool TryResolveType(Type dataContractType, Type declaredType,
DataContractResolver knownTypeResolver, out XmlDictionaryString typeName,
out XmlDictionaryString typeNamespace)
{
if (!knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace))
{
return false;
}
int index;
if (serializationDictionary.TryGetValue(typeNamespace.Value, out index))
{
typeNamespace = dic.Add(index.ToString());
}
else
{
serializationDictionary.Add(typeNamespace.Value, serializationIndex);
typeNamespace = dic.Add(serializationIndex++ + "#" + typeNamespace);
}
return true;
}
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace)
{
EntityUtil.CheckArgumentNull(dataContractType, "dataContractType");
EntityUtil.CheckArgumentNull(declaredType, "declaredType");
EntityUtil.CheckArgumentNull(knownTypeResolver, "knownTypeResolver");
Type nonProxyType = ObjectContext.GetObjectType(dataContractType);
if (nonProxyType != dataContractType)
{
// Type was a proxy type, so map the name to the non-proxy name
XmlQualifiedName qualifiedName = _exporter.GetSchemaTypeName(nonProxyType);
XmlDictionary dictionary = new XmlDictionary(2);
typeName = new XmlDictionaryString(dictionary, qualifiedName.Name, 0);
typeNamespace = new XmlDictionaryString(dictionary, qualifiedName.Namespace, 1);
return true;
}
else
{
// Type was not a proxy type, so do the default
return knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace);
}
}
private bool ResolveType(Type objectType, Type declaredType, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
if (!DataContractResolver.TryResolveType(objectType, declaredType, KnownTypeResolver, out typeName, out typeNamespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ResolveTypeReturnedFalse, DataContract.GetClrTypeFullName(DataContractResolver.GetType()), DataContract.GetClrTypeFullName(objectType))));
}
if (typeName == null)
{
if (typeNamespace == null)
{
return(false);
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ResolveTypeReturnedNull, DataContract.GetClrTypeFullName(DataContractResolver.GetType()), DataContract.GetClrTypeFullName(objectType))));
}
}
if (typeNamespace == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ResolveTypeReturnedNull, DataContract.GetClrTypeFullName(DataContractResolver.GetType()), DataContract.GetClrTypeFullName(objectType))));
}
return(true);
}
/// <summary>During serialization, maps actual types to xsi:type information.</summary>
/// <returns>true if the type was resolved; otherwise, false. </returns>
/// <param name="type">The actual type of the persistence-ignorant object.</param>
/// <param name="declaredType">The declared type.</param>
/// <param name="knownTypeResolver">
/// An instance of <see cref="T:System.Data.Entity.Core.Objects.ProxyDataContractResolver" />.
/// </param>
/// <param name="typeName">When this method returns, contains a list of xsi:type declarations.</param>
/// <param name="typeNamespace">When this method returns, contains a list of namespaces used.</param>
public override bool TryResolveType(
Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName,
out XmlDictionaryString typeNamespace)
{
Check.NotNull(type, "type");
Check.NotNull(declaredType, "declaredType");
Check.NotNull(knownTypeResolver, "knownTypeResolver");
var nonProxyType = ObjectContext.GetObjectType(type);
if (nonProxyType != type)
{
// Type was a proxy type, so map the name to the non-proxy name
var qualifiedName = _exporter.GetSchemaTypeName(nonProxyType);
var dictionary = new XmlDictionary(2);
typeName = new XmlDictionaryString(dictionary, qualifiedName.Name, 0);
typeNamespace = new XmlDictionaryString(dictionary, qualifiedName.Namespace, 1);
return true;
}
else
{
// Type was not a proxy type, so do the default
return knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace);
}
}
/// <summary>
/// Override this method to map a data contract type to an xsi:type name and namespace during serialization.
/// </summary>
/// <param name="type">The type to map.</param>
/// <param name="declaredType">The type declared in the data contract.</param>
/// <param name="knownTypeResolver">The known type resolver.</param>
/// <param name="typeName">The xsi:type name.</param>
/// <param name="typeNamespace">The xsi:type namespace.</param>
/// <returns>
/// true if mapping succeeded; otherwise, false.
/// </returns>
public override bool TryResolveType(Type type,
Type declaredType,
DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName,
out XmlDictionaryString typeNamespace)
{
bool isTypeResolved = knownTypeResolver.TryResolveType(type,
declaredType,
knownTypeResolver,
out typeName,
out typeNamespace);
if (!isTypeResolved)
{
Type ensuredType = EnsureModelType(type);
isTypeResolved = (ensuredType == declaredType) ||
knownTypeResolver.TryResolveType(ensuredType,
declaredType,
knownTypeResolver,
out typeName,
out typeNamespace);
}
return isTypeResolved;
}
public override void WriteStartObject(
XmlDictionaryWriter writer, object graph)
{
Type rootType = type;
if (root_name.Value == "")
{
throw new InvalidDataContractException("Type '" + type.ToString() +
"' cannot have a DataContract attribute Name set to null or empty string.");
}
if (graph == null)
{
if (names_filled)
{
writer.WriteStartElement(root_name.Value, root_ns.Value);
}
else
{
writer.WriteStartElement(root_name, root_ns);
}
writer.WriteAttributeString("i", "nil", XmlSchema.InstanceNamespace, "true");
return;
}
QName rootQName = null;
XmlDictionaryString name, ns;
if (DataContractResolver != null && DataContractResolver.TryResolveType(graph.GetType(), type, default_resolver, out name, out ns))
{
rootQName = new QName(name.Value, ns.Value);
}
// It is error unless 1) TypeResolver resolved the type name, 2) the object is the exact type, 3) the object is known or 4) the type is primitive.
if (rootQName == null &&
graph.GetType() != type &&
IsUnknownType(graph.GetType()))
{
throw new SerializationException(String.Format("Type '{0}' is unexpected. The type should either be registered as a known type, or DataContractResolver should be used.", graph.GetType()));
}
QName instName = rootQName;
rootQName = rootQName ?? known_types.GetQName(rootType);
QName graph_qname = known_types.GetQName(graph.GetType());
known_types.Add(graph.GetType());
if (names_filled)
{
writer.WriteStartElement(root_name.Value, root_ns.Value);
}
else
{
writer.WriteStartElement(root_name, root_ns);
}
if (rootQName != graph_qname || rootQName.Namespace != KnownTypeCollection.MSSimpleNamespace && !rootType.IsEnum)
{
//FIXME: Hack, when should the "i:type" be written?
//Not used in case of enums
writer.WriteXmlnsAttribute("i", XmlSchema.InstanceNamespace);
}
if (root_ns.Value != rootQName.Namespace)
{
if (rootQName.Namespace != KnownTypeCollection.MSSimpleNamespace)
{
writer.WriteXmlnsAttribute(null, rootQName.Namespace);
}
}
if (rootQName == graph_qname)
{
return;
}
/* Different names */
known_types.Add(rootType);
instName = instName ?? KnownTypeCollection.GetPredefinedTypeName(graph.GetType());
if (instName == QName.Empty)
{
/* Not a primitive type */
instName = graph_qname;
}
else
{
/* FIXME: Hack, .. see test WriteObject7 () */
instName = new QName(instName.Name, XmlSchema.Namespace);
}
/* // disabled as it now generates extraneous i:type output.
* // output xsi:type as rootType is not equivalent to the graph's type.
* writer.WriteStartAttribute ("i", "type", XmlSchema.InstanceNamespace);
* writer.WriteQualifiedName (instName.Name, instName.Namespace);
* writer.WriteEndAttribute ();
*/
}
public override bool TryResolveType(Type type,
Type declaredType,
DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName,
out XmlDictionaryString typeNamespace)
{
if (type == typeof(SdkMessages))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(Names.SdkMessages);
typeNamespace = dictionary.Add(CrmSvcUtilNamespace);
return true; // indicating that this resolver knows how to handle "SdkMessages"
}
if (type == typeof(SdkMessage))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(Names.SdkMessage);
typeNamespace = dictionary.Add(CrmSvcUtilNamespace);
return true; // indicating that this resolver knows how to handle "SdkMessages"
}
if (type == typeof(SdkMessagePair))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(Names.SdkMessagePair);
typeNamespace = dictionary.Add(CrmSvcUtilNamespace);
return true; // indicating that this resolver knows how to handle "SdkMessages"
}
if (type == typeof(SdkMessageRequest))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(Names.SdkMessageRequest);
typeNamespace = dictionary.Add(CrmSvcUtilNamespace);
return true; // indicating that this resolver knows how to handle "SdkMessages"
}
if (type == typeof(SdkMessageRequestField))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(Names.SdkMessageRequestField);
typeNamespace = dictionary.Add(CrmSvcUtilNamespace);
return true; // indicating that this resolver knows how to handle "SdkMessages"
}
if (type == typeof(SdkMessageResponse))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(Names.SdkMessageResponse);
typeNamespace = dictionary.Add(CrmSvcUtilNamespace);
return true; // indicating that this resolver knows how to handle "SdkMessages"
}
if (type == typeof(SdkMessageResponseField))
{
var dictionary = new XmlDictionary();
typeName = dictionary.Add(Names.SdkMessageResponseField);
typeNamespace = dictionary.Add(CrmSvcUtilNamespace);
return true; // indicating that this resolver knows how to handle "SdkMessages"
}
// Defer to the known type resolver
var value = knownTypeResolver.TryResolveType(type, declaredType, knownTypeResolver, out typeName, out typeNamespace);
if (!value)
{
value = true;
}
return value;
}
/// <summary>
/// Tries to resolve whether a type is known.
/// Is used for serialization.
/// Gets called by the framework.
/// </summary>
/// <param name="type"></param>
/// <param name="declaredType"></param>
/// <param name="knownTypeResolver"></param>
/// <param name="typeName"></param>
/// <param name="typeNamespace"></param>
/// <returns></returns>
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
Logger.Debug(String.Format("BusDataContractResolver: TryResolveType(type='{0}', declaredType='{1}')", type.FullName, declaredType.FullName));
if (ServiceHelper.IsServiceValidType(type))
{
XmlDictionary dictionary = new XmlDictionary();
string encodedTypeName = Encoding.Encoder.SafeEncode(type.FullName);
Logger.Debug(String.Format("BusDataContractResolver: TryResolveType() got valid type: '{0}'. Encoded name: '{1}'.", type.FullName, encodedTypeName));
typeName = dictionary.Add(encodedTypeName);
typeNamespace = dictionary.Add("http://tempuri.com");
return true;
}
Logger.Error(String.Format("BusDataContractResolver: TryResolveType() got invalid type: '{0}'.", type.FullName));
return knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace);
}
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
TryResolveTypeInvoked = true;
return knownTypeResolver.TryResolveType(type, declaredType, null, out typeName, out typeNamespace);
}
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver, out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
return TryResolveDataContractType(type, declaredType, out typeName, out typeNamespace)
|| knownTypeResolver.TryResolveType(type, declaredType, knownTypeResolver, out typeName, out typeNamespace)
|| TryResolveClrType(type, declaredType, out typeName, out typeNamespace);
}
/// <summary>
/// Attempts to resolve a type to an XML schema type name
/// </summary>
/// <param name="type">
/// The managed type to resolve
/// </param>
/// <param name="declared">
/// The declared parameter type
/// </param>
/// <param name="knownTypes">
/// The base known type resolver
/// </param>
/// <param name="xmlName">
/// Return the type name via here
/// </param>
/// <param name="xmlNamespace">
/// Return the type namespace via here
/// </param>
/// <returns>
/// True if the type was resolved
/// False otherwise
/// </returns>
public override Boolean TryResolveType(
Type type,
Type declared,
DataContractResolver knownTypes,
out XmlDictionaryString xmlName,
out XmlDictionaryString xmlNamespace)
{
if (!knownTypes.TryResolveType(type, declared, null, out xmlName, out xmlNamespace))
{
String ns, name;
if (!TryResolve(type, declared, out ns, out name))
return false;
xmlNamespace = this.dictionary.Add(ns);
xmlName = this.dictionary.Add(name);
}
return true;
}
// Used at serialization
// Maps any Type to a new xsi:type representation
/// <summary>
/// 序列化时将类确定传输用的类型名称
/// </summary>
/// <param name="type">需要处理的类型,默认情况下应该传入的是实体或者DTO类型,通用CRUD查询实体时传入的是实体的代理子类对象,
/// 所以需要特别处理</param>
/// <param name="declaredType">契约上定义的类型</param>
/// <param name="knownTypeResolver">已知类型处理器</param>
/// <param name="typeName">类型全名</param>
/// <param name="typeNamespace">类型所在Assembly</param>
/// <returns></returns>
public override bool TryResolveType(Type type, Type declaredType, DataContractResolver knownTypeResolver,
out XmlDictionaryString typeName, out XmlDictionaryString typeNamespace)
{
typeName = null;// new XmlDictionaryString(XmlDictionary.Empty, "", 0);
typeNamespace = null; new XmlDictionaryString(XmlDictionary.Empty, "", 0);
//if (dataContract == null)
//{
// return false;
//}
//if (type == null)
//{
// return false;s
//}
try
{
//不是实体或者DTO的类型
if (!typeof(XObject).IsAssignableFrom(type))
{
//优先使用系统定义的策略
if (!type.IsPrimitive) //Assembly.FullName.Contains("NHibernate")
{
_logger.Warn(string.Format("Unknown type has occur,Name:{0},NameSpace:{1}",
type.FullName, typeNamespace));
return true;
}
else
{
return knownTypeResolver.TryResolveType(type, declaredType,
knownTypeResolver, out typeName, out typeNamespace);
}
}
//判断是否代理子类对象
if (type.BaseType != null && type.Assembly.IsDynamic)
{
//使用基类来代替
type = type.BaseType;
}
if (!TypeDic.ContainsKey(type))
{
GetTypeInfo(type);
}
typeName = TypeDic[type].TypeName;
typeNamespace = TypeDic[type].AssemblyName;
return true;
}
catch (Exception e)
{
_logger.Error(e);
return false;
}
}
public override bool TryResolveType(Type type,Type declaredType,DataContractResolver knownTypeResolver,out XmlDictionaryString typeName,out XmlDictionaryString typeNamespace)
{
if(m_TypeToNames.ContainsKey(type))
{
XmlDictionary dictionary = new XmlDictionary();
typeNamespace = dictionary.Add(m_TypeToNames[type].Item1);
typeName = dictionary.Add(m_TypeToNames[type].Item2);
return true;
}
else
{
return knownTypeResolver.TryResolveType(type,declaredType,null,out typeName,out typeNamespace);
}
}
public void Serialize(Type type, object graph)
{
if (graph == null)
{
writer.WriteAttributeString("nil", XmlSchema.InstanceNamespace, "true");
}
#if !MOONLIGHT
else if (type == typeof(XmlElement))
{
((XmlElement)graph).WriteTo(Writer);
}
else if (type == typeof(XmlNode []))
{
foreach (var xn in (XmlNode [])graph)
{
xn.WriteTo(Writer);
}
}
#endif
else
{
QName resolvedQName = null;
if (resolver != null)
{
XmlDictionaryString rname, rns;
if (resolver.TryResolveType(graph != null ? graph.GetType() : typeof(object), type, default_resolver, out rname, out rns))
{
resolvedQName = new QName(rname.Value, rns.Value);
}
}
Type actualType = graph.GetType();
SerializationMap map;
map = types.FindUserMap(actualType);
// For some collection types, the actual type does not matter. So get nominal serialization type instead.
// (The code below also covers the lines above, but I don't remove above lines to avoid extra search cost.)
if (map == null)
{
// FIXME: not sure if type.IsInterface is the correct condition to determine whether items are serialized with i:type or not. (e.g. bug #675144 server response).
actualType = types.GetSerializedType(type.IsInterface ? type : actualType);
map = types.FindUserMap(actualType);
}
// If it is still unknown, then register it.
if (map == null)
{
types.Add(actualType);
map = types.FindUserMap(actualType);
}
if (actualType != type && (map == null || map.OutputXsiType))
{
QName qname = resolvedQName ?? types.GetXmlName(actualType);
string name = qname.Name;
string ns = qname.Namespace;
if (qname == QName.Empty)
{
name = XmlConvert.EncodeLocalName(actualType.Name);
ns = KnownTypeCollection.DefaultClrNamespaceBase + actualType.Namespace;
}
else if (qname.Namespace == KnownTypeCollection.MSSimpleNamespace)
{
ns = XmlSchema.Namespace;
}
if (writer.LookupPrefix(ns) == null) // it goes first (extraneous, but it makes att order compatible)
{
writer.WriteXmlnsAttribute(null, ns);
}
writer.WriteStartAttribute("i", "type", XmlSchema.InstanceNamespace);
writer.WriteQualifiedName(name, ns);
writer.WriteEndAttribute();
}
QName predef = KnownTypeCollection.GetPredefinedTypeName(actualType);
if (predef != QName.Empty)
{
SerializePrimitive(type, graph, predef);
}
else
{
map.Serialize(graph, this);
}
}
}