public loadsetting()
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
string text = System.IO.File.ReadAllText(settingfile,Encoding.UTF8);
set = new Dictionary<string, object>();
set = (IDictionary<string, object>)serializer.Deserialize(text, set.GetType());
}
private IDictionary<string, object> CloneCustomDictionary(IDictionary<string, object> source)
{
var clone = Activator.CreateInstance(source.GetType()) as IDictionary<string, object>;
if (clone == null) throw new InvalidOperationException("Internal data structure cannot be cloned.");
CopyDictionaryAndCloneNestedDictionaries(source, clone);
return clone;
}
public IDictionary Convert(IDictionary source)
{
if (source != null && source.Contains(nameof(Type)))
{
var type = source[nameof(Type)].ToString();
if (Types != null && Types.ContainsKey(type))
{
try
{
var _type = Types[type];
if (_type == null) throw new Exception($"Types['{type}'] was null");
var dictionary = Activator.CreateInstance(_type) as IDictionary;
if(dictionary == null)
{
throw new Exception($"unable to create instance of type {_type.FullName}");
}
Copy(source, dictionary);
return dictionary;
}
catch(Exception ex)
{
throw new Exception($"Exception while converting type '{type}', fullname {Types[type].FullName}", ex);
}
}
}
if(source != null)
{
var result = Activator.CreateInstance(source.GetType()) as IDictionary;
Copy(source, result);
return result;
}
return source;
}
private static bool IsValidDictionaryType(IDictionary dictionary)
{
if (dictionary == null)
{
return false;
}
Type[] genericParameters = dictionary.GetType().GetGenericArguments();
// Support non-generics IDictionary
if (genericParameters.Length == 0)
{
return true;
}
// Only support IDictionary<string|object, object>
if (genericParameters[0] != typeof(string) && genericParameters[0] != typeof(object))
{
return false;
}
if (genericParameters[1] != typeof(object))
{
return false;
}
return true;
}
protected string GetClientClass( IDictionary dictionary )
{
Type type = dictionary.GetType();
string className = type.IsGenericType && type.FullName != null
? type.FullName.Substring( 0, type.FullName.IndexOf( "`" ) )
: type.FullName;
#if (FULL_BUILD)
string clientClass = null;
string mappingClassName = ORBConstants.CLIENT_MAPPING + className;
IDictionary props = ThreadContext.getProperties();
if( props.Contains( className ) )
clientClass = (string) props[ mappingClassName ];
#else
string clientClass = null;
#endif
if( clientClass == null )
{
clientClass = Types.Types.getClientClassForServerType( className );
if( clientClass == null && type.IsGenericType )
{
Type keyType = type.GetGenericArguments()[ 0 ];
if( !keyType.IsPrimitive && !StringUtil.IsStringType( keyType ) )
clientClass = "flash.utils.Dictionary";
}
return clientClass;
}
else
{
return clientClass;
}
}
public static Func<int, IDictionary<string, object>> CreateFunc(IDictionary<string, object> source)
{
var dictionary = source as Dictionary<string, object>;
if (dictionary != null) return cap => new Dictionary<string, object>(cap, dictionary.Comparer);
var sortedDictionary = source as SortedDictionary<string, object>;
if (sortedDictionary != null) return cap => new SortedDictionary<string, object>(sortedDictionary.Comparer);
if (source is ConcurrentDictionary<string,object>) return cap => new ConcurrentDictionary<string, object>();
var type = source.GetType();
return cap => (IDictionary<string, object>) Activator.CreateInstance(type);
}
public static IDictionary ConvertTypes(IDictionary source, Dictionary<string, Type> types,string typeKey = "Type")
{
if (source == null) return null;
if (types == null) return source;
var copy = Activator.CreateInstance(source.GetType()) as IDictionary;
if (copy == null) throw new Exception($"failed to create instance of type {source.GetType().FullName}");
var typename = GetTypeName(source,typeKey);
if (typename.Length > 0 && types.ContainsKey(typename))
{
var targetType = types[typename];
if (targetType == null) throw new Exception($"types['{typename}'] was null");
if (source.GetType() != targetType)
{
copy = Activator.CreateInstance(targetType) as IDictionary;
if (copy == null) throw new Exception($"failed to create instance of type {targetType.FullName}");
}
}
foreach (var key in source.Keys)
{
var value = source[key];
var childDictionary = value as IDictionary;
if (childDictionary != null)
{
copy[key] = ConvertTypes(childDictionary, types,typeKey);
}
else
{
var childEnumerable = value as IEnumerable;
if (childEnumerable != null && childEnumerable.GetType() != typeof(string))
{
copy[key] = IEnumerableExtension.ConvertTypes(childEnumerable, types,typeKey);
}
else
{
if (copy.Contains(key)) copy[key] = value;
else copy.Add(key, value);
}
}
}
return copy;
}
private void BenchImpl(IDictionary<int, string> dictionary, int count)
{
dictionary[0] = "0"; // Force JIT
var watch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
dictionary[i] = i.ToString();
string ignored;
for (int i = 0; i < count; i++)
ignored = dictionary[i];
_output.WriteLine(string.Format("Time to process with dictionary of type '{0}': {1}.",
dictionary.GetType(),
watch.Elapsed));
}
private IDictionary Create(IDictionary source)
{
IDictionary result = null;
if (source.Contains(nameof(Type)))
{
var type = source[nameof(Type)].ToString();
if (Types != null && Types.ContainsKey(type))
{
result = Activator.CreateInstance(Types[type]) as IDictionary;
}
}
if(result == null) result = System.Activator.CreateInstance(source.GetType()) as IDictionary;
return result;
}
private static void BenchImpl(IDictionary<string, int> dictionary, int count)
{
Console.WriteLine("Start...");
var watch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
dictionary[i.ToString()] = i;
var sets = watch.Elapsed;
Console.WriteLine(string.Format(" Sets: {0}.", sets));
int ignored;
for (int i = 0; i < count; i++)
ignored = dictionary[i.ToString()];
Console.WriteLine(string.Format(" Gets: {0}.", watch.Elapsed - sets));
Console.WriteLine(string.Format("Global time to process with dictionary of type '{0}': {1}.",
dictionary.GetType(),
watch.Elapsed));
}
public void AddKeyValueTest(IDictionary<int, object> anyDictionary, int size)
{
const string path = @"E:\results.txt";
StreamWriter tr = File.AppendText(path);
var sw = new Stopwatch();
sw.Start();
for (int i = 0; i < size; i++)
{
anyDictionary.Add(i, "Value" + i);
}
sw.Stop();
tr.WriteLine("AddKeyValueTest for " + anyDictionary.GetType().Name + " size: " + size + " took {0}ms",
sw.ElapsedMilliseconds.ToString());
Console.WriteLine("Elapsed time for AddKeyValue is: {0}ms", sw.Elapsed);
Assert.AreEqual(size, anyDictionary.Count);
sw.Reset();
tr.Close();
tr.Dispose();
}
internal static IDictionary CloneDictionary(IDictionary source)
{
if (source == null)
{
return null;
}
if (source is ICloneable)
{
return (IDictionary) ((ICloneable) source).Clone();
}
IDictionary dictionary = (IDictionary) Activator.CreateInstance(source.GetType());
IDictionaryEnumerator enumerator = source.GetEnumerator();
while (enumerator.MoveNext())
{
ICloneable key = enumerator.Key as ICloneable;
ICloneable cloneable2 = enumerator.Value as ICloneable;
if ((key != null) && (cloneable2 != null))
{
dictionary.Add(key.Clone(), cloneable2.Clone());
}
}
return dictionary;
}
public TypedMapType(IDictionary value)
{
Type[] argumentTypes = value.GetType().GetInterface("IDictionary`2").GetGenericArguments();
keyType = JmxTypeMapping.GetJmxXmlType(argumentTypes[0].AssemblyQualifiedName);
valueType = JmxTypeMapping.GetJmxXmlType(argumentTypes[1].AssemblyQualifiedName);
List<MapTypeEntry> mapTypeEntries = new List<MapTypeEntry>();
foreach (DictionaryEntry entry in value)
{
mapTypeEntries.Add(new MapTypeEntry
{
Key = new GenericValueType(entry.Key),
Value = new GenericValueType(entry.Value)
});
}
Entry = mapTypeEntries.ToArray();
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract)
{
contract.InvokeOnSerializing(values);
SerializeStack.Add(values);
writer.WriteStartObject();
bool isReference = contract.IsReference ?? HasFlag(_serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(_serializer.ReferenceResolver.GetReference(values));
}
if (HasFlag(_serializer.TypeNameHandling, TypeNameHandling.Objects))
{
WriteTypeProperty(writer, values.GetType());
}
foreach (DictionaryEntry entry in values)
{
string propertyName = entry.Key.ToString();
object value = entry.Value;
if (ShouldWriteReference(value, null))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null))
continue;
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, null);
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values);
}
public void RemoveElementByKeyTest(IDictionary<int, object> anyDictionary, int size)
{
const string path = @"E:\results.txt";
StreamWriter tr = File.AppendText(path);
//Lets add 3 items in the dictionary
for (int i = 0; i < size; i++)
{
anyDictionary.Add(i, "Value" + i);
}
Assert.AreEqual(size, anyDictionary.Count);
var s = new Stopwatch();
s.Start();
for (int i = 0; i < size; i++)
{
anyDictionary.Remove(i);
}
//anyDictionary.Remove(99);
s.Stop();
Console.WriteLine("Elapsed time for RemoveKey is: {0}ms", s.Elapsed);
tr.WriteLine("RemoveByKey for " + anyDictionary.GetType().Name + " size: " + size + " took {0}ms",
s.ElapsedMilliseconds);
Assert.AreEqual(0, anyDictionary.Count);
s.Reset();
tr.Close();
tr.Dispose();
}
public void TestContainsLastTwo100(IDictionary<int, object> anyDictionary)
{
const string path = @"E:\results.txt";
StreamWriter tr = File.AppendText(path);
var sw = new Stopwatch();
Console.WriteLine("Elapsed time for Contains is: {0}ms", sw.ElapsedMilliseconds);
sw.Stop();
tr.WriteLine("ContainsKey test for " + anyDictionary.GetType().Name.ToString() + " size: " + 100 + " took {0}ms",
sw.ElapsedMilliseconds);
tr.Close();
sw.Reset();
}
private static void XmlSerializeIDictionary(XmlWriter writer, IDictionary obj, Type keyType, Type valueType)
{
Type objType = obj.GetType();
writer.WriteStartElement(GetCleanName(objType.Name));
IDictionaryEnumerator de = obj.GetEnumerator();
if (objType.IsGenericType)
{
if (keyType == null)
{
string keyTypeName = Arithmetic.GetInlineItem(objType.FullName, 1, '[', ']');
if (!string.IsNullOrEmpty(keyTypeName))
{
keyType = Type.GetType(keyTypeName);
}
}
if (valueType == null)
{
string valueTypeName = Arithmetic.GetInlineItem(objType.FullName, 2, '[', ']');
if (!string.IsNullOrEmpty(valueTypeName))
{
valueType = Type.GetType(valueTypeName);
}
}
}
bool writeKeyType = (keyType == null) || keyType.Equals(Generic<object>.Type);
if (!(writeKeyType || SimpleTypes.ContainsValue(keyType)))
{
writer.WriteAttributeString("keyType", GetTypeName(keyType));
}
bool writeValueType = (valueType == null) || valueType.Equals(Generic<object>.Type);
if (!(writeValueType || SimpleTypes.ContainsValue(valueType)))
{
writer.WriteAttributeString("valueType", GetTypeName(valueType));
}
while (de.MoveNext())
{
Type type;
writer.WriteStartElement("Item");
if (de.Key != null)
{
type = de.Key.GetType();
if (!((!writeKeyType && (type == keyType)) || IsKnownType(type)))
{
writer.WriteAttributeString("keyType", GetTypeName(type));
}
}
if (de.Value != null)
{
type = de.Value.GetType();
if (!((!writeValueType && (type == valueType)) || IsKnownType(type)))
{
writer.WriteAttributeString("valueType", GetTypeName(type));
}
}
XmlWriterSerialize(writer, de.Key, keyType);
XmlWriterSerialize(writer, de.Value, valueType);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
/// <summary>
/// Writes a dictionary as a JSON object.
/// </summary>
public void Write(IDictionary dictionary)
{
if (dictionary == null)
throw new ArgumentNullException("dictionary");
// already implements serialization interface?
IJSonWritable jValue = dictionary as IJSonWritable;
if (jValue != null)
{
jValue.Write(this);
return;
}
// is marked with serialization attribute?
Type oType = dictionary.GetType();
JSonSerializableAttribute jsonAttribute = ReflectionHelper.GetCustomAttribute<JSonSerializableAttribute>(oType);
if (jsonAttribute != null)
{
WriteAttributedObject(dictionary, oType, jsonAttribute);
return;
}
WriteObjectBegin();
foreach (DictionaryEntry entry in dictionary)
{
WriteMember(entry.Key.ToString());
WriteEmbeddedValue(entry.Value);
}
WriteObjectEnd();
}
private void WriteDictionary(IDictionary dictionary, int depth, out List<CimInstance> listOfCimInstances)
{
listOfCimInstances = new List<CimInstance>();
Dbg.Assert(dictionary != null, "caller should validate the parameter");
IDictionaryEnumerator dictionaryEnum = null;
try
{
dictionaryEnum = dictionary.GetEnumerator();
}
catch (Exception exception) // ignore non-severe exceptions
{
// Catch-all OK. This is a third-party call-out.
CommandProcessorBase.CheckForSevereException(exception);
PSEtwLog.LogAnalyticWarning(
PSEventId.Serializer_EnumerationFailed, PSOpcode.Exception, PSTask.Serialization,
PSKeyword.Serializer | PSKeyword.UseAlwaysAnalytic,
dictionary.GetType().AssemblyQualifiedName,
exception.ToString());
}
if (dictionaryEnum != null)
{
while (true)
{
object key = null;
object value = null;
try
{
if (!dictionaryEnum.MoveNext())
{
break;
}
else
{
key = dictionaryEnum.Key;
value = dictionaryEnum.Value;
}
}
catch (Exception exception)
{
// Catch-all OK. This is a third-party call-out.
CommandProcessorBase.CheckForSevereException(exception);
PSEtwLog.LogAnalyticWarning(
PSEventId.Serializer_EnumerationFailed, PSOpcode.Exception, PSTask.Serialization,
PSKeyword.Serializer | PSKeyword.UseAlwaysAnalytic,
dictionary.GetType().AssemblyQualifiedName,
exception.ToString());
break;
}
Dbg.Assert(key != null, "Dictionary keys should never be null");
if (key == null) break;
CimInstance dictionaryEntryInstance = CreateCimInstanceForDictionaryEntry(key, value, depth);
listOfCimInstances.Add(dictionaryEntryInstance);
}
}
}
private void SerializeDictionary(IDictionary dictionary)
{
Type keyType = dictionary.GetType().GetGenericArguments()[0];
Type valueType = dictionary.GetType().GetGenericArguments()[1];
this.writer.Write(dictionary.Count);
this.writer.Write(keyType.FullName);
this.writer.Write(valueType.FullName);
foreach (object key in dictionary.Keys)
{
// Write key.
if (keyType.IsSealed() || key == null)
{
this.Serialize(key, keyType);
}
else
{
this.SerializeValueWithType(new ValueWithType(key));
}
// Write value.
object value = dictionary[key];
if (valueType.IsSealed() || value == null)
{
this.Serialize(value, valueType);
}
else
{
this.SerializeValueWithType(new ValueWithType(value));
}
}
}
private static string WriteIDictionary(IDictionary dict, string indent)
{
if (dict == null) { return "[null]"; }
if (dict.Keys.Count == 0) { return "[empty]"; }
//StringBuilder sbDetail = new StringBuilder("[IDictionary]");
StringBuilder sbDetail = new StringBuilder("[" + dict.GetType().ToString() + "]");
foreach (object key in dict.Keys)
{
string detail = FormatObject(dict[key], indent);
sbDetail.AppendFormat(indent + "'{0}' = {1}", key, detail);
}
return sbDetail.ToString();
}
public static void CalculateTime(IDictionary table, int k)
{
// Add
var startAdding = DateTime.Now;
string[] test = { "Key string", "Test string" };
for (int i = 0; i < k; i++)
{
table.Add(i, test[1]);
}
var finishAdding = DateTime.Now;
Console.WriteLine("Addition time (" + k + " elements) : " + table.GetType() + " " + (finishAdding - startAdding));
// Search
var startSearch = DateTime.Now;
for (int i = 0; i < k; i++)
{
bool a = table.Contains("Key");
}
var finishSearch = DateTime.Now;
Console.WriteLine("Search time (" + k + " elements) : " + table.GetType() + " " + (finishSearch - startSearch));
// Remove
k = 1000000;
var startRemoving = DateTime.Now;
for (int i = 0; i < k; i++)
{
table.Remove(i);
}
var finishRemoving = DateTime.Now;
Console.WriteLine("Removal time (" + k + " elements) : " + table.GetType() + " " + (finishRemoving - startRemoving) + "\n");
}
public string Amb(IDictionary obj)
{
return obj.GetType().Name;
}
private static Type GetDictionaryKeyType(IDictionary value)
{
Type type = value.GetType();
Type result;
if (_keyTypeMap == null)
_keyTypeMap = new Dictionary<Type, Type>();
if (!_keyTypeMap.TryGetValue(type, out result))
{
foreach (Type interfaceType in type.GetInterfaces())
{
if (interfaceType.IsGenericType)
{
Type genericTypeDefinition = interfaceType.GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(System.Collections.Generic.IDictionary<,>))
return interfaceType.GetGenericArguments()[0];
}
}
result = typeof(object);
_keyTypeMap[type] = result;
}
return result;
}
void HighlightDictionary(IDictionary value, string name, bool addAnnotation)
{
Type keyType;
Type valueType;
ContainerHelper.GetDictionaryTypes(value.GetType(), out keyType, out valueType);
if(valueType == typeof(de.unika.ipd.grGen.libGr.SetValueType))
{
foreach(DictionaryEntry entry in value)
{
if(entry.Key is IGraphElement)
HighlightSingleValue(entry.Key, name, addAnnotation);
}
}
else
{
int cnt = 0;
foreach(DictionaryEntry entry in value)
{
if(entry.Key is INode && entry.Value is INode)
{
HighlightMapping((INode)entry.Key, (INode)entry.Value, name, cnt, addAnnotation);
++cnt;
}
else
{
if(entry.Key is IGraphElement)
HighlightSingleValue(entry.Key, name + ".Domain -> " + EmitHelper.ToString(entry.Value, shellProcEnv.ProcEnv.NamedGraph), addAnnotation);
if(entry.Value is IGraphElement)
HighlightSingleValue(entry.Value, EmitHelper.ToString(entry.Key, shellProcEnv.ProcEnv.NamedGraph) + " -> " + name + ".Range", addAnnotation);
}
}
}
}
static List<TestResult> TestDictionary(IDictionary<string, string> dictionary, List<string> keys, List<string> values, int iterations, int[] threadCounts)
{
if (iterations > keys.Count)
iterations = keys.Count;
if (iterations > values.Count)
iterations = values.Count;
//test with 1 thread
List<TestResult> testresults = new List<TestResult>();
foreach (var threadCount in threadCounts)
{
try
{
//test write
GC.Collect();
GC.WaitForPendingFinalizers();
var results = TestingPlatform.Test(threadCount, iterations, delegate(int i)
{
dictionary[keys[i]] = values[i];
});
testresults.Add(new TestResult
{
DictionaryType = dictionary.GetType().Name,
ElapsedMilliseconds = results.ElapsedMilliseconds,
Error = (results.Exception != null),
Read = false,
Threads = threadCount,
Write = true
});
Console.WriteLine("Time took to write dictionary {0} with {1} threads: {2} ms", dictionary.GetType().Name, results.ThreadNumber, results.ElapsedMilliseconds);
if (results.Exception != null)
Console.WriteLine("Dictionary {0} threw an exception during the write test with {1} threads", dictionary.GetType().Name,results.ThreadNumber);
//test read
GC.Collect();
GC.WaitForPendingFinalizers();
results = TestingPlatform.Test(threadCount, iterations, delegate(int i)
{
var retval = dictionary[keys[i]];
});
testresults.Add(new TestResult
{
DictionaryType = dictionary.GetType().Name,
ElapsedMilliseconds = results.ElapsedMilliseconds,
Error = (results.Exception != null),
Read = true,
Threads = threadCount,
Write = false
});
Console.WriteLine("Time took to read dictionary {0} with {1} threads: {2} ms", dictionary.GetType().Name, results.ThreadNumber, results.ElapsedMilliseconds);
if (results.Exception != null)
Console.WriteLine("Dictionary {0} threw an exception during the read test with {1} threads", dictionary.GetType().Name, results.ThreadNumber);
//test read
GC.Collect();
GC.WaitForPendingFinalizers();
results = TestingPlatform.Test(threadCount, iterations, delegate(int i)
{
dictionary[keys[i]] = values[i];
var retval = dictionary[keys[i]];
});
testresults.Add(new TestResult
{
DictionaryType = dictionary.GetType().Name,
ElapsedMilliseconds = results.ElapsedMilliseconds,
Error = (results.Exception != null),
Read = true,
Threads = threadCount,
Write = true
});
Console.WriteLine("Time took to read/write dictionary {0} with {1} threads: {2} ms", dictionary.GetType().Name, results.ThreadNumber, results.ElapsedMilliseconds);
if (results.Exception != null)
Console.WriteLine("Dictionary {0} threw an exception during the read test with {1} threads", dictionary.GetType().Name, results.ThreadNumber);
}
catch (Exception ex)
{
Console.WriteLine("Couldn't test dictionary {0} with {1} threads, error", dictionary.GetType().Name, threadCount);
}
}
return testresults;
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract)
{
contract.InvokeOnSerializing(values, Serializer.Context);
SerializeStack.Add(values);
writer.WriteStartObject();
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(values));
}
if (HasFlag(Serializer.TypeNameHandling, TypeNameHandling.Objects))
{
WriteTypeProperty(writer, values.GetType());
}
int initialDepth = writer.Top;
foreach (DictionaryEntry entry in values)
{
string propertyName = GetPropertyName(entry);
try
{
object value = entry.Value;
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null))
continue;
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, null, valueContract);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values, contract, propertyName, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values, Serializer.Context);
}
protected virtual void AssertPlainMapContent(IDictionary map)
{
Assert.AreEqual(ItemFactory().ContainerClass(), map.GetType());
Assert.AreEqual(Elements().Length, map.Count);
for (var eltIdx = 0; eltIdx < Elements().Length; eltIdx++)
{
Assert.AreEqual(Values()[eltIdx], map[Elements()[eltIdx]]);
}
}
private fsResult AddItemToDictionary(IDictionary dictionary, object key, object value) {
// Because we're operating through the IDictionary interface by default (and not the
// generic one), we normally send items through IDictionary.Add(object, object). This
// works fine in the general case, except that the add method verifies that it's
// parameter types are proper types. However, mono is buggy and these type checks do
// not consider null a subtype of the parameter types, and exceptions get thrown. So,
// we have to special case adding null items via the generic functions (which do not
// do the null check), which is slow and messy.
//
// An example of a collection that fails deserialization without this method is
// `new SortedList<int, string> { { 0, null } }`. (SortedDictionary is fine because
// it properly handles null values).
if (key == null || value == null) {
// Life would be much easier if we had MakeGenericType available, but we don't. So
// we're going to find the correct generic KeyValuePair type via a bit of trickery.
// All dictionaries extend ICollection<KeyValuePair<TKey, TValue>>, so we just
// fetch the ICollection<> type with the proper generic arguments, and then we take
// the KeyValuePair<> generic argument, and whola! we have our proper generic type.
var collectionType = fsReflectionUtility.GetInterface(dictionary.GetType(), typeof(ICollection<>));
if (collectionType == null) {
return fsResult.Warn(dictionary.GetType() + " does not extend ICollection");
}
var keyValuePairType = collectionType.GetGenericArguments()[0];
object keyValueInstance = Activator.CreateInstance(keyValuePairType, key, value);
MethodInfo add = collectionType.GetFlattenedMethod("Add");
add.Invoke(dictionary, new object[] { keyValueInstance });
return fsResult.Success;
}
// We use the inline set methods instead of dictionary.Add; dictionary.Add will throw an exception
// if the key already exists.
dictionary[key] = value;
return fsResult.Success;
}
/// <summary>
/// 转换字典类型的对象到LuaTable。
/// </summary>
/// <param name="target"></param>
/// <param name="result"></param>
/// <returns></returns>
public static bool PackLuaTable(IDictionary target, out LuaTable result)
{
Type[] types = target.GetType().GetGenericArguments();
result = new LuaTable();
try
{
foreach (DictionaryEntry item in target)
{
if (IsBaseType(types[1]))
{
object value;
if (types[1] == typeof(bool))//判断值是否布尔类型，是则做特殊转换
value = (bool)item.Value ? 1 : 0;
else
value = item.Value;
if (types[0] == typeof(int))//判断键是否为整型，是则标记键为整型，转lua table字符串时有用
result.Add(item.Key.ToString(), false, value);
else
result.Add(item.Key.ToString(), value);
}
else
{
LuaTable value;
var flag = PackLuaTable(item.Value, out value);
if (flag)
{
if (types[0] == typeof(int))
result.Add(item.Key.ToString(), false, value);
else
result.Add(item.Key.ToString(), value);
}
}
}
}
catch (Exception ex)
{
LoggerHelper.Error("PackLuaTable dictionary error: " + ex.Message);
}
return true;
}
