/// <summary>Get a raw data record.</summary>
/// <param name="manifest">The mod manifest whose fields to match.</param>
/// <param name="displayName">The mod's default display name.</param>
/// <param name="record">The raw mod record.</param>
private bool TryGetRaw(IManifest manifest, out string displayName, out ModDataRecord record)
{
if (manifest != null)
{
foreach (var entry in this.Records)
{
displayName = entry.Key;
record = entry.Value;
// try main ID
if (record.ID != null && record.ID.Equals(manifest.UniqueID, StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
// try former IDs
if (record.FormerIDs != null)
{
foreach (string part in record.FormerIDs.Split('|'))
{
// packed field snapshot
if (part.StartsWith("{"))
{
FieldSnapshot snapshot = JsonConvert.DeserializeObject <FieldSnapshot>(part);
bool isMatch =
(snapshot.ID == null || snapshot.ID.Equals(manifest.UniqueID, StringComparison.InvariantCultureIgnoreCase)) &&
(snapshot.EntryDll == null || snapshot.EntryDll.Equals(manifest.EntryDll, StringComparison.InvariantCultureIgnoreCase)) &&
(
snapshot.Author == null ||
snapshot.Author.Equals(manifest.Author, StringComparison.InvariantCultureIgnoreCase) ||
(manifest.ExtraFields != null && manifest.ExtraFields.ContainsKey("Authour") && snapshot.Author.Equals(manifest.ExtraFields["Authour"].ToString(), StringComparison.InvariantCultureIgnoreCase))
) &&
(snapshot.Name == null || snapshot.Name.Equals(manifest.Name, StringComparison.InvariantCultureIgnoreCase));
if (isMatch)
{
return(true);
}
}
// plain ID
else if (part.Equals(manifest.UniqueID, StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
}
}
}
}
displayName = null;
record = null;
return(false);
}
private void Initialize(Action continuation, IAsyncStateMachine stateMachine, IAsyncOperation asyncOperation)
{
const MemberFlags flags = MemberFlags.NonPublic | MemberFlags.Public | MemberFlags.Instance;
if (stateMachine == null)
{
stateMachine = continuation.Target as IAsyncStateMachine;
if (stateMachine == null)
{
var fieldInfo = continuation.Target
.GetType()
.GetFieldEx("m_continuation", flags);
if (fieldInfo != null)
{
continuation = fieldInfo.GetValueEx <Action>(continuation.Target);
}
fieldInfo = continuation.Target
.GetType()
.GetFieldEx("m_stateMachine", flags);
if (fieldInfo == null)
{
TraceError(continuation.Target);
return;
}
stateMachine = fieldInfo.GetValueEx <IAsyncStateMachine>(continuation.Target);
if (stateMachine == null)
{
TraceError(continuation.Target);
return;
}
}
}
var type = stateMachine.GetType();
StateMachineType = type.AssemblyQualifiedName;
FieldSnapshots = new List <FieldSnapshot>();
foreach (var field in type.GetFieldsEx(flags))
{
var snapshot = FieldSnapshot.Create(field, stateMachine, asyncOperation);
if (snapshot != null)
{
FieldSnapshots.Add(snapshot);
}
}
}
public ISerializableCallback CreateSerializableCallback(Delegate @delegate)
{
Should.NotBeNull(@delegate, "delegate");
var method = @delegate.GetMethodInfo();
bool firstParameterSource;
if (!CheckMethodParameters(method, out firstParameterSource))
{
Tracer.Warn("The method '{0}' cannot be serialized, invalid parameters.", method);
return(null);
}
if (method.IsStatic)
{
return(new DelegateSerializableCallback(method.DeclaringType.AssemblyQualifiedName, method.Name,
firstParameterSource, true, null, null));
}
var target = @delegate.Target;
var targetType = target.GetType();
if (targetType.IsAnonymousClass())
{
var snapshots = new List <FieldSnapshot>();
foreach (var anonymousField in targetType.GetFieldsEx(MemberFlags.Instance | MemberFlags.NonPublic | MemberFlags.Public))
{
var snapshot = FieldSnapshot.Create(anonymousField, target, null);
if (snapshot != null)
{
snapshots.Add(snapshot);
}
}
return(new DelegateSerializableCallback(targetType.AssemblyQualifiedName, method.Name, firstParameterSource,
false, null, snapshots));
}
return(new DelegateSerializableCallback(targetType.AssemblyQualifiedName, method.Name, firstParameterSource,
false, targetType.IsSerializable() ? target : null, null));
}
