/// <summary>
/// Constructor.
/// </summary>
/// <param name="componentABSTRACTDeserializer">Deserializer for the instances in the array</param>
public CArrayDeserializer(AbstractDeserializer componentABSTRACTDeserializer)
{
if (componentABSTRACTDeserializer != null)
{
m_componentType = componentABSTRACTDeserializer.GetOwnType();
}
}
/// <summary>
/// Reads the object as a map. (Hashtable)
/// </summary>
/// <param name="abstractHessianInput">HessianInput instance to read from</param>
/// <param name="strType">Type of the map (can be null)</param>
/// <returns>Object read from stream</returns>
public Object ReadMap(AbstractHessianInput abstractHessianInput, string strType)
{
AbstractDeserializer abstractDeserializer = GetDeserializer(strType);
if (abstractDeserializer == null)
{
abstractDeserializer = new CMapDeserializer(typeof(Hashtable));
}
return(abstractDeserializer.ReadMap(abstractHessianInput));
}
/// <summary>
/// Reads the array.
/// </summary>
/// <param name="abstractHessianInput">HessianInput</param>
/// <param name="intLength">Length of data</param>
/// <param name="strType">Type of the array objects</param>
/// <returns>Array data</returns>
public Object ReadList(AbstractHessianInput abstractHessianInput, int intLength, string strType)
{
AbstractDeserializer abstractDeserializer = GetDeserializer(strType);
if (abstractDeserializer != null)
{
return(abstractDeserializer.ReadList(abstractHessianInput, intLength));
}
else
{
return(new CEnumerableDeserializer(typeof(ArrayList)).ReadList(
abstractHessianInput,
intLength));
}
}
/// <summary>
/// Returns a deserializer based on a string type.
/// </summary>
/// <param name="strType">Type of the object for deserialization</param>
/// <returns>deserializer based on a string type</returns>
public AbstractDeserializer GetDeserializer(string strType)
{
if (strType == null || strType.Equals(""))
{
return(null);
}
AbstractDeserializer abstractDeserializer = null;
abstractDeserializer = (AbstractDeserializer)m_htTypeMap[strType];
if (abstractDeserializer != null)
{
return(abstractDeserializer);
}
if (strType.StartsWith("["))
{
AbstractDeserializer subABSTRACTDeserializer = GetDeserializer(strType.Substring(1));
abstractDeserializer = new CArrayDeserializer(subABSTRACTDeserializer);
return(abstractDeserializer);
}
else
{
#if COMPACT_FRAMEWORK
// do CF stuff
if (m_assamblyFiles == null)
{
m_assamblyFiles = AllAssamblyNamesInCurrentDirectory();
}
foreach (string ass in m_assamblyFiles)
{
string typeString = strType + "," + ass;
Type searchType = Type.GetType(typeString);
if (searchType != null)
{
abstractDeserializer = GetDeserializer(searchType);
return(abstractDeserializer);
}
}
#else
// do other stuff
try
{
//Diese Typsuche funzt bei Mobileloesung nicht:
//Es wurde ein andere Suche implementiert
Assembly[] ass = AppDomain.CurrentDomain.GetAssemblies();
Type t = null;
foreach (Assembly a in ass)
{
t = a.GetType(strType);
if (t != null)
{
break;
}
}
if (t != null)
{
abstractDeserializer = GetDeserializer(t);
}
}
catch (Exception)
{
}
#endif
}
/* TODO: Implementieren Type.GetType(type) geht nicht, man muss die Assembly eingeben.
*/
//deserializer = getDeserializer(Type.GetType(type));
return(abstractDeserializer);
}
/// <summary>
/// Returns according deserializer to the given type
/// </summary>
/// <param name="type">Type of the deserializer</param>
/// <returns>Deserializer instance</returns>
public AbstractDeserializer GetDeserializer(Type type)
{
AbstractDeserializer abstractDeserializer = (AbstractDeserializer)m_htDeserializerMap[type];
if (abstractDeserializer == null)
{
if (typeof(IDictionary).IsAssignableFrom(type))
{
abstractDeserializer = new CMapDeserializer(type);
}
else if (type.IsGenericType && typeof(System.Nullable <>).IsAssignableFrom(type.GetGenericTypeDefinition()))
{
// nullbarer Typ
Type[] args = type.GetGenericArguments();
return(GetDeserializer(args[0]));
}
else if (type.IsArray)
{
abstractDeserializer = new CArrayDeserializer(GetDeserializer(type.GetElementType()));
}
else if (type.IsEnum)
{
abstractDeserializer = new CEnumDeserializer(type);
}
else if (typeof(IList).IsAssignableFrom(type) ||
(type.IsGenericType &&
typeof(System.Collections.Generic.IEnumerable <>).IsAssignableFrom(type.GetGenericTypeDefinition())))
{
abstractDeserializer = new CEnumerableDeserializer(type);
}
else if (typeof(Exception).IsAssignableFrom(type))
{
abstractDeserializer = new CExceptionDeserializer(type);
}
else if (typeof(ISerializable).IsAssignableFrom(type))
{
abstractDeserializer = new CISerializableDeserializer(type);
}
else
{
if (m_htCachedDeserializerMap[type.FullName] != null)
{
abstractDeserializer = (AbstractDeserializer)m_htCachedDeserializerMap[type.FullName];
}
else
{
//加锁防止多线程同时添加同一类型
lock (deserializerLock)
{
//可能有一个线程已经添加，这里再判断一次
abstractDeserializer = (AbstractDeserializer)m_htCachedDeserializerMap[type.FullName];
if (abstractDeserializer != null)
{
return(abstractDeserializer);
}
else
{
abstractDeserializer = new CObjectDeserializer(type);
m_htCachedDeserializerMap.Add(type.FullName, abstractDeserializer);
}
}
}
}
}
return(abstractDeserializer);
}
/// <summary>
/// Reads an arbitrary object from the input stream.
/// </summary>
/// <param name="expectedType">the expected class if the protocol doesn't supply it.</param>
/// <returns>Read object</returns>
/// <exception cref="CHessianException"/>
/// <exception cref="CHessianException"/>
public override object ReadObject(Type expectedType)
{
object objResult = null;
if (expectedType == null || expectedType.Equals(typeof(object)))
{
objResult = ReadObject();
}
else
{
int intTag = Read();
if (intTag != CHessianProtocolConstants.PROT_NULL)
{
switch (intTag)
{
case CHessianProtocolConstants.PROT_MAP_TYPE:
{
string strType = ReadType();
AbstractDeserializer deserializer = GetObjectDeserializer(strType);
if (expectedType == deserializer.GetOwnType() || expectedType.IsAssignableFrom(deserializer.GetOwnType()))
{
return(deserializer.ReadMap(this));
}
deserializer = GetDeserializer(expectedType);
return(deserializer.ReadMap(this));
}
case CHessianProtocolConstants.PROT_REF_TYPE:
{
int intRefNumber = ParseInt();
return(m_arrRefs[intRefNumber]);
}
case 'r':
{
throw new CHessianException("remote type is not implemented");
}
case CHessianProtocolConstants.PROT_LIST_TYPE:
{
string strType = this.ReadType();
int intLength = this.ReadLength();
IDeserializer deserializer = this.m_serializerFactory.GetObjectDeserializer(strType);
if ((expectedType == deserializer.GetOwnType() || expectedType.IsAssignableFrom(deserializer.GetOwnType())))
{
//if (expectedType != deserializer.GetOwnType() && expectedType.IsAssignableFrom(deserializer.GetOwnType()))
return(deserializer.ReadList(this, intLength));
}
deserializer = m_serializerFactory.GetDeserializer(expectedType);
return(deserializer.ReadList(this, intLength));
}
}
m_intPeek = intTag;
objResult = m_serializerFactory.GetDeserializer(expectedType).ReadObject(this);
}
}
return(objResult);
}
