private IValue getControlValue()
{
switch (this._formFieldType)
{
case (int)EnumFormFieldType.ComboBox:
return(ValueFactory.Create(((ComboBox)this._item).SelectedValue.ToString()));
case (int)EnumFormFieldType.ListBox:
return(ValueFactory.Create(((ListBox)this._item).SelectedValue.ToString()));
case (int)EnumFormFieldType.ProgressBarField:
return(ValueFactory.Create(((ProgressBar)this._item).Value));
case (int)EnumFormFieldType.CalendarField:
return(ValueFactory.Create(((DateTimePicker)this._item).Value));
case (int)EnumFormFieldType.CheckBoxField:
return(ValueFactory.Create(((CheckBox)this._item).Checked));
default:
return(ValueFactory.Create(this._item.Text));
}
}
public void InitOwnData()
{
VARIABLE_COUNT = GetOwnVariableCount();
METHOD_COUNT = GetOwnMethodCount();
int stateSize = VARIABLE_COUNT + _module.Variables.Count;
_state = new IVariable[stateSize];
for (int i = 0; i < stateSize; i++)
{
if (i < VARIABLE_COUNT)
{
_state[i] = Variable.CreateContextPropertyReference(this, i, GetOwnPropName(i));
}
else
{
_state[i] = Variable.Create(ValueFactory.Create(), _module.Variables[i - VARIABLE_COUNT]);
}
}
ReadExportedSymbols(_module.ExportedMethods, _methodSearchCache);
ReadExportedSymbols(_module.ExportedProperies, _propertySearchCache);
}
public IValue BinaryOperator(IValue operand1, string op, IValue operand2)
{
switch (op)
{
case "+": return(ValueFactory.make(operand1.Get <int>() + operand2.Get <int>()));
case "-": return(ValueFactory.make(operand1.Get <int>() - operand2.Get <int>()));
case "/": return(ValueFactory.make(operand1.Get <int>() / operand2.Get <int>()));
case "*": return(ValueFactory.make(operand1.Get <int>() * operand2.Get <int>()));
case "%": return(ValueFactory.make(operand1.Get <int>() % operand2.Get <int>()));
case "==": return(ValueFactory.make(operand1.Get <int>() == operand2.Get <int>()));
case ">": return(ValueFactory.make(operand1.Get <int>() > operand2.Get <int>()));
case "<": return(ValueFactory.make(operand1.Get <int>() < operand2.Get <int>()));
}
throw new InvalidOperationException();
}
public IValue Total(IValue ColumnIndex)
{
ValueTableColumn Column = Columns.GetColumnByIIndex(ColumnIndex);
bool has_data = false;
decimal Result = 0;
foreach (ValueTableRow row in _rows)
{
IValue current_value = row.Get(Column);
if (current_value.DataType == Machine.DataType.Number)
{
has_data = true;
Result += current_value.AsNumber();
}
}
if (has_data)
{
return(ValueFactory.Create(Result));
}
return(ValueFactory.Create());
}
/// <summary>
/// Execute value
/// </summary>
public InternalEvaluatorValue Execute(List <InternalEvaluatorValue> args, ValueFactory factory)
{
var arg = args[0];
if (arg.IsNumber)
{
return(arg);
}
var numberWord = arg.GetWord();
if (double.TryParse(numberWord, NumberStyles.Any, RusCulture, out var res))
{
return(res);
}
if (double.TryParse(numberWord, NumberStyles.Any, CultureInfo.InvariantCulture, out res))
{
return(res);
}
return(double.NaN);
}
public PostRequestData(byte [] buffer, string boundary)
{
using (var stdin = new MemoryStream(buffer))
{
var parser = new MultipartFormDataParser(stdin, boundary, Encoding.UTF8);
MapImpl m_params = new MapImpl();
foreach (var param in parser.Parameters)
{
m_params.Insert(ValueFactory.Create(param.Name), ValueFactory.Create(param.Data));
}
_params = new FixedMapImpl(m_params);
MapImpl m_files = new MapImpl();
foreach (var file in parser.Files)
{
m_files.Insert(
ValueFactory.Create(file.Name),
ValueFactory.Create(new PostFileDescription(file))
);
}
_files = new FixedMapImpl(m_files);
}
}
public ArrayImpl StrSplit(string inputString, string stringDelimiter, bool includeEmpty = true)
{
ArrayImpl arrResult = new ArrayImpl();
string[] arrParsed;
if (!string.IsNullOrEmpty(inputString))
{
if (!string.IsNullOrEmpty(stringDelimiter))
{
arrParsed = inputString.Split(new string[] { stringDelimiter }, includeEmpty ? StringSplitOptions.None : StringSplitOptions.RemoveEmptyEntries);
}
else
{
arrParsed = new string[] { inputString };
}
}
else
{
arrParsed = new string[] { string.Empty };
}
arrResult = new ArrayImpl(arrParsed.Select(x => ValueFactory.Create(x)));
return(arrResult);
}
public virtual Variable[] GetEvaluatedVariables(string expression, int threadId, int frameIndex, int[] path)
{
IValue value;
try
{
value = GetMachine(threadId).Evaluate(expression, true);
}
catch (Exception e)
{
value = ValueFactory.Create(e.Message);
}
var locals = GetChildVariables(MachineVariable.Create(value, "$eval"));
foreach (var step in path)
{
var variable = locals[step];
locals = GetChildVariables(variable);
}
return(GetDebugVariables(locals));
}
private void FillProperties(IVariable src, List <IVariable> variables)
{
var obj = src.AsObject();
var propsCount = obj.GetPropCount();
for (int i = 0; i < propsCount; i++)
{
string propName = obj.GetPropName(i);
IVariable value;
try
{
value = MachineVariable.Create(obj.GetPropValue(i), propName);
}
catch (Exception e)
{
value = MachineVariable.Create(ValueFactory.Create(e.Message), propName);
}
variables.Add(value);
}
}
/// <summary>
/// Evaluate value
/// </summary>
public InternalEvaluatorValue Execute(List <InternalEvaluatorValue> args, ValueFactory factory)
{
var sum = 0d;
for (int i = 0; i < args.Count; i++)
{
var arg = args[i];
if (arg.IsNumberList)
{
var numberList = arg.GetNumberList();
for (int j = 0; j < numberList.Count; j++)
{
sum += numberList[j];
}
continue;
}
sum += args[i];
}
return(sum);
}
public HTTPServiceRequestImpl(System.Web.HttpContext ctx)
{
_httpContext = ctx;
// Инициализируем объект для 1С
// Заголовки
MapImpl headers = new MapImpl();
for (int i = 0; i < _httpContext.Request.Headers.Count; i++)
{
headers.Insert(ValueFactory.Create(_httpContext.Request.Headers.GetKey(i))
, ValueFactory.Create(_httpContext.Request.Headers.Get(i))
);
}
this._headers = new FixedMapImpl(headers);
// ПараметрыURL будут пустыми
_urlParams = new FixedMapImpl(new MapImpl());
// Параметры запроса
MapImpl queryOptions = new MapImpl();
// Изменено для совместимости. в 1С только параметры командной строки
// Надо перенести в Контекст
//for (int i = 0; i < _httpContext.Request.Params.Count; i++)
// queryOptions.Insert(ValueFactory.Create(_httpContext.Request.Params.GetKey(i))
// , ValueFactory.Create(_httpContext.Request.Params.Get(i))
// );
for (int i = 0; i < _httpContext.Request.QueryString.Count; i++)
{
queryOptions.Insert(ValueFactory.Create(_httpContext.Request.QueryString.GetKey(i))
, ValueFactory.Create(_httpContext.Request.QueryString.Get(i))
);
}
_queryOptions = new FixedMapImpl(queryOptions);
}
private Object CreateObject(TerminalToken token)
{
switch (token.Symbol.Id)
{
case (int)SymbolConstants.SYMBOL_EOF:
return(null);
case (int)SymbolConstants.SYMBOL_WHITESPACE:
return(null);
case (int)SymbolConstants.SYMBOL_MINUS:
return(null);
case (int)SymbolConstants.SYMBOL_LPARAN:
return(null);
case (int)SymbolConstants.SYMBOL_RPARAN:
return(null);
case (int)SymbolConstants.SYMBOL_TIMES:
return(null);
case (int)SymbolConstants.SYMBOL_DIV:
return(null);
case (int)SymbolConstants.SYMBOL_PLUS:
return(null);
case (int)SymbolConstants.SYMBOL_FLOAT:
return(ValueFactory.CreateValue(Double.Parse(token.Text,
numberFormatInfo)));
case (int)SymbolConstants.SYMBOL_INTEGER:
return(ValueFactory.CreateValue(Int32.Parse(token.Text)));
}
throw new SymbolException("Unknown symbol");
}
public static ObjectNodeBase CreateDeserializable(string name, IValue @object, INode parent,
Context context, CachedMember member = null)
{
var type = @object.SpecifiedType;
var kind = GetTypeKind(type, context.Options);
if (kind == TypeKind.Simple)
{
if (parent == null)
{
throw new TypeNotSupportedException("simple type",
@object.SpecifiedType, Mode.Deserialize, "complex types");
}
return(new ValueNode(context, name, @object, member, parent));
}
Func <object> factory = () => ObjectFactory.CreateInstance(type,
context.Options.Deserialization.ObjectFactory, parent.MapOrDefault(x => x.Value));
if (member == null || parent == null)
{
@object.Instance = factory();
}
else
{
@object = ValueFactory.Create(@object, factory);
}
switch (kind)
{
case TypeKind.Dictionary: return(new DictionaryNode(context, name, @object, member, parent));
case TypeKind.Enumerable: return(new EnumerableNode(context, name, @object, member, parent));
default: return(new ObjectNode(context, name, @object, member, parent));
}
}
public override IValue VisitLogicaloperator(gramParser.LogicaloperatorContext context)
{
var left = Visit(context.expr(0));
if (context.op.Type == gramParser.OR)
{
if (left.Equals(ValueFactory.make(true)))
{
return(ValueFactory.make(true));
}
else if (Visit(context.expr(1)).Equals(ValueFactory.make(true)))
{
return(ValueFactory.make(true));
}
else
{
return(ValueFactory.make(false));
}
}
else if (context.op.Type == gramParser.AND)
{
if (left.Equals(ValueFactory.make(false)))
{
return(ValueFactory.make(false));
}
else if (Visit(context.expr(1)).Equals(ValueFactory.make(true)))
{
return(ValueFactory.make(true));
}
else
{
return(ValueFactory.make(false));
}
}
return(ValueFactory.make(false));
}
public HostedScriptEngine StartEngine()
{
engine = new HostedScriptEngine();
engine.Initialize();
// Тут можно указать любой класс из компоненты
engine.AttachAssembly(System.Reflection.Assembly.GetAssembly(typeof(oscriptcomponent.MyClass)));
// Если проектов компонент несколько, то надо взять по классу из каждой из них
// engine.AttachAssembly(System.Reflection.Assembly.GetAssembly(typeof(oscriptcomponent_2.MyClass_2)));
// engine.AttachAssembly(System.Reflection.Assembly.GetAssembly(typeof(oscriptcomponent_3.MyClass_3)));
// Подключаем тестовую оболочку
engine.AttachAssembly(System.Reflection.Assembly.GetAssembly(typeof(EngineHelpWrapper)));
var testrunnerSource = LoadFromAssemblyResource("NUnitTests.Tests.testrunner.os");
var testrunnerModule = engine.GetCompilerService().Compile(testrunnerSource);
{
var mi = engine.GetType().GetMethod("SetGlobalEnvironment",
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Instance);
mi.Invoke(engine, new object[] { this, testrunnerSource });
}
engine.LoadUserScript(new ScriptEngine.UserAddedScript()
{
Type = ScriptEngine.UserAddedScriptType.Class,
Image = testrunnerModule,
Symbol = "TestRunner"
});
var testRunner = AttachedScriptsFactory.ScriptFactory("TestRunner", new IValue[] { });
TestRunner = ValueFactory.Create(testRunner);
return(engine);
}
private IValue[] MapArguments(int methId, IDictionary <string, object> arguments)
{
var parameters = GetMethodInfo(methId + GetOwnMethodCount()).Params;
IValue[] args = new IValue[parameters.Length];
if (parameters.Length == 0 && arguments.Count != 0)
{
throw RuntimeException.TooManyArgumentsPassed();
}
for (int i = 0; i < parameters.Length; i++)
{
var obj = arguments[parameters[i].Name];
if (obj == null)
{
args[i] = ValueFactory.Create();
continue;
}
var type = obj is IValue ? typeof(IValue) : obj.GetType();
if (obj is DynamicContextWrapper dyn)
{
obj = dyn.UnderlyingObject;
if (type == typeof(DynamicContextWrapper))
{
type = obj.GetType();
}
}
args[i] = CustomMarshaller.ConvertToIValueSafe(obj, type);
}
return(args);
}
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
int methIdx;
try
{
methIdx = _context.FindMethod(binder.Name);
}
catch (MethodAccessException)
{
result = null;
return(false);
}
var methInfo = _context.GetMethodInfo(methIdx);
var valueArgs = new IValue[methInfo.Params.Length];
var passedArgs = args.Select(x => CustomMarshaller.ConvertReturnValue(x, x.GetType())).ToArray();
for (int i = 0; i < valueArgs.Length; i++)
{
if (i < passedArgs.Length)
{
valueArgs[i] = passedArgs[i];
}
else
{
valueArgs[i] = ValueFactory.CreateInvalidValueMarker();
}
}
IValue methResult;
_context.CallAsFunction(methIdx, valueArgs, out methResult);
result = methResult == null? null : CustomMarshaller.ConvertToDynamicCLRObject(methResult);
return(true);
}
private void FillIndexedProperties(IVariable src, List <IVariable> variables)
{
var obj = src.AsObject();
if (obj is ICollectionContext cntx)
{
var itemsCount = cntx.Count();
for (int i = 0; i < itemsCount; i++)
{
IValue value;
try
{
value = obj.GetIndexedValue(ValueFactory.Create(i));
}
catch (Exception)
{
continue;
}
variables.Add(MachineVariable.Create(value, i.ToString()));
}
}
}
/// <summary>
/// Execute value
/// </summary>
public InternalEvaluatorValue Execute(List <InternalEvaluatorValue> args, ValueFactory factory)
{
var res = 0;
for (int i = 0; i < args.Count; i++)
{
var arg = args[i];
if (arg.IsWordList)
{
res += arg.GetWordList().Count;
continue;
}
if (arg.IsNumberList)
{
res += arg.GetNumberList().Count;
continue;
}
res++;
}
return(res);
}
public void CallAsFunction(int methodNumber, IValue[] arguments, out IValue retValue)
{
var paramArray = IntPtr.Zero;
int paramCount = NativeApiProxy.GetNParams(_object, methodNumber);
if (paramCount > 0)
{
paramArray = Marshal.AllocHGlobal(NativeApiVariant.Size * paramCount);
}
SetDefValues(methodNumber, paramCount, arguments);
NativeApiVariant.SetValue(paramArray, arguments, paramCount);
IValue result = retValue = ValueFactory.Create();
bool ok = NativeApiProxy.CallAsFunc(_object, methodNumber, paramArray,
variant => result = NativeApiVariant.GetValue(variant)
);
NativeApiVariant.GetValue(arguments, paramArray, paramCount);
NativeApiVariant.Clear(paramArray, paramCount);
Marshal.FreeHGlobal(paramArray);
if (ok)
{
retValue = result;
}
}
public HostedScriptEngine StartEngine()
{
engine = new HostedScriptEngine();
engine.Initialize();
engine.AttachAssembly(System.Reflection.Assembly.GetAssembly(typeof(OKafkaEco.KafkaClient)));
engine.AttachAssembly(System.Reflection.Assembly.GetAssembly(typeof(OKafkaEco.OKafkaProducer)));
// Подключаем тестовую оболочку
engine.AttachAssembly(System.Reflection.Assembly.GetAssembly(typeof(EngineHelpWrapper)));
var testrunnerSource = LoadFromAssemblyResource("NUnitTests.Tests.testrunner.os");
var testrunnerModule = engine.GetCompilerService()
.Compile(testrunnerSource);
{
var mi = engine.GetType().GetMethod("SetGlobalEnvironment",
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Instance);
mi.Invoke(engine, new object[] { this, testrunnerSource });
}
engine.LoadUserScript(new ScriptEngine.UserAddedScript()
{
Type = ScriptEngine.UserAddedScriptType.Class,
Image = testrunnerModule,
Symbol = "TestRunner"
});
var testRunner = AttachedScriptsFactory.ScriptFactory("TestRunner", new IValue[] { });
TestRunner = ValueFactory.Create(testRunner);
return(engine);
}
public async Task <List <ValueResult <Item> > > CalculateValue(List <Item> entities, bool takeHighestValue)
{
var recipes = new List <ItemRecipeTreeNode>();
foreach (var item in entities)
{
var recipe = new ItemRecipeTreeNode(item.ID);
await recipe.Populate();
recipes.Add(recipe);
}
var result = new List <ValueResult <Item> >();
var values = await ValueFactory.CalculateValue(recipes, takeHighestValue);
foreach (var item in entities)
{
result.Add(new ValueResult <Item> {
Item = item,
Value = values.FirstOrDefault(x => x.Item.ItemID == item.ID)?.Value
});
}
return(result);
}
public async Task TestAsyncListTableNamesLists()
{
var factory = new ValueFactory();
var tables = new List <string> {
"table1", "table2"
};
var ions = tables.Select(t => CreateValueHolder(factory.NewString(t))).ToList();
var h1 = QldbHash.ToQldbHash(TestTransactionId);
h1 = AsyncTransaction.Dot(h1, QldbDriverBase <AsyncQldbSession> .TableNameQuery, new List <IIonValue>());
mockClient.QueueResponse(StartSessionResponse(TestRequestId));
mockClient.QueueResponse(StartTransactionResponse(TestTransactionId, TestRequestId));
mockClient.QueueResponse(ExecuteResponse(TestRequestId, ions));
mockClient.QueueResponse(CommitResponse(TestTransactionId, TestRequestId, h1.Hash));
var result = await testDriver.ListTableNames();
Assert.IsNotNull(result);
CollectionAssert.AreEqual(tables, result.ToList());
mockClient.Clear();
}
/// <summary>
/// Добавить параметры функции.
/// </summary>
/// <param name="function"></param>
/// <param name="method"></param>
private void GetFunctionParameters(IFunction function, MethodInfo method)
{
IValue default_value = null;
FunctionParameters parameters = new FunctionParameters();
var array_param = method.GetParameters().Where(x => x.ParameterType == typeof(IValue[]));
if (array_param.Count() > 0)
{
parameters.AnyCount = true;
if (array_param.Count() > 1)
{
throw new Exception("Тип параметра IValue[] может быть только один.");
}
if (array_param.First().HasDefaultValue)
{
throw new Exception("Тип параметра IValue[] не может иметь значение по умолчанию.");
}
function.DefinedParameters = parameters;
return;
}
foreach (ParameterInfo param_info in method.GetParameters())
{
if (param_info.HasDefaultValue)
{
default_value = ValueFactory.Create(param_info.ParameterType, param_info.DefaultValue);
}
parameters.CreateByRef(param_info.Name, null, default_value);
}
function.DefinedParameters = parameters;
}
public bool HasProperty(string name, [ByRef] IVariable value = null)
{
int propIndex;
try
{
propIndex = FindProperty(name);
}
catch (PropertyAccessException)
{
if (value != null)
{
value.Value = ValueFactory.Create();
}
return(false);
}
if (value != null)
{
value.Value = GetPropValue(propIndex);
}
return(true);
}
private void ShowAnswer(int value)
{
var methodId = GetScriptMethod("ПриВыводеРезультата", "OnResultOutput");
if (methodId == -1)
{
DefaultAnswer(value);
return;
}
var lineVar = ValueFactory.Create(value);
var boolTrue = ValueFactory.Create(true);
var stdProcessFlag = Variable.Create(boolTrue, "stdProcessing");
var arguments = new IValue[2] {
lineVar, stdProcessFlag
};
CallScriptMethod(methodId, arguments);
if (stdProcessFlag.AsBoolean())
{
DefaultAnswer(value);
}
}
public void MapPresentation()
{
var obj = new MapImpl();
obj.Insert(ValueFactory.Create("first"), ValueFactory.Create(1));
obj.Insert(ValueFactory.Create("second"), ValueFactory.Create(2));
var debuggerVar = Visualizer.GetVariable(Variable.Create(obj, "myVar"));
Assert.That(debuggerVar.Presentation, Is.EqualTo("Соответствие"));
Assert.That(debuggerVar.IsStructured, Is.True);
var items = Visualizer.GetChildVariables(obj)
.Select(x => Visualizer.GetVariable(x))
.ToArray();
Assert.That(items, Has.Length.EqualTo(2));
Assert.That(items[0].Name, Is.EqualTo("0"));
Assert.That(items[0].TypeName, Is.EqualTo("КлючИЗначение"));
Assert.That(items[0].Presentation, Is.EqualTo("КлючИЗначение"));
Assert.That(items[0].IsStructured, Is.True);
Assert.That(items[1].Name, Is.EqualTo("1"));
Assert.That(items[1].TypeName, Is.EqualTo("КлючИЗначение"));
Assert.That(items[1].Presentation, Is.EqualTo("КлючИЗначение"));
Assert.That(items[1].IsStructured, Is.True);
var keyValue = Visualizer.GetChildVariables(obj.First())
.Select(x => Visualizer.GetVariable(x))
.ToArray();
Assert.That(keyValue[0].Name, Is.EqualTo("Ключ"));
Assert.That(keyValue[0].Presentation, Is.EqualTo("first"));
Assert.That(keyValue[1].Name, Is.EqualTo("Значение"));
Assert.That(keyValue[1].Presentation, Is.EqualTo("1"));
}
public static IValue ConvertReturnValue(object objParam, Type type)
{
if (objParam == null)
{
return(ValueFactory.Create());
}
if (type == typeof(IValue))
{
return((IValue)objParam);
}
else if (type == typeof(string))
{
return(ValueFactory.Create((string)objParam));
}
else if (type == typeof(int))
{
return(ValueFactory.Create((int)objParam));
}
else if (type == typeof(uint))
{
return(ValueFactory.Create((uint)objParam));
}
else if (type == typeof(long))
{
return(ValueFactory.Create((long)objParam));
}
else if (type == typeof(ulong))
{
return(ValueFactory.Create((ulong)objParam));
}
else if (type == typeof(decimal))
{
return(ValueFactory.Create((decimal)objParam));
}
else if (type == typeof(double))
{
return(ValueFactory.Create((decimal)(double)objParam));
}
else if (type == typeof(DateTime))
{
return(ValueFactory.Create((DateTime)objParam));
}
else if (type == typeof(bool))
{
return(ValueFactory.Create((bool)objParam));
}
else if (type.IsEnum)
{
var wrapperType = typeof(CLREnumValueWrapper <>).MakeGenericType(new Type[] { type });
var constructor = wrapperType.GetConstructor(new Type[] { typeof(EnumerationContext), type, typeof(DataType) });
var osValue = (EnumerationValue)constructor.Invoke(new object[] { null, objParam, DataType.Enumeration });
return(osValue);
}
else if (typeof(IRuntimeContextInstance).IsAssignableFrom(type))
{
return(ValueFactory.Create((IRuntimeContextInstance)objParam));
}
else if (typeof(IValue).IsAssignableFrom(type))
{
return((IValue)objParam);
}
else
{
throw new NotSupportedException($"Type {type} is not supported");
}
}
public void addValueFactory(ValueFactory factory, string id)
{
instance_.servantFactoryManager().add(factory, id);
}
public void Initialize_Success()
{
var buildState = new MockBuildState();
var factory = new ValueFactory();
var uut = new RecipeBuildTask(buildState, factory);
}
public QueryResult(DbDataReader reader)
{
for (int ColIdx = 0; ColIdx < reader.FieldCount; ColIdx++)
{
_resultTable.Columns.Add(reader.GetName(ColIdx));
}
using (reader)
{
foreach (DbDataRecord record in reader)
{
ValueTableRow row = _resultTable.Add();
for (int ColIdx = 0; ColIdx < reader.FieldCount; ColIdx++)
{
if (record.IsDBNull(ColIdx))
{
row.Set(ColIdx, ValueFactory.Create());
continue;
}
if (record.GetFieldType(ColIdx) == typeof(Int32))
{
row.Set(ColIdx, ValueFactory.Create((int)record.GetValue(ColIdx)));
}
if (record.GetFieldType(ColIdx) == typeof(Int64))
{
row.Set(ColIdx, ValueFactory.Create(record.GetInt64(ColIdx)));
}
if (record.GetFieldType(ColIdx) == typeof(Boolean))
{
row.Set(ColIdx, ValueFactory.Create(record.GetBoolean(ColIdx)));
}
if (record.GetFieldType(ColIdx) == typeof(UInt64))
{
row.Set(ColIdx, ValueFactory.Create(record.GetValue(ColIdx).ToString()));
}
if (record.GetFieldType(ColIdx) == typeof(System.Double))
{
double val = record.GetDouble(ColIdx);
row.Set(ColIdx, ValueFactory.Create(val.ToString()));
}
if (record.GetFieldType(ColIdx) == typeof(Single))
{
float val = record.GetFloat(ColIdx);
row.Set(ColIdx, ValueFactory.Create(val.ToString()));
}
if (record.GetFieldType(ColIdx) == typeof(Decimal))
{
row.Set(ColIdx, ValueFactory.Create(record.GetDecimal(ColIdx)));
}
if (record.GetFieldType(ColIdx) == typeof(System.String))
{
row.Set(ColIdx, ValueFactory.Create(record.GetString(ColIdx)));
}
if (record.GetFieldType(ColIdx) == typeof(System.DateTime))
{
row.Set(ColIdx, ValueFactory.Create(record.GetDateTime(ColIdx)));
}
if (record.GetFieldType(ColIdx) == typeof(System.Byte[]))
{
var data = (byte[])record[ColIdx];
var newData = new BinaryDataContext(data);
row.Set(ColIdx, ValueFactory.Create(newData));
}
}
}
}
}
