1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
/*============================================================
**
**
**
** Purpose: A formatter-friendly mechanism for walking all of
** the data in a SerializationInfo. Follows the IEnumerator
** mechanism from Collections.
**
**
============================================================*/
namespace System.Runtime.Serialization {
using System;
using System.Diagnostics;
using System.Collections;
using System.Diagnostics.Contracts;
//
// The tuple returned by SerializationInfoEnumerator.Current.
//
public struct SerializationEntry {
private Type m_type;
private Object m_value;
private String m_name;
public Object Value {
get {
return m_value;
}
}
public String Name {
get {
return m_name;
}
}
public Type ObjectType {
get {
return m_type;
}
}
internal SerializationEntry(String entryName, Object entryValue, Type entryType) {
m_value = entryValue;
m_name = entryName;
m_type = entryType;
}
}
//
// A simple enumerator over the values stored in the SerializationInfo.
// This does not snapshot the values, it just keeps pointers to the
// member variables of the SerializationInfo that created it.
//
public sealed class SerializationInfoEnumerator : IEnumerator {
String[] m_members;
Object[] m_data;
Type[] m_types;
int m_numItems;
int m_currItem;
bool m_current;
internal SerializationInfoEnumerator(String[] members, Object[] info, Type[] types, int numItems) {
Debug.Assert(members!=null, "[SerializationInfoEnumerator.ctor]members!=null");
Debug.Assert(info!=null, "[SerializationInfoEnumerator.ctor]info!=null");
Debug.Assert(types!=null, "[SerializationInfoEnumerator.ctor]types!=null");
Debug.Assert(numItems>=0, "[SerializationInfoEnumerator.ctor]numItems>=0");
Debug.Assert(members.Length>=numItems, "[SerializationInfoEnumerator.ctor]members.Length>=numItems");
Debug.Assert(info.Length>=numItems, "[SerializationInfoEnumerator.ctor]info.Length>=numItems");
Debug.Assert(types.Length>=numItems, "[SerializationInfoEnumerator.ctor]types.Length>=numItems");
m_members = members;
m_data = info;
m_types = types;
//The MoveNext semantic is much easier if we enforce that [0..m_numItems] are valid entries
//in the enumerator, hence we subtract 1.
m_numItems = numItems-1;
m_currItem = -1;
m_current = false;
}
public bool MoveNext() {
if (m_currItem<m_numItems) {
m_currItem++;
m_current = true;
} else {
m_current = false;
}
return m_current;
}
/// <internalonly/>
Object IEnumerator.Current { //Actually returns a SerializationEntry
get {
if (m_current==false) {
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
}
return (Object)(new SerializationEntry(m_members[m_currItem], m_data[m_currItem], m_types[m_currItem]));
}
}
public SerializationEntry Current { //Actually returns a SerializationEntry
get {
if (m_current==false) {
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
}
return (new SerializationEntry(m_members[m_currItem], m_data[m_currItem], m_types[m_currItem]));
}
}
public void Reset() {
m_currItem = -1;
m_current = false;
}
public String Name {
get {
if (m_current==false) {
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
}
return m_members[m_currItem];
}
}
public Object Value {
get {
if (m_current==false) {
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
}
return m_data[m_currItem];
}
}
public Type ObjectType {
get {
if (m_current==false) {
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumOpCantHappen"));
}
return m_types[m_currItem];
}
}
}
}
|
