internal void MapParameters(bool reduceByRef) {
if (reduceByRef) {
_returnArgs = new List<int>();
if (CompilerHelpers.GetReturnType(_method) != typeof(void)) {
_returnArgs.Add(-1);
}
}
BitArray specialParameters = _resolver.MapSpecialParameters(this);
if (_instanceBuilder == null) {
_instanceBuilder = new NullArgBuilder();
}
for (int infoIndex = 0; infoIndex < _parameterInfos.Length; infoIndex++) {
if (!IsSpecialParameter(specialParameters, infoIndex)) {
if (reduceByRef) {
MapParameterReduceByRef(_parameterInfos[infoIndex]);
} else {
MapParameter(_parameterInfos[infoIndex]);
}
}
}
_returnBuilder = MakeReturnBuilder(specialParameters);
}
public KeywordArgBuilder(ArgBuilder builder, int kwArgCount, int kwArgIndex)
: base(builder.ParameterInfo) {
Debug.Assert(BuilderExpectsSingleParameter(builder));
_builder = builder;
Debug.Assert(kwArgIndex < kwArgCount);
_kwArgCount = kwArgCount;
_kwArgIndex = kwArgIndex;
}
internal MethodTarget(MethodBinder binder, MethodBase method, int parameterCount, ArgBuilder instanceBuilder, IList<ArgBuilder> argBuilders, ReturnBuilder returnBuilder) {
this._binder = binder;
this._method = method;
this._parameterCount = parameterCount;
this._instanceBuilder = instanceBuilder;
this._argBuilders = argBuilders;
this._returnBuilder = returnBuilder;
//argBuilders.TrimExcess();
}
public void SetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, LocalBuilder memberValue)
{
generator.Ldarg(targetObject);
if (memberValue.LocalType.FullName.StartsWith("System.Nullable`1["))
{
generator.Ldloc(memberValue);
generator.Load(null);
generator.If(Cmp.EqualTo);
generator.LoadMember(typeof(DBNull).GetField("Value"));
generator.Stloc(memberValue);
generator.EndIf();
}
generator.Load(null);
//如果输出的DataRow对象为空，而创建DataTable结构
generator.If(Cmp.EqualTo);
PropertyInfo columns = typeof(DataTable).GetProperty("Columns");
generator.Ldloc(locDataTable);
generator.LoadMember(columns);
generator.Load(memberName);
generator.Ldtoken(CommonUtils.GetOriginalTypeOfNullableType(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType));
generator.Call(typeof(Type).GetMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) }));
generator.Call(typeof(DataColumnCollection).GetMethod("Add", new Type[] { typeof(string), typeof(Type) }));
generator.Pop();
generator.Ldloc(locMemberValues);
generator.Load(memberName);
generator.Ldloc(memberValue);
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType.IsEnum ? typeof(int) : memberValue.LocalType);
}
generator.Call(typeof(Dictionary <string, object>).GetMethod("Add"));
generator.Else();
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Ldloc(memberValue);
if (memberValue.LocalType.IsValueType)
{
generator.Box(memberValue.LocalType);
}
generator.Call(typeof(DataRow).GetMethod("set_Item", new Type[] { typeof(string), typeof(object) }));
generator.EndIf();
}
internal MethodCandidate(OverloadResolver resolver, MethodBase method, List<ParameterWrapper> parameters, ParameterWrapper paramsDict,
ReturnBuilder returnBuilder, ArgBuilder instanceBuilder, IList<ArgBuilder> argBuilders) {
Assert.NotNull(resolver, method, instanceBuilder, returnBuilder);
Assert.NotNullItems(parameters);
Assert.NotNullItems(argBuilders);
_resolver = resolver;
_method = method;
_instanceBuilder = instanceBuilder;
_argBuilders = argBuilders;
_returnBuilder = returnBuilder;
_parameters = parameters;
_paramsDict = paramsDict;
_paramsArrayIndex = ParameterWrapper.IndexOfParamsArray(parameters);
parameters.TrimExcess();
}
public string[] GetBranches(IGetBranchesArgs args)
{
if (args.Permanent)
{
ThrowPermanentBranchException();
}
var ab = new ArgBuilder();
ab.Add("branch");
var branches = RunCommand(ab, args)
.Select(line => Regex.Match(line, @"^(?<active>\*)? *(?<name>.*)$"));
if (args.Current)
{
branches = branches.Where(b => b.Groups["active"].Value == "*");
}
return(branches.Select(b => b.Groups["name"].Value).ToArray());
}
public Changeset[] DownloadChangesets(IDownloadChangesetArgs args)
{
if (String.IsNullOrEmpty(args.Source))
{
throw new ArgumentNullException(nameof(args.Source));
}
var ab = new ArgBuilder();
ab.Add(args.CheckOnly ? "incoming" : "pull");
ab.Add(args.Source);
if (args.TargetRev != null)
{
ab.Add($"--rev {FormatQuery(args.TargetRev)}");
}
var r = RunCommand(ab, args);
return(args.CheckOnly ? ParseChangesets(r) : new Changeset[] { });
}
private void InitArgs(Type objType)
{
this.xmlWriterArg = this.ilg.GetArg(0);
this.contextArg = this.ilg.GetArg(2);
this.dataContractArg = this.ilg.GetArg(3);
this.objectLocal = this.ilg.DeclareLocal(objType, "objSerialized");
ArgBuilder arg = this.ilg.GetArg(1);
this.ilg.Load(arg);
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
this.ilg.ConvertValue(arg.ArgType, Globals.TypeOfDateTimeOffset);
this.ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
}
else
{
this.ilg.ConvertValue(arg.ArgType, objType);
}
this.ilg.Stloc(this.objectLocal);
}
public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
{
Type inputType = targetObject.ArgType;
MemberInfo memberInfo = ConvertorGeneratorHelper.GetMemberInfo(inputType, memberName);
if (memberInfo == null)
{
return;
}
Type srcMemberType = ConvertorGeneratorHelper.GetMemberType(memberInfo);
Type destMemberType = memberValue.LocalType;
if (memberValue.LocalType.IsAssignableFrom(srcMemberType))
{
generator.Ldarg(targetObject);
generator.LoadMember(memberInfo);
generator.Stloc(memberValue);
return;
}
Type converTargetType = ConvertorGeneratorHelper.GetOriginalType(destMemberType);
Type convertSourceType = ConvertorGeneratorHelper.GetOriginalType(srcMemberType);
//源字段类型是否实现了IConvertible
if (typeof(IConvertible).IsAssignableFrom(convertSourceType))
{
generator.Ldarg(targetObject);
generator.LoadMember(memberInfo);
if (convertSourceType.IsValueType)
{
//一定要是原类型
generator.Box(srcMemberType);
}
generator.Load(converTargetType);
generator.Call(typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) }));
if (destMemberType.IsValueType)
{
generator.UnboxAny(destMemberType);
}
generator.Stloc(memberValue);
}
}
public Changeset[] GetChangesets(IGetChangesetsArgs args)
{
var ab = new ArgBuilder();
if (args.Current)
{
ab.Add("parent");
}
else
{
ab.Add("log");
if (args.Query != null)
{
ab.Add($"--rev \"{FormatQuery(args.Query)}\"");
}
}
ab.Add($"--template \"{XmlLogTemplate}\"");
var lines = RunCommand(ab, args);
return(Changeset.FromXml(lines));
}
private void InitArgs(Type objType)
{
_xmlWriterArg = _ilg.GetArg(0);
_contextArg = _ilg.GetArg(2);
_dataContractArg = _ilg.GetArg(3);
_objectLocal = _ilg.DeclareLocal(objType, "objSerialized");
ArgBuilder objectArg = _ilg.GetArg(1);
_ilg.Load(objectArg);
// Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter.
// DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation
// on DateTimeOffset; which does not work in partial trust.
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset);
_ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
}
else if (objType == Globals.TypeOfMemoryStreamAdapter)
{
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfMemoryStream);
_ilg.Call(XmlFormatGeneratorStatics.GetMemoryStreamAdapterMethod);
}
//Copy the KeyValuePair<K,T> to a KeyValuePairAdapter<K,T>.
else if (objType.IsGenericType && objType.GetGenericTypeDefinition() == Globals.TypeOfKeyValuePairAdapter)
{
ClassDataContract dc = (ClassDataContract)DataContract.GetDataContract(objType);
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfKeyValuePair.MakeGenericType(dc.KeyValuePairGenericArguments !));
_ilg.New(dc.KeyValuePairAdapterConstructorInfo !);
}
else
{
_ilg.ConvertValue(objectArg.ArgType, objType);
}
_ilg.Stloc(_objectLocal);
}
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
{
this.ilg = new CodeGenerator();
bool allowPrivateMemberAccess = classContract.RequiresMemberAccessForWrite(null);
try
{
this.BeginMethod(this.ilg, "Write" + classContract.StableName.Name + "ToJson", typeof(JsonFormatClassWriterDelegate), allowPrivateMemberAccess);
}
catch (SecurityException exception)
{
if (!allowPrivateMemberAccess || !exception.PermissionType.Equals(typeof(ReflectionPermission)))
{
throw;
}
classContract.RequiresMemberAccessForWrite(exception);
}
this.InitArgs(classContract.UnderlyingType);
this.memberNamesArg = this.ilg.GetArg(4);
this.DemandSerializationFormatterPermission(classContract);
this.DemandMemberAccessPermission(allowPrivateMemberAccess);
this.WriteClass(classContract);
return (JsonFormatClassWriterDelegate) this.ilg.EndMethod();
}
private void CreatePermanentBranch(INewBranchArgs args)
{
if (!String.IsNullOrEmpty(args.TargetChangeset))
{
throw new NotSupportedException($"'{nameof(args.TargetChangeset)}' is not supported for permanent branches.");
}
var ab = new ArgBuilder();
ab.Add("branch");
ab.Add($"\"{args.Name}\"");
ab.AddIf(args.Force, "--force");
RunCommand(ab, args);
if (args.Commit)
{
Commit(new CommitScmFileArgs
{
RepositoryPath = args.RepositoryPath,
Message = $"Opened branch '{args.Name}'"
});
}
}
public void EndSetMembers(CodeGenerator generator, ArgBuilder targetObject)
{
generator.Ldarg(targetObject);
generator.Load(null);
generator.If(Cmp.EqualTo);
generator.Pop();
LocalBuilder dataRow = generator.DeclareLocal(typeof(DataRow));
generator.Ldloc(locDataTable);
generator.Call(typeof(DataTable).GetMethod("NewRow"));
generator.Stloc(dataRow);
LocalBuilder locCurrent = generator.DeclareLocal(typeof(string));
LocalBuilder locEnumerator = generator.DeclareLocal(typeof(Dictionary <string, object> .KeyCollection.Enumerator));
generator.Ldloc(locMemberValues);
generator.Call(typeof(Dictionary <string, object>).GetMethod("get_Keys"));
generator.Call(typeof(Dictionary <string, object> .KeyCollection).GetMethod("GetEnumerator"));
generator.Stloc(locEnumerator);
MethodInfo getCurrentMethod = typeof(Dictionary <string, object> .KeyCollection.Enumerator).GetMethod("get_Current");
MethodInfo moveNextMethod = typeof(Dictionary <string, object> .KeyCollection.Enumerator).GetMethod("MoveNext");
generator.ForEach(locCurrent, typeof(string), typeof(Dictionary <string, object> .KeyCollection.Enumerator), locEnumerator, getCurrentMethod);
generator.Ldloc(dataRow);
generator.Ldloc(locCurrent);
generator.Ldloc(locMemberValues);
generator.Ldloc(locCurrent);
generator.Call(typeof(Dictionary <string, object>).GetMethod("get_Item"));
generator.Call(typeof(DataRow).GetMethod("set_Item", new Type[] { typeof(string), typeof(object) }));
generator.EndForEach(moveNextMethod);
generator.Ldloc(dataRow);
generator.EndIf();
}
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract)
{
this.ilg = new CodeGenerator();
bool allowPrivateMemberAccess = classContract.RequiresMemberAccessForWrite(null);
try
{
this.BeginMethod(this.ilg, "Write" + classContract.StableName.Name + "ToJson", typeof(JsonFormatClassWriterDelegate), allowPrivateMemberAccess);
}
catch (SecurityException exception)
{
if (!allowPrivateMemberAccess || !exception.PermissionType.Equals(typeof(ReflectionPermission)))
{
throw;
}
classContract.RequiresMemberAccessForWrite(exception);
}
this.InitArgs(classContract.UnderlyingType);
this.memberNamesArg = this.ilg.GetArg(4);
this.DemandSerializationFormatterPermission(classContract);
this.DemandMemberAccessPermission(allowPrivateMemberAccess);
this.WriteClass(classContract);
return((JsonFormatClassWriterDelegate)this.ilg.EndMethod());
}
public void CheckoutChangeset(ICheckoutChangesetArgs args)
{
var ab = new ArgBuilder();
ab.Add("update");
if (args.Clean)
{
ab.Add("--clean");
}
if (args.TargetRev != null)
{
ab.Add(args.TargetRev);
}
RunCommand(ab, args);
if (!String.IsNullOrEmpty(args.NewBranchName))
{
CreateBranch(new NewBranchArgs
{
Name = args.NewBranchName,
RepositoryPath = args.RepositoryPath
});
}
}
private void IsStartElement(ArgBuilder nameArg, ArgBuilder nsArg)
{
_ilg.Call(_xmlReaderArg, JsonFormatGeneratorStatics.IsStartElementMethod2, nameArg, nsArg);
}
void InitArgs()
{
xmlReaderArg = ilg.GetArg(0);
contextArg = ilg.GetArg(1);
memberNamesArg = ilg.GetArg(2);
memberNamespacesArg = ilg.GetArg(3);
}
/// <summary>
/// Starg
/// </summary>
/// <param name="arg"></param>
public void Starg(ArgBuilder arg)
{
Check.Require(arg, "arg");
this.Starg(arg.Index);
}
/// <summary>
/// Ldarga ���� Ldarga(int) ����
/// </summary>
/// <param name="argBuilder"></param>
public void Ldarga(ArgBuilder argBuilder)
{
Check.Require(argBuilder, "argBuilder");
this.Ldarga(argBuilder.Index);
}
void LoadOutputParametersIntoArray(ParameterInfo[] parameters, LocalBuilder[] parameterLocals, ArgBuilder outputParametersArg, out int outputParameterCount)
{
outputParameterCount = 0;
for (int i = 0; i < parameterLocals.Length; i++)
{
if (ServiceReflector.FlowsOut(parameters[i]))
{
ilg.Load(outputParametersArg);
ilg.Load(outputParameterCount);
ilg.Load(parameterLocals[i]);
ilg.ConvertValue(parameterLocals[i].LocalType, TypeOfObject);
ilg.Stelem(TypeOfObject);
outputParameterCount++;
}
}
}
void LoadInputParametersIntoLocals(ParameterInfo[] parameters, LocalBuilder[] parameterLocals, ArgBuilder inputParametersArg, out int inputParameterCount)
{
inputParameterCount = 0;
for (int i = 0; i < parameterLocals.Length; i++)
{
if (ServiceReflector.FlowsIn(parameters[i]))
{
Type parameterType = parameterLocals[i].LocalType;
ilg.LoadArrayElement(inputParametersArg, inputParameterCount);
if (!parameterType.IsValueType)
{
ilg.ConvertValue(TypeOfObject, parameterType);
ilg.Store(parameterLocals[i]);
}
else
{
ilg.Dup();
ilg.If();
ilg.ConvertValue(TypeOfObject, parameterType);
ilg.Store(parameterLocals[i]);
ilg.Else();
ilg.Pop();
ilg.LoadZeroValueIntoLocal(parameterType, parameterLocals[i]);
ilg.EndIf();
}
inputParameterCount++;
}
}
}
private void InitArgs()
{
_xmlReaderArg = _ilg.GetArg(0);
_contextArg = _ilg.GetArg(1);
_memberNamesArg = _ilg.GetArg(2);
_memberNamespacesArg = _ilg.GetArg(3);
}
public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
{
LocalBuilder tempLocal = generator.DeclareLocal(typeof(object), "dataColumn");
Type targetType = memberValue.LocalType;
Type originalType = ConvertorGeneratorHelper.GetOriginalType(targetType);
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Call(typeof(IDictionary).GetMethod("get_Item", new Type[] { typeof(object) }));
generator.Stloc(tempLocal);
generator.Ldloc(tempLocal);
generator.LoadMember(typeof(DBNull).GetField("Value", BindingFlags.Static | BindingFlags.Public));
generator.If(Cmp.EqualTo);
generator.LoadDefaultValue(targetType);
generator.Stloc(memberValue);
generator.Else();
generator.Ldloc(tempLocal);
//值是否是目标类型的对象
generator.InternalILGenerator.Emit(OpCodes.Isinst, targetType);
generator.InternalILGenerator.Emit(OpCodes.Ldnull);
generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
generator.Load(true);
generator.If(Cmp.EqualTo);
generator.Ldloc(tempLocal);
if (targetType.IsValueType)
{
generator.UnboxAny(targetType);
}
generator.Stloc(memberValue);
generator.Else();
if (targetType == typeof(Guid))
{
generator.Ldloc(tempLocal);
generator.InternalILGenerator.Emit(OpCodes.Isinst, typeof(string));
generator.InternalILGenerator.Emit(OpCodes.Ldnull);
generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
generator.Load(true);
generator.If(Cmp.EqualTo);
generator.Ldloc(tempLocal);
generator.New(typeof(Guid).GetConstructor(new Type[] { typeof(string) }));
generator.Stloc(memberValue);
}
else
{
generator.Ldloc(tempLocal);
generator.InternalILGenerator.Emit(OpCodes.Isinst, typeof(IConvertible));
generator.InternalILGenerator.Emit(OpCodes.Ldnull);
generator.InternalILGenerator.Emit(OpCodes.Cgt_Un);
generator.Load(true);
generator.If(Cmp.EqualTo);
generator.Ldloc(tempLocal);
generator.Load(originalType);
generator.Call(typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) }));
if (targetType.IsValueType)
{
generator.UnboxAny(targetType);
}
generator.Stloc(memberValue);
}
generator.Else();
generator.LoadDefaultValue(targetType);
generator.Stloc(memberValue);
generator.EndIf();
generator.EndIf();
generator.EndIf();
}
internal VariantBuilder(VarEnum targetComType, ArgBuilder builder)
{
_targetComType = targetComType;
_argBuilder = builder;
}
private void InitArgs()
{
this.xmlReaderArg = this.ilg.GetArg(0);
this.contextArg = this.ilg.GetArg(1);
this.memberNamesArg = this.ilg.GetArg(2);
this.memberNamespacesArg = this.ilg.GetArg(3);
}
private CodeGenerator GenerateCollectionReaderHelper(CollectionDataContract collectionContract, bool isGetOnlyCollection)
{
this.ilg = new CodeGenerator();
bool allowPrivateMemberAccess = collectionContract.RequiresMemberAccessForRead(null);
try
{
if (isGetOnlyCollection)
{
this.ilg.BeginMethod("Read" + collectionContract.StableName.Name + "FromXmlIsGetOnly", Globals.TypeOfXmlFormatGetOnlyCollectionReaderDelegate, allowPrivateMemberAccess);
}
else
{
this.ilg.BeginMethod("Read" + collectionContract.StableName.Name + "FromXml" + string.Empty, Globals.TypeOfXmlFormatCollectionReaderDelegate, allowPrivateMemberAccess);
}
}
catch (SecurityException exception)
{
if (!allowPrivateMemberAccess || !exception.PermissionType.Equals(typeof(ReflectionPermission)))
{
throw;
}
collectionContract.RequiresMemberAccessForRead(exception);
}
this.InitArgs();
this.DemandMemberAccessPermission(allowPrivateMemberAccess);
this.collectionContractArg = this.ilg.GetArg(4);
return this.ilg;
}
public void EndSetMembers(CodeGenerator generator, ArgBuilder targetObject)
{
}
internal VariantBuilder(VarEnum targetComType, ArgBuilder builder) {
_targetComType = targetComType;
_argBuilder = builder;
}
private void InitArgs(Type objType)
{
_xmlWriterArg = _ilg.GetArg(0);
_contextArg = _ilg.GetArg(2);
_dataContractArg = _ilg.GetArg(3);
_objectLocal = _ilg.DeclareLocal(objType, "objSerialized");
ArgBuilder objectArg = _ilg.GetArg(1);
_ilg.Load(objectArg);
// Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter.
// DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation
// on DateTimeOffset; which does not work in partial trust.
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset);
_ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
}
//Copy the KeyValuePair<K,T> to a KeyValuePairAdapter<K,T>.
else if (objType.GetTypeInfo().IsGenericType && objType.GetGenericTypeDefinition() == Globals.TypeOfKeyValuePairAdapter)
{
ClassDataContract dc = (ClassDataContract)DataContract.GetDataContract(objType);
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfKeyValuePair.MakeGenericType(dc.KeyValuePairGenericArguments));
_ilg.New(dc.KeyValuePairAdapterConstructorInfo);
}
else
{
_ilg.ConvertValue(objectArg.ArgType, objType);
}
_ilg.Stloc(_objectLocal);
}
/// <summary>
/// The underlying builder should expect a single parameter as KeywordArgBuilder is responsible
/// for calculating the correct parameter to use
/// </summary>
/// <param name="builder"></param>
internal static bool BuilderExpectsSingleParameter(ArgBuilder builder) {
return (((SimpleArgBuilder)builder).Index == 0);
}
protected string[] RunCommand(string exeName, ArgBuilder args, string workingDir)
{
return(RunCommand(exeName, args, null, workingDir));
}
internal void Ldarga(ArgBuilder argBuilder) {
Ldarga(argBuilder.Index);
}
void LoadTarget(ArgBuilder targetArg, Type targetType)
{
ilg.Load(targetArg);
ilg.ConvertValue(targetArg.ArgType, targetType);
if (targetType.IsValueType)
{
LocalBuilder targetLocal = ilg.DeclareLocal(targetType, "target");
ilg.Store(targetLocal);
ilg.LoadAddress(targetLocal);
}
}
void InitILGeneration(Type[] argTypes, string[] argNames, bool isStatic) {
this.methodEndLabel = ilGen.DefineLabel();
this.retLabel = ilGen.DefineLabel();
this.blockStack = new Stack();
this.whileStack = new Stack();
this.currentScope = new LocalScope();
this.freeLocals = new Dictionary<Tuple<Type, string>, Queue<LocalBuilder>>();
this.argList = new Dictionary<string, ArgBuilder>();
// this ptr is arg 0 for non static, assuming ref type (not value type)
if (!isStatic)
argList.Add("this", new ArgBuilder("this", 0, this.typeBuilder.BaseType));
for (int i = 0; i < argTypes.Length; i++) {
ArgBuilder arg = new ArgBuilder(argNames[i], argList.Count, argTypes[i]);
argList.Add(arg.Name, arg);
this.methodBuilder.DefineParameter(arg.Index, ParameterAttributes.None, arg.Name);
}
}
void InitArgs(Type objType)
{
xmlWriterArg = ilg.GetArg(0);
contextArg = ilg.GetArg(2);
dataContractArg = ilg.GetArg(3);
objectLocal = ilg.DeclareLocal(objType, "objSerialized");
ArgBuilder objectArg = ilg.GetArg(1);
ilg.Load(objectArg);
// Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter.
// DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation
// on DateTimeOffset; which does not work in partial trust.
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset);
ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
}
else
{
ilg.ConvertValue(objectArg.ArgType, objType);
}
ilg.Stloc(objectLocal);
}
protected string[] RunCommand(ArgBuilder args, ICredentials creds, string workingDir)
{
return(RunCommand(DefaultExeName, args, creds, workingDir));
}
/// <summary>
/// LdargAddress ���ز�����ַ��ILû�����ָ������ݲ��������ͷֱ���ò�ͬ��ILָ�
/// ������Ϊֵ����ʱ��ͨ������Ldargaָ����ز�����ַ
/// ���β�Ϊֵ����ʱ��ֱ�ӵ���Ldarg���ز���
/// </summary>
/// <param name="argBuilder"></param>
public void LdargAddress(ArgBuilder argBuilder)
{
Check.Require(argBuilder, "argBuilder");
if (argBuilder.ArgType.IsValueType)
{
this.Ldarga(argBuilder);
}
else
{
this.Ldarg(argBuilder);
}
}
protected string[] RunCommand(string exeName, ArgBuilder args, IScmCommandArgsBase cmd)
{
var credentials = (cmd as IRemoteScmCommandArgsBase)?.Credentials;
return(RunCommand(exeName, args, credentials, cmd.RepositoryPath));
}
CodeGenerator GenerateCollectionReaderHelper(CollectionDataContract collectionContract, bool isGetOnlyCollection)
{
ilg = new CodeGenerator();
bool memberAccessFlag = collectionContract.RequiresMemberAccessForRead(null);
try
{
if (isGetOnlyCollection)
{
ilg.BeginMethod("Read" + collectionContract.StableName.Name + "FromXml" + "IsGetOnly", Globals.TypeOfXmlFormatGetOnlyCollectionReaderDelegate, memberAccessFlag);
}
else
{
ilg.BeginMethod("Read" + collectionContract.StableName.Name + "FromXml" + string.Empty, Globals.TypeOfXmlFormatCollectionReaderDelegate, memberAccessFlag);
}
}
catch (SecurityException securityException)
{
if (memberAccessFlag && securityException.PermissionType.Equals(typeof(ReflectionPermission)))
{
collectionContract.RequiresMemberAccessForRead(securityException);
}
else
{
throw;
}
}
InitArgs();
DemandMemberAccessPermission(memberAccessFlag);
collectionContractArg = ilg.GetArg(4);
return ilg;
}
internal void Ldarg(ArgBuilder arg) {
Ldarg(arg.Index);
}
void IsStartElement(ArgBuilder nameArg, ArgBuilder nsArg)
{
ilg.Call(xmlReaderArg, XmlFormatGeneratorStatics.IsStartElementMethod2, nameArg, nsArg);
}
private void InitArgs(Type objType)
{
this.xmlWriterArg = this.ilg.GetArg(0);
this.contextArg = this.ilg.GetArg(2);
this.dataContractArg = this.ilg.GetArg(3);
this.objectLocal = this.ilg.DeclareLocal(objType, "objSerialized");
ArgBuilder arg = this.ilg.GetArg(1);
this.ilg.Load(arg);
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
this.ilg.ConvertValue(arg.ArgType, Globals.TypeOfDateTimeOffset);
this.ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
}
else
{
this.ilg.ConvertValue(arg.ArgType, objType);
}
this.ilg.Stloc(this.objectLocal);
}
internal void LdargAddress(ArgBuilder argBuilder) {
if (argBuilder.ArgType.IsValueType)
Ldarga(argBuilder);
else
Ldarg(argBuilder);
}
internal void LdargAddress(ArgBuilder argBuilder)
{
if (argBuilder.ArgType.IsValueType)
{
this.Ldarga(argBuilder);
}
else
{
this.Ldarg(argBuilder);
}
}
internal void Starg(ArgBuilder arg)
{
Starg(arg.Index);
}
public void GetMemberValue(CodeGenerator generator, ArgBuilder targetObject, string memberName, ref LocalBuilder memberValue)
{
MethodInfo getMethod;
bool mustBeUnBox = false;
switch (Type.GetTypeCode(memberValue.LocalType))
{
//从实测的效果来看，使用特定的函数将不会提高性能，反而性能会更低。
case TypeCode.Boolean:
getMethod = typeof(IDataRecord).GetMethod("GetBoolean");
break;
case TypeCode.Byte:
getMethod = typeof(IDataRecord).GetMethod("GetByte");
break;
case TypeCode.Char:
getMethod = typeof(IDataRecord).GetMethod("GetChar");
break;
case TypeCode.DateTime:
getMethod = typeof(IDataRecord).GetMethod("GetDateTime");
break;
case TypeCode.Decimal:
getMethod = typeof(IDataRecord).GetMethod("GetDecimal");
break;
case TypeCode.Double:
getMethod = typeof(IDataRecord).GetMethod("GetDouble");
break;
case TypeCode.Single:
getMethod = typeof(IDataRecord).GetMethod("GetFloat");
break;
case TypeCode.UInt16:
getMethod = typeof(IDataRecord).GetMethod("GetInt16");
break;
case TypeCode.Int32:
getMethod = typeof(IDataRecord).GetMethod("GetInt32");
break;
case TypeCode.Int64:
getMethod = typeof(IDataRecord).GetMethod("GetInt64");
break;
case TypeCode.String:
getMethod = typeof(IDataRecord).GetMethod("GetString");
break;
default:
getMethod = typeof(IDataRecord).GetMethod("GetValue");
mustBeUnBox = true;
break;
}
if (memberValue.LocalType == typeof(Guid))
{
getMethod = typeof(IDataRecord).GetMethod("GetGuid");
mustBeUnBox = false;
}
var index = generator.DeclareLocal(typeof(int));
generator.Ldarg(targetObject);
generator.Load(memberName);
generator.Call(typeof(IDataRecord).GetMethod("GetOrdinal"));
generator.Stloc(index);
generator.Ldarg(targetObject);
generator.Ldloc(index);
generator.Call(typeof(IDataRecord).GetMethod("IsDBNull"));
generator.If(); //if
generator.LoadDefaultValue(memberValue.LocalType);
generator.Stloc(memberValue);
generator.Else(); //else
generator.Ldarg(targetObject);
generator.Ldloc(index);
generator.Call(getMethod);
if (memberValue.LocalType.IsValueType && mustBeUnBox)
{
generator.UnboxAny(memberValue.LocalType);
}
generator.Stloc(memberValue);
generator.EndIf(); //end
}
//This code is not tested
internal void StoreOutParam(ArgBuilder arg, object value)
{
Type destType = arg.ArgType;
if (!destType.IsByRef)
throw new InvalidOperationException("OutParametersMustBeByRefTypeReceived"); //.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.OutParametersMustBeByRefTypeReceived, DataContract.GetClrTypeFullName(destType))));
destType = destType.GetElementType();
Type sourceType;
if (value is ArgBuilder)
sourceType = ((ArgBuilder) value).ArgType;
else if (value is LocalBuilder)
sourceType = ((LocalBuilder) value).LocalType;
else if (value != null)
sourceType = value.GetType();
else
sourceType = null;
Load(arg);
Load(value);
if (sourceType != null)
ConvertAddress(sourceType, destType);
Stind(destType);
}
public override ConvertHandler GetConvertHandler(Type inputType, Type outputType, object inputObject, object outputObject, Dictionary<string, string> mappingNames, List<string> ignoreList, Dictionary<int, string> mappingOrders, bool mappingSpecifiedOnly)
{
//保存目标字段名，目标MemberInfo
Dictionary<string, string> distToSrc = new Dictionary<string, string>();
Dictionary<string, MemberInfo> members = new Dictionary<string, MemberInfo>();
//先查找显式映射
foreach (string sourceName in mappingNames.Keys)
{
MemberInfo sourceMember = ConvertorGeneratorHelper.GetMemberInfo(inputType, sourceName);
Check.Require(sourceMember != null, string.Format("member named {0} could not be found in {1}", sourceName, outputType.FullName));
distToSrc.Add(mappingNames[sourceName], sourceName);
members.Add(mappingNames[sourceName], sourceMember);
}
//如果不是只显式映射
if (!mappingSpecifiedOnly)
{
Dictionary<string, MemberInfo> sourceMembers = ConvertorGeneratorHelper.GetMembers(inputType);
foreach (string sourceName in sourceMembers.Keys)
{
if (!ignoreList.Contains(sourceName) && !distToSrc.ContainsKey(sourceName))
{
distToSrc.Add(sourceName, sourceName);
members.Add(sourceName, sourceMembers[sourceName]);
}
}
}
CodeGenerator gen = new CodeGenerator();
gen.BeginMethod("m" + Guid.NewGuid().ToString("N"), typeof(ConvertHandler));
ArgBuilder inputObjectArg = new ArgBuilder(0, inputType);
ArgBuilder outputObjectArg = new ArgBuilder(1, outputType);
int currentCount = 0;
int memberCount = members.Count;
string[] keys = new string[memberCount];
distToSrc.Keys.CopyTo(keys, 0);
List<string> keyList = new List<string>(keys);
MemberSetterGenerator.BeginSetMembers(gen, outputObjectArg);
//按排序顺序
while (currentCount < memberCount)
{
currentCount++;
string targetName = ConvertorGeneratorHelper.GetCurrentKey(mappingOrders, currentCount, keyList);
if (string.IsNullOrEmpty(targetName))
{
continue;
}
string sourceName = distToSrc[targetName];
if (MemberGetterGenerator.ContainsMember(sourceName, inputType, inputObject) && MemberSetterGenerator.ContainsMember(targetName, outputType, outputObject))
{
Type targetType = ConvertorGeneratorHelper.GetMemberType(members[targetName]);
LocalBuilder memberValue = gen.DeclareLocal(targetType, "memberValue");
MemberGetterGenerator.GetMemberValue(gen, inputObjectArg, sourceName, ref memberValue);
MemberSetterGenerator.SetMemberValue(gen, outputObjectArg, targetName, memberValue);
}
}
gen.Ldarg(outputObjectArg);
MemberSetterGenerator.EndSetMembers(gen, outputObjectArg);
return (ConvertHandler)gen.EndMethod();
}
// TODO: We might want to add bitmap of all consumed arguments and allow to consume an arbitrary argument, not just the next one.
public void AddBuilder(ArgBuilder builder) {
ContractUtils.Requires(builder.ConsumedArgumentCount != ArgBuilder.AllArguments);
_arguments.Add(builder);
_argIndex += builder.ConsumedArgumentCount;
}
protected string[] RunCommand(ArgBuilder args, IScmCommandArgsBase cmd)
{
return(RunCommand(DefaultExeName, args, cmd));
}
