protected override ArrayType ImplDeserializeEnumerable(
IValueSequence serialization,
IRepositorySerializationContext context)
{
Object array = null;
Int32 arraySize = 0;
Int32 idx = 0;
String itemStrValue = null;
ICollection coll = null;
IList list = null;
NumericStringValue numericString = null;
if ((coll = serialization.Value as ICollection) != null)
{
arraySize = coll.Count;
}
IEnumerator enumerator = ImplDeserializeEnumerable(
serialization.Value, context).GetEnumerator();
if (enumerator == null)
{
return(default(ArrayType));
}
if (!enumerator.MoveNext())
{
return(default(ArrayType));
}
array = new ArrayItemType [arraySize];
list = array as IList;
do
{
try
{
if ((numericString = enumerator.Current as NumericStringValue) != null)
{
list [idx++] = numericString.ToType(typeof(ArrayItemType), null);
}
else if (Type.GetTypeCode(typeof(ArrayItemType)) == TypeCode.DateTime &&
(itemStrValue = enumerator.Current as String) != null)
{
list [idx++] = DateTime.ParseExact(itemStrValue, "o", null);
}
else
{
list [idx++] = enumerator.Current;
}
}
catch { break;; }
}while (enumerator.MoveNext());
return((ArrayType)array);
} // End of ImplDeserializeEnumerable (...)
} // End of ImplPopulateSequence (...)
protected virtual void ImplSerializeEnumerable(
out IValueSequence retVal,
SequenceType instance,
IHierarchicalMetadataSerializationContext context)
{
ArrayList sequenceValues;
if (ImplSerializeEnumerable(out sequenceValues, instance, context))
{
retVal = new ValueSequence(sequenceValues);
}
else
{
retVal = null;
}
} // End of ImplSerializeEnumerable (...)
//protected virtual Boolean ImplAddSequenceItem ( SequenceType sequence, Object item )
//{
// IList list = sequence as IList;
// if ( list == null ) return false;
// try { list.Add ( item ); }
// catch { return false; }
// return true;
//} // End of ImplAddSequenceItem (...)
protected virtual SequenceType ImplDeserializeEnumerable(
IValueSequence serialization,
IRepositorySerializationContext context)
{
IEnumerator enumerator = ImplDeserializeEnumerable(
serialization.Value, context).GetEnumerator();
if (enumerator == null)
{
return(default(SequenceType));
}
if (!enumerator.MoveNext())
{
return(default(SequenceType));
}
return(ImplPopulateSequence(default(SequenceType), enumerator));
} // End of ImplDeserializeEnumerable (...)
protected override void ImplSerialize(
out IValueSequence retVal,
SequenceType instance,
IRepositorySerializationContext context)
=> ImplSerializeEnumerable(out retVal, instance, context);
protected override SequenceType ImplDeserialize(
IValueSequence serialization,
IRepositorySerializationContext context)
=> ImplDeserializeEnumerable(serialization, context);
} // End of _DeserializeEnumerable (...)
private Boolean _DeserializeEnumerable(
PropertyDescriptor pd,
IEnumerable sequence,
IHierarchicalMetadataSerializationContext context)
{
if (pd == null)
{
return(false);
}
if (!typeof(IEnumerable).IsAssignableFrom(pd.PropertyType))
{
return(false);
}
if (sequence == null)
{
return(false);
}
IValueUnit curCtxLvl = context.Hierarchy.Peek() as IValueUnit;
Object propValue = pd.GetValue(this);
if (curCtxLvl == null)
{
return(false);
}
IValueItem valueItem = curCtxLvl [pd.Name] as IValueItem;
IValueSequence subCtxt = null;
if (valueItem == null)
{
return(false);
}
if ((subCtxt = valueItem.Value as IValueSequence) == null)
{
return(false);
}
context.Hierarchy.Push(subCtxt);
try
{
IEnumerator enumerator = ImplDeserializeEnumerable(
sequence, context).GetEnumerator();
IList retColl = null;
if (enumerator == null)
{
return(false);
}
if (!enumerator.MoveNext())
{
return(false);
}
if ((retColl = propValue as IList) == null)
{
Type collType = pd.PropertyType;
if (collType.IsInterface)
{
if (collType.IsGenericType)
{
if (collType.Name == "IList`1")
{
collType = typeof(System.Collections.Generic.List <>).MakeGenericType(collType.GenericTypeArguments);
}
}
}
System.Reflection.ConstructorInfo ci = collType.GetConstructor(Type.EmptyTypes);
if (ci == null)
{
return(false);
}
if ((retColl = ci.Invoke(Type.EmptyTypes) as IList) == null)
{
return(false);
}
pd.SetValue(this, retColl); //retVal = retColl;
}
do
{
retColl.Add(enumerator.Current);
}while (enumerator.MoveNext());
}
finally { context.Hierarchy.Pop(); }
return(true);
} // End of _DeserializeEnumerable (...)
protected override Boolean ImplSerializeEnumerable(
out ArrayList values,
IEnumerable objValue,
IHierarchicalMetadataSerializationContext context)
{
values = new ArrayList();
if (objValue == null)
{
return(false);
}
if (context == null)
{
return(false);
}
IValueSequence valueSeq = context.Hierarchy.Peek() as IValueSequence;
if (valueSeq == null)
{
return(false);
}
IList ctxts = valueSeq.Value as IList;
if (ctxts == null)
{
return(false);
}
IValueUnit ctxUnit = null;
Type instType = null;
context.Hierarchy.Pop();
if ((ctxUnit = context.Hierarchy.Peek() as IValueUnit) == null)
{
return(false);
}
// Add SerMgr key
if ((instType = typeof(SequenceType)).IsGenericType)
{
ctxUnit.Add("SerializationManager",
GetType().GetGenericTypeDefinition().AssemblyQualifiedName);
ArrayList typeParamGuids = new ArrayList();
foreach (Type par in instType.GenericTypeArguments)
{
typeParamGuids.Add(par.GetTypeGuid().ToString());
}
ctxUnit.Add("SerializationManagerInstanceTypeParamGuids",
new ValueSequence(typeParamGuids));
}
else
{
return(false);// ctxUnit.Add ( "SerializationManager", instType.AssemblyQualifiedName );
}
context.Hierarchy.Push(valueSeq);
foreach (KeyValuePair <SequenceKeyType, SequenceValueType> kvp in objValue)
{
ValueUnit kvpValueUnit = new ValueUnit();
Object tmpValue = null;
ctxts.Add(ctxUnit = new ValueUnit());
context.Hierarchy.Push(ctxUnit);
ImplSerializeItem(
out tmpValue,
//delegate ( IValueUnit vu ) { ctxUnit.Add ( nameof ( kvp.Key ), vu ); },
delegate() {
ValueUnit vu = new ValueUnit();
ctxUnit.Add(nameof(kvp.Key), vu);
context.Hierarchy.Push(vu);
},
delegate() { context.Hierarchy.Pop(); },
kvp.Key,
context);
kvpValueUnit.Add(new ValueItem(nameof(kvp.Key), tmpValue));
ImplSerializeItem(
out tmpValue,
//delegate ( IValueUnit vu ) { ctxUnit.Add ( nameof ( kvp.Value ), vu ); },
delegate() {
ValueUnit vu = new ValueUnit();
ctxUnit.Add(nameof(kvp.Value), vu);
context.Hierarchy.Push(vu);
},
delegate() { context.Hierarchy.Pop(); },
kvp.Value,
context);
kvpValueUnit.Add(new ValueItem(nameof(kvp.Value), tmpValue));
values.Add(kvpValueUnit);
context.Hierarchy.Pop();
}
return(true);
} // End of ImplSerializeEnumerable (...)
} // End of ImplSerializeEnumerable (...)
protected virtual Boolean ImplSerializeEnumerable(
out ArrayList values,
IEnumerable objValue,
IHierarchicalMetadataSerializationContext context)
{
values = new ArrayList();
if (objValue == null)
{
return(false);
}
if (context == null)
{
return(false);
}
IValueSequence valueSeq = context.Hierarchy.Peek() as IValueSequence;
if (valueSeq == null)
{
return(false);
}
IList ctxts = ((IValueItemBase)valueSeq).Value as IList;
if (ctxts == null)
{
return(false);
}
IValueUnit ctxUnit = null;
Type itemType = null;
Type serMgrType = null;
IValueUnit subUnit = null;
context.Hierarchy.Pop();
try
{
if ((ctxUnit = context.Hierarchy.Peek() as IValueUnit) == null)
{
return(false);
}
else if ((serMgrType = GetType()).IsGenericType)
{
ctxUnit.Add("SerializationManager",
serMgrType.GetGenericTypeDefinition().AssemblyQualifiedName);
ArrayList typeParamGuids = new ArrayList();
foreach (Type par in serMgrType.GenericTypeArguments)
{
typeParamGuids.Add(par.GetTypeGuid().ToString());
}
ctxUnit.Add("SerializationManagerInstanceTypeParamGuids",
new ValueSequence(typeParamGuids));
}
else
{
ctxUnit.Add("SerializationManager", serMgrType.AssemblyQualifiedName);
}
}
finally { context.Hierarchy.Push(valueSeq); }
foreach (Object item in objValue)
{
if (ImplIsBuiltinType(itemType = item.GetType()))
{
ValueUnit vu = new ValueUnit();
vu.Add(new ValueItem("TypeGuid", itemType.GetTypeGuid().ToString()));
ctxts.Add(vu);
values.Add(item);
}
else if (ImplIsString(item.GetType()))
{
ctxts.Add(null); values.Add(item);
}
//else if ( ImplSerializeEnumerable ( retVal, pd.Name, item as IEnumerable, context ) )
// continue;
else if (ImplSerializeObject(
out subUnit,
//delegate ( IValueUnit vu ) { ctxts.Add ( vu ); },
delegate() {
ValueUnit vu = new ValueUnit();
ctxts.Add(vu);
context.Hierarchy.Push(vu);
},
delegate() { context.Hierarchy.Pop(); },
item, //as IValueObjectContract,
context))
{
values.Add(subUnit);
}
}
return(true);
} // End of ImplSerializeEnumerable (...)