void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
if (!reader.Read())
{
throw new XmlException("Error in Deserialization of Dictionary");
}
//HERE IS THE TRICK
if (reader is KnownTypesXmlReader)
{
SetKnownTypes(((KnownTypesXmlReader)reader).ExtraTypes);
}
//reader.ReadStartElement(DictionaryNodeName);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemNodeName);
reader.ReadStartElement(KeyNodeName);
TKey key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(ValueNodeName);
TVal value = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
this.Add(key, value);
reader.MoveToContent();
}
//reader.ReadEndElement();
reader.ReadEndElement(); // Read End Element to close Read of containing node
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
// Move past container
if (!reader.Read())
{
throw new XmlException("Error in Deserialization of Dictionary");
}
// reader.ReadStartElement(DictionaryNodeName);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(Map <TKey, TVal> .ItemNodeName);
reader.ReadStartElement(Map <TKey, TVal> .KeyNodeName);
var key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(Map <TKey, TVal> .ValueNodeName);
var value = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
Add(key, value);
reader.MoveToContent();
}
// reader.ReadEndElement();
reader.ReadEndElement(); // Read End Element to close Read of containing node
}
void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
if (!reader.Read())
{
throw new System.Xml.XmlException("Error in Deserialization of Dictionary");
}
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemNodeName);
reader.ReadStartElement(KeyNodeName);
TKey key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(ValueNodeName);
TVal value = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
Add(key, value);
reader.MoveToContent();
}
reader.ReadEndElement();
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
if (!reader.Read())
{
throw new XmlException("XmlReader读取异常");
}
while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None)
{
reader.ReadStartElement(ItemNodeName);
reader.ReadStartElement(KeyNodeName);
var key = (TK)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(ValueNodeName);
var value = (TV)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
Add(key, value);
reader.MoveToContent();
}
reader.ReadEndElement();
}
void IXmlSerializable.ReadXml(XmlReader i_Reader)
{
if (i_Reader.IsEmptyElement)
{
return;
}
// Move past container
if (!i_Reader.Read())
{
throw new XmlException("Error in Deserialization of Dictionary");
}
while (i_Reader.NodeType != XmlNodeType.EndElement)
{
i_Reader.ReadStartElement(k_ItemNodeName);
i_Reader.ReadStartElement(k_KeyNodeName);
TKey key = (TKey)KeySerializer.Deserialize(i_Reader);
i_Reader.ReadEndElement();
i_Reader.ReadStartElement(k_ValueNodeName);
TVal value = (TVal)ValueSerializer.Deserialize(i_Reader);
i_Reader.ReadEndElement();
i_Reader.ReadEndElement();
this.Add(key, value);
i_Reader.MoveToContent();
}
//reader.ReadEndElement();
i_Reader.ReadEndElement(); // Read End Element to close Read of containing node
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
// Move past container
if (reader.NodeType == XmlNodeType.Element && !reader.Read())
{
throw new XmlException("Error in Deserialization of SerializableDictionary");
}
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
reader.ReadStartElement("key");
TKey key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
TVal value = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
Add(key, value);
reader.MoveToContent();
}
// Move past container
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
else
{
throw new XmlException("Error in Deserialization of SerializableDictionary");
}
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
// Move past container
if (!reader.Read())
{
throw new XmlException("Error in Deserialization of Dictionary");
}
//reader.ReadStartElement(DictionaryNodeName);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemNodeName);
reader.ReadStartElement(KeyNodeName);
TKey key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(ValueNodeName);
TVal valor = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
this.Add(key, valor);
reader.MoveToContent();
}
//reader.ReadEndElement();
reader.ReadEndElement(); // Read End Element to close Read of containing node
//Debug.Log("IXmlSerializable.ReadXml");
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
// Move past container
if (!reader.Read())
{
throw new XmlException("Error in Deserialization of List");
}
//This is to ensure bad illegal chars are ignored when received via WCF
if (reader.Settings != null)
{
reader.Settings.CheckCharacters = false;
}
//reader.ReadStartElement(DictionaryNodeName);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(ValueNodeName);
var value = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(value);
reader.MoveToContent();
}
//reader.ReadEndElement();
reader.ReadEndElement(); // Read End Element to close Read of containing node
}
public void SerializeEnum()
{
var serializer = new ValueSerializer <UriHostNameType>();
var data = serializer.Serialize(UriHostNameType.IPv4);
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
Assert.AreEqual(UriHostNameType.IPv4, (UriHostNameType)serializer.Deserialize(data));
}
public void SerializeInt()
{
var serializer = new ValueSerializer <int>();
var data = serializer.Serialize(123);
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
Assert.AreEqual(123, serializer.Deserialize(data));
}
/// <summary>
/// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1" /> to an <see cref="T:System.Array" />, starting at a particular <see cref="T:System.Array" /> index.
/// </summary>
/// <param name="array">The one-dimensional <see cref="T:System.Array" /> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1" />. The <see cref="T:System.Array" /> must have zero-based indexing.</param>
/// <param name="arrayIndex">The zero-based index in <paramref name="array" /> at which copying begins.</param>
public void CopyTo(KeyValuePair <TKey, TValue>[] array, int arrayIndex)
{
var values = RedisDb.HashGetAll(RedisKey);
for (var i = 0; i < values.Length; i++)
{
var key = KeySerializer.Deserialize <TKey>(values[i].Name);
var value = ValueSerializer.Deserialize <TValue>(values[i].Value);
array[i + arrayIndex] = new KeyValuePair <TKey, TValue>(key, value);
}
}
/// <summary>
/// Gets or sets the <see cref="TValue"/> with the specified key.
/// </summary>
/// <value>
/// The <see cref="TValue"/>.
/// </value>
/// <param name="key">The key.</param>
/// <returns></returns>
public TValue this[TKey key]
{
get
{
var redisValue = RedisDb.HashGet(RedisKey, KeySerializer.Serialize(key));
return(redisValue.IsNull ? default(TValue) : ValueSerializer.Deserialize <TValue>(redisValue));
}
set
{
Add(key, value);
}
}
public static bool GetValueOrDefault <T>(string name, out T result, T defaultValue)
{
using var key = GetKey(true);
var value = key.GetValue(name);
if (!(value is null))
{
return(ValueSerializer.Deserialize(value.ToString(), out result, defaultValue));
}
result = defaultValue;
return(true);
}
/// <summary>
/// Gets the value associated with the specified key.
/// </summary>
/// <param name="key">The key whose value to get.</param>
/// <param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the <paramref name="value" /> parameter. This parameter is passed uninitialized.</param>
/// <returns>
/// true if the object that implements <see cref="T:System.Collections.Generic.IDictionary`2" /> contains an element with the specified key; otherwise, false.
/// </returns>
public bool TryGetValue(TKey key, out TValue value)
{
var redisValue = RedisDb.HashGet(RedisKey, KeySerializer.Serialize(key));
if (redisValue.IsNull)
{
value = default(TValue);
return(false);
}
value = ValueSerializer.Deserialize <TValue>(redisValue);
return(true);
}
public void SerializeCustomType()
{
var serializer = new ValueSerializer <Point>();
var data = serializer.Serialize(new Point {
X = 1, Y = 2
});
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
var point = (Point)serializer.Deserialize(data);
Assert.AreEqual(1, point.X);
Assert.AreEqual(2, point.Y);
}
public void SerializeCustomCollection()
{
var serializer = new ValueSerializer <CustomCollection>();
var data = serializer.Serialize(new CustomCollection {
1, 2, 3
});
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
var list = (CustomCollection)serializer.Deserialize(data);
Assert.AreEqual(3, list.Count);
Assert.AreEqual(1, list[0]);
}
public void SerializeListOfString()
{
var serializer = new ValueSerializer <List <string> >();
var data = serializer.Serialize(new List <string> {
"a", "b", "cde"
});
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
var list = (List <string>)serializer.Deserialize(data);
Assert.AreEqual(3, list.Count);
Assert.AreEqual("a", list[0]);
Assert.AreEqual("cde", list[2]);
}
public void SerializeHashSet()
{
var serializer = new ValueSerializer <HashSet <int> >();
var data = serializer.Serialize(new HashSet <int> {
1, 2
});
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
var set = (HashSet <int>)serializer.Deserialize(data);
Assert.AreEqual(2, set.Count);
Assert.IsTrue(set.Contains(1));
Assert.IsTrue(set.Contains(2));
Assert.IsFalse(set.Contains(3));
}
public void SerializeDictionaryOfLongAndBlobs()
{
var serializer = new ValueSerializer <Dictionary <long, byte[]> >();
var data = serializer.Serialize(new Dictionary <long, byte[]> {
{ 1, new byte[] { 1, 2, 3 } }, { 2, new byte[] { } }
});
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
var dict = (Dictionary <long, byte[]>)serializer.Deserialize(data);
Assert.AreEqual(2, dict.Count);
Assert.AreEqual(3, dict[1].Length);
Assert.AreEqual(2, dict[1][1]);
Assert.AreEqual(0, dict[2].Length);
}
public void SerializeListOfCustomType()
{
var serializer = new ValueSerializer <List <Point> >();
var data = serializer.Serialize(new List <Point> {
new Point {
X = 1, Y = 2
}
});
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
var pointList = (List <Point>)serializer.Deserialize(data);
Assert.AreEqual(1, pointList.Count);
var point = pointList[0];
Assert.AreEqual(1, point.X);
Assert.AreEqual(2, point.Y);
}
public void SerializeMapOfCustomType()
{
var serializer = new ValueSerializer <Dictionary <string, Point> >();
var data = serializer.Serialize(new Dictionary <string, Point> {
{ "TopLeft", new Point {
X = 1, Y = 2
} }, { "BottomRight", new Point {
X = 5, Y = 7
} }
});
Assert.IsNotNull(data);
Assert.Greater(data.Length, 0);
var dict = (Dictionary <string, Point>)serializer.Deserialize(data);
Assert.AreEqual(2, dict.Count);
var point = dict["BottomRight"];
Assert.AreEqual(5, point.X);
Assert.AreEqual(7, point.Y);
}
/// <summary>
/// Gets the value asynchronous.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public async Task <TValue> GetAsync(TKey key)
{
var redisValue = await RedisDb.HashGetAsync(RedisKey, KeySerializer.Serialize(key));
return(redisValue.IsNull ? default(TValue) : ValueSerializer.Deserialize <TValue>(redisValue));
}
/// <summary>
/// Gets the values asynchronous.
/// </summary>
/// <returns></returns>
public async Task <ICollection <TValue> > GetValuesAsync()
{
return(new Collection <TValue>((await RedisDb.HashValuesAsync(RedisKey)).Select(h => ValueSerializer.Deserialize <TValue>(h)).ToList()));
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>
/// An enumerator that can be used to iterate through the collection.
/// </returns>
public IEnumerator <KeyValuePair <TKey, TValue> > GetEnumerator()
{
foreach (var hashKey in RedisDb.HashKeys(RedisKey))
{
var redisValue = RedisDb.HashGet(RedisKey, hashKey);
yield return(new KeyValuePair <TKey, TValue>(KeySerializer.Deserialize <TKey>(hashKey), ValueSerializer.Deserialize <TValue>(redisValue)));
}
}