Here are the examples of the csharp api System.Type.GetElementType() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
1644 Examples
19
Source : Protocol16Serializer.cs
with MIT License
from 0blu
with MIT License
from 0blu
private static void SerializeArrayWithSameElements(Protocol16Stream output, Array array, bool writeTypeCode)
{
if (array.Length > short.MaxValue)
{
throw new NotSupportedException($"Arrays can only have a maximum size of {short.MaxValue} (short.MaxValue). Yours is: {array.Length}");
}
output.WriteTypeCodeIfTrue(Protocol16Type.Array, writeTypeCode);
SerializeShort(output, (short)array.Length, false);
Type elementType = array.GetType().GetElementType();
Protocol16Type protocol16Type = TypeCodeToProtocol16Type(elementType);
if (protocol16Type == Protocol16Type.Unknown)
{
throw new Exception("Custom types are currently not supported");
}
output.WriteTypeCodeIfTrue(protocol16Type, true);
if (protocol16Type == Protocol16Type.Dictionary)
{
// WTF ExitGames, why are you trying to get GetGenericArguments() of an array..?!
// I think what you wanted to do is just give the element type to SerializeDictionaryHeader not the array type
SerializeDictionaryHeader(output, elementType, out var writeKeyCode, out var writeValueCode);
foreach (var o in array)
{
SerializeDictionaryElements(output, (IDictionary)o, writeKeyCode, writeValueCode);
}
}
else
{
foreach (object o in array)
{
Serialize(output, o, false);
}
}
}
19
Source : Protocol16Serializer.cs
with MIT License
from 0blu
with MIT License
from 0blu
private static Protocol16Type TypeCodeToProtocol16Type(Type type)
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
return Protocol16Type.Boolean;
case TypeCode.Byte:
return Protocol16Type.Byte;
case TypeCode.Int16:
return Protocol16Type.Short;
case TypeCode.Int32:
return Protocol16Type.Integer;
case TypeCode.Int64:
return Protocol16Type.Long;
case TypeCode.Single:
return Protocol16Type.Float;
case TypeCode.Double:
return Protocol16Type.Double;
case TypeCode.String:
return Protocol16Type.String;
}
if (type.IsArray)
{
var elementType = type.GetElementType();
if (elementType == typeof(byte))
{
return Protocol16Type.ByteArray;
}
if (elementType == typeof(string))
{
return Protocol16Type.StringArray;
}
if (elementType == typeof(int))
{
return Protocol16Type.IntegerArray;
}
if (elementType == typeof(object))
{
return Protocol16Type.ObjectArray;
}
return Protocol16Type.Array;
}
if (type == typeof(Hashtable))
{
return Protocol16Type.Hashtable;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>))
{
return Protocol16Type.Dictionary;
}
if (type == typeof(EventData))
{
return Protocol16Type.EventData;
}
if (type == typeof(OperationRequest))
{
return Protocol16Type.OperationRequest;
}
if (type == typeof(OperationResponse))
{
return Protocol16Type.OperationResponse;
}
return Protocol16Type.Unknown;
}
19
Source : ICollectionResolver.cs
with MIT License
from 1996v
with MIT License
from 1996v
private static bool TypeIsArray(Type t, out int rank, out Type elementType)
{
if (t.IsArray)
{
rank = t.GetArrayRank();
elementType = t.GetElementType();
return true;
}
rank = 0;
elementType = null;
return false;
}
19
Source : RandomHelper.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static object RandomValue(this Type t, bool stringValueAllowEmpty = true)
{
if (t.IsPrimitive)
{
if (t == typeof(byte))
{
return (byte)(Rand.Next(byte.MaxValue - byte.MinValue + 1) + byte.MinValue);
}
if (t == typeof(sbyte))
{
return (sbyte)(Rand.Next(sbyte.MaxValue - sbyte.MinValue + 1) + sbyte.MinValue);
}
if (t == typeof(short))
{
return (short)(Rand.Next(short.MaxValue - short.MinValue + 1) + short.MinValue);
}
if (t == typeof(ushort))
{
return (ushort)(Rand.Next(ushort.MaxValue - ushort.MinValue + 1) + ushort.MinValue);
}
if (t == typeof(int))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
return BitConverter.ToInt32(bytes, 0);
}
if (t == typeof(uint))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
return BitConverter.ToUInt32(bytes, 0);
}
if (t == typeof(long))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
return BitConverter.ToInt64(bytes, 0);
}
if (t == typeof(ulong))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
return BitConverter.ToUInt64(bytes, 0);
}
if (t == typeof(float))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
var f = BitConverter.ToSingle(bytes, 0);
if (float.IsNaN(f))
f = (float)RandomValue<short>();
return f;
}
if (t == typeof(double))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
var d= BitConverter.ToDouble(bytes, 0);
if (double.IsNaN(d))
d = (double)RandomValue<short>();
return d;
}
if (t == typeof(char))
{
var roll = Rand.Next(ASCII.Length);
return ASCII[roll];
}
if (t == typeof(bool))
{
return (Rand.Next(2) == 1);
}
throw new InvalidOperationException();
}
if (t == typeof(decimal))
{
return new decimal((int)typeof(int).RandomValue(), (int)typeof(int).RandomValue(), (int)typeof(int).RandomValue(), false, 28);
}
if (t == typeof(string))
{
int start = stringValueAllowEmpty ? 0 : 1;
var len = Rand.Next(start, 40);
var c = new char[len];
for (var i = 0; i < c.Length; i++)
{
c[i] = (char)typeof(char).RandomValue();
}
return new string(c);
}
if (t == typeof(DateTime))
{
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var bytes = new byte[4];
Rand.NextBytes(bytes);
var secsOffset = BitConverter.ToInt32(bytes, 0);
var retDate = epoch.AddSeconds(secsOffset);
return retDate;
}
if (t == typeof(TimeSpan))
{
return new TimeSpan(RandomValue<DateTime>().Ticks);
}
if (t == typeof(DataTable))
{
DataTable dt = new DataTable();
int coluCount = Rand.Next(10, 30);
for (int i = 0; i < coluCount; i++)
{
string n = RandomHelper.RandomValue<string>(false);
while(dt.Columns.Contains(n))
n = RandomHelper.RandomValue<string>(false);
dt.Columns.Add(n, typeof(object));
}
int rowCount = Rand.Next(20, 50);
for (int i = 0; i < rowCount; i++)
{
var row = new object[coluCount];
for (int zi = 0; zi < coluCount; zi++)
{
row[zi] = RandomHelper.RandomValue<object>();
}
dt.Rows.Add(row);
}
return dt;
}
if (t.IsNullable())
{
// leave it unset
if (Rand.Next(2) == 0)
{
// null!
return Activator.CreateInstance(t);
}
var underlying = Nullable.GetUnderlyingType(t);
var val = underlying.RandomValue(stringValueAllowEmpty);
var cons = t.GetConstructor(new[] { underlying });
return cons.Invoke(new object[] { val });
}
if (t.IsEnum)
{
var allValues = Enum.GetValues(t);
var ix = Rand.Next(allValues.Length);
return allValues.GetValue(ix);
}
if (t.IsArray)
{
var valType = t.GetElementType();
var len = Rand.Next(20, 50);
var ret = Array.CreateInstance(valType, len);
//var add = t.GetMethod("SetValue");
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
ret.SetValue(elem, i);
}
return ret;
}
if (t.IsGenericType)
{
var defind = t.GetGenericTypeDefinition();
if (defind == typeof(HashSet<>))
{
var valType = t.GetGenericArguments()[0];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var contains = t.GetMethod("Contains");
var len = Rand.Next(20, 50);
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
while (elem == null || (bool)contains.Invoke(ret, new object[] { elem }))
elem = valType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { elem });
}
return ret;
}
if (defind == typeof(Dictionary<,>))
{
var keyType = t.GetGenericArguments()[0];
var valType = t.GetGenericArguments()[1];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var contains = t.GetMethod("ContainsKey");
var len = Rand.Next(20, 50);
if (keyType == typeof(Boolean))
len = 2;
for (var i = 0; i < len; i++)
{
var val = valType.RandomValue(stringValueAllowEmpty);
var key = keyType.RandomValue(stringValueAllowEmpty);
while (key == null || (bool)contains.Invoke(ret, new object[] { key }))
key = keyType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { key, val });
}
return ret;
}
if (defind == typeof(List<>))
{
var valType = t.GetGenericArguments()[0];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var len = Rand.Next(20, 50);
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { elem });
}
return ret;
}
if (defind == typeof(ArraySegment<>))
{
var valType = t.GetGenericArguments()[0];
var ary = valType.MakeArrayType().RandomValue(stringValueAllowEmpty);
var lenT = ary.GetType().GetProperty("Length");
var offset = Rand.Next(0, (int)lenT.GetValue(ary) - 1);
var len = (int)lenT.GetValue(ary) - offset;
return Activator.CreateInstance(t, ary, offset, len);
}
}
if (t == typeof(Guid))
return Guid.NewGuid();
if (t == typeof(object))
{
var code = Rand.Next(0, 9);
switch (code)
{
case 0:
return RandomValue<int>();
case 1:
return RandomValue<long>();
case 2:
return RandomValue<Char>();
case 3:
return RandomValue<DateTime>();
case 4:
return RandomValue<string>(stringValueAllowEmpty);
case 5:
return RandomValue<Guid>();
case 6:
return RandomValue<decimal>();
case 7:
return RandomValue<double>();
case 8:
return RandomValue<float>();
default:
return RandomValue<short>();
}
}
//model
var retObj = Activator.CreateInstance(t);
foreach (var p in t.GetFields())
{
//if (Rand.Next(5) == 0) continue;
var fieldType = p.FieldType;
p.SetValue(retObj, fieldType.RandomValue(stringValueAllowEmpty));
}
foreach (var p in t.GetProperties())
{
//if (Rand.Next(5) == 0) continue;
if (p.CanWrite && p.CanRead)
{
var fieldType = p.PropertyType;
p.SetValue(retObj, fieldType.RandomValue(stringValueAllowEmpty));
}
}
return retObj;
}
19
Source : RandomHelper.cs
with MIT License
from 1996v
with MIT License
from 1996v
public static object RandomValue(this Type t, bool stringValueAllowEmpty = true)
{
if (t.IsPrimitive)
{
if (t == typeof(byte))
{
return (byte)(Rand.Next(byte.MaxValue - byte.MinValue + 1) + byte.MinValue);
}
if (t == typeof(sbyte))
{
return (sbyte)(Rand.Next(sbyte.MaxValue - sbyte.MinValue + 1) + sbyte.MinValue);
}
if (t == typeof(short))
{
return (short)(Rand.Next(short.MaxValue - short.MinValue + 1) + short.MinValue);
}
if (t == typeof(ushort))
{
return (ushort)(Rand.Next(ushort.MaxValue - ushort.MinValue + 1) + ushort.MinValue);
}
if (t == typeof(int))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
return BitConverter.ToInt32(bytes, 0);
}
if (t == typeof(uint))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
return BitConverter.ToUInt32(bytes, 0);
}
if (t == typeof(long))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
return BitConverter.ToInt64(bytes, 0);
}
if (t == typeof(ulong))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
return BitConverter.ToUInt64(bytes, 0);
}
if (t == typeof(float))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
var f = BitConverter.ToSingle(bytes, 0);
if (float.IsNaN(f))
f = (float)RandomValue<short>();
return f;
}
if (t == typeof(double))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
var d = BitConverter.ToDouble(bytes, 0);
if (double.IsNaN(d))
d = (double)RandomValue<short>();
return d;
}
if (t == typeof(char))
{
var roll = Rand.Next(ASCII.Length);
return ASCII[roll];
}
if (t == typeof(bool))
{
return (Rand.Next(2) == 1);
}
throw new InvalidOperationException();
}
if (t == typeof(decimal))
{
return new decimal((int)typeof(int).RandomValue(), (int)typeof(int).RandomValue(), (int)typeof(int).RandomValue(), false, 28);
}
if (t == typeof(string))
{
int start = stringValueAllowEmpty ? 0 : 1;
var len = Rand.Next(start, 28);
var c = new char[len];
for (var i = 0; i < c.Length; i++)
{
c[i] = (char)typeof(char).RandomValue();
}
return new string(c);
}
if (t == typeof(DateTime))
{
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var bytes = new byte[4];
Rand.NextBytes(bytes);
var secsOffset = BitConverter.ToInt32(bytes, 0);
var retDate = epoch.AddSeconds(secsOffset);
return retDate;
}
if (t == typeof(TimeSpan))
{
return new TimeSpan(RandomValue<DateTime>().Ticks);
}
if (t == typeof(DataTable))
{
DataTable dt = new DataTable();
int coluCount = Rand.Next(10, 30);
for (int i = 0; i < coluCount; i++)
{
dt.Columns.Add(RandomHelper.RandomValue<string>(false), typeof(object));
}
int rowCount = Rand.Next(20, 50);
for (int i = 0; i < rowCount; i++)
{
var row = new object[coluCount];
for (int zi = 0; zi < coluCount; zi++)
{
row[zi] = RandomHelper.RandomValue<object>();
}
dt.Rows.Add(row);
}
return dt;
}
if (t.IsNullable())
{
// leave it unset
if (Rand.Next(2) == 0)
{
// null!
return Activator.CreateInstance(t);
}
var underlying = Nullable.GetUnderlyingType(t);
var val = underlying.RandomValue(stringValueAllowEmpty);
var cons = t.GetConstructor(new[] { underlying });
return cons.Invoke(new object[] { val });
}
if (t.IsEnum)
{
var allValues = Enum.GetValues(t);
var ix = Rand.Next(allValues.Length);
return allValues.GetValue(ix);
}
if (t.IsArray)
{
var valType = t.GetElementType();
var len = Rand.Next(20, 50);
var ret = Array.CreateInstance(valType, len);
//var add = t.GetMethod("SetValue");
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
ret.SetValue(elem, i);
}
return ret;
}
if (t.IsGenericType)
{
var defind = t.GetGenericTypeDefinition();
if (defind == typeof(HashSet<>))
{
var valType = t.GetGenericArguments()[0];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var contains = t.GetMethod("Contains");
var len = Rand.Next(20, 50);
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
while (elem == null || (bool)contains.Invoke(ret, new object[] { elem }))
elem = valType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { elem });
}
return ret;
}
if (defind == typeof(Dictionary<,>))
{
var keyType = t.GetGenericArguments()[0];
var valType = t.GetGenericArguments()[1];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var contains = t.GetMethod("ContainsKey");
var len = Rand.Next(20, 50);
if (keyType == typeof(Boolean))
len = 2;
for (var i = 0; i < len; i++)
{
var val = valType.RandomValue(stringValueAllowEmpty);
var key = keyType.RandomValue(stringValueAllowEmpty);
while (key == null || (bool)contains.Invoke(ret, new object[] { key }))
key = keyType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { key, val });
}
return ret;
}
if (defind == typeof(List<>))
{
var valType = t.GetGenericArguments()[0];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var len = Rand.Next(20, 50);
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { elem });
}
return ret;
}
if (defind == typeof(ArraySegment<>))
{
var valType = t.GetGenericArguments()[0];
var ary = valType.MakeArrayType().RandomValue(stringValueAllowEmpty);
var lenT = ary.GetType().GetProperty("Length");
var offset = Rand.Next(0, (int)lenT.GetValue(ary) - 1);
var len = (int)lenT.GetValue(ary) - offset;
return Activator.CreateInstance(t, ary, offset, len);
}
}
if (t == typeof(Guid))
return Guid.NewGuid();
if (t == typeof(object))
{
var code = Rand.Next(0, 9);
switch (code)
{
case 0:
return RandomValue<int>();
case 1:
return RandomValue<long>();
case 2:
return RandomValue<Char>();
case 3:
return RandomValue<DateTime>();
case 4:
return RandomValue<string>(stringValueAllowEmpty);
case 5:
return RandomValue<Guid>();
case 6:
return RandomValue<decimal>();
case 7:
return RandomValue<double>();
case 8:
return RandomValue<float>();
default:
return RandomValue<short>();
}
}
//model
var retObj = Activator.CreateInstance(t);
foreach (var p in t.GetFields())
{
//if (Rand.Next(5) == 0) continue;
var fieldType = p.FieldType;
p.SetValue(retObj, fieldType.RandomValue(stringValueAllowEmpty));
}
foreach (var p in t.GetProperties())
{
//if (Rand.Next(5) == 0) continue;
if (p.CanWrite && p.CanRead)
{
var fieldType = p.PropertyType;
p.SetValue(retObj, fieldType.RandomValue(stringValueAllowEmpty));
}
}
return retObj;
}
19
Source : TypeExtension.cs
with MIT License
from 2881099
with MIT License
from 2881099
public static string DisplayCsharp(this Type type, bool isNameSpace = true)
{
if (type == null) return null;
if (type == typeof(void)) return "void";
if (type.IsGenericParameter) return type.Name;
if (type.IsArray) return $"{DisplayCsharp(type.GetElementType())}[]";
var sb = new StringBuilder();
var nestedType = type;
while (nestedType.IsNested)
{
sb.Insert(0, ".").Insert(0, DisplayCsharp(nestedType.DeclaringType, false));
nestedType = nestedType.DeclaringType;
}
if (isNameSpace && string.IsNullOrWhiteSpace(nestedType.Namespace) == false)
sb.Insert(0, ".").Insert(0, nestedType.Namespace);
if (type.IsGenericType == false)
return sb.Append(type.Name).ToString();
var genericParameters = type.GetGenericArguments();
if (type.IsNested && type.DeclaringType.IsGenericType)
{
var dic = genericParameters.ToDictionary(a => a.Name);
foreach (var nestedGenericParameter in type.DeclaringType.GetGenericArguments())
if (dic.ContainsKey(nestedGenericParameter.Name))
dic.Remove(nestedGenericParameter.Name);
genericParameters = dic.Values.ToArray();
}
if (genericParameters.Any() == false)
return sb.Append(type.Name).ToString();
sb.Append(type.Name.Remove(type.Name.IndexOf('`'))).Append("<");
var genericTypeIndex = 0;
foreach (var genericType in genericParameters)
{
if (genericTypeIndex++ > 0) sb.Append(", ");
sb.Append(DisplayCsharp(genericType, true));
}
return sb.Append(">").ToString();
}
19
Source : InternalExtensions.cs
with MIT License
from 2881099
with MIT License
from 2881099
public static object FromObject(this Type targetType, object value, Encoding encoding = null)
{
if (targetType == typeof(object)) return value;
if (encoding == null) encoding = Encoding.UTF8;
var valueIsNull = value == null;
var valueType = valueIsNull ? typeof(string) : value.GetType();
if (valueType == targetType) return value;
if (valueType == typeof(byte[])) //byte[] -> guid
{
if (targetType == typeof(Guid))
{
var bytes = value as byte[];
return Guid.TryParse(BitConverter.ToString(bytes, 0, Math.Min(bytes.Length, 36)).Replace("-", ""), out var tryguid) ? tryguid : Guid.Empty;
}
if (targetType == typeof(Guid?))
{
var bytes = value as byte[];
return Guid.TryParse(BitConverter.ToString(bytes, 0, Math.Min(bytes.Length, 36)).Replace("-", ""), out var tryguid) ? (Guid?)tryguid : null;
}
}
if (targetType == typeof(byte[])) //guid -> byte[]
{
if (valueIsNull) return null;
if (valueType == typeof(Guid) || valueType == typeof(Guid?))
{
var bytes = new byte[16];
var guidN = ((Guid)value).ToString("N");
for (var a = 0; a < guidN.Length; a += 2)
bytes[a / 2] = byte.Parse($"{guidN[a]}{guidN[a + 1]}", NumberStyles.HexNumber);
return bytes;
}
return encoding.GetBytes(value.ToInvariantCultureToString());
}
else if (targetType.IsArray)
{
if (value is Array valueArr)
{
var targetElementType = targetType.GetElementType();
var sourceArrLen = valueArr.Length;
var target = Array.CreateInstance(targetElementType, sourceArrLen);
for (var a = 0; a < sourceArrLen; a++) target.SetValue(targetElementType.FromObject(valueArr.GetValue(a), encoding), a);
return target;
}
//if (value is IList valueList)
//{
// var targetElementType = targetType.GetElementType();
// var sourceArrLen = valueList.Count;
// var target = Array.CreateInstance(targetElementType, sourceArrLen);
// for (var a = 0; a < sourceArrLen; a++) target.SetValue(targetElementType.FromObject(valueList[a], encoding), a);
// return target;
//}
}
var func = _dicFromObject.GetOrAdd(targetType, tt =>
{
if (tt == typeof(object)) return vs => vs;
if (tt == typeof(string)) return vs => vs;
if (tt == typeof(char[])) return vs => vs == null ? null : vs.ToCharArray();
if (tt == typeof(char)) return vs => vs == null ? default(char) : vs.ToCharArray(0, 1).FirstOrDefault();
if (tt == typeof(bool)) return vs =>
{
if (vs == null) return false;
switch (vs.ToLower())
{
case "true":
case "1":
return true;
}
return false;
};
if (tt == typeof(bool?)) return vs =>
{
if (vs == null) return false;
switch (vs.ToLower())
{
case "true":
case "1":
return true;
case "false":
case "0":
return false;
}
return null;
};
if (tt == typeof(byte)) return vs => vs == null ? 0 : (byte.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(byte?)) return vs => vs == null ? null : (byte.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (byte?)tryval : null);
if (tt == typeof(decimal)) return vs => vs == null ? 0 : (decimal.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(decimal?)) return vs => vs == null ? null : (decimal.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (decimal?)tryval : null);
if (tt == typeof(double)) return vs => vs == null ? 0 : (double.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(double?)) return vs => vs == null ? null : (double.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (double?)tryval : null);
if (tt == typeof(float)) return vs => vs == null ? 0 : (float.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(float?)) return vs => vs == null ? null : (float.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (float?)tryval : null);
if (tt == typeof(int)) return vs => vs == null ? 0 : (int.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(int?)) return vs => vs == null ? null : (int.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (int?)tryval : null);
if (tt == typeof(long)) return vs => vs == null ? 0 : (long.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(long?)) return vs => vs == null ? null : (long.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (long?)tryval : null);
if (tt == typeof(sbyte)) return vs => vs == null ? 0 : (sbyte.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(sbyte?)) return vs => vs == null ? null : (sbyte.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (sbyte?)tryval : null);
if (tt == typeof(short)) return vs => vs == null ? 0 : (short.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(short?)) return vs => vs == null ? null : (short.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (short?)tryval : null);
if (tt == typeof(uint)) return vs => vs == null ? 0 : (uint.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(uint?)) return vs => vs == null ? null : (uint.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (uint?)tryval : null);
if (tt == typeof(ulong)) return vs => vs == null ? 0 : (ulong.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(ulong?)) return vs => vs == null ? null : (ulong.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (ulong?)tryval : null);
if (tt == typeof(ushort)) return vs => vs == null ? 0 : (ushort.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(ushort?)) return vs => vs == null ? null : (ushort.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (ushort?)tryval : null);
if (tt == typeof(DateTime)) return vs => vs == null ? DateTime.MinValue : (DateTime.TryParse(vs, out var tryval) ? tryval : DateTime.MinValue);
if (tt == typeof(DateTime?)) return vs => vs == null ? null : (DateTime.TryParse(vs, out var tryval) ? (DateTime?)tryval : null);
if (tt == typeof(DateTimeOffset)) return vs => vs == null ? DateTimeOffset.MinValue : (DateTimeOffset.TryParse(vs, out var tryval) ? tryval : DateTimeOffset.MinValue);
if (tt == typeof(DateTimeOffset?)) return vs => vs == null ? null : (DateTimeOffset.TryParse(vs, out var tryval) ? (DateTimeOffset?)tryval : null);
if (tt == typeof(TimeSpan)) return vs => vs == null ? TimeSpan.Zero : (TimeSpan.TryParse(vs, out var tryval) ? tryval : TimeSpan.Zero);
if (tt == typeof(TimeSpan?)) return vs => vs == null ? null : (TimeSpan.TryParse(vs, out var tryval) ? (TimeSpan?)tryval : null);
if (tt == typeof(Guid)) return vs => vs == null ? Guid.Empty : (Guid.TryParse(vs, out var tryval) ? tryval : Guid.Empty);
if (tt == typeof(Guid?)) return vs => vs == null ? null : (Guid.TryParse(vs, out var tryval) ? (Guid?)tryval : null);
if (tt == typeof(BigInteger)) return vs => vs == null ? 0 : (BigInteger.TryParse(vs, NumberStyles.Any, null, out var tryval) ? tryval : 0);
if (tt == typeof(BigInteger?)) return vs => vs == null ? null : (BigInteger.TryParse(vs, NumberStyles.Any, null, out var tryval) ? (BigInteger?)tryval : null);
if (tt.NullableTypeOrThis().IsEnum)
{
var tttype = tt.NullableTypeOrThis();
var ttdefval = tt.CreateInstanceGetDefaultValue();
return vs =>
{
if (string.IsNullOrWhiteSpace(vs)) return ttdefval;
return Enum.Parse(tttype, vs, true);
};
}
var localTargetType = targetType;
var localValueType = valueType;
return vs =>
{
if (vs == null) return null;
throw new NotSupportedException($"convert failed {localValueType.DisplayCsharp()} -> {localTargetType.DisplayCsharp()}");
};
});
var valueStr = valueIsNull ? null : (valueType == typeof(byte[]) ? encoding.GetString(value as byte[]) : value.ToInvariantCultureToString());
return func(valueStr);
}
19
Source : DynamicProxyExtensions.cs
with MIT License
from 2881099
with MIT License
from 2881099
internal static string DisplayCsharp(this Type type, bool isNameSpace = true)
{
if (type == null) return null;
if (type == typeof(void)) return "void";
if (type.IsGenericParameter) return type.Name;
if (type.IsArray) return $"{DisplayCsharp(type.GetElementType())}[]";
var sb = new StringBuilder();
var nestedType = type;
while (nestedType.IsNested)
{
sb.Insert(0, ".").Insert(0, DisplayCsharp(nestedType.DeclaringType, false));
nestedType = nestedType.DeclaringType;
}
if (isNameSpace && string.IsNullOrEmpty(nestedType.Namespace) == false)
sb.Insert(0, ".").Insert(0, nestedType.Namespace);
if (type.IsGenericType == false)
return sb.Append(type.Name).ToString();
var genericParameters = type.GetGenericArguments();
if (type.IsNested && type.DeclaringType.IsGenericType)
{
var dic = genericParameters.ToDictionary(a => a.Name);
foreach (var nestedGenericParameter in type.DeclaringType.GetGenericArguments())
if (dic.ContainsKey(nestedGenericParameter.Name))
dic.Remove(nestedGenericParameter.Name);
genericParameters = dic.Values.ToArray();
}
if (genericParameters.Any() == false)
return sb.Append(type.Name).ToString();
sb.Append(type.Name.Remove(type.Name.IndexOf('`'))).Append("<");
var genericTypeIndex = 0;
foreach (var genericType in genericParameters)
{
if (genericTypeIndex++ > 0) sb.Append(", ");
sb.Append(DisplayCsharp(genericType, true));
}
return sb.Append(">").ToString();
}
19
Source : InternalExtensions.cs
with MIT License
from 2881099
with MIT License
from 2881099
internal static string DisplayCsharp(this Type type, bool isNameSpace = true)
{
if (type == null) return null;
if (type == typeof(void)) return "void";
if (type.IsGenericParameter) return type.Name;
if (type.IsArray) return $"{DisplayCsharp(type.GetElementType())}[]";
var sb = new StringBuilder();
var nestedType = type;
while (nestedType.IsNested)
{
sb.Insert(0, ".").Insert(0, DisplayCsharp(nestedType.DeclaringType, false));
nestedType = nestedType.DeclaringType;
}
if (isNameSpace && string.IsNullOrWhiteSpace(nestedType.Namespace) == false)
sb.Insert(0, ".").Insert(0, nestedType.Namespace);
if (type.IsGenericType == false)
return sb.Append(type.Name).ToString();
var genericParameters = type.GetGenericArguments();
if (type.IsNested && type.DeclaringType.IsGenericType)
{
var dic = genericParameters.ToDictionary(a => a.Name);
foreach (var nestedGenericParameter in type.DeclaringType.GetGenericArguments())
if (dic.ContainsKey(nestedGenericParameter.Name))
dic.Remove(nestedGenericParameter.Name);
genericParameters = dic.Values.ToArray();
}
if (genericParameters.Any() == false)
return sb.Append(type.Name).ToString();
sb.Append(type.Name.Remove(type.Name.IndexOf('`'))).Append("<");
var genericTypeIndex = 0;
foreach (var genericType in genericParameters)
{
if (genericTypeIndex++ > 0) sb.Append(", ");
sb.Append(DisplayCsharp(genericType, true));
}
return sb.Append(">").ToString();
}
19
Source : JsonMapper.cs
with MIT License
from 404Lcc
with MIT License
from 404Lcc
private static object ReadValue (Type inst_type, JsonReader reader)
{
reader.Read ();
if (reader.Token == JsonToken.ArrayEnd)
return null;
//ILRuntime doesn't support nullable valuetype
Type underlying_type = inst_type;//Nullable.GetUnderlyingType(inst_type);
Type value_type = inst_type;
if (reader.Token == JsonToken.Null) {
if (inst_type.IsClreplaced || underlying_type != null) {
return null;
}
throw new JsonException (String.Format (
"Can't replacedign null to an instance of type {0}",
inst_type));
}
if (reader.Token == JsonToken.Double ||
reader.Token == JsonToken.Int ||
reader.Token == JsonToken.Long ||
reader.Token == JsonToken.String ||
reader.Token == JsonToken.Boolean) {
Type json_type = reader.Value.GetType();
var vt = value_type is ILRuntime.Reflection.ILRuntimeWrapperType ? ((ILRuntime.Reflection.ILRuntimeWrapperType)value_type).CLRType.TypeForCLR : value_type;
if (vt.IsreplacedignableFrom(json_type))
return reader.Value;
if (vt is ILRuntime.Reflection.ILRuntimeType && ((ILRuntime.Reflection.ILRuntimeType)vt).ILType.IsEnum)
{
if (json_type == typeof(int) || json_type == typeof(long) || json_type == typeof(short) || json_type == typeof(byte))
return reader.Value;
}
// If there's a custom importer that fits, use it
if (custom_importers_table.ContainsKey (json_type) &&
custom_importers_table[json_type].ContainsKey (
vt)) {
ImporterFunc importer =
custom_importers_table[json_type][vt];
return importer (reader.Value);
}
// Maybe there's a base importer that works
if (base_importers_table.ContainsKey (json_type) &&
base_importers_table[json_type].ContainsKey (
vt)) {
ImporterFunc importer =
base_importers_table[json_type][vt];
return importer (reader.Value);
}
// Maybe it's an enum
if (vt.IsEnum)
return Enum.ToObject (vt, reader.Value);
// Try using an implicit conversion operator
MethodInfo conv_op = GetConvOp (vt, json_type);
if (conv_op != null)
return conv_op.Invoke (null,
new object[] { reader.Value });
// No luck
throw new JsonException (String.Format (
"Can't replacedign value '{0}' (type {1}) to type {2}",
reader.Value, json_type, inst_type));
}
object instance = null;
if (reader.Token == JsonToken.ArrayStart) {
AddArrayMetadata (inst_type);
ArrayMetadata t_data = array_metadata[inst_type];
if (! t_data.IsArray && ! t_data.IsList)
throw new JsonException (String.Format (
"Type {0} can't act as an array",
inst_type));
IList list;
Type elem_type;
if (! t_data.IsArray) {
list = (IList) Activator.CreateInstance (inst_type);
elem_type = t_data.ElementType;
} else {
list = new ArrayList ();
elem_type = inst_type.GetElementType ();
}
while (true) {
object item = ReadValue (elem_type, reader);
if (item == null && reader.Token == JsonToken.ArrayEnd)
break;
var rt = elem_type is ILRuntime.Reflection.ILRuntimeWrapperType ? ((ILRuntime.Reflection.ILRuntimeWrapperType)elem_type).RealType : elem_type;
if (elem_type is ILRuntime.Reflection.ILRuntimeType && ((ILRuntime.Reflection.ILRuntimeType)elem_type).ILType.IsEnum)
{
item = (int) item;
}
else
{
item = rt.CheckCLRTypes(item);
}
list.Add (item);
}
if (t_data.IsArray) {
int n = list.Count;
instance = Array.CreateInstance (elem_type, n);
for (int i = 0; i < n; i++)
((Array) instance).SetValue (list[i], i);
} else
instance = list;
} else if (reader.Token == JsonToken.ObjectStart)
{
AddObjectMetadata(value_type);
ObjectMetadata t_data = object_metadata[value_type];
if (value_type is ILRuntime.Reflection.ILRuntimeType)
instance = ((ILRuntime.Reflection.ILRuntimeType) value_type).ILType.Instantiate();
else
instance = Activator.CreateInstance(value_type);
bool isIntKey = t_data.IsDictionary && value_type.GetGenericArguments()[0] == typeof(int);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
break;
string key = (string) reader.Value;
if (t_data.Properties.ContainsKey(key))
{
PropertyMetadata prop_data =
t_data.Properties[key];
if (prop_data.IsField)
{
((FieldInfo) prop_data.Info).SetValue(
instance, ReadValue(prop_data.Type, reader));
}
else
{
PropertyInfo p_info =
(PropertyInfo) prop_data.Info;
if (p_info.CanWrite)
p_info.SetValue(
instance,
ReadValue(prop_data.Type, reader),
null);
else
ReadValue(prop_data.Type, reader);
}
}
else
{
if (!t_data.IsDictionary)
{
if (!reader.SkipNonMembers)
{
throw new JsonException(String.Format(
"The type {0} doesn't have the " +
"property '{1}'",
inst_type, key));
}
else
{
ReadSkip(reader);
continue;
}
}
var dict = ((IDictionary) instance);
var elem_type = t_data.ElementType;
object readValue = ReadValue(elem_type, reader);
var rt = t_data.ElementType is ILRuntime.Reflection.ILRuntimeWrapperType
? ((ILRuntime.Reflection.ILRuntimeWrapperType) t_data.ElementType).RealType
: t_data.ElementType;
//value 是枚举的情况没处理,毕竟少
if (isIntKey)
{
var dictValueType = value_type.GetGenericArguments()[1];
IConvertible convertible = dictValueType as IConvertible;
if (convertible == null)
{
//自定义类型扩展
if (dictValueType == typeof(double)) //CheckCLRTypes() 没有double,也可以修改ilruntime源码实现
{
var v = Convert.ChangeType(readValue.ToString(), dictValueType);
dict.Add(Convert.ToInt32(key), v);
}
else
{
readValue = rt.CheckCLRTypes(readValue);
dict.Add(Convert.ToInt32(key), readValue);
// throw new JsonException (String.Format("The type {0} doesn't not support",dictValueType));
}
}
else
{
var v = Convert.ChangeType(readValue, dictValueType);
dict.Add(Convert.ToInt32(key), v);
}
}
else
{
readValue = rt.CheckCLRTypes(readValue);
dict.Add(key, readValue);
}
}
}
}
return instance;
}
19
Source : JSONParser.cs
with MIT License
from 5minlab
with MIT License
from 5minlab
internal static object ParseValue(Type type, string json) {
if (type == typeof(string)) {
if (json.Length <= 2)
return string.Empty;
string str = json.Substring(1, json.Length - 2);
return str.Replace("\\\\", "\"\"").Replace("\\", string.Empty).Replace("\"\"", "\\");
}
if (type == typeof(int)) {
int result;
int.TryParse(json, out result);
return result;
}
if (type == typeof(float)) {
float result;
float.TryParse(json, out result);
return result;
}
if (type == typeof(double)) {
double result;
double.TryParse(json, out result);
return result;
}
if (type == typeof(bool)) {
return json.ToLower() == "true";
}
if (json == "null") {
return null;
}
if (type.IsArray) {
Type arrayType = type.GetElementType();
if (json[0] != '[' || json[json.Length - 1] != ']')
return null;
List<string> elems = Split(json);
Array newArray = Array.CreateInstance(arrayType, elems.Count);
for (int i = 0; i < elems.Count; i++)
newArray.SetValue(ParseValue(arrayType, elems[i]), i);
splitArrayPool.Push(elems);
return newArray;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>)) {
Type listType = type.GetGenericArguments()[0];
if (json[0] != '[' || json[json.Length - 1] != ']')
return null;
List<string> elems = Split(json);
var list = (IList)type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { elems.Count });
for (int i = 0; i < elems.Count; i++)
list.Add(ParseValue(listType, elems[i]));
splitArrayPool.Push(elems);
return list;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>)) {
Type keyType, valueType;
{
Type[] args = type.GetGenericArguments();
keyType = args[0];
valueType = args[1];
}
//Refuse to parse dictionary keys that aren't of type string
if (keyType != typeof(string))
return null;
//Must be a valid dictionary element
if (json[0] != '{' || json[json.Length - 1] != '}')
return null;
//The list is split into key/value pairs only, this means the split must be divisible by 2 to be valid JSON
List<string> elems = Split(json);
if (elems.Count % 2 != 0)
return null;
var dictionary = (IDictionary)type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { elems.Count / 2 });
for (int i = 0; i < elems.Count; i += 2) {
if (elems[i].Length <= 2)
continue;
string keyValue = elems[i].Substring(1, elems[i].Length - 2);
object val = ParseValue(valueType, elems[i + 1]);
dictionary.Add(keyValue, val);
}
return dictionary;
}
if (type == typeof(object)) {
return ParseAnonymousValue(json);
}
if (json[0] == '{' && json[json.Length - 1] == '}') {
return ParseObject(type, json);
}
return null;
}
19
Source : CometaryExtensions.cs
with MIT License
from 71
with MIT License
from 71
public static object GetValue(this TypedConstant typedConstant)
{
switch (typedConstant.Kind)
{
case TypedConstantKind.Type:
return ((ITypeSymbol)typedConstant.Value).GetCorrespondingType();
case TypedConstantKind.Primitive:
case TypedConstantKind.Enum:
return typedConstant.Value;
case TypedConstantKind.Array:
break;
default:
throw new ArgumentOutOfRangeException();
}
ImmutableArray<TypedConstant> elements = typedConstant.Values;
Array array = Array.CreateInstance(typedConstant.Type.GetCorrespondingType().GetElementType(), elements.Length);
for (int i = 0; i < elements.Length; i++)
{
array.SetValue(elements[i].GetValue(), i);
}
return array;
}
19
Source : Utils.cs
with MIT License
from 71
with MIT License
from 71
internal static Type GereplacedemType(Expression enumerable)
{
Type type = enumerable.Type;
if (type.IsArray)
return type.GetElementType();
TypeInfo enumerableTypeInfo = typeof(IEnumerable<>).GetTypeInfo();
TypeInfo typeInfo = type.GetTypeInfo();
foreach (var iface in typeInfo.ImplementedInterfaces)
{
if (enumerableTypeInfo.IsreplacedignableFrom(iface.GetTypeInfo()))
{
return iface.GenericTypeArguments[0];
}
}
return typeof(object);
}
19
Source : TypeHelpers.cs
with MIT License
from adrianoc
with MIT License
from adrianoc
private static bool CompareParameters(ParameterInfo candidate, ParamData original)
{
if (candidate.ParameterType.IsArray ^ original.IsArray)
{
return false;
}
var candidateElementType = candidate.ParameterType.HasElementType ? candidate.ParameterType.GetElementType() : candidate.ParameterType;
if (candidateElementType.IsGenericParameter ^ original.IsTypeParameter)
{
return false;
}
if (original.IsTypeParameter)
{
return candidateElementType.Name == original.FullName;
}
return candidateElementType.FullName == original.FullName;
}
19
Source : DirectCall.cs
with GNU General Public License v3.0
from Aekras1a
with GNU General Public License v3.0
from Aekras1a
public static TypedInvocation GetTypedInvocationProxy(MethodBase method, OpCode opCode, Type constrainType)
{
Hashtable table;
object key;
if(constrainType == null)
{
key = new KeyValuePair<MethodBase, OpCode>(method, opCode);
table = typedProxies;
}
else
{
key = new KeyValuePair<MethodBase, Type>(method, constrainType);
table = constrainedProxies;
}
var proxy = (TypedInvocation) table[key];
if(proxy != null)
return proxy;
lock(typedProxies)
{
proxy = (TypedInvocation) table[key];
if(proxy != null)
return proxy;
var parameters = method.GetParameters();
Type[] paramTypes;
if(opCode != System.Reflection.Emit.OpCodes.Newobj)
{
paramTypes = new Type[parameters.Length + (method.IsStatic ? 0 : 1) + 1];
for(var i = 0; i < paramTypes.Length - 1; i++)
if(method.IsStatic)
{
paramTypes[i] = parameters[i].ParameterType;
}
else
{
if(i == 0)
if(constrainType != null)
paramTypes[0] = constrainType.MakeByRefType();
else if(method.DeclaringType.IsValueType)
paramTypes[0] = method.DeclaringType.MakeByRefType();
else
paramTypes[0] = method.DeclaringType;
else
paramTypes[i] = parameters[i - 1].ParameterType;
}
}
else
{
paramTypes = new Type[parameters.Length + 1];
for(var i = 0; i < paramTypes.Length - 1; i++) paramTypes[i] = parameters[i].ParameterType;
}
var retType = method is MethodInfo ? ((MethodInfo) method).ReturnType : typeof(void);
if(opCode == System.Reflection.Emit.OpCodes.Newobj)
retType = method.DeclaringType;
var dm = new DynamicMethod("", typeof(object), new[] {typeof(DarksVMContext), typeof(IReference[]), typeof(Type[])},
Unverifier.Module, true);
var gen = dm.GetILGenerator();
for(var i = 0; i < paramTypes.Length - 1; i++)
{
var paramType = paramTypes[i];
var isByRef = paramType.IsByRef;
if(isByRef)
paramType = paramType.GetElementType();
var typedRefLocal = gen.DeclareLocal(typeof(TypedReference));
gen.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
gen.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, i);
gen.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
gen.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
gen.Emit(System.Reflection.Emit.OpCodes.Ldloca, typedRefLocal);
gen.Emit(System.Reflection.Emit.OpCodes.Ldarg_2);
gen.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, i);
gen.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
gen.Emit(System.Reflection.Emit.OpCodes.Callvirt, refToTypedRef);
gen.Emit(System.Reflection.Emit.OpCodes.Ldloca, typedRefLocal);
gen.Emit(System.Reflection.Emit.OpCodes.Ldarg_2);
gen.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, i);
gen.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
gen.Emit(System.Reflection.Emit.OpCodes.Call, castTypedRef);
gen.Emit(System.Reflection.Emit.OpCodes.Ldloc, typedRefLocal);
gen.Emit(System.Reflection.Emit.OpCodes.Refanyval, paramType);
if(!isByRef)
gen.Emit(System.Reflection.Emit.OpCodes.Ldobj, paramType);
}
if(constrainType != null)
gen.Emit(System.Reflection.Emit.OpCodes.Constrained, constrainType);
if(method is MethodInfo)
gen.Emit(opCode, (MethodInfo) method);
else
gen.Emit(opCode, (ConstructorInfo) method);
if(retType.IsByRef)
{
gen.Emit(System.Reflection.Emit.OpCodes.Mkrefany, retType.GetElementType());
gen.Emit(System.Reflection.Emit.OpCodes.Newobj, newTypedRef);
}
else if(retType == typeof(void))
{
gen.Emit(System.Reflection.Emit.OpCodes.Ldnull);
}
else if(retType.IsValueType)
{
gen.Emit(System.Reflection.Emit.OpCodes.Box, retType);
}
gen.Emit(System.Reflection.Emit.OpCodes.Ret);
proxy = (TypedInvocation) dm.CreateDelegate(typeof(TypedInvocation));
table[key] = proxy;
return proxy;
}
}
19
Source : Ecall.cs
with GNU General Public License v3.0
from Aekras1a
with GNU General Public License v3.0
from Aekras1a
private static IReference PopRef(DarksVMContext ctx, Type type, ref uint sp)
{
var arg = ctx.Stack[sp];
if(type.IsByRef)
{
sp--;
type = type.GetElementType();
if(arg.O is Pointer)
{
var ptr = Pointer.Unbox(arg.O);
return new PointerRef(ptr);
}
if(arg.O is IReference) return (IReference) arg.O;
return new PointerRef((void*) arg.U8);
}
if(Type.GetTypeCode(type) == TypeCode.String && arg.O == null)
{
arg.O = ctx.Instance.Data.LookupString(arg.U4);
ctx.Stack[sp] = arg;
}
return new StackRef(sp--);
}
19
Source : Ecall.cs
with GNU General Public License v3.0
from Aekras1a
with GNU General Public License v3.0
from Aekras1a
private void InvokeNormal(DarksVMContext ctx, MethodBase targetMethod, byte opCode, ref uint sp, out ExecutionState state)
{
var _sp = sp;
var parameters = targetMethod.GetParameters();
object self = null;
var args = new object[parameters.Length];
if(opCode == DarksVMConstants.ECALL_CALL && targetMethod.IsVirtual)
{
var indexOffset = targetMethod.IsStatic ? 0 : 1;
args = new object[parameters.Length + indexOffset];
for(var i = parameters.Length - 1; i >= 0; i--)
args[i + indexOffset] = PopObject(ctx, parameters[i].ParameterType, ref sp);
if(!targetMethod.IsStatic)
args[0] = PopObject(ctx, targetMethod.DeclaringType, ref sp);
targetMethod = DirectCall.GetDirectInvocationProxy(targetMethod);
}
else
{
args = new object[parameters.Length];
for(var i = parameters.Length - 1; i >= 0; i--)
args[i] = PopObject(ctx, parameters[i].ParameterType, ref sp);
if(!targetMethod.IsStatic && opCode != DarksVMConstants.ECALL_NEWOBJ)
{
self = PopObject(ctx, targetMethod.DeclaringType, ref sp);
if(self != null && !targetMethod.DeclaringType.IsInstanceOfType(self))
{
// ConfuserEx sometimes produce this to cirreplacedvent peverify (see ref proxy)
// Reflection won't allow it, so use typed invoke
InvokeTyped(ctx, targetMethod, opCode, ref _sp, out state);
return;
}
}
}
object result;
if(opCode == DarksVMConstants.ECALL_NEWOBJ)
{
try
{
result = ((ConstructorInfo) targetMethod).Invoke(args);
}
catch(TargetInvocationException ex)
{
EHHelper.Rethrow(ex.InnerException, null);
throw;
}
}
else
{
if(!targetMethod.IsStatic && self == null)
throw new NullReferenceException();
Type selfType;
if(self != null && (selfType = self.GetType()).IsArray && targetMethod.Name == "SetValue")
{
Type valueType;
if(args[0] == null)
valueType = selfType.GetElementType();
else
valueType = args[0].GetType();
ArrayStoreHelpers.SetValue((Array) self, (int) args[1], args[0], valueType, selfType.GetElementType());
result = null;
}
else
{
try
{
result = targetMethod.Invoke(self, args);
}
catch(TargetInvocationException ex)
{
DarksVMDispatcher.DoThrow(ctx, ex.InnerException);
throw;
}
}
}
if(targetMethod is MethodInfo && ((MethodInfo) targetMethod).ReturnType != typeof(void)) ctx.Stack[++sp] = DarksVMSlot.FromObject(result, ((MethodInfo) targetMethod).ReturnType);
else if(opCode == DarksVMConstants.ECALL_NEWOBJ) ctx.Stack[++sp] = DarksVMSlot.FromObject(result, targetMethod.DeclaringType);
ctx.Stack.SetTopPosition(sp);
ctx.Registers[DarksVMConstants.REG_SP].U4 = sp;
state = ExecutionState.Next;
}
19
Source : Ecall.cs
with GNU General Public License v3.0
from Aekras1a
with GNU General Public License v3.0
from Aekras1a
private void InvokeTyped(DarksVMContext ctx, MethodBase targetMethod, byte opCode, ref uint sp, out ExecutionState state)
{
var parameters = targetMethod.GetParameters();
var paramCount = parameters.Length;
if(!targetMethod.IsStatic && opCode != DarksVMConstants.ECALL_NEWOBJ)
paramCount++;
Type constrainType = null;
if(opCode == DarksVMConstants.ECALL_CALLVIRT_CONSTRAINED) constrainType = (Type) ctx.Instance.Data.LookupReference(ctx.Stack[sp--].U4);
var indexOffset = targetMethod.IsStatic || opCode == DarksVMConstants.ECALL_NEWOBJ ? 0 : 1;
var references = new IReference[paramCount];
var types = new Type[paramCount];
for(var i = paramCount - 1; i >= 0; i--)
{
Type paramType;
if(!targetMethod.IsStatic && opCode != DarksVMConstants.ECALL_NEWOBJ)
if(i == 0)
{
if(!targetMethod.IsStatic)
{
var thisSlot = ctx.Stack[sp];
if(thisSlot.O is ValueType && !targetMethod.DeclaringType.IsValueType)
{
Debug.replacedert(targetMethod.DeclaringType.IsInterface);
Debug.replacedert(opCode == DarksVMConstants.ECALL_CALLVIRT);
// Interface dispatch on valuetypes => use constrained. invocation
constrainType = thisSlot.O.GetType();
}
}
if(constrainType != null)
paramType = constrainType.MakeByRefType();
else if(targetMethod.DeclaringType.IsValueType)
paramType = targetMethod.DeclaringType.MakeByRefType();
else
paramType = targetMethod.DeclaringType;
}
else
{
paramType = parameters[i - 1].ParameterType;
}
else paramType = parameters[i].ParameterType;
references[i] = PopRef(ctx, paramType, ref sp);
if(paramType.IsByRef)
paramType = paramType.GetElementType();
types[i] = paramType;
}
OpCode callOp;
Type retType;
if(opCode == DarksVMConstants.ECALL_CALL)
{
callOp = System.Reflection.Emit.OpCodes.Call;
retType = targetMethod is MethodInfo ? ((MethodInfo) targetMethod).ReturnType : typeof(void);
}
else if(opCode == DarksVMConstants.ECALL_CALLVIRT ||
opCode == DarksVMConstants.ECALL_CALLVIRT_CONSTRAINED)
{
callOp = System.Reflection.Emit.OpCodes.Callvirt;
retType = targetMethod is MethodInfo ? ((MethodInfo) targetMethod).ReturnType : typeof(void);
}
else if(opCode == DarksVMConstants.ECALL_NEWOBJ)
{
callOp = System.Reflection.Emit.OpCodes.Newobj;
retType = targetMethod.DeclaringType;
}
else
{
throw new InvalidProgramException();
}
var proxy = DirectCall.GetTypedInvocationProxy(targetMethod, callOp, constrainType);
var result = proxy(ctx, references, types);
if(retType != typeof(void)) ctx.Stack[++sp] = DarksVMSlot.FromObject(result, retType);
else if(opCode == DarksVMConstants.ECALL_NEWOBJ) ctx.Stack[++sp] = DarksVMSlot.FromObject(result, retType);
ctx.Stack.SetTopPosition(sp);
ctx.Registers[DarksVMConstants.REG_SP].U4 = sp;
state = ExecutionState.Next;
}
19
Source : TypeExtensions.cs
with MIT License
from ahydrax
with MIT License
from ahydrax
private static object CreateSampleInstanceInternal(this Type type, int currentDepth, int maxDepth)
{
if (currentDepth > maxDepth) return GetDefaultValue(type);
var instance = Activator.CreateInstance(type);
foreach (var property in type.GetProperties())
{
var propertyType = property.PropertyType;
if (propertyType.CanBeInstantiated())
{
type.GetProperty(property.Name).SetValue(instance,
propertyType.CreateSampleInstanceInternal(currentDepth + 1, SampleMaxDepth));
}
if (typeof(IEnumerable).IsreplacedignableFrom(propertyType)
&& propertyType != typeof(string))
{
var elementType = propertyType.IsArray
? propertyType.GetElementType()
: propertyType.GenericTypeArguments[0];
var array = Array.CreateInstance(elementType, 1);
array.SetValue(
elementType.CanBeInstantiated()
? elementType.CreateSampleInstanceInternal(currentDepth + 1, SampleMaxDepth)
: GetDefaultValue(elementType),
0);
type.GetProperty(property.Name).SetValue(instance, array);
}
}
return instance;
}
19
Source : ParamDrawer.cs
with MIT License
from aillieo
with MIT License
from aillieo
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
EnsureParamType();
switch (paramType)
{
case ParamType.Unknown:
Debug.LogError("Unknown type");
break;
case ParamType.Normal:
EditorGUI.PropertyField(position, property.FindPropertyRelative("value"), new GUIContent(property.FindPropertyRelative("key").stringValue));
break;
case ParamType.Array:
if (reorderableList == null)
{
CreateReorderableList(property);
}
reorderableList.DoList(position);
break;
case ParamType.Enum:
Type fieldType = fieldInfo.FieldType;
Type elementType = fieldType.GetElementType();
string enumTypeName = property.FindPropertyRelative("enumType").stringValue;
Type enumType = Type.GetType(enumTypeName);
var paramValue = property.FindPropertyRelative("value");
FieldInfo field = elementType.GetField("value", BindingFlags.Public | BindingFlags.Instance);
if (!Enum.IsDefined(enumType, paramValue.intValue))
{
paramValue.intValue = (int)Enum.GetValues(field.FieldType).GetValue(0);
}
paramValue.intValue = EditorGUI.Popup(position,property.FindPropertyRelative("key").stringValue, paramValue.intValue, enumType.GetEnumNames());
break;
}
}
19
Source : ParamDrawer.cs
with MIT License
from aillieo
with MIT License
from aillieo
void EnsureParamType()
{
if (paramType == ParamType.Unknown)
{
Type fieldType = fieldInfo.FieldType;
Type elementType = fieldType.GetElementType();
FieldInfo valueField = elementType.GetField("value", BindingFlags.Public | BindingFlags.Instance);
Type valueType = valueField.FieldType;
if (valueType.IsArray)
{
paramType = ParamType.Array;
}
else if (elementType.GetField("enumType",BindingFlags.Instance|BindingFlags.Public) != null)
{
paramType = ParamType.Enum;
}
else
{
paramType = ParamType.Normal;
}
}
}
19
Source : DataConverter.cs
with GNU General Public License v3.0
from aiportal
with GNU General Public License v3.0
from aiportal
private static object ArrayFromString(string str, Type type)
{
Debug.replacedert(!string.IsNullOrEmpty(str));
Debug.replacedert(type.IsArray);
string[] vals = str.Split(new char[] { ArraySeparator });
var list = new System.Collections.ArrayList(vals.Length);
var t = type.GetElementType();
for (int i = 0; i < vals.Length; ++i)
list.Add(ObjectFromString(vals[i], t));
return list.ToArray(t);
}
19
Source : InstranceMaker.cs
with MIT License
from AiursoftWeb
with MIT License
from AiursoftWeb
public static object Make(this Type type)
{
if (type == typeof(string))
{
return "an example string.";
}
else if (type == typeof(int) || type == typeof(int?))
{
return 0;
}
else if (type == typeof(DateTime) || type == typeof(DateTime?))
{
return DateTime.UtcNow;
}
else if (type == typeof(Guid) || type == typeof(Guid?))
{
return Guid.NewGuid();
}
else if (type == typeof(DateTimeOffset) || type == typeof(DateTimeOffset?))
{
return DateTimeOffset.UtcNow;
}
else if (type == typeof(TimeSpan) || type == typeof(TimeSpan?))
{
return TimeSpan.FromMinutes(37);
}
else if (type == typeof(bool) || type == typeof(bool?))
{
return true;
}
// List
else if (type.IsGenericType && type.GetGenericTypeDefinition().GetInterfaces().Any(t => t.IsreplacedignableFrom(typeof(IEnumerable))))
{
var itemType = type.GetGenericArguments()[0];
return GetArrayWithInstanceInherts(itemType);
}
// Array
else if (type.GetInterface(typeof(IEnumerable<>).FullName ?? string.Empty) != null)
{
var itemType = type.GetElementType();
var list = GetArrayWithInstanceInherts(itemType);
var array = Array.CreateInstance(itemType ?? typeof(string[]), list.Count);
list.CopyTo(array, 0);
return array;
}
else
{
var instance = GenerateWithConstructor(type);
if (instance != null)
{
foreach (var property in instance.GetType().GetProperties())
{
if (property.CustomAttributes.Any(t => t.AttributeType == typeof(JsonIgnoreAttribute)))
{
property.SetValue(instance, null);
}
else if (property.CustomAttributes.Any(t => t.AttributeType == typeof(InstanceMakerIgnore)))
{
property.SetValue(instance, null);
}
else if (property.SetMethod != null)
{
property.SetValue(instance, Make(property.PropertyType));
}
}
}
return instance;
}
}
19
Source : DataTableConverter.cs
with MIT License
from akaskela
with MIT License
from akaskela
private static void CreateRow(JsonReader reader, DataTable dt, JsonSerializer serializer)
{
DataRow dr = dt.NewRow();
reader.ReadAndreplacedert();
while (reader.TokenType == JsonToken.PropertyName)
{
string columnName = (string)reader.Value;
reader.ReadAndreplacedert();
DataColumn column = dt.Columns[columnName];
if (column == null)
{
Type columnType = GetColumnDataType(reader);
column = new DataColumn(columnName, columnType);
dt.Columns.Add(column);
}
if (column.DataType == typeof(DataTable))
{
if (reader.TokenType == JsonToken.StartArray)
{
reader.ReadAndreplacedert();
}
DataTable nestedDt = new DataTable();
while (reader.TokenType != JsonToken.EndArray)
{
CreateRow(reader, nestedDt, serializer);
reader.ReadAndreplacedert();
}
dr[columnName] = nestedDt;
}
else if (column.DataType.IsArray && column.DataType != typeof(byte[]))
{
if (reader.TokenType == JsonToken.StartArray)
{
reader.ReadAndreplacedert();
}
List<object> o = new List<object>();
while (reader.TokenType != JsonToken.EndArray)
{
o.Add(reader.Value);
reader.ReadAndreplacedert();
}
Array destinationArray = Array.CreateInstance(column.DataType.GetElementType(), o.Count);
Array.Copy(o.ToArray(), destinationArray, o.Count);
dr[columnName] = destinationArray;
}
else
{
dr[columnName] = (reader.Value != null) ? serializer.Deserialize(reader, column.DataType) : DBNull.Value;
}
reader.ReadAndreplacedert();
}
dr.EndEdit();
dt.Rows.Add(dr);
}
19
Source : DynamicReflectionDelegateFactory.cs
with MIT License
from akaskela
with MIT License
from akaskela
private void GenerateCreateMethodCallIL(MethodBase method, ILGenerator generator, int argsIndex)
{
ParameterInfo[] args = method.GetParameters();
Label argsOk = generator.DefineLabel();
// throw an error if the number of argument values doesn't match method parameters
generator.Emit(OpCodes.Ldarg, argsIndex);
generator.Emit(OpCodes.Ldlen);
generator.Emit(OpCodes.Ldc_I4, args.Length);
generator.Emit(OpCodes.Beq, argsOk);
generator.Emit(OpCodes.Newobj, typeof(TargetParameterCountException).GetConstructor(ReflectionUtils.EmptyTypes));
generator.Emit(OpCodes.Throw);
generator.MarkLabel(argsOk);
if (!method.IsConstructor && !method.IsStatic)
{
generator.PushInstance(method.DeclaringType);
}
int localVariableCount = 0;
for (int i = 0; i < args.Length; i++)
{
ParameterInfo parameter = args[i];
Type parameterType = parameter.ParameterType;
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
LocalBuilder localVariable = generator.DeclareLocal(parameterType);
// don't need to set variable for 'out' parameter
if (!parameter.IsOut)
{
generator.PushArrayInstance(argsIndex, i);
if (parameterType.IsValueType())
{
Label skipSettingDefault = generator.DefineLabel();
Label finishedProcessingParameter = generator.DefineLabel();
// check if parameter is not null
generator.Emit(OpCodes.Brtrue_S, skipSettingDefault);
// parameter has no value, initialize to default
generator.Emit(OpCodes.Ldloca_S, localVariable);
generator.Emit(OpCodes.Initobj, parameterType);
generator.Emit(OpCodes.Br_S, finishedProcessingParameter);
// parameter has value, get value from array again and unbox and set to variable
generator.MarkLabel(skipSettingDefault);
generator.PushArrayInstance(argsIndex, i);
generator.UnboxIfNeeded(parameterType);
generator.Emit(OpCodes.Stloc, localVariableCount);
// parameter finished, we out!
generator.MarkLabel(finishedProcessingParameter);
}
else
{
generator.UnboxIfNeeded(parameterType);
generator.Emit(OpCodes.Stloc, localVariableCount);
}
}
generator.Emit(OpCodes.Ldloca_S, localVariable);
localVariableCount++;
}
else if (parameterType.IsValueType())
{
generator.PushArrayInstance(argsIndex, i);
// have to check that value type parameters aren't null
// otherwise they will error when unboxed
Label skipSettingDefault = generator.DefineLabel();
Label finishedProcessingParameter = generator.DefineLabel();
// check if parameter is not null
generator.Emit(OpCodes.Brtrue_S, skipSettingDefault);
// parameter has no value, initialize to default
LocalBuilder localVariable = generator.DeclareLocal(parameterType);
generator.Emit(OpCodes.Ldloca_S, localVariable);
generator.Emit(OpCodes.Initobj, parameterType);
generator.Emit(OpCodes.Ldloc, localVariableCount);
generator.Emit(OpCodes.Br_S, finishedProcessingParameter);
// parameter has value, get value from array again and unbox
generator.MarkLabel(skipSettingDefault);
generator.PushArrayInstance(argsIndex, i);
generator.UnboxIfNeeded(parameterType);
// parameter finished, we out!
generator.MarkLabel(finishedProcessingParameter);
localVariableCount++;
}
else
{
generator.PushArrayInstance(argsIndex, i);
generator.UnboxIfNeeded(parameterType);
}
}
if (method.IsConstructor)
{
generator.Emit(OpCodes.Newobj, (ConstructorInfo)method);
}
else
{
generator.CallMethod((MethodInfo)method);
}
Type returnType = method.IsConstructor
? method.DeclaringType
: ((MethodInfo)method).ReturnType;
if (returnType != typeof(void))
{
generator.BoxIfNeeded(returnType);
}
else
{
generator.Emit(OpCodes.Ldnull);
}
generator.Return();
}
19
Source : ExpressionReflectionDelegateFactory.cs
with MIT License
from akaskela
with MIT License
from akaskela
private Expression BuildMethodCall(MethodBase method, Type type, ParameterExpression targetParameterExpression, ParameterExpression argsParameterExpression)
{
ParameterInfo[] parametersInfo = method.GetParameters();
Expression[] argsExpression = new Expression[parametersInfo.Length];
IList<ByRefParameter> refParameterMap = new List<ByRefParameter>();
for (int i = 0; i < parametersInfo.Length; i++)
{
ParameterInfo parameter = parametersInfo[i];
Type parameterType = parameter.ParameterType;
bool isByRef = false;
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
isByRef = true;
}
Expression indexExpression = Expression.Constant(i);
Expression paramAccessorExpression = Expression.ArrayIndex(argsParameterExpression, indexExpression);
Expression argExpression;
if (parameterType.IsValueType())
{
BinaryExpression ensureValueTypeNotNull = Expression.Coalesce(paramAccessorExpression, Expression.New(parameterType));
argExpression = EnsureCastExpression(ensureValueTypeNotNull, parameterType);
}
else
{
argExpression = EnsureCastExpression(paramAccessorExpression, parameterType);
}
if (isByRef)
{
ParameterExpression variable = Expression.Variable(parameterType);
refParameterMap.Add(new ByRefParameter
{
Value = argExpression,
Variable = variable,
IsOut = parameter.IsOut
});
argExpression = variable;
}
argsExpression[i] = argExpression;
}
Expression callExpression;
if (method.IsConstructor)
{
callExpression = Expression.New((ConstructorInfo)method, argsExpression);
}
else if (method.IsStatic)
{
callExpression = Expression.Call((MethodInfo)method, argsExpression);
}
else
{
Expression readParameter = EnsureCastExpression(targetParameterExpression, method.DeclaringType);
callExpression = Expression.Call(readParameter, (MethodInfo)method, argsExpression);
}
if (method is MethodInfo)
{
MethodInfo m = (MethodInfo)method;
if (m.ReturnType != typeof(void))
{
callExpression = EnsureCastExpression(callExpression, type);
}
else
{
callExpression = Expression.Block(callExpression, Expression.Constant(null));
}
}
else
{
callExpression = EnsureCastExpression(callExpression, type);
}
if (refParameterMap.Count > 0)
{
IList<ParameterExpression> variableExpressions = new List<ParameterExpression>();
IList<Expression> bodyExpressions = new List<Expression>();
foreach (ByRefParameter p in refParameterMap)
{
if (!p.IsOut)
{
bodyExpressions.Add(Expression.replacedign(p.Variable, p.Value));
}
variableExpressions.Add(p.Variable);
}
bodyExpressions.Add(callExpression);
callExpression = Expression.Block(variableExpressions, bodyExpressions);
}
return callExpression;
}
19
Source : ReflectionUtils.cs
with MIT License
from akaskela
with MIT License
from akaskela
public static Type GetCollectionItemType(Type type)
{
ValidationUtils.ArgumentNotNull(type, nameof(type));
Type genericListType;
if (type.IsArray)
{
return type.GetElementType();
}
if (ImplementsGenericDefinition(type, typeof(IEnumerable<>), out genericListType))
{
if (genericListType.IsGenericTypeDefinition())
{
throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, type));
}
return genericListType.GetGenericArguments()[0];
}
if (typeof(IEnumerable).IsreplacedignableFrom(type))
{
return null;
}
throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, type));
}
19
Source : NodeEditorUtilities.cs
with MIT License
from aksyr
with MIT License
from aksyr
public static string PrettyName(this Type type) {
if (type == null) return "null";
if (type == typeof(System.Object)) return "object";
if (type == typeof(float)) return "float";
else if (type == typeof(int)) return "int";
else if (type == typeof(long)) return "long";
else if (type == typeof(double)) return "double";
else if (type == typeof(string)) return "string";
else if (type == typeof(bool)) return "bool";
else if (type.IsGenericType) {
string s = "";
Type genericType = type.GetGenericTypeDefinition();
if (genericType == typeof(List<>)) s = "List";
else s = type.GetGenericTypeDefinition().ToString();
Type[] types = type.GetGenericArguments();
string[] stypes = new string[types.Length];
for (int i = 0; i < types.Length; i++) {
stypes[i] = types[i].PrettyName();
}
return s + "<" + string.Join(", ", stypes) + ">";
} else if (type.IsArray) {
string rank = "";
for (int i = 1; i < type.GetArrayRank(); i++) {
rank += ",";
}
Type elementType = type.GetElementType();
if (!elementType.IsArray) return elementType.PrettyName() + "[" + rank + "]";
else {
string s = elementType.PrettyName();
int i = s.IndexOf('[');
return s.Substring(0, i) + "[" + rank + "]" + s.Substring(i);
}
} else return type.ToString();
}
19
Source : ProgramArguments.cs
with MIT License
from Alan-FGR
with MIT License
from Alan-FGR
private static Type ElementType(FieldInfo field)
{
if (IsCollectionType(field.FieldType))
return field.FieldType.GetElementType();
else
return null;
}
19
Source : ExpressionVisitor.cs
with MIT License
from albyho
with MIT License
from albyho
protected virtual Expression VisitNewArray(NewArrayExpression na)
{
IEnumerable<Expression> exprs = VisitExpressionList(na.Expressions);
if (exprs != na.Expressions)
{
if (na.NodeType == ExpressionType.NewArrayInit)
{
return Expression.NewArrayInit(na.Type.GetElementType(), exprs);
}
else
{
return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);
}
}
return na;
}
19
Source : JSON.cs
with MIT License
from AlenToma
with MIT License
from AlenToma
public T ToObject<T>(string json)
{
Type t = typeof(T);
var o = ToObject(json, t);
if (t.IsArray)
{
if ((o as ICollection).Count == 0) // edge case for "[]" -> T[]
{
Type tt = t.GetElementType();
object oo = Array.CreateInstance(tt, 0);
return (T)oo;
}
else
return (T)o;
}
else
return (T)o;
}
19
Source : Reflection.cs
with MIT License
from AlenToma
with MIT License
from AlenToma
private myPropInfo CreateMyProp(Type t, string name)
{
myPropInfo d = new myPropInfo();
myPropInfoType d_type = myPropInfoType.Unknown;
if (t == typeof(int) || t == typeof(int?)) d_type = myPropInfoType.Int;
else if (t == typeof(long) || t == typeof(long?)) d_type = myPropInfoType.Long;
else if (t == typeof(string)) d_type = myPropInfoType.String;
else if (t == typeof(bool) || t == typeof(bool?)) d_type = myPropInfoType.Bool;
else if (t == typeof(DateTime) || t == typeof(DateTime?)) d_type = myPropInfoType.DateTime;
else if (t.IsEnum) d_type = myPropInfoType.Enum;
else if (t == typeof(Guid) || t == typeof(Guid?)) d_type = myPropInfoType.Guid;
else if (t == typeof(StringDictionary)) d_type = myPropInfoType.StringDictionary;
else if (t == typeof(NameValueCollection)) d_type = myPropInfoType.NameValue;
else if (t.IsArray)
{
d.bt = t.GetElementType();
if (t == typeof(byte[]))
d_type = myPropInfoType.ByteArray;
else
d_type = myPropInfoType.Array;
}
else if (t.Name.Contains("Dictionary"))
{
d.GenericTypes = Reflection.Instance.GetGenericArguments(t);
if (d.GenericTypes.Length > 0 && d.GenericTypes[0] == typeof(string))
d_type = myPropInfoType.StringKeyDictionary;
else
d_type = myPropInfoType.Dictionary;
}
#if !SILVERLIGHT
else if (t == typeof(Hashtable)) d_type = myPropInfoType.Hashtable;
else if (t == typeof(DataSet)) d_type = myPropInfoType.DataSet;
else if (t == typeof(DataTable)) d_type = myPropInfoType.DataTable;
#endif
else if (IsTypeRegistered(t))
d_type = myPropInfoType.Custom;
if (t.IsValueType && !t.IsPrimitive && !t.IsEnum && t != typeof(decimal))
d.IsStruct = true;
d.IsInterface = t.IsInterface;
d.IsClreplaced = t.IsClreplaced;
d.IsValueType = t.IsValueType;
if (t.IsGenericType)
{
d.IsGenericType = true;
d.bt = Reflection.Instance.GetGenericArguments(t)[0];
}
d.pt = t;
d.Name = name;
d.changeType = GetChangeType(t);
d.Type = d_type;
return d;
}
19
Source : Extension.cs
with MIT License
from AlenToma
with MIT License
from AlenToma
public static Type GetActualType(this Type type)
{
if (CachedActualType.ContainsKey(type))
return CachedActualType[type];
if (type.GetTypeInfo().IsArray)
CachedActualType.TryAdd(type, type.GetElementType());
else if (type.GenericTypeArguments.Any())
CachedActualType.TryAdd(type, type.GenericTypeArguments.First());
else if (type.FullName?.Contains("List`1") ?? false)
CachedActualType.TryAdd(type, type.GetRuntimeProperty("Item").PropertyType);
else
CachedActualType.TryAdd(type, type);
return CachedActualType.Get(type);
}
19
Source : JSON.cs
with MIT License
from AlenToma
with MIT License
from AlenToma
private object CreateArray(List<object> data, Type pt, Type bt, Dictionary<string, object> globalTypes)
{
if (bt == null)
bt = typeof(object);
Array col = Array.CreateInstance(bt, data.Count);
var arraytype = bt.GetElementType();
// create an array of objects
for (int i = 0; i < data.Count; i++)
{
object ob = data[i];
if (ob == null)
{
continue;
}
if (ob is IDictionary)
col.SetValue(ParseDictionary((Dictionary<string, object>)ob, globalTypes, bt, null), i);
else if (ob is ICollection)
col.SetValue(CreateArray((List<object>)ob, bt, arraytype, globalTypes), i);
else
col.SetValue(ChangeType(ob, bt), i);
}
return col;
}
19
Source : JSON.cs
with MIT License
from AlenToma
with MIT License
from AlenToma
private object CreateStringKeyDictionary(Dictionary<string, object> reader, Type pt, Type[] types, Dictionary<string, object> globalTypes)
{
var col = (IDictionary)FastDeepCloner.DeepCloner.CreateInstance(pt);
Type arraytype = null;
Type t2 = null;
if (types != null)
t2 = types[1];
Type generictype = null;
var ga = Reflection.Instance.GetGenericArguments(t2);// t2.GetGenericArguments();
if (ga.Length > 0)
generictype = ga[0];
arraytype = t2.GetElementType();
foreach (KeyValuePair<string, object> values in reader)
{
var key = values.Key;
object val = null;
if (values.Value is Dictionary<string, object>)
val = ParseDictionary((Dictionary<string, object>)values.Value, globalTypes, t2, null);
else if (types != null && t2.IsArray)
{
if (values.Value is Array)
val = values.Value;
else
val = CreateArray((List<object>)values.Value, t2, arraytype, globalTypes);
}
else if (values.Value is IList)
val = CreateGenericList((List<object>)values.Value, t2, generictype, globalTypes);
else
val = ChangeType(values.Value, t2);
col.Add(key, val);
}
return col;
}
19
Source : TypeHelper.cs
with MIT License
from AlenToma
with MIT License
from AlenToma
public static Type FindIEnumerable(Type seqType)
{
if (seqType == null || seqType == typeof(string))
return null;
if (seqType.IsArray)
return typeof(IEnumerable<>).MakeGenericType(seqType.GetElementType());
if (seqType.IsGenericType)
{
foreach (Type arg in seqType.GetGenericArguments())
{
Type ienum = typeof(IEnumerable<>).MakeGenericType(arg);
if (ienum.IsreplacedignableFrom(seqType))
{
return ienum;
}
}
}
Type[] ifaces = seqType.GetInterfaces();
if (ifaces != null && ifaces.Length > 0)
{
foreach (Type iface in ifaces)
{
Type ienum = FindIEnumerable(iface);
if (ienum != null) return ienum;
}
}
if (seqType.BaseType != null && seqType.BaseType != typeof(object))
{
return FindIEnumerable(seqType.BaseType);
}
return null;
}
19
Source : Reflection.cs
with MIT License
from alfa-laboratory
with MIT License
from alfa-laboratory
public static Type GetObjectType(this object obj, bool checkElementType = false)
{
Type t;
switch(obj)
{
case null:
return null;
case Type type:
t = type;
break;
case ParameterInfo info:
t = info.ParameterType;
break;
case PropertyInfo info:
t = info.PropertyType;
break;
case FieldInfo info:
t = info.FieldType;
break;
default:
t = obj.GetType();
break;
}
if(checkElementType && t.HasElementType)
{
t = t.GetElementType();
}
t = Nullable.GetUnderlyingType(t) ?? t;
return t;
}
19
Source : Reflection.cs
with MIT License
from alfa-laboratory
with MIT License
from alfa-laboratory
public static object ConvertObject(object obj, Type type)
{
var t = GetObjectType(type);
if(obj == null)
{
return GetDefault(t);
}
if(t.IsEnum)
{
obj = Enum.Parse(t, obj is string value ? value : obj.ToString(), false);
}
if(t == typeof(string))
{
if(obj is string convertObject)
{
return convertObject;
}
var mi = obj.GetType().GetMethods().SingleOrDefault(m => m.Name == "ToString" && !m.GetMethodParameters().Any());
return mi?.Invoke(obj, Array.Empty<object>());
}
if((obj is string s) && t == typeof(char[]))
{
return s.Split();
}
if(t.IsArray)
{
if(obj is Array arrSrc)
{
var arrDest = (Array)CreateArray(t.GetElementType(), arrSrc.Length);
Array.Copy(arrSrc, arrDest, arrSrc.Length);
return arrDest;
}
}
if(t == typeof(object))
{
return obj;
}
if(obj is not string o)
{
return Convert.ChangeType(obj, t);
}
if(t == typeof(bool))
{
if(short.TryParse(o, out var i))
{
return i != 0;
}
return bool.Parse(o);
}
if(t == typeof(decimal) || t == typeof(float))
{
var types = new[] { typeof(string), typeof(NumberStyles), typeof(IFormatProvider), t.MakeByRefType() };
var args = new[] { o, NumberStyles.Any, new NumberFormatInfo { NumberDecimalSeparator = "," }, GetDefault(t) };
if((bool)t.GetMethod("TryParse", types)?.Invoke(null, args)!)
{
return args[3];
}
types = new[] { typeof(string), typeof(NumberStyles), typeof(IFormatProvider) };
args = new object[] { o, NumberStyles.Any, new NumberFormatInfo { NumberDecimalSeparator = "." } };
return t.GetMethod("Parse", types)?.Invoke(null, args);
}
if(t == typeof(long)
|| t == typeof(ulong)
|| t == typeof(int)
|| t == typeof(uint)
|| t == typeof(short)
|| t == typeof(ushort)
|| t == typeof(byte)
|| t == typeof(sbyte)
|| t == typeof(char))
{
return t.GetMethod("Parse", new[] { typeof(string) })?.Invoke(null, new object[] {o});
}
if(t == typeof(DateTime))
{
return DateTime.TryParse(o, CultureInfo.GetCultureInfo("ru-RU"), DateTimeStyles.replacedumeLocal, out var dt) ? dt : DateTime.Parse(o, CultureInfo.GetCultureInfo("en-US"), DateTimeStyles.replacedumeLocal);
}
return Convert.ChangeType(o, t);
}
19
Source : TypeExtensions.cs
with MIT License
from aliencube
with MIT License
from aliencube
public static Type GetOpenApiSubType(this Type type)
{
if (type.IsDictionaryType())
{
return type.GetGenericArguments()[1];
}
if (type.BaseType == typeof(Array))
{
return type.GetElementType();
}
if (type.IsArrayType())
{
return type.GetGenericArguments()[0];
}
return null;
}
19
Source : TypeExtensions.cs
with MIT License
from aliencube
with MIT License
from aliencube
public static string GetOpenApiSubTypeName(this Type type, NamingStrategy namingStrategy = null)
{
if (namingStrategy.IsNullOrDefault())
{
namingStrategy = new DefaultNamingStrategy();
}
if (type.IsDictionaryType())
{
var name = type.GetGenericArguments()[1].Name;
return namingStrategy.GetPropertyName(name, hreplacedpecifiedName: false);
}
if (type.BaseType == typeof(Array))
{
var name = type.GetElementType().Name;
return namingStrategy.GetPropertyName(name, hreplacedpecifiedName: false);
}
if (type.IsArrayType())
{
var name = type.GetGenericArguments()[0].Name;
return namingStrategy.GetPropertyName(name, hreplacedpecifiedName: false);
}
return null;
}
19
Source : OpenApiSchemaExtensions.cs
with MIT License
from aliencube
with MIT License
from aliencube
[Obsolete("This method is now obsolete", error: true)]
public static Dictionary<string, OpenApiSchema> ToOpenApiSchemas(this Type type, NamingStrategy namingStrategy, OpenApiSchemaVisibilityAttribute attribute = null, bool returnSingleSchema = false, int depth = 0)
{
type.ThrowIfNullOrDefault();
var schema = (OpenApiSchema)null;
var schemeName = type.GetOpenApiTypeName(namingStrategy);
if (depth == 8)
{
schema = new OpenApiSchema()
{
Type = type.ToDataType(),
Format = type.ToDataFormat()
};
return new Dictionary<string, OpenApiSchema>() { { schemeName, schema } };
}
depth++;
if (type.IsJObjectType())
{
schema = typeof(object).ToOpenApiSchemas(namingStrategy, null, true, depth).Single().Value;
return new Dictionary<string, OpenApiSchema>() { { schemeName, schema } };
}
if (type.IsOpenApiNullable(out var unwrappedValueType))
{
schema = unwrappedValueType.ToOpenApiSchemas(namingStrategy, null, true, depth).Single().Value;
schema.Nullable = true;
return new Dictionary<string, OpenApiSchema>() { { schemeName, schema } };
}
schema = new OpenApiSchema()
{
Type = type.ToDataType(),
Format = type.ToDataFormat()
};
if (!attribute.IsNullOrDefault())
{
var visibility = new OpenApiString(attribute.Visibility.ToDisplayName());
schema.Extensions.Add("x-ms-visibility", visibility);
}
if (type.IsUnflaggedEnumType())
{
var converterAttribute = type.GetCustomAttribute<JsonConverterAttribute>();
if (!converterAttribute.IsNullOrDefault()
&& typeof(StringEnumConverter).IsreplacedignableFrom(converterAttribute.ConverterType))
{
var enums = type.ToOpenApiStringCollection(namingStrategy);
schema.Type = "string";
schema.Format = null;
schema.Enum = enums;
schema.Default = enums.First();
}
else
{
var enums = type.ToOpenApiIntegerCollection();
schema.Enum = enums;
schema.Default = enums.First();
}
}
if (type.IsSimpleType())
{
return new Dictionary<string, OpenApiSchema>() { { schemeName, schema } };
}
if (type.IsOpenApiDictionary())
{
schema.AdditionalProperties = type.GetGenericArguments()[1].ToOpenApiSchemas(namingStrategy, null, true, depth).Single().Value;
return new Dictionary<string, OpenApiSchema>() { { schemeName, schema } };
}
if (type.IsOpenApiArray())
{
schema.Type = "array";
schema.Items = (type.GetElementType() ?? type.GetGenericArguments()[0]).ToOpenApiSchemas(namingStrategy, null, true, depth).Single().Value;
return new Dictionary<string, OpenApiSchema>() { { schemeName, schema } };
}
var allProperties = type.IsInterface
? new[] { type }.Concat(type.GetInterfaces()).SelectMany(i => i.GetProperties())
: type.GetProperties();
var properties = allProperties.Where(p => !p.ExistsCustomAttribute<JsonIgnoreAttribute>());
var retVal = new Dictionary<string, OpenApiSchema>();
foreach (var property in properties)
{
var visiblity = property.GetCustomAttribute<OpenApiSchemaVisibilityAttribute>(inherit: false);
var propertyName = property.GetJsonPropertyName(namingStrategy);
var ts = property.DeclaringType.GetGenericArguments();
if (!ts.Any())
{
if (property.PropertyType.IsUnflaggedEnumType() && !returnSingleSchema)
{
var recur1 = property.PropertyType.ToOpenApiSchemas(namingStrategy, visiblity, false, depth);
retVal.AddRange(recur1);
var enumReference = new OpenApiReference()
{
Type = ReferenceType.Schema,
Id = property.PropertyType.GetOpenApiReferenceId(false, false)
};
var schema1 = new OpenApiSchema() { Reference = enumReference };
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = schema1;
}
else if (property.PropertyType.IsSimpleType() || Nullable.GetUnderlyingType(property.PropertyType) != null || returnSingleSchema)
{
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = property.PropertyType.ToOpenApiSchemas(namingStrategy, visiblity, true, depth).Single().Value;
}
else if (property.PropertyType.IsOpenApiDictionary())
{
var elementType = property.PropertyType.GetGenericArguments()[1];
if (elementType.IsSimpleType() || elementType.IsOpenApiDictionary() || elementType.IsOpenApiArray())
{
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = property.PropertyType.ToOpenApiSchemas(namingStrategy, visiblity, true, depth).Single().Value;
}
else
{
var recur1 = elementType.ToOpenApiSchemas(namingStrategy, visiblity, false, depth);
retVal.AddRange(recur1);
var elementReference = new OpenApiReference()
{
Type = ReferenceType.Schema,
Id = elementType.GetOpenApiReferenceId(false, false)
};
var dictionarySchema = new OpenApiSchema()
{
Type = "object",
AdditionalProperties = new OpenApiSchema() { Reference = elementReference }
};
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = dictionarySchema;
}
}
else if (property.PropertyType.IsOpenApiArray())
{
var elementType = property.PropertyType.GetElementType() ?? property.PropertyType.GetGenericArguments()[0];
if (elementType.IsSimpleType() || elementType.IsOpenApiDictionary() || elementType.IsOpenApiArray())
{
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = property.PropertyType.ToOpenApiSchemas(namingStrategy, visiblity, true, depth).Single().Value;
}
else
{
var elementReference = elementType.ToOpenApiSchemas(namingStrategy, visiblity, false, depth);
retVal.AddRange(elementReference);
var reference1 = new OpenApiReference()
{
Type = ReferenceType.Schema,
Id = elementType.GetOpenApiReferenceId(false, false)
};
var arraySchema = new OpenApiSchema()
{
Type = "array",
Items = new OpenApiSchema()
{
Reference = reference1
}
};
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = arraySchema;
}
}
else
{
var recur1 = property.PropertyType.ToOpenApiSchemas(namingStrategy, visiblity, false, depth);
retVal.AddRange(recur1);
var reference1 = new OpenApiReference()
{
Type = ReferenceType.Schema,
Id = property.PropertyType.GetOpenApiReferenceId(false, false)
};
var schema1 = new OpenApiSchema() { Reference = reference1 };
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = schema1;
}
continue;
}
var reference = new OpenApiReference()
{
Type = ReferenceType.Schema,
Id = property.PropertyType.GetOpenApiRootReferenceId()
};
var referenceSchema = new OpenApiSchema() { Reference = reference };
if (!ts.Contains(property.PropertyType))
{
if (property.PropertyType.IsOpenApiDictionary())
{
reference.Id = property.PropertyType.GetOpenApiReferenceId(true, false);
var dictionarySchema = new OpenApiSchema()
{
Type = "object",
AdditionalProperties = referenceSchema
};
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = dictionarySchema;
continue;
}
if (property.PropertyType.IsOpenApiArray())
{
reference.Id = property.PropertyType.GetOpenApiReferenceId(false, true);
var arraySchema = new OpenApiSchema()
{
Type = "array",
Items = referenceSchema
};
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = arraySchema;
continue;
}
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = property.PropertyType.ToOpenApiSchemas(namingStrategy, visiblity, true, depth).Single().Value;
continue;
}
schema.Properties[namingStrategy.GetPropertyName(propertyName, false)] = referenceSchema;
}
retVal[schemeName] = schema;
return retVal;
}
19
Source : TypeExtensions.cs
with MIT License
from aliencube
with MIT License
from aliencube
public static Type GetUnderlyingType(this Type type)
{
var underlyingType = default(Type);
if (type.IsOpenApiNullable(out var nullableUnderlyingType))
{
underlyingType = nullableUnderlyingType;
}
if (type.IsOpenApiArray())
{
underlyingType = type.GetElementType() ?? type.GetGenericArguments()[0];
}
if (type.IsOpenApiDictionary())
{
underlyingType = type.GetGenericArguments()[1];
}
if (underlyingType.IsNullOrDefault())
{
return underlyingType;
}
if (underlyingType.IsGenericType)
{
var underlyingTypeOfUnderlyingType = underlyingType.GetUnderlyingType();
underlyingType = underlyingTypeOfUnderlyingType;
}
return underlyingType;
}
19
Source : DynamicGenericResolver.cs
with Apache License 2.0
from allenai
with Apache License 2.0
from allenai
internal static object GetFormatter(Type t)
{
TypeInfo ti = t.GetTypeInfo();
if (t.IsArray)
{
var rank = t.GetArrayRank();
if (rank == 1)
{
if (t.GetElementType() == typeof(byte))
{
// byte[] is also supported in builtin formatter.
return ByteArrayFormatter.Instance;
}
return Activator.CreateInstance(typeof(ArrayFormatter<>).MakeGenericType(t.GetElementType()));
}
else if (rank == 2)
{
return Activator.CreateInstance(typeof(TwoDimensionalArrayFormatter<>).MakeGenericType(t.GetElementType()));
}
else if (rank == 3)
{
return Activator.CreateInstance(typeof(ThreeDimensionalArrayFormatter<>).MakeGenericType(t.GetElementType()));
}
else if (rank == 4)
{
return Activator.CreateInstance(typeof(FourDimensionalArrayFormatter<>).MakeGenericType(t.GetElementType()));
}
else
{
return null; // not supported built-in
}
}
else if (ti.IsGenericType)
{
Type genericType = ti.GetGenericTypeDefinition();
TypeInfo genericTypeInfo = genericType.GetTypeInfo();
var isNullable = genericTypeInfo.IsNullable();
Type nullableElementType = isNullable ? ti.GenericTypeArguments[0] : null;
if (genericType == typeof(KeyValuePair<,>))
{
return CreateInstance(typeof(KeyValuePairFormatter<,>), ti.GenericTypeArguments);
}
// Tuple
else if (ti.FullName.StartsWith("System.Tuple"))
{
Type tupleFormatterType = null;
switch (ti.GenericTypeArguments.Length)
{
case 1:
tupleFormatterType = typeof(TupleFormatter<>);
break;
case 2:
tupleFormatterType = typeof(TupleFormatter<,>);
break;
case 3:
tupleFormatterType = typeof(TupleFormatter<,,>);
break;
case 4:
tupleFormatterType = typeof(TupleFormatter<,,,>);
break;
case 5:
tupleFormatterType = typeof(TupleFormatter<,,,,>);
break;
case 6:
tupleFormatterType = typeof(TupleFormatter<,,,,,>);
break;
case 7:
tupleFormatterType = typeof(TupleFormatter<,,,,,,>);
break;
case 8:
tupleFormatterType = typeof(TupleFormatter<,,,,,,,>);
break;
default:
break;
}
return CreateInstance(tupleFormatterType, ti.GenericTypeArguments);
}
// ValueTuple
else if (ti.FullName.StartsWith("System.ValueTuple"))
{
Type tupleFormatterType = null;
switch (ti.GenericTypeArguments.Length)
{
case 1:
tupleFormatterType = typeof(ValueTupleFormatter<>);
break;
case 2:
tupleFormatterType = typeof(ValueTupleFormatter<,>);
break;
case 3:
tupleFormatterType = typeof(ValueTupleFormatter<,,>);
break;
case 4:
tupleFormatterType = typeof(ValueTupleFormatter<,,,>);
break;
case 5:
tupleFormatterType = typeof(ValueTupleFormatter<,,,,>);
break;
case 6:
tupleFormatterType = typeof(ValueTupleFormatter<,,,,,>);
break;
case 7:
tupleFormatterType = typeof(ValueTupleFormatter<,,,,,,>);
break;
case 8:
tupleFormatterType = typeof(ValueTupleFormatter<,,,,,,,>);
break;
default:
break;
}
return CreateInstance(tupleFormatterType, ti.GenericTypeArguments);
}
// ArraySegment
else if (genericType == typeof(ArraySegment<>))
{
if (ti.GenericTypeArguments[0] == typeof(byte))
{
return ByteArraySegmentFormatter.Instance;
}
else
{
return CreateInstance(typeof(ArraySegmentFormatter<>), ti.GenericTypeArguments);
}
}
// Memory
else if (genericType == typeof(Memory<>))
{
if (ti.GenericTypeArguments[0] == typeof(byte))
{
return ByteMemoryFormatter.Instance;
}
else
{
return CreateInstance(typeof(MemoryFormatter<>), ti.GenericTypeArguments);
}
}
// ReadOnlyMemory
else if (genericType == typeof(ReadOnlyMemory<>))
{
if (ti.GenericTypeArguments[0] == typeof(byte))
{
return ByteReadOnlyMemoryFormatter.Instance;
}
else
{
return CreateInstance(typeof(ReadOnlyMemoryFormatter<>), ti.GenericTypeArguments);
}
}
// ReadOnlySequence
else if (genericType == typeof(ReadOnlySequence<>))
{
if (ti.GenericTypeArguments[0] == typeof(byte))
{
return ByteReadOnlySequenceFormatter.Instance;
}
else
{
return CreateInstance(typeof(ReadOnlySequenceFormatter<>), ti.GenericTypeArguments);
}
}
// Standard Nullable
else if (isNullable)
{
return CreateInstance(typeof(NullableFormatter<>), new[] { nullableElementType });
}
// Mapped formatter
else
{
Type formatterType;
if (FormatterMap.TryGetValue(genericType, out formatterType))
{
return CreateInstance(formatterType, ti.GenericTypeArguments);
}
}
}
else if (ti.IsEnum)
{
return CreateInstance(typeof(GenericEnumFormatter<>), new[] { t });
}
else
{
// NonGeneric Collection
if (t == typeof(IEnumerable))
{
return NonGenericInterfaceEnumerableFormatter.Instance;
}
else if (t == typeof(ICollection))
{
return NonGenericInterfaceCollectionFormatter.Instance;
}
else if (t == typeof(IList))
{
return NonGenericInterfaceListFormatter.Instance;
}
else if (t == typeof(IDictionary))
{
return NonGenericInterfaceDictionaryFormatter.Instance;
}
if (typeof(IList).GetTypeInfo().IsreplacedignableFrom(ti) && ti.DeclaredConstructors.Any(x => x.GetParameters().Length == 0))
{
return Activator.CreateInstance(typeof(NonGenericListFormatter<>).MakeGenericType(t));
}
else if (typeof(IDictionary).GetTypeInfo().IsreplacedignableFrom(ti) && ti.DeclaredConstructors.Any(x => x.GetParameters().Length == 0))
{
return Activator.CreateInstance(typeof(NonGenericDictionaryFormatter<>).MakeGenericType(t));
}
}
// check inherited types(e.g. Foo : ICollection<>, Bar<T> : ICollection<T>)
{
// generic dictionary
var dictionaryDef = ti.ImplementedInterfaces.FirstOrDefault(x => x.GetTypeInfo().IsConstructedGenericType() && x.GetGenericTypeDefinition() == typeof(IDictionary<,>));
if (dictionaryDef != null && ti.DeclaredConstructors.Any(x => x.GetParameters().Length == 0))
{
Type keyType = dictionaryDef.GenericTypeArguments[0];
Type valueType = dictionaryDef.GenericTypeArguments[1];
return CreateInstance(typeof(GenericDictionaryFormatter<,,>), new[] { keyType, valueType, t });
}
// generic collection
var collectionDef = ti.ImplementedInterfaces.FirstOrDefault(x => x.GetTypeInfo().IsConstructedGenericType() && x.GetGenericTypeDefinition() == typeof(ICollection<>));
if (collectionDef != null && ti.DeclaredConstructors.Any(x => x.GetParameters().Length == 0))
{
Type elemType = collectionDef.GenericTypeArguments[0];
return CreateInstance(typeof(GenericCollectionFormatter<,>), new[] { elemType, t });
}
}
return null;
}
19
Source : TypeExtensions.cs
with MIT License
from allisterb
with MIT License
from allisterb
public static bool IsNullable(this Type type)
{
while (type.IsArray)
type = type.GetElementType();
return (type.IsGenericType && type.GetGenericTypeDefinition() == typeof (Nullable<>));
}
19
Source : DynamoDbContextMetadata.cs
with MIT License
from AllocZero
with MIT License
from AllocZero
private DdbConverter GetOrAddKnownConverter(Type propertyType, Type converterType)
{
if (!converterType.IsGenericTypeDefinition)
return _factoryConvertersCache.GetOrAdd(converterType, CreateConverter);
var arguments = propertyType.IsArray ? new [] {propertyType.GetElementType()!} : propertyType.GenericTypeArguments;
var fullConverterType = converterType.MakeGenericType(arguments);
return _factoryConvertersCache.GetOrAdd(fullConverterType, CreateConverter);
}
19
Source : ArrayDdbConverter.cs
with MIT License
from AllocZero
with MIT License
from AllocZero
public override DdbConverter CreateConverter(Type typeToConvert, DynamoDbContextMetadata metadata)
{
var elementType = typeToConvert.GetElementType()!;
var converterType = typeof(ArrayDdbConverter<>).MakeGenericType(elementType);
return (DdbConverter) Activator.CreateInstance(converterType, metadata.GetOrAddConverter(elementType, null))!;
}
19
Source : BinaryDdbConverter.cs
with MIT License
from AllocZero
with MIT License
from AllocZero
public override bool CanConvert(Type typeToConvert) => typeToConvert.IsArray && typeToConvert.GetElementType() == typeof(byte);
19
Source : RowValidator.cs
with MIT License
from aloneguid
with MIT License
from aloneguid
private static void ValidatePrimitive(DataField df, object value)
{
if(value == null)
{
if (!df.HasNulls)
throw new ArgumentException($"element is null but column '{df.Name}' does not accept nulls");
}
else
{
Type vt = value.GetType();
Type st = df.ClrType;
if (vt.IsNullable())
vt = vt.GetNonNullable();
if(df.IsArray)
{
if(!vt.IsArray)
{
throw new ArgumentException($"expected array but found {vt}");
}
if(vt.GetElementType() != st)
{
throw new ArgumentException($"expected array element type {st} but found {vt.GetElementType()}");
}
}
else
{
if (vt != st)
throw new ArgumentException($"expected {st} but found {vt}");
}
}
}
19
Source : DataColumn.cs
with MIT License
from aloneguid
with MIT License
from aloneguid
internal ArrayView PackDefinitions(int maxDefinitionLevel, out int[] pooledDefinitionLevels, out int definitionLevelCount, out int nullCount)
{
pooledDefinitionLevels = ArrayPool<int>.Shared.Rent(Data.Length);
definitionLevelCount = Data.Length;
bool isNullable = Field.ClrType.IsNullable() || Data.GetType().GetElementType().IsNullable();
if (!Field.HasNulls || !isNullable)
{
SetPooledDefinitionLevels(maxDefinitionLevel, pooledDefinitionLevels);
nullCount = 0; //definitely no nulls here
return new ArrayView(Data);
}
return _dataTypeHandler.PackDefinitions(Data, maxDefinitionLevel, out pooledDefinitionLevels, out definitionLevelCount, out nullCount);
}
19
Source : TypeExtensions.cs
with MIT License
from aloneguid
with MIT License
from aloneguid
public static bool TryExtractEnumerableType(this Type t, out Type baseType)
{
if(typeof(byte[]) == t)
{
//it's a special case to avoid confustion between byte arrays and repeatable bytes
baseType = null;
return false;
}
TypeInfo ti = t.GetTypeInfo();
Type[] args = ti.GenericTypeArguments;
if (args.Length == 1)
{
//check derived interfaces
foreach (Type interfaceType in ti.ImplementedInterfaces)
{
TypeInfo iti = interfaceType.GetTypeInfo();
if (iti.IsGenericType && iti.GetGenericTypeDefinition() == typeof(IEnumerable<>))
{
baseType = ti.GenericTypeArguments[0];
return true;
}
}
//check if this is an IEnumerable<>
if (ti.IsGenericType && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>))
{
baseType = ti.GenericTypeArguments[0];
return true;
}
}
if(ti.IsArray)
{
baseType = ti.GetElementType();
return true;
}
baseType = null;
return false;
}
See More Examples