public static void Test_TraceCompanies(string file, TypeValues <Test_Company> typeValues, bool onlyNextValue)
{
string[] values = typeValues.TypeValueNodes.Values.Where(memberValue => memberValue.TypeValueAccess.IsValueType).Select(memberValue => memberValue.TypeValueAccess.TreeName).ToArray();
int index = 1;
foreach (Test_Company company in Test_Data.GetCompanies(file))
{
typeValues.SetData(company);
Trace.WriteLine("row {0}", index++);
foreach (string value in values)
{
Trace.Write(" {0,-20}", value);
}
Trace.WriteLine();
foreach (string value in values)
{
Trace.Write(" {0,-20}", typeValues.GetValue(value));
}
Trace.WriteLine();
while (typeValues.NextValues())
{
foreach (string value in values)
{
Trace.Write(" {0,-20}", typeValues.GetValue(value, onlyNextValue: onlyNextValue));
}
Trace.WriteLine();
}
Trace.WriteLine();
}
}
public void CreateCompiled_ShouldHandleTypeValueArray()
{
var value = new TypeValues
{
Primitives = new[]
{
new Value {
B = 8, S = 16, I = 32, L = 64
},
new Value {
B = 8, S = 16, I = 32, L = 64
}
}
};
var writer = _binFactory.Get(34);
writer.WriteValue(value.Primitives.Length);
foreach (var v in value.Primitives)
{
v.Serialize(writer);
}
var reader = _binFactory.Get(writer.GetBuffer());
var compiledStorage = DeserializerStorageProvider.CreateCompiled <TypeValues>();
var desValue = new TypeValues();
compiledStorage.Deserialize(_emptyDes, reader, _policy, desValue);
Assert.True(!value.Primitives.Where((t, i) => !_valueComparer.Equals(t, desValue.Primitives[i])).Any());
}
public void CreateCompiled_ShouldHandleTypeValueArray()
{
var value = new TypeValues
{
Primitives = new[]
{
new Value {
B = 8, S = 16, I = 32, L = 64
},
new Value {
B = 8, S = 16, I = 32, L = 64
}
}
};
var writer = _binFactory.Get(34);
var writerSer = _binFactory.Get(34);
var compiledStorage = SerializerStorageProvider.CreateCompiled <TypeValues>();
writer.WriteValue(value.Primitives.Length);
foreach (var v in value.Primitives)
{
v.Serialize(writer);
}
compiledStorage.Serialize(_emptySer, writerSer, value);
Assert.Equal(
writer.GetBuffer().ToArray(),
writerSer.GetBuffer().ToArray());
}
private void CreateXmlValuesExport()
{
_typeValues = new TypeValues <T>();
List <XmlValueExport> valueList = new List <XmlValueExport>();
if (_xmlDefinition.ValuesDefinition != null)
{
foreach (XmlValueDefinition valueDefinition in _xmlDefinition.ValuesDefinition)
{
XmlValueExport xmlValueExport = new XmlValueExport();
xmlValueExport.ElementName = valueDefinition.ElementName;
xmlValueExport.TypeValueNode = _typeValues.AddValue(valueDefinition.ValueName, MemberType.Instance | MemberType.Public | MemberType.Field | MemberType.Property,
valueDefinition.NotEnumerable);
xmlValueExport.TransformValue = valueDefinition.TransformValue;
valueList.Add(xmlValueExport);
}
}
else
{
_typeValues.AddAllValues(MemberType.Instance | MemberType.Public | MemberType.Field | MemberType.Property);
foreach (TypeValueNode typeValueNode in _typeValues.TypeValueNodes.Values)
{
if (typeValueNode.TypeValueAccess.IsValueType)
{
XmlValueExport xmlValueExport = new XmlValueExport();
xmlValueExport.ElementName = typeValueNode.TypeValueAccess.TreeName;
xmlValueExport.TypeValueNode = typeValueNode;
valueList.Add(xmlValueExport);
}
}
}
_valuesExport = valueList.ToArray();
}
public static void Test_TraceCompanies(string file, TypeValues<Test_Company> typeValues, bool onlyNextValue)
{
string[] values = typeValues.TypeValueNodes.Values.Where(memberValue => memberValue.TypeValueAccess.IsValueType).Select(memberValue => memberValue.TypeValueAccess.TreeName).ToArray();
int index = 1;
foreach (Test_Company company in Test_Data.GetCompanies(file))
{
typeValues.SetData(company);
Trace.WriteLine("row {0}", index++);
foreach (string value in values)
Trace.Write(" {0,-20}", value);
Trace.WriteLine();
foreach (string value in values)
Trace.Write(" {0,-20}", typeValues.GetValue(value));
Trace.WriteLine();
while (typeValues.NextValues())
{
foreach (string value in values)
Trace.Write(" {0,-20}", typeValues.GetValue(value, onlyNextValue: onlyNextValue));
Trace.WriteLine();
}
Trace.WriteLine();
}
}
public static void Test_TypeValues_02(string file, params string[] values)
{
bool onlyNextValue = true;
//bool onlyNextValue = false;
TypeValues<Test_Company> typeValues = new TypeValues<Test_Company>();
foreach (string value in values)
typeValues.AddValue(value);
int index = 1;
foreach (Test_Company company in Test_Data.GetCompanies(file))
{
typeValues.SetData(company);
Trace.WriteLine("row {0}", index++);
foreach (string value in values)
Trace.Write(" {0,-20}", value);
Trace.WriteLine();
foreach (string value in values)
Trace.Write(" {0,-20}", typeValues.GetValue(value));
Trace.WriteLine();
while (typeValues.NextValues())
{
foreach (string value in values)
Trace.Write(" {0,-20}", typeValues.GetValue(value, onlyNextValue: onlyNextValue));
Trace.WriteLine();
}
Trace.WriteLine();
}
}
public static void Test_TypeValues_03(string file)
{
bool onlyNextValue = true;
//bool onlyNextValue = false;
TypeValues<Test_Company> typeValues = new TypeValues<Test_Company>();
typeValues.AddAllValues(MemberType.Instance | MemberType.Public | MemberType.Field | MemberType.Property);
Test_TraceCompanies(file, typeValues, onlyNextValue);
}
public static void Test_TypeValues_03(string file)
{
bool onlyNextValue = true;
//bool onlyNextValue = false;
TypeValues <Test_Company> typeValues = new TypeValues <Test_Company>();
typeValues.AddAllValues(MemberType.Instance | MemberType.Public | MemberType.Field | MemberType.Property);
Test_TraceCompanies(file, typeValues, onlyNextValue);
}
public void appendValues(TypeValues to_append)
{
if (!flagHasValues)
{
flagHasValues = true;
storeValues.Clear();
}
Debug.Assert(flagHasValues);
storeValues.Add(to_append);
}
public Beer(int id, string name, TypeValues type, bool ai, string manufacture, Chars c, Ingredients ingredient)
{
ID = id;
Name = name;
Type = type;
Ai = ai;
Manufacture = manufacture;
Char = c;
Ingredient = ingredient;
}
public static List <ValueListing> GetValueList(TypeValues entry)
{
List <ValueListing> result = null;
if (entry != null)
{
result = GetValueList(entry.Id);
}
return(result);
}
public static string stringFromValues(TypeValues the_enum)
{
switch (the_enum)
{
case TypeValues.Values_Heads:
return("Heads");
case TypeValues.Values_Tails:
return("Tails");
default:
Debug.Assert(false);
return(null);
}
}
public static void Test_TypeValues_02(string file, params string[] values)
{
bool onlyNextValue = true;
//bool onlyNextValue = false;
TypeValues <Test_Company> typeValues = new TypeValues <Test_Company>();
foreach (string value in values)
{
typeValues.AddValue(value);
}
int index = 1;
foreach (Test_Company company in Test_Data.GetCompanies(file))
{
typeValues.SetData(company);
Trace.WriteLine("row {0}", index++);
foreach (string value in values)
{
Trace.Write(" {0,-20}", value);
}
Trace.WriteLine();
foreach (string value in values)
{
Trace.Write(" {0,-20}", typeValues.GetValue(value));
}
Trace.WriteLine();
while (typeValues.NextValues())
{
foreach (string value in values)
{
Trace.Write(" {0,-20}", typeValues.GetValue(value, onlyNextValue: onlyNextValue));
}
Trace.WriteLine();
}
Trace.WriteLine();
}
}
protected override void handle_result(TypeValues result)
{
top.value.Add(result);
}
protected override void handle_result(TypeValues result)
{
//@@@ Debug.Assert(!have_value);
have_value = true;
value = result;
}
public static ValueClass createBonus(TypeValues type_values, float value)
{
return(new ValueClass(type_values, value));
}
public IEnumerable <Function> Read(SqlConnection connection, Version platformVersion)
{
var components = new Dictionary <string, Function>();
var query = this.GetFunctionQuery(platformVersion);
if (string.IsNullOrEmpty(query))
{
return(components.Values.ToList());
}
var command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var function = new Function
{
Name = reader["Name"] as string,
Title = reader["Title"] as string,
IsSystem = IsSystemValue.Equals(reader["IsSystem"] as string),
Help = reader["Help"] as string,
Comment = reader["Comment"] as string,
CalculationText = reader["CalculationText"] as string
};
if (function.CalculationText == null)
{
function.CalculationText = string.Empty;
}
components.Add(function.Name, function);
}
}
}
query = this.GetFunctionArgumentQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var functionName = reader["FunctionName"] as string;
if (!components.ContainsKey(functionName))
{
continue;
}
var function = components[functionName];
var argument = new FunctionArgument
{
Number = (int)reader["Number"],
Name = reader["Name"] as string
};
if (reader["Type"] is string typeValue &&
TypeValues.ContainsKey(typeValue))
{
argument.Type = TypeValues[typeValue];
}
argument.DefaultValue = reader["DefaultValue"] as string;
if (!string.IsNullOrEmpty(argument.DefaultValue))
{
argument.HasDefaultValue = true;
}
function.Arguments.Add(argument);
}
}
}
}
return(components.Values.ToList());
}
public IEnumerable <ReferenceType> Read(SqlConnection connection, Version platformVersion)
{
var components = new Dictionary <string, ReferenceType>();
var query = this.GetReferenceTypeQuery(platformVersion);
if (string.IsNullOrEmpty(query))
{
return(components.Values.ToList());
}
var command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var referenceType = new ReferenceType
{
Name = reader["Name"] as string,
Title = reader["Title"] as string
};
if (reader["State"] is string stateValue &&
StateValues.ContainsKey(stateValue))
{
referenceType.State = StateValues[stateValue];
}
if (reader["NumerationMethod"] is string numerationMethodValue &&
NumerationMethodValues.ContainsKey(numerationMethodValue))
{
referenceType.NumerationMethod = NumerationMethodValues[numerationMethodValue];
}
if (reader["DisplayRequisite"] is string displayRequisiteValue &&
DisplayRequisiteValues.ContainsKey(displayRequisiteValue))
{
referenceType.DisplayRequisite = DisplayRequisiteValues[displayRequisiteValue];
}
referenceType.LeadingReference = reader["LeadingReference"] as string;
referenceType.HasLongRecordNames = YesValue.Equals(reader["HasLongRecordNames"] as string);
referenceType.HasUniqueRecordNames = YesValue.Equals(reader["HasUniqueRecordNames"] as string);
var eventsValue = reader["Events"] as string;
if (!string.IsNullOrEmpty(eventsValue))
{
var events = EventTextParser.Parse(eventsValue);
foreach (var @event in events)
{
referenceType.Events.Add(@event);
}
}
components.Add(referenceType.Name, referenceType);
}
}
}
query = this.GetMethodsQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var referenceTypeName = reader["ReferenceTypeName"] as string;
if (!components.TryGetValue(referenceTypeName, out ReferenceType referenceType))
{
continue;
}
var method = new Method
{
Name = reader["Name"] as string,
CalculationText = reader["CalculationText"] as string ?? string.Empty
};
referenceType.Methods.Add(method);
}
}
}
}
query = this.GetMethodParamsQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var referenceTypeName = reader["ReferenceTypeName"] as string;
if (!components.TryGetValue(referenceTypeName, out ReferenceType referenceType))
{
continue;
}
var methodName = reader["MethodName"] as string;
var method = referenceType.Methods
.FirstOrDefault(m => m.Name == methodName);
if (method == null)
{
continue;
}
var parameter = new MethodParam
{
Number = (int)reader["Number"],
Name = reader["Name"] as string
};
var typeValue = reader["Type"] as string;
if (TypeValues.TryGetValue(typeValue, out MethodParamType methodParamType))
{
parameter.Type = methodParamType;
}
parameter.DefaultValue = reader["DefaultValue"] as string;
parameter.HasDefaultValue = !string.IsNullOrEmpty(parameter.DefaultValue);
method.Params.Add(parameter);
}
}
}
}
query = this.GetActionQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var referenceTypeName = reader["ReferenceTypeName"] as string;
if (!components.TryGetValue(referenceTypeName, out ReferenceType referenceType))
{
continue;
}
var action = new ActionWithHandler {
Name = reader["Name"] as string
};
var calculationText = reader["CalculationText"] as string;
var executionHandler = referenceType.Methods
.FirstOrDefault(m => m.Name == calculationText);
if (executionHandler != null)
{
action.ExecutionHandler = executionHandler;
}
else
{
action.CalculationText = calculationText ?? string.Empty;
}
referenceType.Actions.Add(action);
}
}
}
}
query = this.GetRequisiteQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var referenceTypeName = reader["ReferenceTypeName"] as string;
if (!components.TryGetValue(referenceTypeName, out ReferenceType referenceType))
{
continue;
}
var cardRequisite = new CardRequisite {
Number = (int)reader["Number"]
};
if (reader["Section"] is string sectionValue &&
RequisiteSectionValues.ContainsKey(sectionValue))
{
cardRequisite.Section = RequisiteSectionValues[sectionValue];
}
cardRequisite.Name = reader["Name"] as string;
cardRequisite.IsRequired = RuYesValue.Equals(reader["IsRequired"] as string);
cardRequisite.IsFilter = RuYesValue.Equals(reader["IsFilter"] as string);
cardRequisite.IsLeading = RuYesValue.Equals(reader["IsLeading"] as string);
cardRequisite.IsControl = RuYesValue.Equals(reader["IsControl"] as string);
var changeEventValue = reader["ChangeEvent"] as string;
if (!string.IsNullOrEmpty(changeEventValue))
{
var @event = new Event
{
EventType = EventType.Change,
CalculationText = changeEventValue
};
cardRequisite.Events.Add(@event);
}
var selectEventsValue = reader["SelectEvents"] as string;
if (!string.IsNullOrEmpty(selectEventsValue))
{
var events = EventTextParser.Parse(selectEventsValue);
foreach (var @event in events)
{
if (@event.EventType == EventType.Unknown)
{
@event.EventType = EventType.Select;
}
cardRequisite.Events.Add(@event);
}
}
referenceType.Requisites.Add(cardRequisite);
}
}
}
}
query = this.GetViewQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var referenceTypeName = reader["ReferenceTypeName"] as string;
if (!components.TryGetValue(referenceTypeName, out ReferenceType referenceType))
{
continue;
}
var view = new View
{
Name = reader["Name"] as string,
IsMain = RuYesValue.Equals(reader["IsMain"] as string),
ListForm = reader["ListForm"] as string,
CardForm = reader["CardForm"] as string
};
referenceType.Views.Add(view);
referenceType.Views.Add(view);
}
}
}
}
return(components.Values.ToList());
}
public IEnumerable <Dialog> Read(SqlConnection connection, Version platformVersion)
{
var components = new Dictionary <string, Dialog>();
var query = this.GetDialogQuery(platformVersion);
if (string.IsNullOrEmpty(query))
{
return(components.Values.ToList());
}
var command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var dialog = new Dialog
{
Name = reader["Name"] as string,
Title = reader["Title"] as string,
CardForm = reader["CardForm"] as string
};
var eventsValue = reader["Events"] as string;
if (!string.IsNullOrEmpty(eventsValue))
{
var events = EventTextParser.Parse(eventsValue);
foreach (var @event in events)
{
dialog.Events.Add(@event);
}
}
components.Add(dialog.Name, dialog);
}
}
}
query = this.GetMethodsQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var dialogName = reader["DialogName"] as string;
if (!components.TryGetValue(dialogName, out Dialog dialog))
{
continue;
}
var method = new Method
{
Name = reader["Name"] as string,
CalculationText = reader["CalculationText"] as string ?? string.Empty
};
dialog.Methods.Add(method);
}
}
}
}
query = this.GetMethodParamsQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var dialogName = reader["DialogName"] as string;
if (!components.TryGetValue(dialogName, out Dialog dialog))
{
continue;
}
var methodName = reader["MethodName"] as string;
var method = dialog.Methods
.FirstOrDefault(m => m.Name == methodName);
if (method == null)
{
continue;
}
var parameter = new MethodParam
{
Number = (int)reader["Number"],
Name = reader["Name"] as string
};
var typeValue = reader["Type"] as string;
if (TypeValues.TryGetValue(typeValue, out MethodParamType methodParamType))
{
parameter.Type = methodParamType;
}
parameter.DefaultValue = reader["DefaultValue"] as string;
parameter.HasDefaultValue = !string.IsNullOrEmpty(parameter.DefaultValue);
method.Params.Add(parameter);
}
}
}
}
query = this.GetActionQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var dialogName = reader["DialogName"] as string;
if (!components.TryGetValue(dialogName, out Dialog dialog))
{
continue;
}
var action = new ActionWithHandler {
Name = reader["Name"] as string
};
var calculationText = reader["CalculationText"] as string;
var executionHandler = dialog.Methods
.FirstOrDefault(m => m.Name == calculationText);
if (executionHandler != null)
{
action.ExecutionHandler = executionHandler;
}
else
{
action.CalculationText = calculationText ?? string.Empty;
}
dialog.Actions.Add(action);
}
}
}
}
query = this.GetRequisiteQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var dialogName = reader["DialogName"] as string;
if (!components.TryGetValue(dialogName, out Dialog dialog))
{
continue;
}
var cardRequisite = new CardRequisite {
Number = (int)reader["Number"]
};
if (reader["Section"] is string sectionValue &&
RequisiteSectionValues.ContainsKey(sectionValue))
{
cardRequisite.Section = RequisiteSectionValues[sectionValue];
}
cardRequisite.Name = reader["Name"] as string;
cardRequisite.IsRequired = YesValue.Equals(reader["IsRequired"] as string);
cardRequisite.IsLastValueSaved = YesValue.Equals(reader["IsLastValueSaved"] as string);
cardRequisite.IsSelectionConstrained = YesValue.Equals(reader["IsSelectionConstrained"] as string);
var changeEventValue = reader["ChangeEvent"] as string;
if (!string.IsNullOrEmpty(changeEventValue))
{
var @event = new Event
{
EventType = EventType.Change,
CalculationText = changeEventValue
};
cardRequisite.Events.Add(@event);
}
var selectEventsValue = reader["SelectEvents"] as string;
if (!string.IsNullOrEmpty(selectEventsValue))
{
var events = EventTextParser.Parse(selectEventsValue);
foreach (var @event in events)
{
if (@event.EventType == EventType.Unknown)
{
@event.EventType = EventType.Select;
}
cardRequisite.Events.Add(@event);
}
}
dialog.Requisites.Add(cardRequisite);
}
}
}
}
return(components.Values.ToList());
}
public static Sprite getSpriteValue(TypeValues type_values)
{
string path = $"Sprites/TypeValues/{type_values.ToString()}";
return(Resources.Load <Sprite>(path));
}
protected abstract void handle_result(TypeValues result);
public IEnumerable <ManagedFolder> Read(SqlConnection connection, Version platformVersion)
{
var components = new Dictionary <string, ManagedFolder>();
var query = this.GetManagedFoldersQuery(platformVersion);
if (string.IsNullOrEmpty(query))
{
return(components.Values.ToList());
}
var command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var managedFolder = new ManagedFolder
{
Name = (reader["Name"] as string).Trim(),
Title = (reader["Title"] as string).Trim()
};
if (ActiveValue.Equals(reader["State"] as string))
{
managedFolder.State = ComponentState.Active;
}
else
{
managedFolder.State = ComponentState.Closed;
}
if (reader["SearchDescription"] is byte[] searchDescriptionRawData)
{
var searchDescriptionDfm = Encoding.GetEncoding(1251).GetString(searchDescriptionRawData);
if (!string.IsNullOrWhiteSpace(searchDescriptionDfm))
{
managedFolder.SearchDescription = SearchDescriptionParser.Parse(searchDescriptionDfm);
}
}
components.Add(managedFolder.Name, managedFolder);
}
}
}
query = this.GetMethodsQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var managedFolderName = reader["ManagedFolderName"] as string;
if (!components.TryGetValue(managedFolderName, out ManagedFolder managedFolder))
{
continue;
}
var method = new Method {
Name = reader["Name"] as string
};
if (reader["CalculationText"] is byte[] calculationValue)
{
method.CalculationText = Encoding.GetEncoding(1251).GetString(calculationValue);
}
else
{
method.CalculationText = string.Empty;
}
managedFolder.Methods.Add(method);
}
}
}
}
query = this.GetMethodParamsQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var managedFolderName = reader["ManagedFolderName"] as string;
if (!components.TryGetValue(managedFolderName, out ManagedFolder managedFolder))
{
continue;
}
var methodName = reader["MethodName"] as string;
var method = managedFolder.Methods
.FirstOrDefault(m => m.Name == methodName);
if (method == null)
{
continue;
}
var parameter = new MethodParam
{
Number = (int)reader["Number"],
Name = reader["Name"] as string
};
var typeValue = reader["Type"] as string;
if (TypeValues.TryGetValue(typeValue, out MethodParamType methodParamType))
{
parameter.Type = methodParamType;
}
parameter.DefaultValue = reader["DefaultValue"] as string;
parameter.HasDefaultValue = !string.IsNullOrEmpty(parameter.DefaultValue);
method.Params.Add(parameter);
}
}
}
}
query = this.GetActionQuery(platformVersion);
if (!string.IsNullOrEmpty(query))
{
command = new SqlCommand(query, connection);
using (var reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
var managedFolderName = reader["ManagedFolderName"] as string;
if (!components.TryGetValue(managedFolderName, out ManagedFolder managedFolder))
{
continue;
}
var action = new ActionWithHandler {
Name = reader["Name"] as string
};
var methodName = reader["MethodName"] as string;
var executionHandler = managedFolder.Methods.FirstOrDefault(m => m.Name == methodName);
if (executionHandler != null)
{
action.ExecutionHandler = executionHandler;
}
else
{
action.CalculationText = string.Empty;
}
managedFolder.Actions.Add(action);
}
}
}
}
return(components.Values.ToList());
}
public ValueClass(TypeValues type_values, float value)
{
this.type_values = type_values;
this.value = value;
}
