public void MaskedValueData()
{
string maskedValue = "erotueur";
ParameterData data = new ParameterData("testName", maskedValue);
SensitiveParameterNode node = new SensitiveParameterNode(data);
Assert.AreEqual(maskedValue, node.MaskedValue.PasswordText);
}
public void AddRemoveTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameters.Add(parameter);
Assert.AreEqual(1, parameters.Count);
parameters.Remove(parameter.Name);
}
private ISequenceStep CreateClassGenStep(string instanceName, ISequence parentSequence)
{
if (parentSequence.Variables.All(item => !item.Name.Equals(instanceName)))
{
// 添加实例变量
Variable instanceVariable = new Variable()
{
Description = $"Variable {instanceName}",
LogRecordLevel = RecordLevel.FinalResult,
Name = instanceName,
OIRecordLevel = RecordLevel.FinalResult,
Parent = parentSequence,
ReportRecordLevel = RecordLevel.FinalResult,
Type = _testClassTypeData,
TypeIndex = 1,
VariableType = VariableType.Class
};
parentSequence.Variables.Add(instanceVariable);
}
// 添加实例化类的step
ISequenceStep step = _sequenceManager.CreateSequenceStep();
step.RecordStatus = true;
step.Function = new FunctionData()
{
ClassType = _testClassTypeData,
ClassTypeIndex = 1,
Description = null,
Instance = instanceName,
MethodName = _testClassTypeData.Name,
Return = string.Empty,
Type = FunctionType.Constructor
};
step.Function.ParameterType = new ArgumentCollection();
Argument intArgument = new Argument()
{
Modifier = ArgumentModifier.None,
Name = "waitTime",
Type = _intTypeData,
TypeIndex = 0,
VariableType = VariableType.Value
};
step.Function.ParameterType.Add(intArgument);
step.Function.Parameters = new ParameterDataCollection();
ParameterData intParameterData = new ParameterData()
{
Index = 0,
ParameterType = ParameterType.Value,
Value = "100"
};
step.Function.Parameters.Add(intParameterData);
return(step);
}
public void ClearTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameters.Add(parameter);
Assert.AreEqual(1, parameters.Count);
parameters.Clear();
Assert.AreEqual(0, parameters.Count);
}
public override Task <GetParameterDataReply> GetParameterData(GetParameterDataRequest request, ServerCallContext context)
{
var dataList = new ParameterData();
var reply = new GetParameterDataReply();
reply.ParameterData.Add(dataList);
return(Task.FromResult(reply));
}
/// <summary>
/// <para>
/// Initialize a new instance of the <see cref="ParameterNode"/> class with a <see cref="ParameterData"/> object.
/// </para>
/// </summary>
/// <param name="parameter">
/// <para>The <see cref="ParameterData"/> runtime configuration.</para>
/// </param>
public ParameterNode(ParameterData parameter)
: base()
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
this.parameterData = parameter;
}
public void AddRemoveTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameters.Add(parameter);
Assert.AreEqual(1, parameters.Count);
parameters.Remove(parameter.Name);
}
private ISequenceStep CreateCallBackStep(int x, int y)
{
ISequenceStep step = _sequenceManager.CreateSequenceStep();
step.RecordStatus = true;
step.Function = new FunctionData()
{
ClassType = _testCallBackTypeData,
ClassTypeIndex = 6,
Description = null,
Instance = string.Empty,
MethodName = CallBackMethodName,
Return = string.Empty,
Type = FunctionType.CallBack
};
#region 添加参数类型
step.Function.ParameterType = new ArgumentCollection();
Argument intArgument = new Argument()
{
Modifier = ArgumentModifier.None,
Name = "x",
Type = _intTypeData,
TypeIndex = 0
};
step.Function.ParameterType.Add(intArgument);
intArgument = new Argument()
{
Modifier = ArgumentModifier.None,
Name = "y",
Type = _intTypeData,
TypeIndex = 0
};
step.Function.ParameterType.Add(intArgument);
#endregion
#region 添加参数值
step.Function.Parameters = new ParameterDataCollection();
ParameterData intParameterData = new ParameterData()
{
Index = 0,
ParameterType = ParameterType.Value,
Value = x.ToString()
};
step.Function.Parameters.Add(intParameterData);
intParameterData = new ParameterData()
{
Index = 0,
ParameterType = ParameterType.Value,
Value = y.ToString()
};
step.Function.Parameters.Add(intParameterData);
#endregion
return(step);
}
public static Parameter ToModel(this ParameterData node)
{
return(new Parameter()
{
Id = node.Id,
BrandId = node.BrandId,
TypeId = node.DictionaryId,
Unit = node.Unit
});
}
public ParameterVm(ParameterData <int> model)
{
Model = model;
Hp = model.ToReactivePropertyAsSynchronized(x => x.Hp).AddTo(CompositeDisposable);
Attack = model.ToReactivePropertyAsSynchronized(x => x.Attack).AddTo(CompositeDisposable);
Defense = model.ToReactivePropertyAsSynchronized(x => x.Defense).AddTo(CompositeDisposable);
SpecialAttack = model.ToReactivePropertyAsSynchronized(x => x.SpecialAttack).AddTo(CompositeDisposable);
SpecialDefense = model.ToReactivePropertyAsSynchronized(x => x.SpecialDefense).AddTo(CompositeDisposable);
Speed = model.ToReactivePropertyAsSynchronized(x => x.Speed).AddTo(CompositeDisposable);
}
public readonly IDictionary <string, string> DictionaryParameters; // external storage for custom parameters
public ParameterData(ParameterData parent)
{
Parent = parent;
#if MEMORY_PRIORITY
ObjectParameters = new Dictionary <int, object>();
#else
ObjectParameters = new object[(int)WidgetParameterIndex.Max];
#endif
DictionaryParameters = new Dictionary <string, string>();
}
public void Test_Valid_Parameter_Value()
{
string parameter = "param1=value1¶m2=value2¶m3=value3";
ParameterData parameterData = new ParameterData(parameter);
string value2 = parameterData.GetParameterValue("param2");
string value3 = parameterData.GetParameterValue("param3");
Assert.AreEqual(value2, "value2");
Assert.AreEqual(value3, "value3");
}
public void ClearTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameters.Add(parameter);
Assert.AreEqual(1, parameters.Count);
parameters.Clear();
Assert.AreEqual(0, parameters.Count);
}
/// <summary>
/// Get all important information of ParameterInstance
/// Return a parameterInfo with:
/// -ParameterName
/// -ParameterRange(start,end)
/// </summary>
/// <param name="instance">current ParameterInstance</param>
/// <returns></returns>
private ParameterData GetParameterName(ParameterInstance instance)
{
///Create the parameter description
///useflue to get all information
PARAMETER_DESCRIPTION desc = new PARAMETER_DESCRIPTION();
instance.getDescription(out desc);
ParameterData parameterInfo = new ParameterData(instance, desc.name, desc.minimum, desc.maximum, desc.defaultvalue);
return(parameterInfo);
}
public IHttpActionResult PostParameter(ParameterData parameter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var node = paramBLL.Create(parameter.ToModel());
return(Ok(node.ToViewData()));
}
private void SetParameter(ParameterData parameterData)
{
for (int i = 0; i < _parametersList.Length; i++)
{
TimelineParameter timelineParameter = _parametersList[i];
if ((parameterData._index >= 0) ? (i == parameterData._index) : (timelineParameter._ID == parameterData._parameter))
{
timelineParameter.SetValue(parameterData._value);
}
}
}
public ParameterData Clone()
{
ParameterData data = new ParameterData();
data.Name = this.Name;
data.JsonName = this.JsonName;
data.SubNodeName = this.SubNodeName;
data.RawJsonName = this.RawJsonName;
data.Type = this.Type == null ? null : this.Type.Clone();
return(data);
}
public static bool IsExistInParameterData(this ParameterData parameterData, string[] symbols)
{
foreach (var symbol in symbols)
{
if (!parameterData.IsExist(symbol))
{
return(false);
}
}
return(true);
}
public void MaskedValue()
{
string maskedValue = "erotueur";
SensitiveParameterNode node = new SensitiveParameterNode();
node.MaskedValue = new Password(maskedValue);
Assert.AreEqual(maskedValue, node.MaskedValue.PasswordText);
ParameterData nodeData = node.Parameter;
Assert.AreEqual(maskedValue, nodeData.Value);
}
private void StoreParameter(ValueEntry refrenceVal, string keyString, ParameterData newParamData)
{
if (!_entry.Parameters.ContainsKey(keyString))
{
_entry.Parameters[keyString] = newParamData;
}
else
{
_entry.Parameters[keyString].RefrenceValue = refrenceVal;
}
}
/// <summary>
/// 获取默认请求参数
/// </summary>
/// <returns></returns>
public static ParameterData GetDefaultParameter()
{
var data = new ParameterData();
data.SetValue("version", "2.0"); //接口版本号
data.SetValue("charset", "UTF-8"); //字符集
data.SetValue("sign_type", "MD5"); //签名方式
data.SetValue("mch_id", SwiftPassConfig.mch_id); //必填项，商户号，由平台分配
data.SetValue("mch_create_ip", System.Web.HttpContext.Current.Request.UserHostAddress); //终端IP
data.SetValue("nonce_str", Guid.NewGuid().ToString().Replace("-", "")); //随机字符串，必填项，不长于 32 位
return(data);
}
private CommandData ProcessCommandsParameters(CommandData command)
{
Increment();
for (int p = 0; p < command.ParameterCount; p++)
{
var parameter = new ParameterData(commandDataSource[structureIndex]);
command[p] = parameter;
Increment();
}
return(command);
}
private void SetData(ParameterData data)
{
if (data == null)
{
return;
}
Data = data;
parameterLabel.Text = data.Parameter;
unitLabel.Text = data.Unit;
}
public override void VisitParameterData(ParameterData item)
{
_owner._writer.Write(item.Name);
_owner._writer.Write(_owner.GetTypeId(item.Type));
_owner._writer.Write((byte)item.Modifer);
_owner._writer.Write(item.IsParamsArray);
_owner._writer.Write(item.IsOptional);
if (item.IsOptional)
{
WriteDefaultValue(item.DefaultValue);
}
}
private static List <BreakingChangeBase> CompareParameters(ParameterData oldParameter, ParameterData newParameter, AssemblyFamily newAssemblyFamily, MetadataItemBase declaringMember)
{
var breakingChanges = CompareItems(oldParameter, newParameter, newAssemblyFamily, declaringMember);
// If a parameter is changed completely, it will most likely have a new type and name. We should only warn about the type change.
var typeChanges = new HashSet <ParameterData>(
breakingChanges.OfType <ChangedParameterType>().Select(b => b.NewParameter)
);
breakingChanges.RemoveAll(b => b.BreakingChangeKind == BreakingChangeKind.ChangedParameterName && typeChanges.Contains((ParameterData)b.NewItem));
return(breakingChanges);
}
public static ParameterData[] ReadArray(BinaryReader reader)
{
Int32 count = reader.ReadInt16();
ParameterData[] arr = new ParameterData[count];
for (Int32 i = 0; i < arr.Length; i++)
{
arr[i] = new ParameterData(reader);
}
return(arr);
}
public void SetParameters(VirtuosoParameterCollection parameters)
{
if (parameterData != null)
{
parameterData.Dispose();
parameterData = null;
}
if (parameters != null && parameters.Count > 0)
{
parameterData = new ParameterData(parameters);
parameterData.SetParameters((VirtuosoConnection)outerCommand.Connection, hstmt);
}
}
private void OnDGSelectionChanged(object sender, SelectionChangedEventArgs e)
{
ParameterData pd = dg.SelectedItem as ParameterData;
if (pd.Name == "备注")
{
var content = dg.Columns[0].GetCellContent(pd);
dg.Columns[1].SetValue(DataGridColumn.IsReadOnlyProperty, false);
}
else if ((bool)dg.Columns[1].GetValue(DataGridColumn.IsReadOnlyProperty) == false)
{
dg.Columns[1].SetValue(DataGridColumn.IsReadOnlyProperty, true);
}
}
public void EnumeratorTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameters.Add(parameter);
IEnumerator enumerator = parameters.GetEnumerator();
enumerator.Reset();
while (enumerator.MoveNext())
{
Assert.IsNotNull(enumerator.Current);
}
}
public void CreateFromRuntimeTest()
{
DatabaseSettings databaseSettings = DatabaseSettingsBuilder.Create(Host);
ParameterData data = databaseSettings.ConnectionStrings["Northwind"].Parameters["server"];
ParameterNode node = new ParameterNode(data);
CreateHierarchyAndAddToHierarchyService(node, CreateDefaultConfiguration());
Assert.AreEqual(data.Name, node.Name);
Assert.AreEqual(data.Value, node.Value);
ValidateNodeCommand cmd = new ValidateNodeCommand(Host);
cmd.Execute(node);
Assert.AreEqual(0, ValidationErrorsCount);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JsonSerializer cleanSerializer = new JsonSerializer();
LiveTestRequest request = cleanSerializer.Deserialize(reader, objectType) as LiveTestRequest;
// Current test protocol states that the method is given as A.B_C, so ignore anything without a '.'.
int dotIndex = request.Method.IndexOf('.');
if (dotIndex != -1)
{
request.OperationId = request.Method.Substring(dotIndex + 1).ToLowerInvariant();
if (module.Operations.ContainsKey(request.OperationId))
{
OperationData op = module.Operations[request.OperationId];
if (request.Params != null)
{
Dictionary <string, object> newParams = new Dictionary <string, object>();
foreach (string key in request.Params.Keys)
{
// Reserved parameter will be converted later.
if (key.Equals("__reserved", StringComparison.OrdinalIgnoreCase))
{
newParams[key] = request.Params[key];
}
else
{
ParameterData match = op.Parameters.Where((kvp) => !String.IsNullOrEmpty(kvp.Value.JsonName) &&
kvp.Value.JsonName.Equals(key, StringComparison.OrdinalIgnoreCase)).Select((kvp) => kvp.Value).FirstOrDefault();
if (match == null && op.Parameters.ContainsKey(key.ToLowerInvariant()))
{
match = op.Parameters[key.ToLowerInvariant()];
}
if (match != null)
{
// This means that the parameter has been renamed from the spec name.
object converted;
if (ConvertObject(request.Params[key], match.Type.Type, serializer, out converted))
{
newParams[match.Name.ToLowerInvariant()] = converted;
}
}
}
}
request.Params = newParams;
}
}
}
return(request);
}
public override int Score(ParameterData parameterData)
{
int highScore = 0;
foreach (var selector in _selectors)
{
var score = selector.Score(parameterData);
if (score > highScore)
{
highScore = score;
}
}
return(highScore);
}
/// <summary>
/// 微信公众号支付
/// </summary>
/// <param name="out_trade_no"></param>
/// <param name="total_fee"></param>
/// <param name="notify_url"></param>
/// <param name="time_expire"></param>
/// <param name="openid"></param>
/// <returns></returns>
public static string WeChatJsApiPay(string out_trade_no, int total_fee, string notify_url, string time_expire, string openid)
{
var reqData = SwiftPassCore.GetDefaultParameter();
reqData.SetValue("service", "pay.weixin.jspay"); //接口类型：pay.weixin.jspay
reqData.SetValue("out_trade_no", out_trade_no); //商户订单号
reqData.SetValue("body", string.Format("{0}订单:{1}", AppConfig.Global.WebSiteName, out_trade_no)); //商品描述
reqData.SetValue("attach", string.Format("{0}订单:{1}", AppConfig.Global.WebSiteName, out_trade_no)); //附加信息
reqData.SetValue("total_fee", total_fee.ToString()); //总金额
reqData.SetValue("time_start", DateTime.Now.ToString("yyyyMMddHHmmss")); //订单生成时间
reqData.SetValue("time_expire", time_expire); //订单超时时间
reqData.SetValue("notify_url", notify_url); //通知地址，必填项，接收平台通知的URL，需给绝对路径，255字符内;此URL要保证外网能访问
reqData.SetValue("is_raw", "1"); //是否原生态支付方式 1.是 0.否 默认0
reqData.SetValue("sub_openid", openid); //微信用户关注商家公众号的openid
reqData.SetValue("sub_appid", CQSS.Pay.BLL.WeChatPay.Api.WxPayConfig.APPID); //微信公众平台基本配置中的AppID
reqData.SetValue("sign", SwiftPassCore.CreateSign(reqData)); //以上参数进行签名
string data = reqData.ToXml(); //生成XML报文
Dictionary <string, string> reqContent = new Dictionary <string, string>();
reqContent.Add("url", SwiftPassConfig.req_url);
reqContent.Add("data", data);
PayHttpClient pay = new PayHttpClient();
pay.setReqContent(reqContent);
if (!pay.call())
{
throw new BizException(string.Format("HTTP ERROR：Code[{0}] Message[{1}]", pay.getResponseCode(), pay.getErrInfo()));
}
var resData = new ParameterData();
resData.FromXml(pay.getResContent());
if (resData.GetValue("status") != "0") //校验返回状态
{
throw new BizException("返回状态错误代码：" + resData.GetValue("status") + "，错误信息：" + resData.GetValue("message"));
}
if (!SwiftPassCore.CheckSign(resData)) //校验数据签名
{
throw new BizException("公众号支付签名校验未通过");
}
if (resData.GetValue("result_code") != "0") //校验业务结果
{
throw new BizException("业务结果错误代码：" + resData.GetValue("err_code") + "，错误信息：" + resData.GetValue("err_msg"));
}
return(resData.GetValue("pay_info"));//json格式的字符串，作用于原生态js支付时的参数
}
public OverloadEntry(MethodBase mi)
{
IEnumerable <ParameterData> ie;
if (mi.IsStatic || mi is ConstructorInfo)
{
ie = new ParameterData[] { new ParameterData()
{
name = "(static this)"
} };
}
else
{
ie = new ParameterData[] {
new ParameterData {
name = "this",
parameterType = mi.DeclaringType
}
};
}
ie = ie.Concat(mi.GetParameters().Select(e =>
{
var d = new ParameterData();
d.name = e.Name;
d.parameterType = e.ParameterType;
d.isOut = e.IsOut;
d.isParams = e.IsDefined(typeof(ParamArrayAttribute), false);
return(d);
}));
ps = ie.ToArray();
cachedFunction = null;
entityWrapper = null;
cachedData = default(GCHandle);
if (mi is ConstructorInfo)
{
entityWrapper = new ConstructorWrapper((ConstructorInfo)mi);
}
else if (mi is MethodInfo)
{
if (mi.IsStatic)
{
entityWrapper = new StaticMethodWrapper((MethodInfo)mi);
}
else
{
entityWrapper = new InstanceMethodWrapper((MethodInfo)mi);
}
}
}
public void EnumeratorCurrentTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameter.Value = "MyValue";
parameters.Add(parameter);
ParameterData parameter2 = new ParameterData();
parameter2.Name = "MyName2";
parameter2.Value = "MyValue2";
parameters.Add(parameter2);
int count = 0;
foreach (ParameterData param1 in parameters)
{
Assert.IsNotNull(param1);
count++;
foreach (ParameterData param2 in parameters)
{
Assert.IsNotNull(param2);
count++;
}
}
Assert.AreEqual(6, count);
}
/// <summary>
/// AttributeConvention -> NamingPolicy
/// </summary>
/// <param name="api"></param>
/// <param name="param"></param>
/// <returns></returns>
private string ProcessConvention(object api, ParameterData param)
{
string output = param.name;
if (param.requestAttribute != null &&
Conv(param.requestAttribute.convention, param.name, out output))
{
return output;
}
var policy = (NamingPolicy)api
.GetType()
.GetProperty(nameof(WithNamingPolicy.namingPolicy))
.GetValue(api);
ConventionType convention = ConventionType.None;
switch (param.type)
{
case ParameterType.PostJson:
convention = policy.postJson;
break;
case ParameterType.Header:
convention = policy.header;
break;
case ParameterType.RequestUri:
convention = policy.requestUri;
break;
}
if (Conv(convention, param.name, out output))
{
return output;
}
return param.name;
}
/// <summary>
/// <para>
/// Initialize a new instance of the <see cref="SensitiveParameterNode"/> class with a <see cref="ParameterData"/> object.
/// </para>
/// </summary>
/// <param name="parameterData">
/// <para>The <see cref="ParameterData"/> runtime configuration.</para>
/// </param>
public SensitiveParameterNode(ParameterData parameterData)
: base(parameterData)
{
this.parameter = parameterData;
this.parameter.IsSensitive = true;
}
private void DisposeParameters ()
{
CLI.ReturnCode rc = (CLI.ReturnCode) CLI.SQLFreeStmt (hstmt, (ushort) CLI.FreeStmtOption.SQL_RESET_PARAMS);
if (rc != CLI.ReturnCode.SQL_SUCCESS && rc != CLI.ReturnCode.SQL_NO_DATA)
Diagnostics.HandleResult (rc, this, outerCommand.Connection);
GC.KeepAlive (this);
if (parameterData != null)
{
parameterData.Dispose ();
parameterData = null;
}
}
private void AddDefaultParameter(ParameterData data)
{
ParameterNode node = new ParameterNode(data);
Nodes.AddWithDefaultChildren(node);
}
private void GetTypeParts(System.Type type, out System.Type baseType, out ParameterData[] parameterDataArray, out int[] arrayRanks)
{
baseType = null;
parameterDataArray = null;
arrayRanks = null;
if (type.IsArray)
{
ArrayList list = new ArrayList();
this.GetTypeParts(type.GetElementType(), out baseType, out parameterDataArray, out arrayRanks);
if (arrayRanks != null)
{
list.AddRange(arrayRanks);
}
list.Add(type.GetArrayRank());
arrayRanks = (int[]) list.ToArray(typeof(int));
}
else if (type.IsGenericType)
{
System.Type underlyingSystemType = null;
System.Type type3 = null;
if (type.ContainsGenericParameters)
{
type3 = null;
underlyingSystemType = type.UnderlyingSystemType;
}
else
{
type3 = type;
underlyingSystemType = type.GetGenericTypeDefinition().UnderlyingSystemType;
}
ArrayList list2 = new ArrayList();
for (int i = 0; i < underlyingSystemType.GetGenericArguments().Length; i++)
{
ParameterData data = new ParameterData {
ParameterType = underlyingSystemType.GetGenericArguments()[i]
};
if (type3 != null)
{
data.Type = type.GetGenericArguments()[i];
}
list2.Add(data);
}
parameterDataArray = (ParameterData[]) list2.ToArray(typeof(ParameterData));
baseType = underlyingSystemType;
}
else
{
baseType = type;
}
}
public string OnParameter(object api, ParameterData param)
{
return ProcessConvention(api, param);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value == null)
return new ParameterData();
else if (value is string)
{
ParameterData parameterData = new ParameterData();
if ((string)value != string.Empty)
{
ITypeProvider typeProvider = context.GetService(typeof(ITypeProvider)) as ITypeProvider;
parameterData.Type = typeProvider.GetType(value as string, true);
}
return parameterData;
}
return base.ConvertFrom(context, culture, value);
}
public void SetParameters (VirtuosoParameterCollection parameters)
{
if (parameterData != null)
{
parameterData.Dispose ();
parameterData = null;
}
if (parameters != null && parameters.Count > 0)
{
parameterData = new ParameterData (parameters);
parameterData.SetParameters ((VirtuosoConnection) outerCommand.Connection, hstmt);
}
}
public void EnumeratorTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameters.Add(parameter);
IEnumerator enumerator = parameters.GetEnumerator();
enumerator.Reset();
while (enumerator.MoveNext())
{
Assert.IsNotNull(enumerator.Current);
}
}
public void AddAsObjectTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameters.Add((Object)parameter);
}
public void AddItemTest()
{
ParameterData parameter = new ParameterData();
parameter.Name = "MyName";
parameters[parameter.Name] = parameter;
}
public static ParameterData[] ReadArray(BinaryReader reader)
{
Int32 count = reader.ReadInt16();
ParameterData[] arr = new ParameterData[count];
for (Int32 i = 0; i < arr.Length; i++)
arr[i] = new ParameterData(reader);
return arr;
}
private void GetTypeParts(Type type, out Type baseType, out ParameterData[] parameterDataArray, out int[] arrayRanks)
{
baseType = null;
parameterDataArray = null;
arrayRanks = null;
if (type.IsArray == true)
{
ArrayList arrayRankList = new ArrayList();
GetTypeParts(type.GetElementType(), out baseType, out parameterDataArray, out arrayRanks);
if (arrayRanks != null)
arrayRankList.AddRange(arrayRanks);
arrayRankList.Add(type.GetArrayRank());
arrayRanks = (int[])arrayRankList.ToArray(typeof(int));
}
else if (type.IsGenericType)
{
Type unboundedType = null;
Type boundedType = null;
if (type.ContainsGenericParameters)
{
boundedType = null;
unboundedType = type.UnderlyingSystemType;
}
else
{
boundedType = type;
unboundedType = type.GetGenericTypeDefinition().UnderlyingSystemType;
}
ArrayList parameterDataList = new ArrayList();
for (int loop = 0; loop < unboundedType.GetGenericArguments().Length; loop++)
{
ParameterData parameterData = new ParameterData();
parameterData.ParameterType = unboundedType.GetGenericArguments()[loop];
if (boundedType != null)
parameterData.Type = type.GetGenericArguments()[loop];
parameterDataList.Add(parameterData);
}
parameterDataArray = (ParameterData[])parameterDataList.ToArray(typeof(ParameterData));
baseType = unboundedType;
}
else
{
baseType = type;
}
}
public void Initialize()
{
XmlTextReader xmlReader = new XmlTextReader(new StringReader(xmlString));
XmlSerializer xmlSerializer = new XmlSerializer(typeof(ParameterData));
parameter = xmlSerializer.Deserialize(xmlReader) as ParameterData;
}
