1012 lines
36 KiB
C#
1012 lines
36 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="LOSFormatter.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
#if OBJECTSTATEFORMATTER
|
|
|
|
namespace System.Web.UI {
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
|
|
/// <devdoc>
|
|
/// Serializes Web Froms view state. The limited object serialization (LOS)
|
|
/// formatter is designed for ASCII format serialization. This class
|
|
/// supports serializing any object graph, but is optimized for those containing
|
|
/// strings, arrays, and hashtables. It offers second order optimization for many of
|
|
/// the .NET primitive types.
|
|
/// This class has been replaced with a more optimal serialization mechanism implemented
|
|
/// in LosSerializer. LosFormatter itself uses LosSerialization as part of its
|
|
/// implementation to benefit from the highly compact serialization when possible.
|
|
/// </devdoc>
|
|
public sealed class LosFormatter {
|
|
|
|
private const int InitialBufferSize = 24;
|
|
|
|
private ObjectStateFormatter _formatter;
|
|
private bool _enableMac;
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Creates a LosFormatter object.</para>
|
|
/// </devdoc>
|
|
public LosFormatter() : this(false, (byte[])null) {
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Creates a LosFormatter object, specifying whether view state mac should be
|
|
/// enabled. If it is, use macKeyModifier to modify the mac key.</para>
|
|
/// </devdoc>
|
|
public LosFormatter(bool enableMac, string macKeyModifier): this (enableMac, GetBytes(macKeyModifier)) {
|
|
}
|
|
|
|
public LosFormatter(bool enableMac, byte[] macKeyModifier) {
|
|
_enableMac = enableMac;
|
|
if (enableMac) {
|
|
_formatter = new ObjectStateFormatter(macKeyModifier);
|
|
}
|
|
else {
|
|
_formatter = new ObjectStateFormatter();
|
|
}
|
|
}
|
|
|
|
private static byte[] GetBytes(string s) {
|
|
if (s != null && s.Length != 0)
|
|
return Encoding.Unicode.GetBytes(s);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Deserializes a LOS-formatted object from a <see cref='System.IO.Stream'/> object.</para>
|
|
/// </devdoc>
|
|
public object Deserialize(Stream stream) {
|
|
TextReader input = null;
|
|
input = new StreamReader(stream);
|
|
return Deserialize(input);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Deserializes a LOS-formatted object from a <see cref='System.IO.TextReader'/> object.</para>
|
|
/// </devdoc>
|
|
public object Deserialize(TextReader input) {
|
|
char[] data = new char[128];
|
|
int read = 0;
|
|
int current = 0;
|
|
int blockSize = InitialBufferSize;
|
|
do {
|
|
read = input.Read(data, current, blockSize);
|
|
current += read;
|
|
if (current > data.Length - blockSize) {
|
|
char[] bigger = new char[data.Length * 2];
|
|
Array.Copy(data, bigger, data.Length);
|
|
data = bigger;
|
|
}
|
|
} while (read == blockSize);
|
|
|
|
return Deserialize(new String(data, 0, current));
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Deserializes a LOS formatted object from a string.</para>
|
|
/// </devdoc>
|
|
public object Deserialize(string input) {
|
|
return _formatter.Deserialize(input);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Serializes the Web Forms view state value into
|
|
/// a <see cref='System.IO.Stream'/> object.</para>
|
|
/// </devdoc>
|
|
public void Serialize(Stream stream, object value) {
|
|
TextWriter output = new StreamWriter(stream);
|
|
SerializeInternal(output, value);
|
|
output.Flush();
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Serializes the view state value into a <see cref='System.IO.TextWriter'/> object.</para>
|
|
/// </devdoc>
|
|
public void Serialize(TextWriter output, object value) {
|
|
SerializeInternal(output, value);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Serialized value into the writer.
|
|
/// </devdoc>
|
|
private void SerializeInternal(TextWriter output, object value) {
|
|
string data = _formatter.Serialize(value);
|
|
output.Write(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
#else // !OBJECTSTATEFORMATTER
|
|
|
|
// uncomment for "human readable" debugging output - no base64 encoding.
|
|
//#define NO_BASE64
|
|
|
|
namespace System.Web.UI {
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.Runtime.Serialization;
|
|
using System;
|
|
using System.IO;
|
|
using System.Security.Principal;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Diagnostics;
|
|
using System.ComponentModel;
|
|
using System.Globalization;
|
|
using System.Threading;
|
|
using System.Text;
|
|
using System.Web.Configuration;
|
|
using System.Security.Permissions;
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Serializes Web Froms view state. The limited object serialization (LOS)
|
|
/// formatter is designed for highly compact ASCII format serialization. This class
|
|
/// supports serializing any object graph, but is optimized for those containing
|
|
/// strings, arrays, and hashtables. It offers second order optimization for many of
|
|
/// the .NET primitive types.</para>
|
|
/// </devdoc>
|
|
public sealed class LosFormatter : IStateFormatter {
|
|
|
|
// NOTE : This formatter is not very fault tolerant, by design. I want
|
|
// : to avoid a bunch of reduntant checking... Since the format
|
|
// : is short lived we shouldn't have to worry about it.
|
|
//
|
|
|
|
// NOTE : Although hex encoding of numbers would be more effecient, it
|
|
// : would make it much harder to determine what are numbers vs.
|
|
// : names & types. Unless this becomes a problem, I suggest we
|
|
// : keep encoding in decimal.
|
|
//
|
|
|
|
// Known Types. There can only be 50 of these... The order shouldn't
|
|
// matter, we store and index into this array... although there is a
|
|
// slight perf advantage being at the top of the list...
|
|
//
|
|
private static readonly Type[] knownTypes = new Type[]
|
|
{
|
|
typeof(object),
|
|
typeof(System.Web.UI.WebControls.Unit),
|
|
typeof(System.Drawing.Color),
|
|
typeof(System.Int16),
|
|
typeof(System.Int64),
|
|
};
|
|
|
|
static readonly Encoding EncodingInstance = new UTF8Encoding(false);
|
|
static readonly NumberFormatInfo NumberFormat = NumberFormatInfo.InvariantInfo;
|
|
|
|
private const int UntypedTypeId = -1;
|
|
private const int NoTypeId = -2;
|
|
private const int InitialBufferSize = 24;
|
|
private const int BufferGrowth = 48;
|
|
|
|
|
|
// Constant chars and strings... you can change these and all references to the
|
|
// begin, end, and delimiter chars are fixed up
|
|
private const char leftAngleBracketChar = '<';
|
|
private const char rightAngleBracketChar = '>';
|
|
private const char valueDelimiterChar = ';';
|
|
|
|
private static readonly char[] escapedCharacters = { leftAngleBracketChar, rightAngleBracketChar, valueDelimiterChar, '\\' };
|
|
private static CharBufferAllocator _charBufferAllocator = new CharBufferAllocator(256, 16);
|
|
|
|
// reusable Temp buffer used for constructing strings from char arrays... this is
|
|
// more performant than using a StringBuilder.
|
|
//
|
|
private char[] _builder;
|
|
private bool _recyclable;
|
|
|
|
// Tables used to build up the type and name tables during
|
|
// serialization. Not used during deserilization.
|
|
private IDictionary _typeTable;
|
|
|
|
// Deserialization variables. Not used during serialization.
|
|
private ArrayList _deserializedTypeTable;
|
|
private ListDictionary _deserializedConverterTable;
|
|
private char[] _deserializationData;
|
|
private int _current;
|
|
|
|
// MAC authentication
|
|
private bool _enableViewStateMac;
|
|
private bool EnableViewStateMac {
|
|
get { return _enableViewStateMac; }
|
|
}
|
|
|
|
private byte [] _macKey = null;
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Creates a LosFormatter object.</para>
|
|
/// </devdoc>
|
|
public LosFormatter() {}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Creates a LosFormatter object, specifying whether view state mac should be
|
|
/// enabled. If it is, use macKeyModifier to modify the mac key.</para>
|
|
/// </devdoc>
|
|
public LosFormatter(bool enableMac, string macKeyModifier) {
|
|
_enableViewStateMac = enableMac;
|
|
|
|
if (macKeyModifier != null)
|
|
_macKey = Encoding.Unicode.GetBytes(macKeyModifier);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Deserializes a LOS-formatted object from a <see cref='System.IO.Stream'/> object.</para>
|
|
/// </devdoc>
|
|
public object Deserialize(Stream stream) {
|
|
TextReader input = null;
|
|
input = new StreamReader(stream);
|
|
return Deserialize(input);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Deserializes a LOS-formatted object from a <see cref='System.IO.TextReader'/> object.</para>
|
|
/// </devdoc>
|
|
public object Deserialize(TextReader input) {
|
|
char[] data = new char[128];
|
|
int read = 0;
|
|
int current = 0;
|
|
int blockSize = InitialBufferSize;
|
|
do {
|
|
read = input.Read(data, current, blockSize);
|
|
current += read;
|
|
if (current > data.Length - blockSize) {
|
|
char[] bigger = new char[data.Length * 2];
|
|
Array.Copy(data, bigger, data.Length);
|
|
data = bigger;
|
|
}
|
|
} while (read == blockSize);
|
|
|
|
return Deserialize(new String(data, 0, current));
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Deserializes a LOS formatted object from a string.</para>
|
|
/// </devdoc>
|
|
public object Deserialize(string input) {
|
|
|
|
#if NO_BASE64
|
|
char[] data = input.ToCharArray();
|
|
#else
|
|
byte[] dataBytes = Convert.FromBase64String(input);
|
|
|
|
int dataLength = -1;
|
|
if (EnableViewStateMac) {
|
|
|
|
try {
|
|
dataBytes = MachineKeySection.GetDecodedData(dataBytes, _macKey, 0, dataBytes.Length, ref dataLength);
|
|
}
|
|
catch (Exception e) {
|
|
PerfCounters.IncrementCounter(AppPerfCounter.VIEWSTATE_MAC_FAIL);
|
|
ViewStateException.ThrowMacValidationError(e, input);
|
|
}
|
|
}
|
|
|
|
if (dataLength == -1) {
|
|
dataLength = dataBytes.Length;
|
|
}
|
|
|
|
char[] data = EncodingInstance.GetChars(dataBytes, 0, dataLength);
|
|
#endif
|
|
|
|
|
|
// clear or allocate name and type tables.
|
|
//
|
|
if (_deserializedTypeTable == null) {
|
|
_deserializedTypeTable = new ArrayList();
|
|
_deserializedConverterTable = new ListDictionary();
|
|
}
|
|
else {
|
|
_deserializedTypeTable.Clear();
|
|
_deserializedConverterTable.Clear();
|
|
}
|
|
|
|
_builder = (char[]) _charBufferAllocator.GetBuffer();
|
|
_recyclable = true;
|
|
|
|
// DeserializeValueInternal is recursive, so we just kick this off
|
|
// starting at 0
|
|
_current = 0;
|
|
_deserializationData = data;
|
|
object ret = DeserializeValueInternal();
|
|
|
|
if (_recyclable)
|
|
_charBufferAllocator.ReuseBuffer(_builder);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Deserializes a value from tokens, starting at current. When this
|
|
/// function returns, current will be left at the next token.
|
|
///
|
|
/// This function is recursive.
|
|
/// </devdoc>
|
|
private object DeserializeValueInternal() {
|
|
// Determine the data type... possible combinations are:
|
|
//
|
|
// @<...> == array of strings
|
|
// @T<...> == array of (typeref T)
|
|
// b<...> == base64 encoded value
|
|
// h<...> == hashtable
|
|
// l<...> == arraylist
|
|
// p<...> == pair
|
|
// t<...> == triplet
|
|
// i<...> == int
|
|
// o<t/f> == boolean true/false
|
|
// T<...> == (typeref T)
|
|
// ... == string
|
|
//
|
|
|
|
object value = null;
|
|
|
|
string token = ConsumeOneToken();
|
|
|
|
if (_current >= _deserializationData.Length || _deserializationData[_current] != leftAngleBracketChar) {
|
|
// just a string - next token is not a left angle bracket
|
|
// we can shortcut here and just return the string
|
|
//_current++; //consume right angle bracket or delimiter
|
|
return token;
|
|
}
|
|
|
|
_current++; // consume left angle bracket
|
|
|
|
// otherwise, we have typeref followed by value
|
|
if (token.Length == 1) {
|
|
// simple type we recognize
|
|
char ch = token[0];
|
|
if (ch == 'p') {
|
|
Pair p = new Pair();
|
|
|
|
if (_deserializationData[_current] != valueDelimiterChar) {
|
|
p.First = DeserializeValueInternal();
|
|
}
|
|
_current++; // consume delimeter
|
|
if (_deserializationData[_current] != rightAngleBracketChar) {
|
|
p.Second = DeserializeValueInternal();
|
|
}
|
|
value = p;
|
|
}
|
|
else if (ch == 't') {
|
|
Triplet t = new Triplet();
|
|
|
|
if (_deserializationData[_current] != valueDelimiterChar) {
|
|
t.First = DeserializeValueInternal();
|
|
}
|
|
_current++; // consume delimeter
|
|
if (_deserializationData[_current] != valueDelimiterChar) {
|
|
t.Second = DeserializeValueInternal();
|
|
}
|
|
_current++; // consume delimeter
|
|
if (_deserializationData[_current] != rightAngleBracketChar) {
|
|
t.Third = DeserializeValueInternal();
|
|
}
|
|
value = t;
|
|
}
|
|
|
|
// Parse int32...
|
|
else if (ch == 'i') {
|
|
value = Int32.Parse(ConsumeOneToken(), NumberFormat);
|
|
}
|
|
|
|
else if (ch == 'o') {
|
|
value = _deserializationData[_current] == 't';
|
|
_current++; // consume t or f
|
|
}
|
|
|
|
// Parse arrayList...
|
|
//
|
|
else if (ch == 'l') {
|
|
ArrayList data = new ArrayList();
|
|
|
|
while (_deserializationData[_current] != rightAngleBracketChar) {
|
|
object itemValue = null;
|
|
if (_deserializationData[_current] != valueDelimiterChar) {
|
|
itemValue = DeserializeValueInternal();
|
|
}
|
|
data.Add(itemValue);
|
|
_current++; //consume the delimiter
|
|
}
|
|
|
|
value = data;
|
|
}
|
|
else if (ch == '@') {
|
|
// if we're here, length == 1 so this is a string array
|
|
value = ConsumeStringArray();
|
|
}
|
|
|
|
// Parse hashtable...
|
|
//
|
|
else if (ch == 'h') {
|
|
Hashtable data = new Hashtable();
|
|
|
|
while (_deserializationData[_current] != rightAngleBracketChar) {
|
|
object key;
|
|
key = DeserializeValueInternal(); // hashtable key cannot be null
|
|
|
|
_current++; // consume delimiter
|
|
if (_deserializationData[_current] != valueDelimiterChar) {
|
|
data[key] = DeserializeValueInternal();
|
|
}
|
|
else {
|
|
data[key] = null;
|
|
}
|
|
|
|
_current++; // consume delimiter
|
|
}
|
|
|
|
value = data;
|
|
}
|
|
|
|
// base64 encoded...
|
|
//
|
|
else if (ch == 'b') {
|
|
string text = ConsumeOneToken();
|
|
byte[] serializedData;
|
|
serializedData = Convert.FromBase64String(text);
|
|
|
|
if (!String.IsNullOrEmpty(serializedData)) {
|
|
System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
|
|
value = formatter.Deserialize(new MemoryStream(serializedData));
|
|
}
|
|
}
|
|
|
|
// Parse typeconverter value ...
|
|
//
|
|
else {
|
|
// we have a typeref which is only one character long
|
|
value = ConsumeTypeConverterValue(token);
|
|
}
|
|
|
|
|
|
}
|
|
else {
|
|
// length > 1
|
|
|
|
// Parse array...
|
|
//
|
|
if (token[0] == '@') {
|
|
// if we're here, length > 1 so we must have a type ref after the @
|
|
Type creatableType = TypeFromTypeRef(token.Substring(1));
|
|
value = ConsumeArray(creatableType);
|
|
}
|
|
|
|
// Parse typeconverter value ...
|
|
//
|
|
else {
|
|
// we have a typeref which is more than one character long
|
|
value = ConsumeTypeConverterValue(token);
|
|
}
|
|
}
|
|
|
|
_current++; //consume right angle bracket
|
|
return value;
|
|
}
|
|
|
|
|
|
|
|
private string ConsumeOneToken() {
|
|
int locInBuilder = 0;
|
|
|
|
while (_current < _deserializationData.Length)
|
|
{
|
|
switch (_deserializationData[_current]) {
|
|
case '\\':
|
|
_current++; // skip slash
|
|
if (_deserializationData[_current] == 'e') {
|
|
_current++;
|
|
return String.Empty;
|
|
}
|
|
_builder[locInBuilder] = _deserializationData[_current];
|
|
locInBuilder++;
|
|
break;
|
|
case valueDelimiterChar:
|
|
case leftAngleBracketChar:
|
|
case rightAngleBracketChar:
|
|
return new string(_builder, 0, locInBuilder);
|
|
|
|
default:
|
|
_builder[locInBuilder] = _deserializationData[_current];
|
|
locInBuilder++;
|
|
break;
|
|
}
|
|
|
|
_current++;
|
|
|
|
// Alloc _builder always 2 greater than locInBuilder to make sure
|
|
// we can do nested/escape parsing without error...
|
|
//
|
|
if (locInBuilder >= _builder.Length) {
|
|
char[] bigger = new char[_builder.Length + BufferGrowth];
|
|
Array.Copy(_builder, bigger, _builder.Length);
|
|
_builder = bigger;
|
|
_recyclable = false;
|
|
}
|
|
}
|
|
return new string(_builder, 0, locInBuilder);
|
|
}
|
|
|
|
private object ConsumeStringArray() {
|
|
ArrayList data = new ArrayList();
|
|
while (_deserializationData[_current] != rightAngleBracketChar) {
|
|
object itemValue = null;
|
|
if (_deserializationData[_current] != valueDelimiterChar) {
|
|
itemValue = ConsumeOneToken();
|
|
}
|
|
data.Add(itemValue);
|
|
_current++; //consume the delimiter
|
|
}
|
|
|
|
return data.ToArray(typeof(string));
|
|
}
|
|
|
|
private object ConsumeArray(Type creatableType) {
|
|
ArrayList data = new ArrayList();
|
|
while (_deserializationData[_current] != rightAngleBracketChar) {
|
|
object itemValue = null;
|
|
if (_deserializationData[_current] != valueDelimiterChar) {
|
|
itemValue = DeserializeValueInternal();
|
|
}
|
|
data.Add(itemValue);
|
|
_current++; //consume the delimiter
|
|
}
|
|
|
|
return data.ToArray(creatableType);
|
|
}
|
|
|
|
private object ConsumeTypeConverterValue(string token) {
|
|
int typeref = ParseNumericString(token);
|
|
TypeConverter tc;
|
|
|
|
if (typeref != -1) {
|
|
// token is the string representation of the number here
|
|
tc = (TypeConverter) _deserializedConverterTable[token];
|
|
if (tc == null) {
|
|
// wasn't in the converter table, add it now
|
|
// we need this case because arrays can add types but not typeconverters
|
|
Type t = TypeFromTypeCode(typeref);
|
|
tc = TypeDescriptor.GetConverter(t);
|
|
_deserializedConverterTable[token] = tc;
|
|
}
|
|
}
|
|
else {
|
|
// it's just a name, lookup type and add to type table
|
|
Type t = Type.GetType(token);
|
|
tc = TypeDescriptor.GetConverter(t);
|
|
|
|
// add to type table and converter table.
|
|
_deserializedConverterTable[(_deserializedTypeTable.Count + 50).ToString(NumberFormat)] = tc;
|
|
_deserializedTypeTable.Add(t);
|
|
}
|
|
string text = ConsumeOneToken();
|
|
return tc.ConvertFrom(null, CultureInfo.InvariantCulture, text);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Serializes the Web Forms view state value into
|
|
/// a <see cref='System.IO.Stream'/> object.</para>
|
|
/// </devdoc>
|
|
public void Serialize(Stream stream, object value) {
|
|
TextWriter output = new StreamWriter(stream);
|
|
SerializeInternal(output, value);
|
|
output.Flush();
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Serializes the view state value into a <see cref='System.IO.TextWriter'/> object.</para>
|
|
/// </devdoc>
|
|
public void Serialize(TextWriter output, object value) {
|
|
SerializeInternal(output, value);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Serialized value into the writer.
|
|
/// </devdoc>
|
|
private void SerializeInternal(TextWriter output, object value) {
|
|
if (value == null)
|
|
return;
|
|
|
|
if (_typeTable == null)
|
|
_typeTable = new HybridDictionary();
|
|
else
|
|
_typeTable.Clear();
|
|
|
|
#if NO_BASE64
|
|
SerializeValue(output, value);
|
|
#else
|
|
|
|
LosWriter writer = new LosWriter();
|
|
|
|
SerializeValue(writer, value);
|
|
|
|
writer.CompleteTransforms(output, EnableViewStateMac, _macKey);
|
|
writer.Dispose();
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Recursively serializes value into the writer.
|
|
/// </devdoc>
|
|
private void SerializeValue(TextWriter output, object value) {
|
|
if (value == null)
|
|
return;
|
|
|
|
// First determine the type... either typeless (string), array,
|
|
// typed array, hashtable, pair, triplet, knowntype, typetable reference, or
|
|
// type...
|
|
//
|
|
|
|
// serialize string...
|
|
//
|
|
if (value is string) {
|
|
WriteEscapedString(output, (string)value);
|
|
}
|
|
|
|
// serialize Int32...
|
|
//
|
|
else if (value is Int32) {
|
|
output.Write('i');
|
|
output.Write(leftAngleBracketChar);
|
|
output.Write(((Int32)value).ToString(NumberFormat));
|
|
output.Write(rightAngleBracketChar);
|
|
}
|
|
else if (value is Boolean) {
|
|
output.Write('o');
|
|
output.Write(leftAngleBracketChar);
|
|
output.Write( ((bool) value) ? 't' : 'f');
|
|
output.Write(rightAngleBracketChar);
|
|
}
|
|
|
|
// serialize arraylist...
|
|
//
|
|
else if (value is ArrayList) {
|
|
output.Write('l');
|
|
output.Write(leftAngleBracketChar);
|
|
|
|
ArrayList ar = (ArrayList)value;
|
|
int c = ar.Count;
|
|
for (int i=0; i<c; i++) {
|
|
SerializeValue(output, ar[i]);
|
|
output.Write(valueDelimiterChar);
|
|
}
|
|
output.Write(rightAngleBracketChar);
|
|
}
|
|
|
|
// serialize hashtable...
|
|
//
|
|
else if (value is Hashtable) {
|
|
output.Write('h');
|
|
output.Write(leftAngleBracketChar);
|
|
|
|
Hashtable table = (Hashtable)value;
|
|
|
|
IDictionaryEnumerator e = table.GetEnumerator();
|
|
while (e.MoveNext()) {
|
|
SerializeValue(output, e.Key);
|
|
output.Write(valueDelimiterChar);
|
|
|
|
SerializeValue(output, e.Value);
|
|
output.Write(valueDelimiterChar);
|
|
}
|
|
output.Write(rightAngleBracketChar);
|
|
}
|
|
|
|
else {
|
|
// we'll need the Type object for the last two possibilities
|
|
Type valueType = value.GetType();
|
|
Type strtype = typeof(string);
|
|
|
|
// serialize Pair
|
|
if (valueType == typeof(Pair)) {
|
|
Pair p = (Pair) value;
|
|
output.Write('p');
|
|
output.Write(leftAngleBracketChar);
|
|
|
|
SerializeValue(output, p.First);
|
|
output.Write(valueDelimiterChar);
|
|
SerializeValue(output, p.Second);
|
|
output.Write(rightAngleBracketChar);
|
|
}
|
|
|
|
// serialize Triplet
|
|
//
|
|
else if (valueType == typeof(Triplet)) {
|
|
Triplet t = (Triplet) value;
|
|
output.Write('t');
|
|
output.Write(leftAngleBracketChar);
|
|
|
|
SerializeValue(output, t.First);
|
|
output.Write(valueDelimiterChar);
|
|
SerializeValue(output, t.Second);
|
|
output.Write(valueDelimiterChar);
|
|
SerializeValue(output, t.Third);
|
|
output.Write(rightAngleBracketChar);
|
|
}
|
|
|
|
// serialize array...
|
|
//
|
|
else if (valueType.IsArray) {
|
|
Type underlyingValueType;
|
|
underlyingValueType = valueType.GetElementType();
|
|
|
|
output.Write('@');
|
|
|
|
if (underlyingValueType != strtype) {
|
|
// write type of array before elements
|
|
int typeId = GetTypeId(underlyingValueType);
|
|
WriteTypeId(output, typeId, underlyingValueType);
|
|
|
|
output.Write(leftAngleBracketChar);
|
|
Array ar = (Array)value;
|
|
for (int i=0; i<ar.Length; i++) {
|
|
SerializeValue(output, ar.GetValue(i));
|
|
output.Write(valueDelimiterChar);
|
|
}
|
|
}
|
|
else {
|
|
// optimization: since we know the underlying values are strings,
|
|
// we can skip the recursive call to SerializeValue
|
|
output.Write(leftAngleBracketChar);
|
|
string[] ar = (string[])value;
|
|
for (int i=0; i<ar.Length; i++) {
|
|
WriteEscapedString(output, ar[i]);
|
|
output.Write(valueDelimiterChar);
|
|
}
|
|
}
|
|
output.Write(rightAngleBracketChar);
|
|
}
|
|
|
|
// serialize other value...
|
|
//
|
|
else {
|
|
int typeId = GetTypeId(valueType);
|
|
|
|
// get the type converter
|
|
TypeConverter tc = TypeDescriptor.GetConverter(valueType);
|
|
|
|
bool toString;
|
|
bool fromString;
|
|
if (tc == null || tc is ReferenceConverter) {
|
|
toString = false;
|
|
fromString = false;
|
|
}
|
|
else {
|
|
toString = tc.CanConvertTo(strtype);
|
|
fromString = tc.CanConvertFrom(strtype);
|
|
}
|
|
|
|
if (toString && fromString) {
|
|
//we can convert to and from a string
|
|
WriteTypeId(output, typeId, valueType);
|
|
|
|
output.Write(leftAngleBracketChar);
|
|
WriteEscapedString(output, tc.ConvertToInvariantString(null, value));
|
|
}
|
|
else {
|
|
// the typeconverter failed us, so we are resorting to binary serialization
|
|
MemoryStream ms = new MemoryStream();
|
|
System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
|
|
try {
|
|
formatter.Serialize(ms, value);
|
|
}
|
|
catch (SerializationException) {
|
|
throw new HttpException(SR.GetString(SR.NonSerializableType, value.GetType().FullName));
|
|
}
|
|
|
|
output.Write('b');
|
|
output.Write(leftAngleBracketChar);
|
|
|
|
// Since base64 doesn't have any chars that we escape, we can
|
|
// skip WriteEscapedString
|
|
output.Write(Convert.ToBase64String(ms.GetBuffer(), 0, (int) ms.Length));
|
|
}
|
|
output.Write(rightAngleBracketChar);
|
|
}
|
|
}
|
|
}
|
|
|
|
private int GetTypeId(Type valueType) {
|
|
|
|
int typeId = NoTypeId;
|
|
|
|
// check if it is a known type
|
|
for (int i=0; i<knownTypes.Length; i++) {
|
|
if (valueType == knownTypes[i]) {
|
|
typeId = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
if (typeId == NoTypeId) {
|
|
// not a known type, see if it's in the type table
|
|
object found = _typeTable[valueType];
|
|
if (found != null)
|
|
typeId = 50 + (int)found;
|
|
}
|
|
|
|
return typeId;
|
|
}
|
|
|
|
private void WriteTypeId(TextWriter output, int typeId, Type valueType) {
|
|
if (typeId != NoTypeId)
|
|
output.Write(typeId.ToString(NumberFormat));
|
|
else {
|
|
// ASURT 60173: use AssemblyQualifiedName here, not FullName
|
|
WriteEscapedString(output, valueType.AssemblyQualifiedName);
|
|
//
|
|
_typeTable[valueType] = _typeTable.Count;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// Takes a typeRef, and converts it to a Type. Either by returning
|
|
/// Type.GetType(typeRef), or looking it up.
|
|
/// </devdoc>
|
|
private Type TypeFromTypeRef(string typeRef) {
|
|
|
|
int number = ParseNumericString(typeRef);
|
|
|
|
Type t = TypeFromTypeCode(number);
|
|
|
|
if (t != null)
|
|
return t;
|
|
|
|
// it's just a name, lookup type and add to type table
|
|
t = Type.GetType(typeRef);
|
|
_deserializedTypeTable.Add(t);
|
|
return t;
|
|
|
|
}
|
|
|
|
private Type TypeFromTypeCode(int number) {
|
|
if (number != -1) {
|
|
// it is a type id, either in the known table or in our type table
|
|
if (number <= 49)
|
|
return knownTypes[number];
|
|
|
|
return (Type) _deserializedTypeTable[number - 50];
|
|
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
// Note : We have to determine if "typeRef" is a number. The easiest
|
|
// : and fastest way to do this is to walk the string. While
|
|
// : we are doing this, lets build up the number... after
|
|
// : all this is much faster than Int32.Parse
|
|
//
|
|
private int ParseNumericString(string num) {
|
|
int number = 0;
|
|
int len = num.Length;
|
|
|
|
for (int i=0; i<len; i++) {
|
|
switch (num[i]) {
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
number *= 10;
|
|
number += (((int)num[i]) - ((int)'0'));
|
|
break;
|
|
default:
|
|
number = -1;
|
|
i = len;
|
|
break;
|
|
}
|
|
}
|
|
return number;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Escapes and writes the escaped value of str into the writer.
|
|
/// </devdoc>
|
|
private void WriteEscapedString(TextWriter output, string str) {
|
|
|
|
if (str == null)
|
|
return;
|
|
|
|
// need to "escape" the empty string to distinguish it
|
|
// from a null value
|
|
if (str.Length == 0) {
|
|
output.Write('\\');
|
|
output.Write('e');
|
|
return;
|
|
}
|
|
|
|
int first = str.IndexOfAny(escapedCharacters);
|
|
if (first == -1) {
|
|
output.Write(str);
|
|
}
|
|
else {
|
|
char[] strData = str.ToCharArray();
|
|
output.Write(strData, 0, first);
|
|
int len = strData.Length;
|
|
|
|
for (int i=first; i<len; i++) {
|
|
char c = strData[i];
|
|
switch (c) {
|
|
case '\\':
|
|
output.Write('\\');
|
|
output.Write('\\');
|
|
break;
|
|
case leftAngleBracketChar:
|
|
output.Write('\\');
|
|
output.Write(leftAngleBracketChar);
|
|
break;
|
|
case rightAngleBracketChar:
|
|
output.Write('\\');
|
|
output.Write(rightAngleBracketChar);
|
|
break;
|
|
case valueDelimiterChar:
|
|
output.Write('\\');
|
|
output.Write(valueDelimiterChar);
|
|
break;
|
|
default:
|
|
output.Write(c);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static internal int EstimateSize(object obj) {
|
|
if (obj == null)
|
|
return 0;
|
|
StringWriter sw = new StringWriter();
|
|
LosFormatter formatter = new LosFormatter();
|
|
formatter.Serialize(sw, obj);
|
|
return sw.ToString().Length;
|
|
}
|
|
|
|
#region Implementation of IStateFormatter
|
|
object IStateFormatter.Deserialize(string serializedState) {
|
|
return Deserialize(serializedState);
|
|
}
|
|
|
|
string IStateFormatter.Serialize(object state) {
|
|
StringWriter writer = new StringWriter();
|
|
Serialize(writer, state);
|
|
return writer.ToString();
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
#endif // OBJECTSTATEFORMATTER
|