Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

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