/// <summary>
/// Writes the specified expression.
/// </summary>
/// <param name="expression">The expression to write.</param>
/// <returns>The number of written characters.</returns>
private int WriteExpression(FunctionBase expression)
{
#region Contract
if (expression == null) return 0;
#endregion
throw new LanguageException(ExceptionStrings.FunctionsNotSupported);
}
protected override void OnValueChanged(FunctionBase element, string oldValue, string newValue)
{
if (element.nHydrateModel != null && !element.nHydrateModel.IsLoading)
{
if (string.IsNullOrEmpty(newValue))
throw new Exception("The name must have a value.");
var count = element.nHydrateModel.Functions.Count(x => x.Name.ToLower() == newValue.ToLower() && x.Id != element.Id);
if (count > 0)
throw new Exception("There is already an object with the specified name. The change has been cancelled.");
}
base.OnValueChanged(element, oldValue, newValue);
}
} = 0; // mu
protected Population(FunctionBase optimizationFunction, int dimensions)
{
OptimizationFunction = optimizationFunction;
Dimensions = dimensions;
}
public PopulationBuilder WithOptimizationFunction <TOptimizationFunction>() where TOptimizationFunction : FunctionBase, new()
{
_function = new TOptimizationFunction();
return(this);
}
public object Call(object obj, ScriptObject[] parameters)
{
FunctionBase methodInfo = null;
FunctionBase functionBase = null;
for (int i = 0; i < m_Count; ++i)
{
functionBase = m_Methods[i];
if (functionBase.Params || functionBase.HasDefault)
{
continue;
}
if (CheckNormalType(parameters, functionBase.ParameterType, functionBase.ParameterCount))
{
methodInfo = functionBase;
goto callMethod;
}
}
for (int i = 0; i < m_Count; ++i)
{
functionBase = m_Methods[i];
if (functionBase.Params || !functionBase.HasDefault)
{
continue;
}
if (CheckDefaultType(parameters, functionBase.ParameterType, functionBase.RequiredNumber, functionBase.ParameterCount))
{
methodInfo = functionBase;
goto callMethod;
}
}
for (int i = 0; i < m_Count; ++i)
{
functionBase = m_Methods[i];
if (!functionBase.Params)
{
continue;
}
if (CheckArgsType(parameters, functionBase.ParameterType, functionBase.ParamType, functionBase.RequiredNumber, functionBase.ParameterCount))
{
methodInfo = functionBase;
goto callMethod;
}
}
callMethod:
try {
if (methodInfo != null)
{
int requiredNumber = methodInfo.RequiredNumber; //函数必须传入的参数个数
int parameterCount = methodInfo.ParameterCount; //参数个数
int parameterNumber = parameters.Length; //脚本传入的参数个数
object[] args = methodInfo.Args; //参数数组
if (methodInfo.Params)
{
for (int i = 0; i < parameterCount; ++i)
{
args[i] = i >= parameterNumber ? methodInfo.DefaultParameter[i - requiredNumber] : Util.ChangeType(m_Script, parameters[i], methodInfo.ParameterType[i]);
}
if (parameterNumber > parameterCount)
{
Array array = Array.CreateInstance(methodInfo.ParamType, parameterNumber - parameterCount);
for (int i = parameterCount; i < parameterNumber; ++i)
{
array.SetValue(Util.ChangeType(m_Script, parameters[i], methodInfo.ParamType), i - parameterCount);
}
args[parameterCount] = array;
}
else
{
args[parameterCount] = Array.CreateInstance(methodInfo.ParamType, 0);
}
return(methodInfo.Invoke(obj, m_Type));
}
else
{
for (int i = 0; i < parameterCount; ++i)
{
args[i] = i >= parameterNumber ? methodInfo.DefaultParameter[i - requiredNumber] : Util.ChangeType(m_Script, parameters[i], methodInfo.ParameterType[i]);
}
return(methodInfo.Invoke(obj, m_Type));
}
}
} catch (System.Exception e) {
throw new ExecutionException(m_Script, "Type[" + m_Type.ToString() + "] 调用函数出错 [" + MethodName + "] : " + e.ToString());
}
throw new ExecutionException(m_Script, "Type[" + m_Type.ToString() + "] 找不到合适的函数 [" + MethodName + "]");
}
public AddFunctionCommand(string nameFunction, FunctionBase function)
{
this.nameFunction = nameFunction;
this.function = function;
}
private void Move_MouseDown(object sender, MouseEventArgs e)
{
FunctionBase.ReleaseCapture();
FunctionBase.SendMessage(this.Handle, 0x112, 0xf012, 0);
}
public object Call(object obj, ScriptObject[] parameters)
{
FunctionBase base2 = null;
FunctionBase base3 = null;
for (int i = 0; i < this.m_Count; i++)
{
base3 = this.m_Methods[i];
if ((!base3.Params && !base3.HasDefault) && this.CheckNormalType(parameters, base3.ParameterType, base3.ParameterCount))
{
base2 = base3;
goto Label_00DF;
}
}
for (int j = 0; j < this.m_Count; j++)
{
base3 = this.m_Methods[j];
if ((!base3.Params && base3.HasDefault) && this.CheckDefaultType(parameters, base3.ParameterType, base3.RequiredNumber, base3.ParameterCount))
{
base2 = base3;
goto Label_00DF;
}
}
for (int k = 0; k < this.m_Count; k++)
{
base3 = this.m_Methods[k];
if (base3.Params && this.CheckArgsType(parameters, base3.ParameterType, base3.ParamType, base3.RequiredNumber, base3.ParameterCount))
{
base2 = base3;
break;
}
}
Label_00DF:
try
{
if (base2 != null)
{
int requiredNumber = base2.RequiredNumber;
int parameterCount = base2.ParameterCount;
int length = parameters.Length;
object[] args = base2.Args;
if (base2.Params)
{
for (int n = 0; n < parameterCount; n++)
{
args[n] = (n >= length) ? base2.DefaultParameter[n - requiredNumber] : Util.ChangeType(this.m_Script, parameters[n], base2.ParameterType[n]);
}
if (length > parameterCount)
{
Array array = Array.CreateInstance(base2.ParamType, (int)(length - parameterCount));
for (int num8 = parameterCount; num8 < length; num8++)
{
array.SetValue(Util.ChangeType(this.m_Script, parameters[num8], base2.ParamType), (int)(num8 - parameterCount));
}
args[parameterCount] = array;
}
else
{
args[parameterCount] = Array.CreateInstance(base2.ParamType, 0);
}
return(base2.Invoke(obj, this.m_Type));
}
for (int m = 0; m < parameterCount; m++)
{
args[m] = (m >= length) ? base2.DefaultParameter[m - requiredNumber] : Util.ChangeType(this.m_Script, parameters[m], base2.ParameterType[m]);
}
return(base2.Invoke(obj, this.m_Type));
}
}
catch (Exception exception)
{
throw new ExecutionException(this.m_Script, "Type[" + this.m_Type.ToString() + "] 调用函数出错 [" + this.MethodName + "] : " + exception.ToString());
}
throw new ExecutionException(this.m_Script, "Type[" + this.m_Type.ToString() + "] 找不到合适的函数 [" + this.MethodName + "]");
}
public static async Task <HttpResponseMessage> CreateRespone(HttpRequestMessage req, string functionName)
{
// Get request body
var jsonBody = await req.Content.ReadAsStringAsync();
if (string.IsNullOrWhiteSpace(jsonBody))
{
jsonBody = @"{}";
}
var body = JsonConvert.DeserializeObject <JObject>(jsonBody);
// Get parameters
var inputParameters = body.Values();
var arguments = new object[inputParameters.Count()];
var i = 0;
foreach (var p in inputParameters.Values())
{
arguments[i++] = p.Value <string>();
}
var web3 = new Nethereum.Web3.Web3(SmartContract.BlockchainRpcEndpoint);
var contract = web3.Eth.GetContract(SmartContract.Abi, SmartContract.ContractAddress);
var functionABI = contract.ContractBuilder.ContractABI.Functions
.FirstOrDefault(f => f.Name == functionName);
if (functionABI == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "Function not found!"));
}
var functionParameters = functionABI.InputParameters;
if (functionParameters?.Count() != inputParameters.Count())
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "Parameters do not match!"));
}
Function function = contract.GetFunction(functionName);
Type returnType = GetFunctionReturnType(functionABI);
IEthCall ethCall = contract.Eth.Transactions.Call;
var result = await ethCall.SendRequestAsync(function.CreateCallInput(arguments), contract.Eth.DefaultBlock)
.ConfigureAwait(false);
FunctionBase functionBase = function;
PropertyInfo builderBaseProperty = functionBase.GetType()
.GetProperty("FunctionBuilderBase", BindingFlags.Instance | BindingFlags.NonPublic);
if (builderBaseProperty != null)
{
FunctionBuilderBase builderBase = (FunctionBuilderBase)builderBaseProperty.GetValue(functionBase);
PropertyInfo funcCallDecoderProperty = builderBase.GetType()
.GetProperty("FunctionCallDecoder", BindingFlags.Instance | BindingFlags.NonPublic);
if (funcCallDecoderProperty != null)
{
ParameterDecoder decoder = (ParameterDecoder)funcCallDecoderProperty.GetValue(builderBase);
var results = decoder.DecodeDefaultData(result, functionABI.OutputParameters);
if (results.Count == 1)
{
var resultValue = JsonConvert.SerializeObject(results[0].Result);
return(req.CreateResponse(HttpStatusCode.OK, resultValue));
}
var resultMultiValue = Activator.CreateInstance(returnType, results.Select(r => r.Result).ToArray());
return(req.CreateResponse(HttpStatusCode.OK, JsonConvert.SerializeObject(resultMultiValue)));
}
}
return(req.CreateResponse(HttpStatusCode.InternalServerError));
}
