/// <summary> 从指定的 Type 创建新的 JsonType 对象,该方法必须保证类型公开的构造函数有且只有一个
/// </summary>
public JsonType(Type type)
: this(type, 0)
{
_ctor = Literacy.CreateNewObject(type);
if (_ctor == null)
{
if (TypeInfo.IsSpecialType)
{
return;
}
var ctors = type.GetConstructors();
switch (ctors.Length)
{
case 0:
_ctor = args => {
throw new TypeInitializationException(TypesHelper.DisplayName(type),
new MissingMethodException("当前类型没有构造函数"));
};
break;
case 1:
_ctor = Literacy.CreateNewObject(ctors[0]);
break;
default:
_ctor = args => {
throw new TypeInitializationException(TypesHelper.DisplayName(type),
new MethodAccessException("构造函数调用不明确"));
};
break;
}
}
}
internal Literacy(TypeInfo info, bool ignoreCase)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
TypeInfo = info;
Type = info.Type;
_CallNewObject = PreNewObject;
Property = new ObjectPropertyCollection(ignoreCase);
foreach (var p in Type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (p.GetIndexParameters().Length == 0) //排除索引器
{
if (!Property.ContainsKey(p.Name))
{
var a = new ObjectProperty(p);
Property.Add(a);
}
}
}
ID = Interlocked.Increment(ref Sequence);
UID = Guid.NewGuid();
TypeCodes = info.TypeCodes;
}
/// <summary>
/// </summary>
/// <param name="args"></param>
private object PreNewObject(params object[] args)
{
var call = CreateNewObject(Type);
if (call != null)
{
_ctorArgs = new object[0];
_CallNewObject = call;
return(call());
}
if (Type.Name.StartsWith("<>f__AnonymousType")) //匿名类
{
var ctor = Type.GetConstructors()[0];
if (ctor != null)
{
var ps = ctor.GetParameters();
args = new object[ps.Length];
for (int i = 0; i < ps.Length; i++)
{
var type = ps[i].ParameterType;
if (type.IsValueType)
{
args[i] = Activator.CreateInstance(type);
}
}
call = CreateNewObject(ctor);
_ctorArgs = args;
return(call(args));
}
}
_ctorArgs = new object[0];
_CallNewObject = ErrorNewObject;
return(_CallNewObject());
}
public ConstructorInfoEx(ConstructorInfo constructor)
{
if (constructor == null)
{
throw new ArgumentNullException("constructor");
}
_Constructor = constructor;
_New = Literacy.CreateNewObject(constructor);
}
object PreNewObject(params object[] args)
{
_CallNewObject = CreateNewObject(_Type);
if (_CallNewObject == null)
{
_CallNewObject = ErrorNewObject;
}
return(_CallNewObject());
}
/// <summary> 从指定的 Type 创建新的 JsonType 对象,并指定构造函数
/// </summary>
public JsonType(Type type, ConstructorInfo ctor)
: this(type, 1)
{
if (ctor == null && TypeInfo.IsSpecialType)
{
return;
}
AreNull(ctor, "ctor");
AreTrue(type == ctor.ReflectedType, "ctor不属于当前类型");
_ctor = Literacy.CreateNewObject(ctor);
}
/// <summary> 从指定的 Type 创建新的 JsonType 对象,并指定构造函数的参数
/// </summary>
public JsonType(Type type, Type[] ctorArgsType)
: this(type, 2)
{
_ctor = Literacy.CreateNewObject(type, ctorArgsType);
if (_ctor == null && TypeInfo.IsSpecialType)
{
return;
}
else
{
throw new ArgumentException("没有找到符合条件的构造函数");
}
}
/// <summary> 初始化对象属性,字段访问组件,ignoreCase参数指示是否需要区分大小写
/// </summary>
/// <param name="type">需快速访问的类型</param>
/// <param name="ignoreCase">是否区分大小写(不区分大小写时应保证类中没有同名的(仅大小写不同的)属性或字段)</param>
public Literacy(Type type, bool ignoreCase)
{
_Type = type;
_CallNewObject = PreNewObject;
Property = new ObjectPropertyCollection(ignoreCase);
foreach (var p in type.GetProperties())
{
if (p.GetIndexParameters().Length == 0)//排除索引器
{
if (!Property.ContainsKey(p.Name))
{
var a = new ObjectProperty(p);
Property.Add(a);
}
}
}
}
/// <summary> 初始化对象属性,字段访问组件,ignoreCase参数指示是否需要区分大小写
/// </summary>
/// <param name="type">需快速访问的类型</param>
/// <param name="ignoreCase">是否区分大小写(不区分大小写时应保证类中没有同名的(仅大小写不同的)属性或字段)</param>
public Literacy(Type type, bool ignoreCase)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
Type = type;
_CallNewObject = PreNewObject;
Property = new ObjectPropertyCollection(ignoreCase);
foreach (var p in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (p.GetIndexParameters().Length == 0) //排除索引器
{
if (!Property.ContainsKey(p.Name))
{
var a = new ObjectProperty(p);
Property.Add(a);
}
}
}
}
/// <summary>
/// </summary>
/// <param name="args"></param>
private object PreNewObject(params object[] args)
{
_CallNewObject = CreateNewObject(Type) ?? ErrorNewObject;
return(_CallNewObject());
}
internal Literacy(TypeInfo info, bool ignoreCase)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
TypeInfo = info;
Type = info.Type;
_CallNewObject = PreNewObject;
Property = new ObjectPropertyCollection(ignoreCase);
foreach (var p in Type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (p.GetIndexParameters().Length == 0) //排除索引器
{
if (!Property.ContainsKey(p.Name))
{
var a = new ObjectProperty(p);
Property.Add(a);
}
}
}
ID = Interlocked.Increment(ref Sequence);
UID = Guid.NewGuid();
TypeCodes = info.TypeCodes;
}
/// <summary>
/// </summary>
/// <param name="args"></param>
private object PreNewObject(params object[] args)
{
_CallNewObject = CreateNewObject(Type) ?? ErrorNewObject;
return _CallNewObject();
}
/// <summary> 初始化对象属性,字段访问组件,ignoreCase参数指示是否需要区分大小写
/// </summary>
/// <param name="type">需快速访问的类型</param>
/// <param name="ignoreCase">是否区分大小写(不区分大小写时应保证类中没有同名的(仅大小写不同的)属性或字段)</param>
public Literacy(Type type, bool ignoreCase) {
if (type == null) {
throw new ArgumentNullException("type");
}
Type = type;
_CallNewObject = PreNewObject;
Property = new ObjectPropertyCollection(ignoreCase);
foreach (var p in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
if (p.GetIndexParameters().Length == 0) //排除索引器
{
if (!Property.ContainsKey(p.Name)) {
var a = new ObjectProperty(p);
Property.Add(a);
}
}
}
}
