//============================================================ // 変換処理 //============================================================ public ScriptObject ToScriptObject(object value) { if (value == null) { return(new ScriptObject(this, null)); } IWrapper wrapper = value as IWrapper; if (wrapper != null) { value = wrapper.Value; } System.Type t = value.GetType(); if (t.IsArray && t.GetArrayRank() == 1) { value = ArrayFromClr((object[])value); } else if (value is System.Delegate) { System.Delegate dlg = (System.Delegate)value; ScriptObject ret; if (!funcs.TryGetValue(dlg, out ret)) { ret = new ScriptObject(this, this.exec(@"var ret=function(){return " + ROOT + @".InvokeD(args[0],arguments);}; ret.toString=function(){return 'function " + dlg.Method.Name + @"(){\r\n\t[native code]\r\n}';}; return ret;", dlg)); funcs.Add(dlg, ret); } return(ret); } return(new ScriptObject(this, value)); }
public static TypeSyntax Create(System.Type type) { if (type is null) { return(null); } TypeSyntax value; if (type.IsArray) { value = new ArrayTypeSyntax(Create(type.GetElementType()), type.GetArrayRank()); } else if (type.IsGenericType) { var types = type.GetGenericArguments(); NodeList <TypeSyntax> typeNodes = new NodeList <TypeSyntax>(types.Length); foreach (var arg in types) { typeNodes.Add(Create(arg)); } value = new RefTypeSyntax(type.FullName, typeNodes); } else { value = new RefTypeSyntax(type.FullName); } value.Type = type; return(value); }
private void InternalAppend(System.Type itemType, System.Object item) { if (itemType.IsPrimitive || itemType.IsEnum || itemType == typeof(string)) { Append(item.ToString()); return; } if (itemType.IsSubclassOf(typeof(UnityEngine.Object))) { var unityObject = item as UnityEngine.Object; Append((unityObject != null) ? unityObject.name : ""); return; } if (itemType.IsArray) { var array = item as System.Array; if (array == null || itemType.GetArrayRank() > 1) { Append("0"); } else { var objectList = new List <System.Object>(); foreach (var subItem in array) { if (subItem != null) { objectList.Add(subItem); } } Append(objectList.Count.ToString()); foreach (var subItem in objectList) { InternalAppend(itemType.GetElementType(), subItem); } } return; } var bindingFlags = BindingFlags.Instance | BindingFlags.Public; var members = itemType.GetFields(bindingFlags); foreach (var member in members) { InternalAppend(member.FieldType, member.GetValue(item)); } }
private static object CopyArray(List <object> items, System.Type arrayType, ArrayList counts) { if (arrayType.IsArray) { if (arrayType.GetArrayRank() == 2) { int rank0 = int.Parse(counts[0].ToString()); int rank1 = int.Parse(counts[1].ToString()); System.Array list = System.Array.CreateInstance(arrayType.GetElementType(), rank0, rank1); int size = rank0 * rank1; if (size != items.Count) { EB.Debug.Log("Bad!!! size= " + size + " count=" + items.Count); } int x = 0; int y = 0; for (int i = 0; i < items.Count; ++i) { list.SetValue(items[i], x, y); ++y; if (y == rank1) { y = 0; ++x; } } return(list); } else { System.Array list = System.Array.CreateInstance(arrayType.GetElementType(), items.Count); System.Array.Copy(items.ToArray(), list, items.Count); return(list); } } else { IList list = (IList)System.Activator.CreateInstance(arrayType); foreach (object item in items) { list.Add(item); } return(list); } }
/// <summary> /// System.Type を表す文字列を C# 形式で取得します。 /// </summary> /// <param name="t">文字列に直す前の System.Type を指定します。</param> /// <returns>System.Type を文字列で表した物を取得します。</returns> public static string CSharpName(System.Type t) { if (t.IsArray) { return(CSharpName(t.GetElementType()) + "[" + new string(',', t.GetArrayRank() - 1) + "]"); } if (t.IsPointer) { return(CSharpName(t.GetElementType()) + "*"); } if (t.IsByRef) { return(CSharpName(t.GetElementType()) + "&"); } if (t.IsGenericType) { if (t.GetGenericTypeDefinition() == typeof(System.Nullable <>)) { return(CSharpName(t.GetGenericArguments()[0]) + "?"); } string temp = CSharpName_gen(t); System.Type[] args = t.GetGenericArguments(); int i = 0; return(CSharpName_rxGen.Replace(temp, delegate(Rgx::Match m){ int M = int.Parse(m.Groups[1].Value); if (M == 0 || i + M > args.Length) { return m.Value; } string ret = CSharpName(args[i++]); for (int j = 1; j < M; j++) { ret += "," + CSharpName(args[i++]); } return "<" + ret + ">"; })); } if (t.IsGenericParameter) { return(t.Name); } switch (GetTypeCode(t)) { case TypeCodes.Void: return("void"); case TypeCodes.SByte: return("sbyte"); case TypeCodes.Byte: return("byte"); case TypeCodes.Short: return("short"); case TypeCodes.UShort: return("ushort"); case TypeCodes.Int: return("int"); case TypeCodes.UInt: return("uint"); case TypeCodes.Long: return("long"); case TypeCodes.ULong: return("ulong"); case TypeCodes.Float: return("float"); case TypeCodes.Double: return("double"); case TypeCodes.Decimal: return("decimal"); case TypeCodes.Char: return("char"); case TypeCodes.Bool: return("bool"); case TypeCodes.String: return("string"); case TypeCodes.Object: return("object"); default: return(t.FullName); } }
static void GetClassName(System.Type type, out string clsName, out string realClsName, out bool isByRef, bool simpleClassName = false) { isByRef = type.IsByRef; if (isByRef) { type = type.GetElementType(); } bool isArray = type.IsArray; int arrayCount = 1; if (isArray) { arrayCount = type.GetArrayRank(); type = type.GetElementType(); } string realNamespace = null; bool isNestedGeneric = false; if (type.IsNested) { string bClsName, bRealClsName; bool tmp; var rt = type.ReflectedType; if (rt.IsGenericType && rt.IsGenericTypeDefinition) { if (type.IsGenericType) { rt = rt.MakeGenericType(type.GetGenericArguments()); isNestedGeneric = true; } } if (rt == type) { wxb.L.LogErrorFormat("type:{0} -> {1}", type.Name, rt.Name); } GetClassName(rt, out bClsName, out bRealClsName, out tmp); clsName = simpleClassName ? "" : bClsName + "_"; realNamespace = bRealClsName + "."; } else { clsName = simpleClassName ? "" : (!string.IsNullOrEmpty(type.Namespace) ? type.Namespace.Replace(".", "_") + "_" : ""); realNamespace = !string.IsNullOrEmpty(type.Namespace) ? type.Namespace + "." : null; } clsName = clsName + type.Name.Replace(".", "_").Replace("`", "_").Replace("<", "_").Replace(">", "_"); bool isGeneric = false; string ga = null; if (type.IsGenericType && !isNestedGeneric) { isGeneric = true; clsName += "_"; ga = "<"; var args = type.GetGenericArguments(); bool first = true; foreach (var j in args) { if (first) { first = false; } else { clsName += "_"; ga += ", "; } string a, b; bool tmp; if (type == j) { wxb.L.LogErrorFormat("type:{0} -> {1}", type.Name, j.Name); } GetClassName(j, out a, out b, out tmp, true); clsName += a; ga += b; } ga += ">"; } if (!simpleClassName) { clsName += "_Binding"; } if (isArray) { clsName += "_Array"; } realClsName = realNamespace; if (isGeneric) { int idx = type.Name.IndexOf("`"); if (idx > 0) { realClsName += type.Name.Substring(0, idx); realClsName += ga; } else { realClsName += type.Name; } } else { realClsName += type.Name; } if (isArray) { if (arrayCount == 1) { realClsName += "[]"; } else { realClsName += "["; for (int i = 1; i < arrayCount; ++i) { realClsName += ","; } realClsName += "]"; } } }
public int GetArrayRank() => t.GetArrayRank();
public bool IsValid(System.Type type) { return(type.IsArray == true && type.GetArrayRank() == 1); }