|
public static CheckSerializable ( |
||
| type | ||
| selector | ISurrogateSelector | |
| context | StreamingContext | |
| Résultat | void | |
public void WriteValue(BinaryWriter writer, Type valueType, object val)
{
if (val == null)
{
BinaryCommon.CheckSerializable(valueType, this._surrogateSelector, this._context);
writer.Write(10);
}
else if (BinaryCommon.IsPrimitive(val.GetType()))
{
if (!BinaryCommon.IsPrimitive(valueType))
{
writer.Write(8);
this.WriteTypeSpec(writer, val.GetType());
}
ObjectWriter.WritePrimitiveValue(writer, val);
}
else if (valueType.IsValueType)
{
this.WriteObjectInstance(writer, val, true);
}
else if (val is string)
{
bool flag;
long id = this._idGenerator.GetId(val, out flag);
if (flag)
{
this.WriteObjectInstance(writer, val, false);
}
else
{
this.WriteObjectReference(writer, id);
}
}
else
{
bool flag2;
long id2 = this._idGenerator.GetId(val, out flag2);
if (flag2)
{
this._pendingObjects.Enqueue(val);
}
this.WriteObjectReference(writer, id2);
}
}
private void GetObjectData(object obj, out TypeMetadata metadata, out object data)
{
Type instanceType = obj.GetType();
// Check if the formatter has a surrogate selector, if it does,
// check if the surrogate selector handles objects of the given type.
if (_surrogateSelector != null)
{
ISurrogateSelector selector;
ISerializationSurrogate surrogate = _surrogateSelector.GetSurrogate(instanceType, _context, out selector);
if (surrogate != null)
{
SerializationInfo info = new SerializationInfo(instanceType, new FormatterConverter());
surrogate.GetObjectData(obj, info, _context);
metadata = new SerializableTypeMetadata(instanceType, info);
data = info;
return;
}
}
// Check if the object is marked with the Serializable attribute
BinaryCommon.CheckSerializable(instanceType, _surrogateSelector, _context);
#if NET_2_0
_manager.RegisterObject(obj);
#endif
ISerializable ser = obj as ISerializable;
if (ser != null)
{
SerializationInfo info = new SerializationInfo(instanceType, new FormatterConverter());
ser.GetObjectData(info, _context);
metadata = new SerializableTypeMetadata(instanceType, info);
data = info;
}
else
{
data = obj;
if (_context.Context != null)
{
// Don't cache metadata info when the Context property is not null sice
// we can't control the number of possible contexts in this case
metadata = new MemberTypeMetadata(instanceType, _context);
return;
}
Hashtable typesTable;
bool isNew = false;
lock (_cachedTypes) {
typesTable = (Hashtable)_cachedTypes [_context.State];
if (typesTable == null)
{
typesTable = new Hashtable();
_cachedTypes [_context.State] = typesTable;
isNew = true;
}
}
metadata = null;
lock (typesTable) {
if (!isNew)
{
metadata = (TypeMetadata)typesTable [instanceType];
}
if (metadata == null)
{
metadata = CreateMemberTypeMetadata(instanceType);
}
typesTable [instanceType] = metadata;
}
}
}
private void GetObjectData(object obj, out TypeMetadata metadata, out object data)
{
Type type = obj.GetType();
if (this._surrogateSelector != null)
{
ISurrogateSelector surrogateSelector;
ISerializationSurrogate surrogate = this._surrogateSelector.GetSurrogate(type, this._context, out surrogateSelector);
if (surrogate != null)
{
SerializationInfo serializationInfo = new SerializationInfo(type, new FormatterConverter());
surrogate.GetObjectData(obj, serializationInfo, this._context);
metadata = new SerializableTypeMetadata(type, serializationInfo);
data = serializationInfo;
return;
}
}
BinaryCommon.CheckSerializable(type, this._surrogateSelector, this._context);
this._manager.RegisterObject(obj);
ISerializable serializable = obj as ISerializable;
if (serializable != null)
{
SerializationInfo serializationInfo2 = new SerializationInfo(type, new FormatterConverter());
serializable.GetObjectData(serializationInfo2, this._context);
metadata = new SerializableTypeMetadata(type, serializationInfo2);
data = serializationInfo2;
}
else
{
data = obj;
if (this._context.Context != null)
{
metadata = new MemberTypeMetadata(type, this._context);
return;
}
bool flag = false;
Hashtable cachedTypes = ObjectWriter._cachedTypes;
Hashtable hashtable;
lock (cachedTypes)
{
hashtable = (Hashtable)ObjectWriter._cachedTypes[this._context.State];
if (hashtable == null)
{
hashtable = new Hashtable();
ObjectWriter._cachedTypes[this._context.State] = hashtable;
flag = true;
}
}
metadata = null;
Hashtable obj2 = hashtable;
lock (obj2)
{
if (!flag)
{
metadata = (TypeMetadata)hashtable[type];
}
if (metadata == null)
{
metadata = this.CreateMemberTypeMetadata(type);
}
hashtable[type] = metadata;
}
}
}
