public object GetValue(string name, Type type)
{
if (name == null)
{
throw new ArgumentNullException("name is null.");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!serialized.ContainsKey(name))
{
throw new SerializationException("No element named " + name + " could be found.");
}
SerializationEntry entry = (SerializationEntry)serialized[name];
if (entry.Value != null && !type.IsInstanceOfType(entry.Value))
{
return(converter.Convert(entry.Value, type));
}
else
{
return(entry.Value);
}
}
// Methods
public void AddValue(string name, object value, Type type)
{
#if NOT_PFX
if (name == null)
{
throw new ArgumentNullException("name is null");
}
if (type == null)
{
throw new ArgumentNullException("type is null");
}
if (serialized.ContainsKey(name))
{
throw new SerializationException("Value has been serialized already.");
}
SerializationEntry entry = new SerializationEntry(name, type, value);
serialized.Add(name, entry);
values.Add(entry);
#else
throw new NotSupportedException();
#endif
}
private SerializationEntry[] get_entries()
{
SerializationEntry[] array = new SerializationEntry[this.MemberCount];
int num = 0;
foreach (SerializationEntry serializationEntry in this)
{
array[num++] = serializationEntry;
}
return(array);
}
/** used by the runtime */
#pragma warning disable 169
private SerializationEntry[] get_entries()
{
SerializationEntry[] res = new SerializationEntry[this.MemberCount];
int i = 0;
foreach (SerializationEntry e in this)
{
res[i++] = e;
}
return(res);
}
/* used by the runtime */
private SerializationInfo (Type type, SerializationEntry [] data)
{
int len = data.Length;
assemblyName = type.Assembly.FullName;
fullTypeName = type.FullName;
converter = new FormatterConverter ();
for (int i = 0; i < len; i++) {
serialized.Add (data [i].Name, data [i]);
values.Add (data [i]);
}
}
/// <summary>Adds a value into the <see cref="T:System.Runtime.Serialization.SerializationInfo" /> store, where <paramref name="value" /> is associated with <paramref name="name" /> and is serialized as being of <see cref="T:System.Type" /><paramref name="type" />.</summary>
/// <param name="name">The name to associate with the value, so it can be deserialized later. </param>
/// <param name="value">The value to be serialized. Any children of this object will automatically be serialized. </param>
/// <param name="type">The <see cref="T:System.Type" /> to associate with the current object. This parameter must always be the type of the object itself or of one of its base classes. </param>
/// <exception cref="T:System.ArgumentNullException">If <paramref name="name" /> or <paramref name="type" /> is null. </exception>
/// <exception cref="T:System.Runtime.Serialization.SerializationException">A value has already been associated with <paramref name="name" />. </exception>
public void AddValue(string name, object value, Type type)
{
if (name == null)
{
throw new ArgumentNullException("name is null");
}
if (type == null)
{
throw new ArgumentNullException("type is null");
}
if (this.serialized.ContainsKey(name))
{
throw new SerializationException("Value has been serialized already.");
}
SerializationEntry serializationEntry = new SerializationEntry(name, type, value);
this.serialized.Add(name, serializationEntry);
this.values.Add(serializationEntry);
}
internal void WriteSerializationInfo(XmlWriterDelegator xmlWriter, Type objType, SerializationInfo serInfo)
{
if (DataContract.GetClrTypeFullName(objType) != serInfo.FullTypeName)
{
if (base.DataContractResolver != null)
{
XmlDictionaryString str;
XmlDictionaryString str2;
if (this.ResolveType(serInfo.ObjectType, objType, out str, out str2))
{
xmlWriter.WriteAttributeQualifiedName("z", DictionaryGlobals.ISerializableFactoryTypeLocalName, DictionaryGlobals.SerializationNamespace, str, str2);
}
}
else
{
string str3;
string str4;
DataContract.GetDefaultStableName(serInfo.FullTypeName, out str3, out str4);
xmlWriter.WriteAttributeQualifiedName("z", DictionaryGlobals.ISerializableFactoryTypeLocalName, DictionaryGlobals.SerializationNamespace, DataContract.GetClrTypeString(str3), DataContract.GetClrTypeString(str4));
}
}
this.WriteClrTypeInfo(xmlWriter, objType, serInfo);
base.IncrementItemCount(serInfo.MemberCount);
SerializationInfoEnumerator enumerator = serInfo.GetEnumerator();
while (enumerator.MoveNext())
{
SerializationEntry current = enumerator.Current;
XmlDictionaryString clrTypeString = DataContract.GetClrTypeString(DataContract.EncodeLocalName(current.Name));
xmlWriter.WriteStartElement(clrTypeString, DictionaryGlobals.EmptyString);
object obj2 = current.Value;
if (obj2 == null)
{
this.WriteNull(xmlWriter);
}
else
{
this.InternalSerializeReference(xmlWriter, obj2, false, false, -1, Globals.TypeOfObject.TypeHandle);
}
xmlWriter.WriteEndElement();
}
}
/* used by the runtime */
#pragma warning disable 169
private SerializationEntry [] get_entries ()
{
SerializationEntry [] res = new SerializationEntry [this.MemberCount];
int i = 0;
foreach (SerializationEntry e in this)
res [i++] = e;
return res;
}
// Methods
public void AddValue (string name, object value, Type type)
{
if (name == null)
throw new ArgumentNullException ("name is null");
if (type == null)
throw new ArgumentNullException ("type is null");
if (serialized.ContainsKey (name))
throw new SerializationException ("Value has been serialized already.");
SerializationEntry entry = new SerializationEntry (name, type, value);
serialized.Add (name, entry);
values.Add (entry);
}
private void serializeArray(XmlWriter xmlWriter, Array array, IFormatterConverter converter)
{
System.Diagnostics.Debug.Assert(null != xmlWriter, "The 'xmlWriter' argument cannot be null.");
System.Diagnostics.Debug.Assert(null != array, "The 'array' argument cannot be null.");
System.Diagnostics.Debug.Assert(null != converter, "The 'converter' argument cannot be null.");
this.writeType(xmlWriter, array, this.assemblyFormat);
int rank = array.Rank;
int itemCount = 1;
int[] upperBounds = new int[rank];
for (int i = 0; i < rank; i++) {
upperBounds[i] = array.GetUpperBound(i);
itemCount *= upperBounds[i] + 1;
}
SerializationEntry[] entries = new SerializationEntry[itemCount]; // Return value
int[] indices = new int[rank];
for (int itemIndex = 0; itemIndex < itemCount; itemIndex++) {
entries[itemIndex] = this.createSerializationEntry("Item", array.GetValue(indices), converter);
for (int dimensionIndex = rank - 1; dimensionIndex >= 0; dimensionIndex--) {
if (indices[dimensionIndex] < upperBounds[dimensionIndex]) {
indices[dimensionIndex]++;
break;
}
else {
indices[dimensionIndex] = 0;
}
}
}
foreach (SerializationEntry entry in entries)
this.serializeEntry(xmlWriter, entry, converter);
}
private void serializeEntry(XmlWriter xmlWriter, SerializationEntry entry, IFormatterConverter converter)
{
System.Diagnostics.Debug.Assert(null != xmlWriter, "The 'xmlWriter' argument cannot be null.");
System.Diagnostics.Debug.Assert(null != converter, "The 'converter' argument cannot be null.");
if (entry.Name.Contains("+")) {
string[] nameParts = entry.Name.Split(new char[] { '+' });
xmlWriter.WriteStartElement(nameParts[1]);
xmlWriter.WriteStartAttribute("declaringType");
xmlWriter.WriteValue(nameParts[0]);
xmlWriter.WriteEndAttribute();
}
else {
xmlWriter.WriteStartElement(entry.Name);
}
object entryValue = entry.Value;
if (null == entryValue) {
xmlWriter.WriteStartAttribute("isNull");
xmlWriter.WriteValue(true);
xmlWriter.WriteEndAttribute();
}
else {
this.serializeObject(xmlWriter, entryValue, converter);
}
xmlWriter.WriteEndElement();
}
