/// <summary>
/// 创建随机对象
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
internal static T CreateNotNull(Config config)
{
if (defaultCreator != null)
{
return(defaultCreator());
}
if (configNullCreator != null)
{
return(configNullCreator(config));
}
if (DefaultConstructor <T> .Type == AutoCSer.Metadata.DefaultConstructorType.None)
{
return(default(T));
}
if (isValueType)
{
T value = DefaultConstructor <T> .Constructor();
MemberCreator(ref value, config);
return(value);
}
else
{
object historyValue = config.TryGetValue(typeof(T));
if (historyValue != null)
{
return((T)historyValue);
}
T value = config.SaveHistory(DefaultConstructor <T> .Constructor());
MemberCreator(ref value, config);
return(value);
}
}
/// <summary>
/// Maintains a set of serializers.
/// </summary>
/// <param name="Context">Serialization context.</param>
public SerializerCollection(ISerializerContext Context)
#endif
{
this.context = Context;
this.serializers = new Dictionary <Type, IObjectSerializer>();
#if NETSTANDARD1_5
this.compiled = Compiled;
#endif
ConstructorInfo DefaultConstructor;
IObjectSerializer S;
TypeInfo TI;
foreach (Type T in Types.GetTypesImplementingInterface(typeof(IObjectSerializer)))
{
TI = T.GetTypeInfo();
if (TI.IsAbstract || TI.IsGenericTypeDefinition)
{
continue;
}
DefaultConstructor = null;
try
{
foreach (ConstructorInfo CI in TI.DeclaredConstructors)
{
if (CI.IsPublic && CI.GetParameters().Length == 0)
{
DefaultConstructor = CI;
break;
}
}
if (DefaultConstructor is null)
{
continue;
}
S = DefaultConstructor.Invoke(Types.NoParameters) as IObjectSerializer;
if (S is null)
{
continue;
}
}
catch (Exception)
{
continue;
}
this.serializers[S.ValueType] = S;
}
this.serializers[typeof(GenericObject)] = new GenericObjectSerializer(this.context, false);
this.serializers[typeof(object)] = new GenericObjectSerializer(this.context, true);
}
public void CreateDefaultConstructor()
{
if (Members.Any(m => m is ConstructorDeclarationSyntax))
{
return;
}
var metatype = (Metatype)Type.Resolved();
var constructor = new DefaultConstructor((ObjectType)metatype.Instance);
ChildSymbols = new SymbolSet(ChildSymbols.Values.SelectMany(s => s).Append(constructor));
}
private static object TryClone(object obj)
{
if (obj == null)
{
return(null);
}
var type = obj.GetType();
if (obj is IList list)
{
if (type.IsArray)
{
var ret = Array.CreateInstance(type.GetElementType(), list.Count);
Array.Copy((Array)list, 0, ret, 0, list.Count);
return(ret);
}
if (list is ExpandableList e)
{
return(e.Expand());
}
if (type.GetGenericTypeDefinition() == typeof(List <>))
{
var ret = (IList)DefaultConstructor.Activator(type)();
foreach (var o in list)
{
ret.Add(o);
}
return(ret);
}
throw new Exception($"Unable to clone {type.FullName} from IList");
}
if (obj is IDictionary dict)
{
var ret = (IDictionary)DefaultConstructor.Activator(type)();
foreach (DictionaryEntry entry in dict)
{
ret.Add(entry.Key, entry.Value);
}
return(ret);
}
return(obj);
}
/// <summary>
/// 创建随机对象
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public static T Create(Config config = null)
{
if (defaultCreator != null)
{
return(defaultCreator());
}
if (configCreator != null)
{
if (config == null)
{
config = Config.Default;
}
if (config.History == null)
{
return(configCreator(config));
}
try
{
return(configCreator(config));
}
finally { config.History.Clear(); }
}
if (DefaultConstructor <T> .Type == DefaultConstructorType.None)
{
return(default(T));
}
T value = DefaultConstructor <T> .Constructor();
if (config == null)
{
config = Config.Default;
}
if (config.History == null)
{
MemberCreator(ref value, config);
}
else
{
try
{
MemberCreator(ref value, config);
}
finally { config.History.Clear(); }
}
return(value);
}
private static bool Test_SearchKnuthMorrisPratt_Stub0001(string a, string b)
{
var r0 = a.IndexOf(b);
var r1 = (int?)null;
var a1 = a.AsReadOnlyList();
var b1 = b.AsReadOnlyList();
try {
r1 = SequenceSearchModule.IndexOf_A_KnuthMorrisPratt <char, StandardStringAsReadOnlyList, StandardStringAsReadOnlyList, CharComparer>(a1, b1, DefaultConstructor.Invoke <CharComparer>());
} catch (Exception) {
}
return(r0 == r1);
}
public void Test_01_DefaultConstructor()
{
DefaultConstructor Obj = Types.Instantiate <DefaultConstructor>(false);
Assert.IsNotNull(Obj);
}
