private void CheckParameterForDuplication(string name)
{
if (Parameters.ContainsKey(name) || OutputParameters.ContainsKey(name))
{
throw new DuplicateNameException("Duplicate parameter '" + name + "'.");
}
}
public OutputParameters MLS_getMLS(double[] xArray_change, int[] vArray_change)
{
OutputParameters outputParameters = new OutputParameters();
pub_function.logit_MLS_getMLS(xArray_change, vArray_change, out outputParameters.μ0_final, out outputParameters.σ0_final, out outputParameters.Maxf, out outputParameters.Mins);
return(outputParameters);
}
/// <summary>
/// 设置回传参数
/// </summary>
public override Dictionary <string, string> SetViewParameters()
{
Dictionary <string, string> result = base.SetViewParameters();
OutputParameters = OutputParameters ?? new SortedList();
if (_confirmUser != null)
{
SortedList confirmUserParams = new SortedList();
//是否需要确认包的人编码和信息
confirmUserParams.Add("confirmUserId", _confirmUser.UserID);
if (OutputParameters.ContainsKey("confirmUserParams"))
{
OutputParameters["confirmUserParams"] = confirmUserParams;
}
else
{
OutputParameters.Add("confirmUserParams", confirmUserParams);
}
}
if (!_isPrintedBCU)
{
PrintBCUCode();
}
return(result);
}
public UseCase(UseCaseTypes type)
: this()
{
Type = type;
Name = type.ToString();
IsCustom = false;
if (type == UseCaseTypes.RetrieveByPk)
{
InputParameters.Add(new DataParameter(DomainInputType.Guid, "Id"));
OutputParameters.Add(new DataParameter(DomainInputType.DomainEntity, "Entity"));
}
else if (type == UseCaseTypes.RetrieveByUn)
{
InputParameters.Add(new DataParameter(DomainInputType.String, "Name"));
OutputParameters.Add(new DataParameter(DomainInputType.DomainEntity, "Entity"));
}
else if (type == UseCaseTypes.Create)
{
InputParameters.Add(new DataParameter(DomainInputType.DomainEntity, "Entity"));
OutputParameters.Add(new DataParameter(DomainInputType.Guid, "Id"));
}
else if (type == UseCaseTypes.Update)
{
InputParameters.Add(new DataParameter(DomainInputType.DomainEntity, "Entity"));
}
else if (type == UseCaseTypes.DeleteByPk)
{
InputParameters.Add(new DataParameter(DomainInputType.Guid, "Id"));
}
else if (type == UseCaseTypes.DeleteByUn)
{
InputParameters.Add(new DataParameter(DomainInputType.String, "Name"));
}
}
public void AssignOutputParameterContainer(string ParamName, out SqlParameter ParamOut, object Value = null)
{
SqlParameter _param;
if (ParamName.Substring(0, 1) != "@")
{
ParamName = '@' + ParamName;
}
if (Parameters[ParamName] != null)
{
_param = Parameters[ParamName];
}
else
{
_param = new SqlParameter()
{
ParameterName = ParamName
};
Parameters.Add(_param);
}
if (Value != null)
{
AddParameterValue(ParamName, Value);
}
OutputParameters.Add(_param);
ParamOut = _param;
//ObjectParameters.Add(new ObjectParameter() {Container=Container, Parameter=_param });
}
public SqlQuery SetInt64OutParam(string paramName)
{
String pname = SetOutParam(paramName, DbType.Int64);
OutputParameters.Add(paramName, new OutputParameter(pname, typeof(Int64)));
return(this);
}
/// <summary>
/// Convert all DBNull values to null
/// </summary>
public void ConvertDBNullToNull()
{
if (Convert.IsDBNull(ReturnValue))
{
ReturnValue = null;
}
if (OutputParameters != null)
{
OutputParameters.ConvertDBNullToNull();
}
if (ResultSets != null)
{
foreach (var resultSet in ResultSets)
{
if (resultSet != null)
{
foreach (var record in resultSet)
{
if (record != null)
{
record.ConvertDBNullToNull();
}
}
}
}
}
}
public void Init()
{
// MAKE SURE before you run this test, you MUST change the API key to yours; otherwise the test fails.
this._settings = ConverterSettings.CreateInstance();
this._formats = new Formats();
this._wrapper = new ConverterWrapper(this._settings);
this._input = new InputParameters()
{
InputFormat = this._formats.Document.Md,
InputMethod = InputMethod.Download,
Filepath = "https://raw.githubusercontent.com/aliencube/CloudConvert.NET/dev/README.md",
Filename = "README.md",
};
this._output = new OutputParameters()
{
DownloadMethod = DownloadMethod.False,
OutputStorage = OutputStorage.OneDrive,
};
this._conversion = new ConversionParameters()
{
OutputFormat = this._formats.Document.Docx,
ConverterOptions = new MarkdownConverterOptions()
{
InputMarkdownSyntax = MarkdownSyntaxType.Auto
},
};
}
public void Init()
{
// MAKE SURE before you run this test, you MUST change the API key to yours; otherwise the test fails.
this._settings = ConverterSettings.CreateInstance();
this._formats = new Formats();
this._wrapper = new ConverterWrapper(this._settings);
this._input = new InputParameters()
{
InputFormat = this._formats.Website.Website,
InputMethod = InputMethod.Url,
Filepath = "http://www.google.com"
};
this._output = new OutputParameters()
{
DownloadMethod = DownloadMethod.False,
OutputStorage = OutputStorage.None,
Wait = true
};
this._conversion = new ConversionParameters()
{
OutputFormat = this._formats.Document.Pdf,
ConverterOptions = null
};
}
public DbValue[] GetOutputParameters()
{
if (OutputParameters != null && OutputParameters.Count > 0)
{
return(OutputParameters.Dequeue());
}
return(null);
}
public RepositoryMethod AddDefaultOutputViewParameter()
{
OutputParameters.Add(new DataParameter(DomainInputType.Enumerable, "Collection")
{
EnumerableType = DomainInputType.DomainEntity
});
return(this);
}
public override OutputParameters DotDistribution(double[] xArray, int[] vArray)
{
OutputParameters outputParameters = new OutputParameters();
pub_function.logit_MLS_getMLS(xArray, vArray, out outputParameters.μ0_final, out outputParameters.σ0_final, out outputParameters.Maxf, out outputParameters.Mins);
return(Class_区间估计.LogisticInterval_estimation_渐进法_方差(xArray.Length, xArray, vArray, outputParameters));
}
/// <summary>
/// Gets the <c>ConvertRequest</c> object.
/// </summary>
/// <param name="input"><c>InputParameters</c> object.</param>
/// <param name="output"><c>OutputParameters</c> object.</param>
/// <param name="conversion"><c>ConversionParameters</c> object.</param>
/// <returns>Returns the <c>ConvertRequest</c> object.</returns>
public ConvertRequest GetConvertRequest(InputParameters input, OutputParameters output, ConversionParameters conversion)
{
var request = Mapper.Map <ConvertRequest>(input)
.Map(output)
.Map(conversion);
return(request);
}
public void OutputParameterShouldHonorParameterMappings()
{
ColumnMapping.Parameters.RemovePrefixes("out_");
var output = new OutputParameters();
Connection().Execute("OutputParameterMappingTest", outputParameters: output);
Assert.AreEqual(0, output.out_foo);
Assert.AreEqual(5, output.foo);
}
public T GetOutputParameter <T>(OutputParameters parameterName)
{
if (_outputParameters.ContainsKey(parameterName))
{
return((T)_outputParameters[parameterName]);
}
;
throw new ArgumentException(string.Format("No Output parameter {0} has been set", parameterName.ToString()));
}
internal void SetOutputParameters(ProcessNode node)
{
if (OutputParameters == null)
{
OutputParameters = ImmutableDictionary.Create <string, IImmutableDictionary <string, object> >();
}
OutputParameters.Add(node.NodeName, node.OutputParameters);
}
public void CloseFunctionEditor()
{
m_functionGraph = null;
InputParameters.Clear();
OutputParameters.Clear();
RaisePropertyChanged(nameof(IsVisible));
}
public void OutputParameterShouldHonorParameterMappings()
{
ColumnMapping.Parameters.RemovePrefixes("out_");
var output = new OutputParameters();
Connection().Execute("OutputParameterMappingTest", outputParameters: output);
Assert.AreEqual(0, output.out_foo);
Assert.AreEqual(5, output.foo);
}
/// <summary>
/// Casts an output parameter by name to the specified type
/// </summary>
/// <typeparam name="TResult">The value of the output parameter</typeparam>
/// <param name="parameterName">The name of the parameter</param>
/// <returns>The value of the output parameter</returns>
public TResult GetOutputParameter <TResult>(string parameterName)
{
if (!OutputParameters.ContainsKey(parameterName))
{
throw new InvalidOperationException($"No Output parameter named {parameterName} was found");
}
return((TResult)OutputParameters[parameterName].Value);
}
public CalculateTrajectoryEventArgs(
StagesVariableValues StagesVariableValues,
OutputParameters OutputParameters,
CalculationInputData id) : base()
{
this.StagesVariableValues = StagesVariableValues;
this.OutputParameters = OutputParameters;
this.id = id;
}
public OutputParameters GetResult(double[] xArray, int[] vArray, double mumin, double mumax, double reso, out double z, double sigmaguess)
{
OutputParameters outputParameters = new OutputParameters();
outputParameters.sigmaguess = sigmaguess;
GetDistribution(xArray, vArray, mumin, mumax, 0.000000000000001, ref outputParameters, out z, sigmaguess);
pub_function.resolution_getReso(StandardSelection.ProcessValue(z), reso, out z);
outputParameters.μ0_final = StandardSelection.GetAvgValue(outputParameters.μ0_final);
return(outputParameters);
}
public Dictionary <string, object> PrepareExecution(ProjectState project, List <ActionParameter> parameters)
{
OutputParameters = parameters.ToDictionary(ActionParametersDefinition);
if (OutputParameters.ContainsKey("help"))
{
OutputParameters.Remove("help");
}
Execute(project, parameters);
return(OutputParameters);
}
public static void UpdateDoptimizeDataTable(ref DoptimizeDataTable ddt, OutputParameters outputParameters, string response, string sq)
{
ddt.ddt_StimulusQuantity = double.Parse(sq);
ddt.ddt_Response = int.Parse(response);
ddt.ddt_Mean = double.Parse(outputParameters.μ0_final.ToString("f13"));
ddt.ddt_StandardDeviation = double.Parse(outputParameters.σ0_final.ToString("f13"));
ddt.ddt_MeanVariance = double.IsNaN(outputParameters.varmu) ? 0 : outputParameters.varmu;
ddt.ddt_StandardDeviationVariance = double.IsNaN(outputParameters.varsigma) ? 0 : outputParameters.varsigma;
ddt.ddt_Covmusigma = double.IsNaN(outputParameters.covmusigma) ? 0 : outputParameters.covmusigma;
}
/* Private Internal methods */
override public void AnalyzeParam(SqlParameter Param)
{
if (Param.Direction == ParameterDirection.Output)
{
OutputParameters.Push(Param);
}
else if (Param.Direction == ParameterDirection.ReturnValue)
{
OutputParameters.Push(Param);
}
}
public object this[OutputParameters parameterName]
{
get
{
return(_outputParameters[parameterName]);
}
set
{
_outputParameters[parameterName] = value;
}
}
public OutputParameters GetResult(double[] xArray, int[] vArray)
{
for (int i = 0; i < xArray.Length; i++)
{
xArray[i] = StandardSelection.InverseProcessValue(xArray[i]);
}
OutputParameters outputParameters = DistributionSelection.DotDistribution(xArray, vArray);
outputParameters.μ0_final = StandardSelection.GetAvgValue(outputParameters.μ0_final);
return(outputParameters);
}
public override Dictionary <string, string> SetViewParameters()
{
Dictionary <string, string> result = base.SetViewParameters();
string personStr = personTxt.Text.Trim();
OutputParameters = OutputParameters ?? new SortedList();
SortedList personParams = new SortedList();
personParams.Add("person_barcode", personStr);
OutputParameters.Add("personParams", personParams);
return(result);
}
private static OutputParameters GetOutputParameters(OracleParameterCollection parameters)
{
OutputParameters outputParameters = new OutputParameters();
foreach (OracleParameter parameter in parameters)
{
if (parameter.Direction == ParameterDirection.Output)
{
outputParameters.Add(parameter);
}
}
return(outputParameters);
}
protected void Clear()
{
if (_rows != null && _rows.Count > 0)
{
_rows.Clear();
}
if (OutputParameters != null && OutputParameters.Count > 0)
{
OutputParameters.Clear();
}
_allRowsFetched = false;
}
public override Dictionary <string, string> SetViewParameters()
{
Dictionary <string, string> result = base.SetViewParameters();
OutputParameters = OutputParameters ?? new SortedList();
SortedList deviceParams = new SortedList();
deviceParams.Add("device_runtimes", txtBatch.Text);
deviceParams.Add("device_barcode", _MachineCode);
OutputParameters.Add("deviceParams", deviceParams);
return(result);
}
protected async Task ProcessStoredProcedureExecuteResponse(SqlResponse response, AsyncWrappingCommonArgs async)
{
try
{
if (response.Count > 0)
{
OutputParameters.Enqueue(await ReadRow(async).ConfigureAwait(false));
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public void OutputParameterShouldHonorParameterMappings()
{
try
{
using (var connection = _connectionStringBuilder.OpenWithTransaction())
{
connection.ExecuteSql("CREATE OR REPLACE PROCEDURE OutputParameterMappingTest (out_foo out int) IS BEGIN out_foo := 5; END;");
ColumnMapping.Parameters.RemovePrefixes("out_");
var output = new OutputParameters();
connection.Execute("OutputParameterMappingTest", outputParameters: output);
Assert.AreEqual(0, output.out_foo);
Assert.AreEqual(5, output.foo);
}
}
finally
{
ColumnMapping.All.ResetTransforms();
}
}
