internal void Init(InternalPrimitiveTypeE code, Array array)
{
this.code = code;
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
this.booleanA = (bool[]) array;
return;
case InternalPrimitiveTypeE.Byte:
case InternalPrimitiveTypeE.Currency:
case InternalPrimitiveTypeE.Decimal:
case InternalPrimitiveTypeE.TimeSpan:
case InternalPrimitiveTypeE.DateTime:
break;
case InternalPrimitiveTypeE.Char:
this.charA = (char[]) array;
return;
case InternalPrimitiveTypeE.Double:
this.doubleA = (double[]) array;
return;
case InternalPrimitiveTypeE.Int16:
this.int16A = (short[]) array;
return;
case InternalPrimitiveTypeE.Int32:
this.int32A = (int[]) array;
return;
case InternalPrimitiveTypeE.Int64:
this.int64A = (long[]) array;
return;
case InternalPrimitiveTypeE.SByte:
this.sbyteA = (sbyte[]) array;
return;
case InternalPrimitiveTypeE.Single:
this.singleA = (float[]) array;
return;
case InternalPrimitiveTypeE.UInt16:
this.uint16A = (ushort[]) array;
return;
case InternalPrimitiveTypeE.UInt32:
this.uint32A = (uint[]) array;
return;
case InternalPrimitiveTypeE.UInt64:
this.uint64A = (ulong[]) array;
break;
default:
return;
}
}
internal static Array CreatePrimitiveArray(InternalPrimitiveTypeE code, int length)
{
Array array = null;
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
return new bool[length];
case InternalPrimitiveTypeE.Byte:
return new byte[length];
case InternalPrimitiveTypeE.Char:
return new char[length];
case InternalPrimitiveTypeE.Currency:
return array;
case InternalPrimitiveTypeE.Decimal:
return new decimal[length];
case InternalPrimitiveTypeE.Double:
return new double[length];
case InternalPrimitiveTypeE.Int16:
return new short[length];
case InternalPrimitiveTypeE.Int32:
return new int[length];
case InternalPrimitiveTypeE.Int64:
return new long[length];
case InternalPrimitiveTypeE.SByte:
return new sbyte[length];
case InternalPrimitiveTypeE.Single:
return new float[length];
case InternalPrimitiveTypeE.TimeSpan:
return new TimeSpan[length];
case InternalPrimitiveTypeE.DateTime:
return new DateTime[length];
case InternalPrimitiveTypeE.UInt16:
return new ushort[length];
case InternalPrimitiveTypeE.UInt32:
return new uint[length];
case InternalPrimitiveTypeE.UInt64:
return new ulong[length];
}
return array;
}
internal void Init()
{
this.NIFullName = null;
this.NIobjectId = 0L;
this.NIassemId = 0L;
this.NIprimitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
this.NItype = null;
this.NIisSealed = false;
this.NItransmitTypeOnObject = false;
this.NItransmitTypeOnMember = false;
this.NIisParentTypeOnObject = false;
this.NIisArray = false;
this.NIisArrayItem = false;
this.NIarrayEnum = InternalArrayTypeE.Empty;
this.NIsealedStatusChecked = false;
}
internal void Init()
{
this.PRparseTypeEnum = InternalParseTypeE.Empty;
this.PRobjectTypeEnum = InternalObjectTypeE.Empty;
this.PRarrayTypeEnum = InternalArrayTypeE.Empty;
this.PRmemberTypeEnum = InternalMemberTypeE.Empty;
this.PRmemberValueEnum = InternalMemberValueE.Empty;
this.PRobjectPositionEnum = InternalObjectPositionE.Empty;
this.PRname = null;
this.PRvalue = null;
this.PRkeyDt = null;
this.PRdtType = null;
this.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
this.PRisEnum = false;
this.PRobjectId = 0L;
this.PRidRef = 0L;
this.PRarrayElementTypeString = null;
this.PRarrayElementType = null;
this.PRisArrayVariant = false;
this.PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
this.PRrank = 0;
this.PRlengthA = null;
this.PRpositionA = null;
this.PRlowerBoundA = null;
this.PRupperBoundA = null;
this.PRindexMap = null;
this.PRmemberIndex = 0;
this.PRlinearlength = 0;
this.PRrectangularMap = null;
this.PRisLowerBound = false;
this.PRtopId = 0L;
this.PRheaderId = 0L;
this.PRisValueTypeFixup = false;
this.PRnewObj = null;
this.PRobjectA = null;
this.PRprimitiveArray = null;
this.PRobjectInfo = null;
this.PRisRegistered = false;
this.PRmemberData = null;
this.PRsi = null;
this.PRnullCount = 0;
}
internal static bool IsWriteAsByteArray(InternalPrimitiveTypeE code)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
case InternalPrimitiveTypeE.Char:
case InternalPrimitiveTypeE.Byte:
case InternalPrimitiveTypeE.Double:
case InternalPrimitiveTypeE.Int16:
case InternalPrimitiveTypeE.Int32:
case InternalPrimitiveTypeE.Int64:
case InternalPrimitiveTypeE.SByte:
case InternalPrimitiveTypeE.Single:
case InternalPrimitiveTypeE.UInt16:
case InternalPrimitiveTypeE.UInt32:
case InternalPrimitiveTypeE.UInt64:
return true;
default:
return false;
}
}
internal static bool IsWriteAsByteArray(InternalPrimitiveTypeE code)
{
bool isWrite = false;
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
case InternalPrimitiveTypeE.Char:
case InternalPrimitiveTypeE.Byte:
case InternalPrimitiveTypeE.Double:
case InternalPrimitiveTypeE.Int16:
case InternalPrimitiveTypeE.Int32:
case InternalPrimitiveTypeE.Int64:
case InternalPrimitiveTypeE.SByte:
case InternalPrimitiveTypeE.Single:
case InternalPrimitiveTypeE.UInt16:
case InternalPrimitiveTypeE.UInt32:
case InternalPrimitiveTypeE.UInt64:
isWrite = true;
break;
}
return isWrite;
}
internal void Init()
{
this.NInameSpaceEnum = InternalNameSpaceE.None;
this.NIname = null;
this.NIobjectId = 0L;
this.NIassemId = 0L;
this.NIprimitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
this.NItype = null;
this.NIisSealed = false;
this.NItransmitTypeOnObject = false;
this.NItransmitTypeOnMember = false;
this.NIisParentTypeOnObject = false;
this.NIisMustUnderstand = false;
this.NInamespace = null;
this.NIheaderPrefix = null;
this.NIitemName = null;
this.NIisArray = false;
this.NIisArrayItem = false;
this.NIisTopLevelObject = false;
this.NIisNestedObject = false;
this.NIisHeader = false;
this.NIisRemoteRecord = false;
this.NIattributeInfo = null;
}
internal static InternalPrimitiveTypeE ToCode(Type type)
{
InternalPrimitiveTypeE invalid = InternalPrimitiveTypeE.Invalid;
if (type.IsEnum)
{
return(invalid = InternalPrimitiveTypeE.Invalid);
}
TypeCode typeCode = Type.GetTypeCode(type);
if (typeCode == TypeCode.Object)
{
if (typeofISoapXsd.IsAssignableFrom(type))
{
if (type == typeofSoapTime)
{
return(InternalPrimitiveTypeE.Time);
}
if (type == typeofSoapDate)
{
return(InternalPrimitiveTypeE.Date);
}
if (type == typeofSoapYearMonth)
{
return(InternalPrimitiveTypeE.YearMonth);
}
if (type == typeofSoapYear)
{
return(InternalPrimitiveTypeE.Year);
}
if (type == typeofSoapMonthDay)
{
return(InternalPrimitiveTypeE.MonthDay);
}
if (type == typeofSoapDay)
{
return(InternalPrimitiveTypeE.Day);
}
if (type == typeofSoapMonth)
{
return(InternalPrimitiveTypeE.Month);
}
if (type == typeofSoapHexBinary)
{
return(InternalPrimitiveTypeE.HexBinary);
}
if (type == typeofSoapBase64Binary)
{
return(InternalPrimitiveTypeE.Base64Binary);
}
if (type == typeofSoapInteger)
{
return(InternalPrimitiveTypeE.Integer);
}
if (type == typeofSoapPositiveInteger)
{
return(InternalPrimitiveTypeE.PositiveInteger);
}
if (type == typeofSoapNonPositiveInteger)
{
return(InternalPrimitiveTypeE.NonPositiveInteger);
}
if (type == typeofSoapNonNegativeInteger)
{
return(InternalPrimitiveTypeE.NonNegativeInteger);
}
if (type == typeofSoapNegativeInteger)
{
return(InternalPrimitiveTypeE.NegativeInteger);
}
if (type == typeofSoapAnyUri)
{
return(InternalPrimitiveTypeE.AnyUri);
}
if (type == typeofSoapQName)
{
return(InternalPrimitiveTypeE.QName);
}
if (type == typeofSoapNotation)
{
return(InternalPrimitiveTypeE.Notation);
}
if (type == typeofSoapNormalizedString)
{
return(InternalPrimitiveTypeE.NormalizedString);
}
if (type == typeofSoapToken)
{
return(InternalPrimitiveTypeE.Token);
}
if (type == typeofSoapLanguage)
{
return(InternalPrimitiveTypeE.Language);
}
if (type == typeofSoapName)
{
return(InternalPrimitiveTypeE.Name);
}
if (type == typeofSoapIdrefs)
{
return(InternalPrimitiveTypeE.Idrefs);
}
if (type == typeofSoapEntities)
{
return(InternalPrimitiveTypeE.Entities);
}
if (type == typeofSoapNmtoken)
{
return(InternalPrimitiveTypeE.Nmtoken);
}
if (type == typeofSoapNmtokens)
{
return(InternalPrimitiveTypeE.Nmtokens);
}
if (type == typeofSoapNcName)
{
return(InternalPrimitiveTypeE.NcName);
}
if (type == typeofSoapId)
{
return(InternalPrimitiveTypeE.Id);
}
if (type == typeofSoapIdref)
{
return(InternalPrimitiveTypeE.Idref);
}
if (type == typeofSoapEntity)
{
invalid = InternalPrimitiveTypeE.Entity;
}
return(invalid);
}
if (type == typeofTimeSpan)
{
return(InternalPrimitiveTypeE.TimeSpan);
}
return(InternalPrimitiveTypeE.Invalid);
}
return(ToPrimitiveTypeEnum(typeCode));
}
private NameInfo TypeToNameInfo(WriteObjectInfo objectInfo, InternalPrimitiveTypeE code)
{
return TypeToNameInfo(objectInfo.objectType, objectInfo, code, null);
}
internal static string SoapToString(object data, InternalPrimitiveTypeE code)
{
return(ToString(data, code));
}
internal void Set(InternalPrimitiveTypeE typeInformation)
{
_typeInformation = typeInformation;
}
// ReadValue from stream using InternalPrimitiveTypeE code
internal Object ReadValue(InternalPrimitiveTypeE code)
{
SerTrace.Log( this, "ReadValue ",((Enum)code).ToString());
Object var = null;
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
var = ReadBoolean();
break;
case InternalPrimitiveTypeE.Byte:
var = ReadByte();
break;
case InternalPrimitiveTypeE.Char:
var = ReadChar();
break;
case InternalPrimitiveTypeE.Double:
var = ReadDouble();
break;
case InternalPrimitiveTypeE.Int16:
var = ReadInt16();
break;
case InternalPrimitiveTypeE.Int32:
var = ReadInt32();
break;
case InternalPrimitiveTypeE.Int64:
var = ReadInt64();
break;
case InternalPrimitiveTypeE.SByte:
var = ReadSByte();
break;
case InternalPrimitiveTypeE.Single:
var = ReadSingle();
break;
case InternalPrimitiveTypeE.UInt16:
var = ReadUInt16();
break;
case InternalPrimitiveTypeE.UInt32:
var = ReadUInt32();
break;
case InternalPrimitiveTypeE.UInt64:
var = ReadUInt64();
break;
case InternalPrimitiveTypeE.Decimal:
var = ReadDecimal();
break;
case InternalPrimitiveTypeE.TimeSpan:
var = ReadTimeSpan();
break;
case InternalPrimitiveTypeE.DateTime:
var = ReadDateTime();
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeCode",((Enum)code).ToString()));
}
SerTrace.Log( "ReadValue Exit ",var);
return var;
}
internal static string ToComType(InternalPrimitiveTypeE code)
{
if (s_valueA == null)
{
InitValueA();
}
return s_valueA[(int)code];
}
// Initialize ParseRecord. Called when reusing.
internal void Init()
{
// Enums
PRparseTypeEnum = InternalParseTypeE.Empty;
PRobjectTypeEnum = InternalObjectTypeE.Empty;
PRarrayTypeEnum = InternalArrayTypeE.Empty;
PRmemberTypeEnum = InternalMemberTypeE.Empty;
PRmemberValueEnum = InternalMemberValueE.Empty;
PRobjectPositionEnum = InternalObjectPositionE.Empty;
// Object
PRname = null;
PRnameXmlKey = null;
PRxmlNameSpace = null;
PRisParsed = false;
PRisProcessAttributes = false;
// Value
PRvalue = null;
// dt attribute
PRkeyDt = null;
PRdtType = null;
PRassemblyName = null;
PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
PRisEnum = false;
// Object ID
PRobjectId = 0;
// Reference ID
PRidRef = 0;
// Array
// Array Element Type
PRarrayElementTypeString = null;
PRarrayElementType = null;
PRisArrayVariant = false;
PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
// Array Primitive Element type
PRprimitiveArrayTypeString = null;
// Parsed array information
PRrank = 0;
PRlengthA = null;
PRpositionA = null;
PRlowerBoundA = null;
PRupperBoundA = null;
// Array map for placing array elements in array
PRindexMap = null;
PRmemberIndex = 0;
PRlinearlength = 0;
PRrectangularMap = null;
PRisLowerBound = false;
// SerializedStreamHeader information
PRtopId = 0;
PRheaderId = 0;
PRisHeaderRoot = false;
PRisAttributesProcessed = false;
// Parsed HeaderMember Information
PRisMustUnderstand = false;
// Parse State
PRparseStateEnum = InternalParseStateE.Initial;
PRisWaitingForNestedObject = false;
// ValueType Fixup needed
PRisValueTypeFixup = false;
PRnewObj = null;
PRobjectA = null;
PRprimitiveArray = null;
PRobjectInfo = null;
PRisRegistered = false;
PRisXmlAttribute = false;
}
internal InternalPrimitiveTypeE ToCode(Type type)
{
if (Object.ReferenceEquals(previousType, type))
{
return previousCode;
}
else
{
InternalPrimitiveTypeE code = Converter.ToCode(type);
if (code != InternalPrimitiveTypeE.Invalid)
{
previousType = type;
previousCode = code;
}
return code;
}
}
internal static InternalPrimitiveTypeE ToCode(string value)
{
if (value == null)
{
throw new ArgumentNullException("serParser", string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("ArgumentNull_WithParamName"), new object[] { value }));
}
string str = value.ToLower(CultureInfo.InvariantCulture);
char ch = str[0];
InternalPrimitiveTypeE invalid = InternalPrimitiveTypeE.Invalid;
switch (ch)
{
case 'a':
if (str == "anyuri")
{
invalid = InternalPrimitiveTypeE.AnyUri;
}
return(invalid);
case 'b':
if (!(str == "boolean"))
{
switch (str)
{
case "byte":
return(InternalPrimitiveTypeE.SByte);
case "base64binary":
return(InternalPrimitiveTypeE.Base64Binary);
case "base64":
invalid = InternalPrimitiveTypeE.Base64Binary;
break;
}
return(invalid);
}
return(InternalPrimitiveTypeE.Boolean);
case 'c':
if (!(str == "char") && !(str == "character"))
{
return(invalid);
}
return(InternalPrimitiveTypeE.Char);
case 'd':
switch (str)
{
case "double":
invalid = InternalPrimitiveTypeE.Double;
break;
case "datetime":
return(InternalPrimitiveTypeE.DateTime);
case "duration":
return(InternalPrimitiveTypeE.TimeSpan);
case "date":
return(InternalPrimitiveTypeE.Date);
case "decimal":
invalid = InternalPrimitiveTypeE.Decimal;
break;
}
return(invalid);
case 'e':
if (!(str == "entities"))
{
if (str == "entity")
{
invalid = InternalPrimitiveTypeE.Entity;
}
return(invalid);
}
return(InternalPrimitiveTypeE.Entities);
case 'f':
if (str == "float")
{
invalid = InternalPrimitiveTypeE.Single;
}
return(invalid);
case 'g':
if (!(str == "gyearmonth"))
{
if (str == "gyear")
{
return(InternalPrimitiveTypeE.Year);
}
if (str == "gmonthday")
{
return(InternalPrimitiveTypeE.MonthDay);
}
if (str == "gday")
{
return(InternalPrimitiveTypeE.Day);
}
if (str == "gmonth")
{
invalid = InternalPrimitiveTypeE.Month;
}
return(invalid);
}
return(InternalPrimitiveTypeE.YearMonth);
case 'h':
if (str == "hexbinary")
{
invalid = InternalPrimitiveTypeE.HexBinary;
}
return(invalid);
case 'i':
switch (str)
{
case "int":
invalid = InternalPrimitiveTypeE.Int32;
break;
case "integer":
return(InternalPrimitiveTypeE.Integer);
case "idrefs":
return(InternalPrimitiveTypeE.Idrefs);
case "id":
return(InternalPrimitiveTypeE.Id);
case "idref":
invalid = InternalPrimitiveTypeE.Idref;
break;
}
return(invalid);
case 'l':
if (!(str == "long"))
{
if (str == "language")
{
invalid = InternalPrimitiveTypeE.Language;
}
return(invalid);
}
return(InternalPrimitiveTypeE.Int64);
case 'n':
if (!(str == "number"))
{
if (str == "normalizedstring")
{
return(InternalPrimitiveTypeE.NormalizedString);
}
if (str == "nonpositiveinteger")
{
return(InternalPrimitiveTypeE.NonPositiveInteger);
}
if (str == "negativeinteger")
{
return(InternalPrimitiveTypeE.NegativeInteger);
}
if (str == "nonnegativeinteger")
{
return(InternalPrimitiveTypeE.NonNegativeInteger);
}
if (str == "notation")
{
return(InternalPrimitiveTypeE.Notation);
}
if (str == "nmtoken")
{
return(InternalPrimitiveTypeE.Nmtoken);
}
if (str == "nmtokens")
{
return(InternalPrimitiveTypeE.Nmtokens);
}
if (str == "name")
{
return(InternalPrimitiveTypeE.Name);
}
if (str == "ncname")
{
invalid = InternalPrimitiveTypeE.NcName;
}
return(invalid);
}
return(InternalPrimitiveTypeE.Decimal);
case 'p':
if (str == "positiveinteger")
{
invalid = InternalPrimitiveTypeE.PositiveInteger;
}
return(invalid);
case 'q':
if (str == "qname")
{
invalid = InternalPrimitiveTypeE.QName;
}
return(invalid);
case 's':
if (!(str == "short"))
{
if (str == "system.byte")
{
return(InternalPrimitiveTypeE.Byte);
}
if (str == "system.sbyte")
{
return(InternalPrimitiveTypeE.SByte);
}
if (str == "system")
{
return(ToCode(value.Substring(7)));
}
if (str == "system.runtime.remoting.metadata")
{
invalid = ToCode(value.Substring(0x21));
}
return(invalid);
}
return(InternalPrimitiveTypeE.Int16);
case 't':
if (!(str == "time"))
{
if (str == "token")
{
return(InternalPrimitiveTypeE.Token);
}
if (str == "timeinstant")
{
return(InternalPrimitiveTypeE.DateTime);
}
if (str == "timeduration")
{
invalid = InternalPrimitiveTypeE.TimeSpan;
}
return(invalid);
}
return(InternalPrimitiveTypeE.Time);
case 'u':
if (!(str == "unsignedlong"))
{
if (str == "unsignedint")
{
return(InternalPrimitiveTypeE.UInt32);
}
if (str == "unsignedshort")
{
return(InternalPrimitiveTypeE.UInt16);
}
if (str == "unsignedbyte")
{
invalid = InternalPrimitiveTypeE.Byte;
}
return(invalid);
}
return(InternalPrimitiveTypeE.UInt64);
}
return(InternalPrimitiveTypeE.Invalid);
}
public void Read(__BinaryParser input)
{
this.primitiveTypeEnum = (InternalPrimitiveTypeE)input.ReadByte();
this.value = input.ReadValue(this.primitiveTypeEnum);
}
internal static void TypeFromInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, ObjectReader objectReader, BinaryAssemblyInfo assemblyInfo, out InternalPrimitiveTypeE primitiveTypeEnum, out string typeString, out Type type, out bool isVariant)
{
isVariant = false;
primitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
typeString = null;
type = null;
switch (binaryTypeEnum)
{
case BinaryTypeEnum.Primitive:
primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation;
typeString = Converter.ToComType(primitiveTypeEnum);
type = Converter.ToType(primitiveTypeEnum);
return;
case BinaryTypeEnum.String:
type = Converter.typeofString;
return;
case BinaryTypeEnum.Object:
type = Converter.typeofObject;
isVariant = true;
return;
case BinaryTypeEnum.ObjectUrt:
case BinaryTypeEnum.ObjectUser:
if (typeInformation != null)
{
typeString = typeInformation.ToString();
type = objectReader.GetType(assemblyInfo, typeString);
if (type == Converter.typeofObject)
{
isVariant = true;
return;
}
}
return;
case BinaryTypeEnum.ObjectArray:
type = Converter.typeofObjectArray;
return;
case BinaryTypeEnum.StringArray:
type = Converter.typeofStringArray;
return;
case BinaryTypeEnum.PrimitiveArray:
primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation;
type = Converter.ToArrayType(primitiveTypeEnum);
return;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeRead", new object[]
{
binaryTypeEnum.ToString()
}));
}
}
// Token: 0x06005295 RID: 21141 RVA: 0x00121EF4 File Offset: 0x001200F4
internal static BinaryTypeEnum GetBinaryTypeInfo(Type type, WriteObjectInfo objectInfo, string typeName, ObjectWriter objectWriter, out object typeInformation, out int assemId)
{
assemId = 0;
typeInformation = null;
BinaryTypeEnum result;
if (type == Converter.typeofString)
{
result = BinaryTypeEnum.String;
}
else if ((objectInfo == null || (objectInfo != null && !objectInfo.isSi)) && type == Converter.typeofObject)
{
result = BinaryTypeEnum.Object;
}
else if (type == Converter.typeofStringArray)
{
result = BinaryTypeEnum.StringArray;
}
else if (type == Converter.typeofObjectArray)
{
result = BinaryTypeEnum.ObjectArray;
}
else if (Converter.IsPrimitiveArray(type, out typeInformation))
{
result = BinaryTypeEnum.PrimitiveArray;
}
else
{
InternalPrimitiveTypeE internalPrimitiveTypeE = objectWriter.ToCode(type);
if (internalPrimitiveTypeE == InternalPrimitiveTypeE.Invalid)
{
string text;
if (objectInfo == null)
{
text = type.Assembly.FullName;
typeInformation = type.FullName;
}
else
{
text = objectInfo.GetAssemblyString();
typeInformation = objectInfo.GetTypeFullName();
}
if (text.Equals(Converter.urtAssemblyString))
{
result = BinaryTypeEnum.ObjectUrt;
assemId = 0;
}
else
{
result = BinaryTypeEnum.ObjectUser;
assemId = (int)objectInfo.assemId;
if (assemId == 0)
{
throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", new object[]
{
typeInformation
}));
}
}
}
else
{
result = BinaryTypeEnum.Primitive;
typeInformation = internalPrimitiveTypeE;
}
}
return(result);
}
// ReadValue from stream using InternalPrimitiveTypeE code
internal Object ReadValue(InternalPrimitiveTypeE code)
{
SerTrace.Log(this, "ReadValue ", ((Enum)code).ToString());
Object var = null;
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
var = ReadBoolean();
break;
case InternalPrimitiveTypeE.Byte:
var = ReadByte();
break;
case InternalPrimitiveTypeE.Char:
var = ReadChar();
break;
case InternalPrimitiveTypeE.Double:
var = ReadDouble();
break;
case InternalPrimitiveTypeE.Int16:
var = ReadInt16();
break;
case InternalPrimitiveTypeE.Int32:
var = ReadInt32();
break;
case InternalPrimitiveTypeE.Int64:
var = ReadInt64();
break;
case InternalPrimitiveTypeE.SByte:
var = ReadSByte();
break;
case InternalPrimitiveTypeE.Single:
var = ReadSingle();
break;
case InternalPrimitiveTypeE.UInt16:
var = ReadUInt16();
break;
case InternalPrimitiveTypeE.UInt32:
var = ReadUInt32();
break;
case InternalPrimitiveTypeE.UInt64:
var = ReadUInt64();
break;
case InternalPrimitiveTypeE.Decimal:
var = ReadDecimal();
break;
case InternalPrimitiveTypeE.TimeSpan:
var = ReadTimeSpan();
break;
case InternalPrimitiveTypeE.DateTime:
var = ReadDateTime();
break;
default:
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_TypeCode"), ((Enum)code).ToString()));
}
SerTrace.Log("ReadValue Exit ", var);
return(var);
}
internal PrimitiveArray(InternalPrimitiveTypeE code, Array array)
{
this.Init(code, array);
}
internal void WriteValue(InternalPrimitiveTypeE code, object value)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
this.WriteBoolean(Convert.ToBoolean(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Byte:
this.WriteByte(Convert.ToByte(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Char:
this.WriteChar(Convert.ToChar(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Decimal:
this.WriteDecimal(Convert.ToDecimal(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Double:
this.WriteDouble(Convert.ToDouble(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int16:
this.WriteInt16(Convert.ToInt16(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int32:
this.WriteInt32(Convert.ToInt32(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int64:
this.WriteInt64(Convert.ToInt64(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.SByte:
this.WriteSByte(Convert.ToSByte(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Single:
this.WriteSingle(Convert.ToSingle(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.TimeSpan:
this.WriteTimeSpan((TimeSpan)value);
break;
case InternalPrimitiveTypeE.DateTime:
this.WriteDateTime((DateTime)value);
break;
case InternalPrimitiveTypeE.UInt16:
this.WriteUInt16(Convert.ToUInt16(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.UInt32:
this.WriteUInt32(Convert.ToUInt32(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.UInt64:
this.WriteUInt64(Convert.ToUInt64(value, (IFormatProvider)CultureInfo.InvariantCulture));
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeCode", (object)code.ToString()));
}
}
// Method to write a value onto a stream given its primitive type code
internal void WriteValue(InternalPrimitiveTypeE code, Object value)
{
SerTrace.Log( this, "WriteValue Entry ",((Enum)code).ToString()," " , ((value==null)?"<null>":value.GetType().ToString()) , " ",value);
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
WriteBoolean(Convert.ToBoolean(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Byte:
WriteByte(Convert.ToByte(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Char:
WriteChar(Convert.ToChar(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Double:
WriteDouble(Convert.ToDouble(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int16:
WriteInt16(Convert.ToInt16(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int32:
WriteInt32(Convert.ToInt32(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int64:
WriteInt64(Convert.ToInt64(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.SByte:
WriteSByte(Convert.ToSByte(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Single:
WriteSingle(Convert.ToSingle(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.UInt16:
WriteUInt16(Convert.ToUInt16(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.UInt32:
WriteUInt32(Convert.ToUInt32(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.UInt64:
WriteUInt64(Convert.ToUInt64(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Decimal:
WriteDecimal(Convert.ToDecimal(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.TimeSpan:
WriteTimeSpan((TimeSpan)value);
break;
case InternalPrimitiveTypeE.DateTime:
WriteDateTime((DateTime)value);
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeCode",((Enum)code).ToString()));
}
SerTrace.Log( this, "Write Exit ");
}
// Method to write a value onto a stream given its primitive type code
internal void WriteValue(InternalPrimitiveTypeE code, Object value)
{
SerTrace.Log(this, "WriteValue Entry ", ((Enum)code).ToString(), " ", ((value == null)?"<null>":value.GetType().ToString()), " ", value);
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
WriteBoolean(Convert.ToBoolean(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Byte:
WriteByte(Convert.ToByte(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Char:
WriteChar(Convert.ToChar(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Double:
WriteDouble(Convert.ToDouble(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int16:
WriteInt16(Convert.ToInt16(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int32:
WriteInt32(Convert.ToInt32(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Int64:
WriteInt64(Convert.ToInt64(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.SByte:
WriteSByte(Convert.ToSByte(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Single:
WriteSingle(Convert.ToSingle(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.UInt16:
WriteUInt16(Convert.ToUInt16(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.UInt32:
WriteUInt32(Convert.ToUInt32(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.UInt64:
WriteUInt64(Convert.ToUInt64(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.Decimal:
WriteDecimal(Convert.ToDecimal(value, CultureInfo.InvariantCulture));
break;
case InternalPrimitiveTypeE.TimeSpan:
WriteTimeSpan((TimeSpan)value);
break;
case InternalPrimitiveTypeE.DateTime:
WriteDateTime((DateTime)value);
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeCode", ((Enum)code).ToString()));
}
SerTrace.Log(this, "Write Exit ");
}
internal PrimitiveArray(InternalPrimitiveTypeE code, Array array)
{
_code = code;
switch (code)
{
case InternalPrimitiveTypeE.Boolean: _booleanA = (bool[])array; break;
case InternalPrimitiveTypeE.Char: _charA = (char[])array; break;
case InternalPrimitiveTypeE.Double: _doubleA = (double[])array; break;
case InternalPrimitiveTypeE.Int16: _int16A = (short[])array; break;
case InternalPrimitiveTypeE.Int32: _int32A = (int[])array; break;
case InternalPrimitiveTypeE.Int64: _int64A = (long[])array; break;
case InternalPrimitiveTypeE.SByte: _sbyteA = (sbyte[])array; break;
case InternalPrimitiveTypeE.Single: _singleA = (float[])array; break;
case InternalPrimitiveTypeE.UInt16: _uint16A = (ushort[])array; break;
case InternalPrimitiveTypeE.UInt32: _uint32A = (uint[])array; break;
case InternalPrimitiveTypeE.UInt64: _uint64A = (ulong[])array; break;
}
}
internal void Set(InternalPrimitiveTypeE typeInformation, Object value)
{
SerTrace.Log(this, "MemberPrimitiveUnTyped Set typeInformation ", typeInformation, " value ", value);
this.typeInformation = typeInformation;
this.value = value;
}
internal static InternalNameSpaceE GetNameSpaceEnum(InternalPrimitiveTypeE code, Type type, WriteObjectInfo objectInfo, out string typeName)
{
InternalNameSpaceE nameSpaceEnum = InternalNameSpaceE.None;
typeName = null;
if (code != InternalPrimitiveTypeE.Invalid)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
case InternalPrimitiveTypeE.Char:
case InternalPrimitiveTypeE.Byte:
case InternalPrimitiveTypeE.Double:
case InternalPrimitiveTypeE.Int16:
case InternalPrimitiveTypeE.Int32:
case InternalPrimitiveTypeE.Int64:
case InternalPrimitiveTypeE.SByte:
case InternalPrimitiveTypeE.Single:
case InternalPrimitiveTypeE.UInt16:
case InternalPrimitiveTypeE.UInt32:
case InternalPrimitiveTypeE.UInt64:
case InternalPrimitiveTypeE.DateTime:
case InternalPrimitiveTypeE.TimeSpan:
nameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
typeName = "System." + ToComType(code);
break;
case InternalPrimitiveTypeE.Decimal:
nameSpaceEnum = InternalNameSpaceE.UrtSystem;
typeName = "System." + ToComType(code);
break;
}
}
if ((nameSpaceEnum == InternalNameSpaceE.None) && type != null)
{
if (ReferenceEquals(type, s_typeofString))
{
nameSpaceEnum = InternalNameSpaceE.XdrString;
}
else
{
if (objectInfo == null)
{
typeName = type.FullName;
nameSpaceEnum = type.GetTypeInfo().Assembly == s_urtAssembly ? InternalNameSpaceE.UrtSystem : InternalNameSpaceE.UrtUser;
}
else
{
typeName = objectInfo.GetTypeFullName();
nameSpaceEnum = objectInfo.GetAssemblyString().Equals(s_urtAssemblyString) ? InternalNameSpaceE.UrtSystem : InternalNameSpaceE.UrtUser;
}
}
}
return nameSpaceEnum;
}
internal static InternalNameSpaceE GetNameSpaceEnum(InternalPrimitiveTypeE code, Type type, WriteObjectInfo objectInfo, out string typeName)
{
InternalNameSpaceE none = InternalNameSpaceE.None;
typeName = null;
if (code != InternalPrimitiveTypeE.Invalid)
{
if (code == InternalPrimitiveTypeE.Char)
{
none = InternalNameSpaceE.UrtSystem;
typeName = "System.Char";
}
else
{
none = InternalNameSpaceE.XdrPrimitive;
typeName = ToXmlDataType(code);
}
}
if ((none == InternalNameSpaceE.None) && (type != null))
{
if (type == typeofString)
{
none = InternalNameSpaceE.XdrString;
}
else if (objectInfo == null)
{
typeName = type.FullName;
if (type.Module.Assembly == urtAssembly)
{
none = InternalNameSpaceE.UrtSystem;
}
else
{
none = InternalNameSpaceE.UrtUser;
}
}
else
{
typeName = objectInfo.GetTypeFullName();
if (objectInfo.GetAssemblyString().Equals(urtAssemblyString))
{
none = InternalNameSpaceE.UrtSystem;
}
else
{
none = InternalNameSpaceE.UrtUser;
}
}
}
if (objectInfo != null)
{
if (!objectInfo.isSi && ((objectInfo.IsAttributeNameSpace() || objectInfo.IsCustomXmlAttribute()) || objectInfo.IsCustomXmlElement()))
{
return(InternalNameSpaceE.Interop);
}
if (objectInfo.IsCallElement())
{
none = InternalNameSpaceE.CallElement;
}
}
return(none);
}
private static void InitCodeA()
{
var codeATemp = new InternalPrimitiveTypeE[19];
codeATemp[(int)TypeCode.Empty] = InternalPrimitiveTypeE.Invalid;
codeATemp[(int)TypeCode.Object] = InternalPrimitiveTypeE.Invalid;
codeATemp[2] = InternalPrimitiveTypeE.Invalid; // TODO: Change 2 to (int)TypeCode.DBNull when it's available
codeATemp[(int)TypeCode.Boolean] = InternalPrimitiveTypeE.Boolean;
codeATemp[(int)TypeCode.Char] = InternalPrimitiveTypeE.Char;
codeATemp[(int)TypeCode.SByte] = InternalPrimitiveTypeE.SByte;
codeATemp[(int)TypeCode.Byte] = InternalPrimitiveTypeE.Byte;
codeATemp[(int)TypeCode.Int16] = InternalPrimitiveTypeE.Int16;
codeATemp[(int)TypeCode.UInt16] = InternalPrimitiveTypeE.UInt16;
codeATemp[(int)TypeCode.Int32] = InternalPrimitiveTypeE.Int32;
codeATemp[(int)TypeCode.UInt32] = InternalPrimitiveTypeE.UInt32;
codeATemp[(int)TypeCode.Int64] = InternalPrimitiveTypeE.Int64;
codeATemp[(int)TypeCode.UInt64] = InternalPrimitiveTypeE.UInt64;
codeATemp[(int)TypeCode.Single] = InternalPrimitiveTypeE.Single;
codeATemp[(int)TypeCode.Double] = InternalPrimitiveTypeE.Double;
codeATemp[(int)TypeCode.Decimal] = InternalPrimitiveTypeE.Decimal;
codeATemp[(int)TypeCode.DateTime] = InternalPrimitiveTypeE.DateTime;
codeATemp[17] = InternalPrimitiveTypeE.Invalid;
codeATemp[(int)TypeCode.String] = InternalPrimitiveTypeE.Invalid;
s_codeA = codeATemp;
}
internal static Type SoapToType(InternalPrimitiveTypeE code)
{
return(ToType(code));
}
internal void Set(InternalPrimitiveTypeE typeInformation, object?value)
{
_typeInformation = typeInformation;
_value = value;
}
// Transforms a type to the serialized string form. URT Primitive types are converted to XMLData Types
private NameInfo TypeToNameInfo(Type type, WriteObjectInfo objectInfo, InternalPrimitiveTypeE code, NameInfo nameInfo)
{
InternalST.Soap( this, "TypeToNameInfo Entry type ",type,", objectInfo ",objectInfo,", code ", ((Enum)code).ToString());
if (nameInfo == null)
nameInfo = GetNameInfo();
else
nameInfo.Init();
nameInfo.NIisSealed = type.IsSealed;
String typeName = null;
nameInfo.NInameSpaceEnum = Converter.GetNameSpaceEnum(code, type, objectInfo, out typeName);
nameInfo.NIprimitiveTypeEnum = code;
nameInfo.NItype = type;
nameInfo.NIname = typeName;
if (objectInfo != null)
{
nameInfo.NIattributeInfo = objectInfo.typeAttributeInfo;
nameInfo.NIassemId = objectInfo.assemId;
}
switch (nameInfo.NInameSpaceEnum)
{
case InternalNameSpaceE.XdrPrimitive:
break;
case InternalNameSpaceE.XdrString:
nameInfo.NIname = "string";
break;
case InternalNameSpaceE.UrtSystem:
break;
case InternalNameSpaceE.UrtUser:
//if (type.FullName.StartsWith("System."))
if (type.Module.Assembly == Converter.urtAssembly)
{
// The type name could be an ISerializable
// But the type returned (typeName) could be a fake
// type
}
else
{
if (objectInfo == null)
{
InternalST.Soap( this, "TypeToNameInfo ObjectInfo is null 2 ",type);
}
}
break;
}
InternalST.Soap( this, "TypeToNameInfo Exit ",type, " typeName "+nameInfo.NIname);
return nameInfo;
}
internal void Set(InternalPrimitiveTypeE typeInformation)
{
SerTrace.Log(this, "MemberPrimitiveUnTyped Set ", typeInformation);
this.typeInformation = typeInformation;
}
internal static object FromString(string value, InternalPrimitiveTypeE code)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
if (!(value == "1") && !(value == "true"))
{
if ((value != "0") && (value != "false"))
{
throw new SerializationException(string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_typeCoercion"), new object[] { value, "Boolean" }));
}
return(false);
}
return(true);
case InternalPrimitiveTypeE.Double:
if (!(value == "INF"))
{
if (value == "-INF")
{
return((double)-1.0 / (double)0.0);
}
return(double.Parse(value, CultureInfo.InvariantCulture));
}
return((double)1.0 / (double)0.0);
case InternalPrimitiveTypeE.Single:
if (!(value == "INF"))
{
if (value == "-INF")
{
return((float)-1.0 / (float)0.0);
}
return(float.Parse(value, CultureInfo.InvariantCulture));
}
return((float)1.0 / (float)0.0);
case InternalPrimitiveTypeE.TimeSpan:
return(SoapDuration.Parse(value));
case InternalPrimitiveTypeE.DateTime:
return(SoapDateTime.Parse(value));
case InternalPrimitiveTypeE.Time:
return(SoapTime.Parse(value));
case InternalPrimitiveTypeE.Date:
return(SoapDate.Parse(value));
case InternalPrimitiveTypeE.YearMonth:
return(SoapYearMonth.Parse(value));
case InternalPrimitiveTypeE.Year:
return(SoapYear.Parse(value));
case InternalPrimitiveTypeE.MonthDay:
return(SoapMonthDay.Parse(value));
case InternalPrimitiveTypeE.Day:
return(SoapDay.Parse(value));
case InternalPrimitiveTypeE.Month:
return(SoapMonth.Parse(value));
case InternalPrimitiveTypeE.HexBinary:
return(SoapHexBinary.Parse(value));
case InternalPrimitiveTypeE.Base64Binary:
return(SoapBase64Binary.Parse(value));
case InternalPrimitiveTypeE.Integer:
return(SoapInteger.Parse(value));
case InternalPrimitiveTypeE.PositiveInteger:
return(SoapPositiveInteger.Parse(value));
case InternalPrimitiveTypeE.NonPositiveInteger:
return(SoapNonPositiveInteger.Parse(value));
case InternalPrimitiveTypeE.NonNegativeInteger:
return(SoapNonNegativeInteger.Parse(value));
case InternalPrimitiveTypeE.NegativeInteger:
return(SoapNegativeInteger.Parse(value));
case InternalPrimitiveTypeE.AnyUri:
return(SoapAnyUri.Parse(value));
case InternalPrimitiveTypeE.QName:
return(SoapQName.Parse(value));
case InternalPrimitiveTypeE.Notation:
return(SoapNotation.Parse(value));
case InternalPrimitiveTypeE.NormalizedString:
return(SoapNormalizedString.Parse(value));
case InternalPrimitiveTypeE.Token:
return(SoapToken.Parse(value));
case InternalPrimitiveTypeE.Language:
return(SoapLanguage.Parse(value));
case InternalPrimitiveTypeE.Name:
return(SoapName.Parse(value));
case InternalPrimitiveTypeE.Idrefs:
return(SoapIdrefs.Parse(value));
case InternalPrimitiveTypeE.Entities:
return(SoapEntities.Parse(value));
case InternalPrimitiveTypeE.Nmtoken:
return(SoapNmtoken.Parse(value));
case InternalPrimitiveTypeE.Nmtokens:
return(SoapNmtokens.Parse(value));
case InternalPrimitiveTypeE.NcName:
return(SoapNcName.Parse(value));
case InternalPrimitiveTypeE.Id:
return(SoapId.Parse(value));
case InternalPrimitiveTypeE.Idref:
return(SoapIdref.Parse(value));
case InternalPrimitiveTypeE.Entity:
return(SoapEntity.Parse(value));
}
if (code != InternalPrimitiveTypeE.Invalid)
{
return(Convert.ChangeType(value, ToTypeCode(code), CultureInfo.InvariantCulture));
}
return(value);
}
// Translates a string into an Object
internal static Object FromString(String value, InternalPrimitiveTypeE code)
{
Object var;
SerTrace.Log( "Converter", "FromString Entry ",value," " , ((Enum)code).ToString());
// InternalPrimitiveTypeE needs to be a primitive type
Contract.Assert((code != InternalPrimitiveTypeE.Invalid), "[Converter.FromString]!InternalPrimitiveTypeE.Invalid ");
if (code != InternalPrimitiveTypeE.Invalid)
var = Convert.ChangeType(value, ToTypeCode(code), CultureInfo.InvariantCulture);
else
var = value;
SerTrace.Log( "Converter", "FromString Exit "+((var == null)?"null":var+" var type "+((var==null)?"<null>":var.GetType().ToString())));
return var;
}
internal void Set(InternalPrimitiveTypeE primitiveTypeEnum, Object value)
{
this.primitiveTypeEnum = primitiveTypeEnum;
this.value = value;
}
internal static int TypeLength(InternalPrimitiveTypeE code)
{
int length = 0;
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
length = 1;
break;
case InternalPrimitiveTypeE.Char:
length = 2;
break;
case InternalPrimitiveTypeE.Byte:
length = 1;
break;
case InternalPrimitiveTypeE.Double:
length = 8;
break;
case InternalPrimitiveTypeE.Int16:
length = 2;
break;
case InternalPrimitiveTypeE.Int32:
length = 4;
break;
case InternalPrimitiveTypeE.Int64:
length = 8;
break;
case InternalPrimitiveTypeE.SByte:
length = 1;
break;
case InternalPrimitiveTypeE.Single:
length = 4;
break;
case InternalPrimitiveTypeE.UInt16:
length = 2;
break;
case InternalPrimitiveTypeE.UInt32:
length = 4;
break;
case InternalPrimitiveTypeE.UInt64:
length = 8;
break;
}
return length;
}
public void Read(BinaryReader input)
{
primitiveTypeEnum = (InternalPrimitiveTypeE)input.ReadByte();
value = BinaryConverter.ReadPrimitiveType(input, primitiveTypeEnum);
}
private NameInfo TypeToNameInfo(Type type, InternalPrimitiveTypeE code)
{
return TypeToNameInfo(type, null, code, null);
}
internal static int TypeLength(InternalPrimitiveTypeE code) =>
code switch
{
internal void WriteValue(InternalPrimitiveTypeE code, object value)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
this.WriteBoolean(Convert.ToBoolean(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.Byte:
this.WriteByte(Convert.ToByte(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.Char:
this.WriteChar(Convert.ToChar(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.Decimal:
this.WriteDecimal(Convert.ToDecimal(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.Double:
this.WriteDouble(Convert.ToDouble(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.Int16:
this.WriteInt16(Convert.ToInt16(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.Int32:
this.WriteInt32(Convert.ToInt32(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.Int64:
this.WriteInt64(Convert.ToInt64(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.SByte:
this.WriteSByte(Convert.ToSByte(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.Single:
this.WriteSingle(Convert.ToSingle(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.TimeSpan:
this.WriteTimeSpan((TimeSpan) value);
return;
case InternalPrimitiveTypeE.DateTime:
this.WriteDateTime((DateTime) value);
return;
case InternalPrimitiveTypeE.UInt16:
this.WriteUInt16(Convert.ToUInt16(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.UInt32:
this.WriteUInt32(Convert.ToUInt32(value, CultureInfo.InvariantCulture));
return;
case InternalPrimitiveTypeE.UInt64:
this.WriteUInt64(Convert.ToUInt64(value, CultureInfo.InvariantCulture));
return;
}
throw new SerializationException(Environment.GetResourceString("Serialization_TypeCode", new object[] { code.ToString() }));
}
// Initialize ParseRecord. Called when reusing.
internal void Init()
{
// Enums
PRparseTypeEnum = InternalParseTypeE.Empty;
PRobjectTypeEnum = InternalObjectTypeE.Empty;
PRarrayTypeEnum = InternalArrayTypeE.Empty;
PRmemberTypeEnum = InternalMemberTypeE.Empty;
PRmemberValueEnum = InternalMemberValueE.Empty;
PRobjectPositionEnum = InternalObjectPositionE.Empty;
// Object
PRname = null;
// Value
PRvalue = null;
// dt attribute
PRkeyDt = null;
PRdtType = null;
PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
PRisEnum = false;
// Object ID
PRobjectId = 0;
// Reference ID
PRidRef = 0;
// Array
// Array Element Type
PRarrayElementTypeString = null;
PRarrayElementType = null;
PRisArrayVariant = false;
PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
// Parsed array information
PRrank = 0;
PRlengthA = null;
PRpositionA = null;
PRlowerBoundA = null;
PRupperBoundA = null;
// Array map for placing array elements in array
PRindexMap = null;
PRmemberIndex = 0;
PRlinearlength = 0;
PRrectangularMap = null;
PRisLowerBound = false;
// SerializedStreamHeader information
PRtopId = 0;
PRheaderId = 0;
// ValueType Fixup needed
PRisValueTypeFixup = false;
PRnewObj = null;
PRobjectA = null;
PRprimitiveArray = null;
PRobjectInfo = null;
PRisRegistered = false;
PRmemberData = null;
PRsi = null;
PRnullCount = 0;
}
internal static void TypeFromInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, ObjectReader objectReader, BinaryAssemblyInfo assemblyInfo, out InternalPrimitiveTypeE primitiveTypeEnum, out string typeString, out Type type, out bool isVariant)
{
isVariant = false;
primitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
typeString = null;
type = null;
switch (binaryTypeEnum)
{
case BinaryTypeEnum.Primitive:
primitiveTypeEnum = (InternalPrimitiveTypeE) typeInformation;
typeString = Converter.ToComType(primitiveTypeEnum);
type = Converter.ToType(primitiveTypeEnum);
return;
case BinaryTypeEnum.String:
type = Converter.typeofString;
return;
case BinaryTypeEnum.Object:
type = Converter.typeofObject;
isVariant = true;
return;
case BinaryTypeEnum.ObjectUrt:
case BinaryTypeEnum.ObjectUser:
if (typeInformation == null)
{
break;
}
typeString = typeInformation.ToString();
type = objectReader.GetType(assemblyInfo, typeString);
if (!object.ReferenceEquals(type, Converter.typeofObject))
{
break;
}
isVariant = true;
return;
case BinaryTypeEnum.ObjectArray:
type = Converter.typeofObjectArray;
return;
case BinaryTypeEnum.StringArray:
type = Converter.typeofStringArray;
return;
case BinaryTypeEnum.PrimitiveArray:
primitiveTypeEnum = (InternalPrimitiveTypeE) typeInformation;
type = Converter.ToArrayType(primitiveTypeEnum);
return;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeRead", new object[] { binaryTypeEnum.ToString() }));
}
}
internal PrimitiveArray(InternalPrimitiveTypeE code, Array array)
{
Init(code, array);
}
// Transforms a type to the serialized string form. URT Primitive types are converted to XMLData Types
private NameInfo TypeToNameInfo(Type type, WriteObjectInfo objectInfo, InternalPrimitiveTypeE code, NameInfo nameInfo)
{
SerTrace.Log( this, "TypeToNameInfo Entry type ",type,", objectInfo ",objectInfo,", code ", ((Enum)code).ToString());
if (nameInfo == null)
nameInfo = GetNameInfo();
else
nameInfo.Init();
if (code == InternalPrimitiveTypeE.Invalid)
{
if (objectInfo != null)
{
nameInfo.NIname = objectInfo.GetTypeFullName();
nameInfo.NIassemId = objectInfo.assemId;
}
}
nameInfo.NIprimitiveTypeEnum = code;
nameInfo.NItype = type;
SerTrace.Log( this, "TypeToNameInfo Exit ",type, " typeName "+nameInfo.NIname);
return nameInfo;
}
// From the type create the BinaryTypeEnum and typeInformation which describes the type on the wire
internal static BinaryTypeEnum GetBinaryTypeInfo(Type type, WriteObjectInfo?objectInfo, string?typeName, ObjectWriter objectWriter, out object?typeInformation, out int assemId)
{
BinaryTypeEnum binaryTypeEnum;
assemId = 0;
typeInformation = null;
if (ReferenceEquals(type, Converter.s_typeofString))
{
binaryTypeEnum = BinaryTypeEnum.String;
}
else if (((objectInfo == null) || ((objectInfo != null) && !objectInfo._isSi)) && (ReferenceEquals(type, Converter.s_typeofObject)))
{
// If objectInfo.Si then can be a surrogate which will change the type
binaryTypeEnum = BinaryTypeEnum.Object;
}
else if (ReferenceEquals(type, Converter.s_typeofStringArray))
{
binaryTypeEnum = BinaryTypeEnum.StringArray;
}
else if (ReferenceEquals(type, Converter.s_typeofObjectArray))
{
binaryTypeEnum = BinaryTypeEnum.ObjectArray;
}
else if (Converter.IsPrimitiveArray(type, out typeInformation))
{
binaryTypeEnum = BinaryTypeEnum.PrimitiveArray;
}
else
{
InternalPrimitiveTypeE primitiveTypeEnum = objectWriter.ToCode(type);
switch (primitiveTypeEnum)
{
case InternalPrimitiveTypeE.Invalid:
string?assembly = null;
if (objectInfo == null)
{
assembly = type.Assembly.FullName;
typeInformation = type.FullName;
}
else
{
assembly = objectInfo.GetAssemblyString();
typeInformation = objectInfo.GetTypeFullName();
}
Debug.Assert(assembly != null);
if (assembly.Equals(Converter.s_urtAssemblyString) || assembly.Equals(Converter.s_urtAlternativeAssemblyString))
{
binaryTypeEnum = BinaryTypeEnum.ObjectUrt;
assemId = 0;
}
else
{
binaryTypeEnum = BinaryTypeEnum.ObjectUser;
Debug.Assert(objectInfo != null, "[BinaryConverter.GetBinaryTypeInfo]objectInfo null for user object");
assemId = (int)objectInfo._assemId;
if (assemId == 0)
{
throw new SerializationException(SR.Format(SR.Serialization_AssemblyId, typeInformation));
}
}
break;
default:
binaryTypeEnum = BinaryTypeEnum.Primitive;
typeInformation = primitiveTypeEnum;
break;
}
}
return(binaryTypeEnum);
}
internal void Init()
{
_fullName = null;
_objectId = 0;
_assemId = 0;
_primitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
_type = null;
_isSealed = false;
_transmitTypeOnObject = false;
_transmitTypeOnMember = false;
_isParentTypeOnObject = false;
_isArray = false;
_isArrayItem = false;
_arrayEnum = InternalArrayTypeE.Empty;
_sealedStatusChecked = false;
}
internal static void TypeFromInfo(BinaryTypeEnum binaryTypeEnum,
object?typeInformation,
ObjectReader objectReader,
BinaryAssemblyInfo?assemblyInfo,
out InternalPrimitiveTypeE primitiveTypeEnum,
out string?typeString,
out Type?type,
out bool isVariant)
{
isVariant = false;
primitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
typeString = null;
type = null;
switch (binaryTypeEnum)
{
case BinaryTypeEnum.Primitive:
primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation !;
typeString = Converter.ToComType(primitiveTypeEnum);
type = Converter.ToType(primitiveTypeEnum);
break;
case BinaryTypeEnum.String:
type = Converter.s_typeofString;
break;
case BinaryTypeEnum.Object:
type = Converter.s_typeofObject;
isVariant = true;
break;
case BinaryTypeEnum.ObjectArray:
type = Converter.s_typeofObjectArray;
break;
case BinaryTypeEnum.StringArray:
type = Converter.s_typeofStringArray;
break;
case BinaryTypeEnum.PrimitiveArray:
primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation !;
type = Converter.ToArrayType(primitiveTypeEnum);
break;
case BinaryTypeEnum.ObjectUser:
case BinaryTypeEnum.ObjectUrt:
if (typeInformation != null)
{
typeString = typeInformation.ToString();
type = objectReader.GetType(assemblyInfo !, typeString !);
if (ReferenceEquals(type, Converter.s_typeofObject))
{
isVariant = true;
}
}
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_TypeRead, binaryTypeEnum.ToString()));
}
}
// Initialize ParseRecord. Called when reusing.
internal void Init()
{
// Enums
_parseTypeEnum = InternalParseTypeE.Empty;
_objectTypeEnum = InternalObjectTypeE.Empty;
_arrayTypeEnum = InternalArrayTypeE.Empty;
_memberTypeEnum = InternalMemberTypeE.Empty;
_memberValueEnum = InternalMemberValueE.Empty;
_objectPositionEnum = InternalObjectPositionE.Empty;
// Object
_name = null;
// Value
_value = null;
// dt attribute
_keyDt = null;
_dtType = null;
_dtTypeCode = InternalPrimitiveTypeE.Invalid;
// Object ID
_objectId = 0;
// Reference ID
_idRef = 0;
// Array
// Array Element Type
_arrayElementTypeString = null;
_arrayElementType = null;
_isArrayVariant = false;
_arrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
// Parsed array information
_rank = 0;
_lengthA = null;
_lowerBoundA = null;
// Array map for placing array elements in array
_indexMap = null;
_memberIndex = 0;
_linearlength = 0;
_rectangularMap = null;
_isLowerBound = false;
// ValueType Fixup needed
_isValueTypeFixup = false;
_newObj = null;
_objectA = null;
_primitiveArray = null;
_objectInfo = null;
_isRegistered = false;
_memberData = null;
_si = null;
_consecutiveNullArrayEntryCount = 0;
}
internal static InternalNameSpaceE GetNameSpaceEnum(InternalPrimitiveTypeE code, Type type, WriteObjectInfo objectInfo, out String typeName)
{
SerTrace.Log("Converter", "GetNameSpaceEnum Entry ", ((Enum)code).ToString(), " type ", type);
InternalNameSpaceE nameSpaceEnum = InternalNameSpaceE.None;
typeName = null;
if (code != InternalPrimitiveTypeE.Invalid)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
case InternalPrimitiveTypeE.Char:
case InternalPrimitiveTypeE.Byte:
case InternalPrimitiveTypeE.Double:
case InternalPrimitiveTypeE.Int16:
case InternalPrimitiveTypeE.Int32:
case InternalPrimitiveTypeE.Int64:
case InternalPrimitiveTypeE.SByte:
case InternalPrimitiveTypeE.Single:
case InternalPrimitiveTypeE.UInt16:
case InternalPrimitiveTypeE.UInt32:
case InternalPrimitiveTypeE.UInt64:
case InternalPrimitiveTypeE.DateTime:
case InternalPrimitiveTypeE.TimeSpan:
nameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
typeName = "System." + ToComType(code);
break;
case InternalPrimitiveTypeE.Decimal:
nameSpaceEnum = InternalNameSpaceE.UrtSystem;
typeName = "System." + ToComType(code);
break;
}
}
if ((nameSpaceEnum == InternalNameSpaceE.None) && (type != null))
{
if (type == typeofString)
{
nameSpaceEnum = InternalNameSpaceE.XdrString;
}
else
{
if (objectInfo == null)
{
typeName = type.FullName;
if (type.Module.Assembly == urtAssembly)
{
nameSpaceEnum = InternalNameSpaceE.UrtSystem;
}
else
{
nameSpaceEnum = InternalNameSpaceE.UrtUser;
}
}
else
{
typeName = objectInfo.GetTypeFullName();
if (objectInfo.GetAssemblyString().Equals(urtAssemblyString))
{
nameSpaceEnum = InternalNameSpaceE.UrtSystem;
}
else
{
nameSpaceEnum = InternalNameSpaceE.UrtUser;
}
}
}
}
SerTrace.Log("Converter", "GetNameSpaceEnum Exit ", ((Enum)nameSpaceEnum).ToString(), " typeName ", typeName);
return(nameSpaceEnum);
}
// ReadValue from stream using InternalPrimitiveTypeE code
internal object ReadValue(InternalPrimitiveTypeE code)
{
object var = null;
switch (code)
{
case InternalPrimitiveTypeE.Boolean: var = ReadBoolean(); break;
case InternalPrimitiveTypeE.Byte: var = ReadByte(); break;
case InternalPrimitiveTypeE.Char: var = ReadChar(); break;
case InternalPrimitiveTypeE.Double: var = ReadDouble(); break;
case InternalPrimitiveTypeE.Int16: var = ReadInt16(); break;
case InternalPrimitiveTypeE.Int32: var = ReadInt32(); break;
case InternalPrimitiveTypeE.Int64: var = ReadInt64(); break;
case InternalPrimitiveTypeE.SByte: var = ReadSByte(); break;
case InternalPrimitiveTypeE.Single: var = ReadSingle(); break;
case InternalPrimitiveTypeE.UInt16: var = ReadUInt16(); break;
case InternalPrimitiveTypeE.UInt32: var = ReadUInt32(); break;
case InternalPrimitiveTypeE.UInt64: var = ReadUInt64(); break;
case InternalPrimitiveTypeE.Decimal: var = ReadDecimal(); break;
case InternalPrimitiveTypeE.TimeSpan: var = ReadTimeSpan(); break;
case InternalPrimitiveTypeE.DateTime: var = ReadDateTime(); break;
default: throw new SerializationException(SR.Format(SR.Serialization_TypeCode, code.ToString()));
}
return var;
}
internal static Array CreatePrimitiveArray(InternalPrimitiveTypeE code, int length)
{
Array array = null;
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
array = new Boolean[length];
break;
case InternalPrimitiveTypeE.Byte:
array = new Byte[length];
break;
case InternalPrimitiveTypeE.Char:
array = new Char[length];
break;
case InternalPrimitiveTypeE.Decimal:
array = new Decimal[length];
break;
case InternalPrimitiveTypeE.Double:
array = new Double[length];
break;
case InternalPrimitiveTypeE.Int16:
array = new Int16[length];
break;
case InternalPrimitiveTypeE.Int32:
array = new Int32[length];
break;
case InternalPrimitiveTypeE.Int64:
array = new Int64[length];
break;
case InternalPrimitiveTypeE.SByte:
array = new SByte[length];
break;
case InternalPrimitiveTypeE.Single:
array = new Single[length];
break;
case InternalPrimitiveTypeE.TimeSpan:
array = new TimeSpan[length];
break;
case InternalPrimitiveTypeE.DateTime:
array = new DateTime[length];
break;
case InternalPrimitiveTypeE.UInt16:
array = new UInt16[length];
break;
case InternalPrimitiveTypeE.UInt32:
array = new UInt32[length];
break;
case InternalPrimitiveTypeE.UInt64:
array = new UInt64[length];
break;
}
return(array);
}
internal static Type ToArrayType(InternalPrimitiveTypeE code)
{
if (s_arrayTypeA == null)
{
InitArrayTypeA();
}
return s_arrayTypeA[(int)code];
}
// Writes a given object to the stream.
private void Write(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo)
{
object?obj = objectInfo._obj;
if (obj == null)
{
throw new ArgumentNullException(nameof(objectInfo) + "." + nameof(objectInfo._obj));
}
Type?objType = objectInfo._objectType;
long objectId = objectInfo._objectId;
if (ReferenceEquals(objType, Converter.s_typeofString))
{
Debug.Assert(_serWriter != null);
// Top level String
memberNameInfo._objectId = objectId;
_serWriter.WriteObjectString((int)objectId, obj.ToString());
}
else
{
if (objectInfo._isArray)
{
WriteArray(objectInfo, memberNameInfo, null);
}
else
{
objectInfo.GetMemberInfo(out string[]? memberNames, out Type[]? memberTypes, out object?[]? memberData);
// Only Binary needs to transmit types for ISerializable because the binary formatter transmits the types in URT format.
// Soap transmits all types as strings, so it is up to the ISerializable object to convert the string back to its URT type
if (objectInfo._isSi || CheckTypeFormat(_formatterEnums._typeFormat, FormatterTypeStyle.TypesAlways))
{
memberNameInfo._transmitTypeOnObject = true;
memberNameInfo._isParentTypeOnObject = true;
typeNameInfo._transmitTypeOnObject = true;
typeNameInfo._isParentTypeOnObject = true;
}
Debug.Assert(memberNames != null && memberTypes != null && memberData != null);
var memberObjectInfos = new WriteObjectInfo[memberNames.Length];
// Get assembly information
// Binary Serializer, assembly names need to be
// written before objects are referenced.
// GetAssemId here will write out the
// assemblyStrings at the right Binary
// Serialization object boundary.
for (int i = 0; i < memberTypes.Length; i++)
{
Type type =
memberTypes[i] != null ? memberTypes[i] :
memberData[i] != null?GetType(memberData[i] !) : // TODO-NULLABLE https://github.com/dotnet/roslyn/issues/34644
Converter.s_typeofObject;
InternalPrimitiveTypeE code = ToCode(type);
if ((code == InternalPrimitiveTypeE.Invalid) &&
(!ReferenceEquals(type, Converter.s_typeofString)))
{
Debug.Assert(_serObjectInfoInit != null && _formatterConverter != null);
if (memberData[i] != null)
{
memberObjectInfos[i] = WriteObjectInfo.Serialize(
memberData[i] !, // TODO-NULLABLE https://github.com/dotnet/roslyn/issues/34644
_surrogates,
_context,
_serObjectInfoInit,
_formatterConverter,
this,
_binder);
memberObjectInfos[i]._assemId = GetAssemblyId(memberObjectInfos[i]);
}
else
{
memberObjectInfos[i] = WriteObjectInfo.Serialize(
memberTypes[i],
_surrogates,
_context,
_serObjectInfoInit,
_formatterConverter,
_binder);
memberObjectInfos[i]._assemId = GetAssemblyId(memberObjectInfos[i]);
}
}
}
Write(objectInfo, memberNameInfo, typeNameInfo, memberNames, memberTypes, memberData, memberObjectInfos);
}
}
}
// Returns a System.TypeCode from a InternalPrimitiveTypeE
internal static TypeCode ToTypeCode(InternalPrimitiveTypeE code)
{
if (s_typeCodeA == null)
{
InitTypeCodeA();
}
return s_typeCodeA[(int)code];
}
internal static string ToString(object data, InternalPrimitiveTypeE code)
{
switch (code)
{
case InternalPrimitiveTypeE.Invalid:
return(data.ToString());
case InternalPrimitiveTypeE.Boolean:
if (!((bool)data))
{
return("false");
}
return("true");
case InternalPrimitiveTypeE.Double:
{
double d = (double)data;
if (!double.IsPositiveInfinity(d))
{
if (double.IsNegativeInfinity(d))
{
return("-INF");
}
return(d.ToString("R", CultureInfo.InvariantCulture));
}
return("INF");
}
case InternalPrimitiveTypeE.Single:
{
float f = (float)data;
if (!float.IsPositiveInfinity(f))
{
if (float.IsNegativeInfinity(f))
{
return("-INF");
}
return(f.ToString("R", CultureInfo.InvariantCulture));
}
return("INF");
}
case InternalPrimitiveTypeE.TimeSpan:
return(SoapDuration.ToString((TimeSpan)data));
case InternalPrimitiveTypeE.DateTime:
return(SoapDateTime.ToString((DateTime)data));
case InternalPrimitiveTypeE.Time:
case InternalPrimitiveTypeE.Date:
case InternalPrimitiveTypeE.YearMonth:
case InternalPrimitiveTypeE.Year:
case InternalPrimitiveTypeE.MonthDay:
case InternalPrimitiveTypeE.Day:
case InternalPrimitiveTypeE.Month:
case InternalPrimitiveTypeE.HexBinary:
case InternalPrimitiveTypeE.Base64Binary:
case InternalPrimitiveTypeE.Integer:
case InternalPrimitiveTypeE.PositiveInteger:
case InternalPrimitiveTypeE.NonPositiveInteger:
case InternalPrimitiveTypeE.NonNegativeInteger:
case InternalPrimitiveTypeE.NegativeInteger:
case InternalPrimitiveTypeE.AnyUri:
case InternalPrimitiveTypeE.QName:
case InternalPrimitiveTypeE.Notation:
case InternalPrimitiveTypeE.NormalizedString:
case InternalPrimitiveTypeE.Token:
case InternalPrimitiveTypeE.Language:
case InternalPrimitiveTypeE.Name:
case InternalPrimitiveTypeE.Idrefs:
case InternalPrimitiveTypeE.Entities:
case InternalPrimitiveTypeE.Nmtoken:
case InternalPrimitiveTypeE.Nmtokens:
case InternalPrimitiveTypeE.NcName:
case InternalPrimitiveTypeE.Id:
case InternalPrimitiveTypeE.Idref:
case InternalPrimitiveTypeE.Entity:
return(data.ToString());
}
return((string)Convert.ChangeType(data, typeofString, CultureInfo.InvariantCulture));
}
// Translates a string into an Object
internal static object FromString(string value, InternalPrimitiveTypeE code)
{
// InternalPrimitiveTypeE needs to be a primitive type
Debug.Assert((code != InternalPrimitiveTypeE.Invalid), "[Converter.FromString]!InternalPrimitiveTypeE.Invalid ");
return code != InternalPrimitiveTypeE.Invalid ?
Convert.ChangeType(value, ToTypeCode(code), CultureInfo.InvariantCulture) :
value;
}
internal static string SoapToComType(InternalPrimitiveTypeE code)
{
return(ToComType(code));
}
internal static int TypeLength(InternalPrimitiveTypeE code)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean: return 1;
case InternalPrimitiveTypeE.Char: return 2;
case InternalPrimitiveTypeE.Byte: return 1;
case InternalPrimitiveTypeE.Double: return 8;
case InternalPrimitiveTypeE.Int16: return 2;
case InternalPrimitiveTypeE.Int32: return 4;
case InternalPrimitiveTypeE.Int64: return 8;
case InternalPrimitiveTypeE.SByte: return 1;
case InternalPrimitiveTypeE.Single: return 4;
case InternalPrimitiveTypeE.UInt16: return 2;
case InternalPrimitiveTypeE.UInt32: return 4;
case InternalPrimitiveTypeE.UInt64: return 8;
default: return 0;
}
}
// ReadValue from stream using InternalPrimitiveTypeE code
internal object ReadValue(InternalPrimitiveTypeE code) =>
code switch
{
