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)); }
/// <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(); } }