public string SendOrder(ref OrderField[] orders)
{
int OrderField_size = Marshal.SizeOf(typeof(OrderField));
int OrderIDType_size = Marshal.SizeOf(typeof(OrderIDType));
IntPtr OrderField_Ptr = Marshal.AllocHGlobal(OrderField_size * orders.Length);
IntPtr OrderIDType_Ptr = Marshal.AllocHGlobal(OrderIDType_size * orders.Length);
// 将结构体写成内存块
for (int i = 0; i < orders.Length;++i)
{
Marshal.StructureToPtr(orders[i], new IntPtr(OrderField_Ptr.ToInt64() + i * OrderField_size), false);
}
IntPtr ptr = proxy.XRequest((byte)RequestType.ReqOrderInsert, Handle, IntPtr.Zero,
0, 0,
OrderField_Ptr, orders.Length, OrderIDType_Ptr, 0, IntPtr.Zero, 0);
string ret = Marshal.PtrToStringAnsi(ptr);
Marshal.FreeHGlobal(OrderField_Ptr);
Marshal.FreeHGlobal(OrderIDType_Ptr);
return ret;
}
public string SendOrder(int OrderRef, ref OrderField order1, ref OrderField order2)
{
int size = Marshal.SizeOf(typeof(OrderField));
IntPtr order1Ptr = Marshal.AllocHGlobal(size);
IntPtr order2Ptr = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(order1, order1Ptr, false);
Marshal.StructureToPtr(order2, order2Ptr, false);
IntPtr ptr = proxy.XRequest((byte)RequestType.ReqOrderInsert, Handle, IntPtr.Zero,
OrderRef, 0,
order1Ptr, size, order2Ptr, size, IntPtr.Zero, 0);
Marshal.FreeHGlobal(order1Ptr);
Marshal.FreeHGlobal(order2Ptr);
if (ptr.ToInt64() == 0)
return null;
return Marshal.PtrToStringAnsi(ptr);
}
/// <summary>
/// Converts an instance of order field into an enumerable list of fields.
/// </summary>
/// <param name="orderField">The order field instance to be converted.</param>
/// <returns>An enumerable list of fields.</returns>
internal static string AsField(this OrderField orderField)
{
return($"[{orderField.Name}] {orderField.GetOrderText()}");
}
private void OnRtnOrder_callback(object sender, ref OrderField order)
{
if (null != OnRtnOrder)
{
OnRtnOrder(this, new OnRtnOrderEventArgs(ref order));
}
}
/// <summary>
/// Converts an instance of order field into an enumerable list of fields.
/// </summary>
/// <param name="orderField">The order field instance to be converted.</param>
/// <param name="dbSetting">The currently in used <see cref="IDbSetting"/> object.</param>
/// <returns>An enumerable list of fields.</returns>
public static string AsField(this OrderField orderField,
IDbSetting dbSetting) =>
AsField(orderField, null, dbSetting);
/// <summary>
/// Converts an instance of an object into an enumerable list of order fields.
/// </summary>
/// <param name="obj">The object to be converted.</param>
/// <returns>An enumerable list of order fields.</returns>
public static IEnumerable <OrderField> AsOrderFields(this object obj)
{
return(OrderField.Parse(obj));
}
private void _onRtnOrder(object sender, ref OrderField field)
{
Order order = convertOrder(field);
mOnOrder?.Invoke(order);
}
public void SendOrder(ref OrderField[] orders,out string[] OrderRefs)
{
int OrderField_size = Marshal.SizeOf(typeof(OrderField));
int OrderIDType_size = Marshal.SizeOf(typeof(OrderIDType));
IntPtr OrderField_Ptr = Marshal.AllocHGlobal(OrderField_size * orders.Length);
IntPtr OrderIDType_Ptr = Marshal.AllocHGlobal(OrderIDType_size * orders.Length);
// 将结构体写成内存块
for (int i = 0; i < orders.Length;++i)
{
Marshal.StructureToPtr(orders[i], new IntPtr(OrderField_Ptr.ToInt64() + i * OrderField_size), false);
}
IntPtr ptr = proxy.XRequest((byte)RequestType.ReqOrderInsert, Handle, IntPtr.Zero,
0, 0,
OrderField_Ptr, orders.Length, OrderIDType_Ptr, 0, IntPtr.Zero, 0);
OrderRefs = new string[orders.Length];
for(int i = 0;i<orders.Length;++i)
{
// 这里定义一个ID占64字节
OrderIDType output = (OrderIDType)Marshal.PtrToStructure(new IntPtr(OrderIDType_Ptr.ToInt64() + i * OrderIDType_size), typeof(OrderIDType));
OrderRefs[i] = output.ID;
}
Marshal.FreeHGlobal(OrderField_Ptr);
Marshal.FreeHGlobal(OrderIDType_Ptr);
}
/// <summary>
/// Converts an instance of order field into an stringified alias-formatted string.
/// </summary>
/// <param name="orderField">The order field to be converted.</param>
/// <param name="alias">The alias to be used for conversion.</param>
/// <returns>A string value for the stringified alias-formatted converted string.</returns>
internal static string AsAliasField(this OrderField orderField, string alias)
{
return(string.Concat(alias, ".", orderField.Name, " ", orderField.GetOrderText()));
}
public async Task <List <Event> > GetFilteredAsync(int limit, string source, int days, OrderField field, OrderType type)
{
var data = await _dataProvider.GetAsync(limit, source, days);
var result = type == OrderType.Asc
? data.OrderBy(_orderingContainer[field])
: data.OrderByDescending(_orderingContainer[field]);
return(result.ToList());
}
protected virtual void OnRtnOrder(object sender, OrderField order)
{
}
public string SendOrder(ref OrderField order)
{
OrderField[] orders = new OrderField[1];
orders[0] = order;
return SendOrder(ref orders);
}
public OrderBy(OrderField field, OrderDirection direction)
{
Field = field;
Direction = direction;
}
public void OrderList(int column)
{
bool ascending = false;
if(behavior == CardListBehavior.EditorArchive)
{
OrderField field = OrderField.None;
if(this.Columns[column].Equals(colName))
field = OrderField.Name;
if(this.Columns[column].Equals(colType))
field = OrderField.Type;
if(this.Columns[column].Equals(colCost))
field = OrderField.Cost;
if(this.Columns[column].Equals(colCharacteristics))
field = OrderField.Characteristics;
if(this.Columns[column].Equals(colRarity))
field = OrderField.Rarity;
if(this.Columns[column].Equals(colColor))
field = OrderField.Color;
if(this.Columns[column].Equals(colEdition))
field = OrderField.Set;
if(this.Columns[column].Equals(colText))
field = OrderField.Text;
if(this.Columns[column].Equals(colFlavorText))
field = OrderField.FlavorText;
if(this.Columns[column].Equals(colArtist))
field = OrderField.Artist;
if(field == currentOrderField)
ascending = !orderAscending;
else
ascending = true;
OrderCriteria criteria = new OrderCriteria() { Field = field, Ascending = ascending };
OnOrderingRequested(criteria);
//SortableList list = new SortableList(new CardItemComparer(criteria), this.dataSource.Count);
//list.AddRange(this.dataSource);
//this.dataSource.Clear();
//foreach(var item in list)
// this.dataSource.Add((CardItem)item);
currentOrderField = field;
orderAscending = ascending;
}
else
{
ListViewColumnSorter columnSorter = (ListViewColumnSorter)this.ListViewItemSorter;
if(column == columnSorter.SortColumn)
{
if(columnSorter.Order == SortOrder.Ascending)
columnSorter.Order = SortOrder.Descending;
else
columnSorter.Order = SortOrder.Ascending;
}
else
{
columnSorter.SortColumn = column;
columnSorter.Order = SortOrder.Ascending;
}
ascending = columnSorter.Order == SortOrder.Ascending;
Sort();
}
for(int i = 0; i < Columns.Count; i++)
{
if(i == column)
Columns[i].ImageKey = ascending ? "ASC" : "DESC";
else
Columns[i].ImageKey = "NONE";
}
this.Refresh();
}
public void NewOrder()
{
_Order = default(OrderField);
}
/// <summary>
/// Converts an instance of order field into an enumerable list of order fields.
/// </summary>
/// <param name="orderField">The order field instance to be converted.</param>
/// <returns>An enumerable list of order fields.</returns>
public static IEnumerable <OrderField> AsEnumerable(this OrderField orderField)
{
yield return(orderField);
}
public void Process(ref OrderField order)
{
// 所有的成交信息都不处理，交给TradeField处理
if (order.ExecType == XAPI.ExecType.Trade)
{
return;
}
OrderRecord record;
switch (order.ExecType)
{
case XAPI.ExecType.New:
if (this.pendingOrders.TryRemove(order.LocalID, out record))
{
this.workingOrders.Add(order.ID, record);
// 将LocalID更新为ID
this.orderIDs[record.Order.Id] = order.ID;
EmitExecutionReport(record, (SQ.ExecType)order.ExecType, (SQ.OrderStatus)order.Status);
}
break;
case XAPI.ExecType.Rejected:
if (this.pendingOrders.TryRemove(order.LocalID, out record))
{
orderIDs.Remove(record.Order.Id);
EmitExecutionReport(record, (SQ.ExecType)order.ExecType, (SQ.OrderStatus)order.Status, order.Text());
}
else if (this.workingOrders.TryGetValue(order.ID, out record))
{
// 比如说出现超出涨跌停时，先会到ProcessNew，所以得再多判断一次
workingOrders.Remove(order.ID);
orderIDs.Remove(record.Order.Id);
EmitExecutionReport(record, (SQ.ExecType)order.ExecType, (SQ.OrderStatus)order.Status, order.Text());
}
break;
case XAPI.ExecType.Cancelled:
if (this.workingOrders.TryGetValue(order.ID, out record))
{
workingOrders.Remove(order.ID);
orderIDs.Remove(record.Order.Id);
EmitExecutionReport(record, SQ.ExecType.ExecCancelled, SQ.OrderStatus.Cancelled);
}
else if (this.pendingOrders.TryRemove(order.LocalID, out record))
{
orderIDs.Remove(record.Order.Id);
EmitExecutionReport(record, (SQ.ExecType)order.ExecType, (SQ.OrderStatus)order.Status, order.Text());
}
break;
case XAPI.ExecType.PendingCancel:
if (this.workingOrders.TryGetValue(order.ID, out record))
{
EmitExecutionReport(record, SQ.ExecType.ExecPendingCancel, SQ.OrderStatus.PendingCancel);
}
break;
case XAPI.ExecType.CancelReject:
if (this.pendingCancels.TryRemove(order.ID, out record))
{
EmitExecutionReport(record, SQ.ExecType.ExecCancelReject, (SQ.OrderStatus)order.Status, order.Text());
}
break;
}
}
public void NewOrder()
{
_Order = default(OrderField);
}
private void ProcessReturnOrder(OrderField field)
{
_provider.Logger.Info(field.DebugInfo);
_orderHandlers[(byte)field.ExecType](field);
}
/// <summary>
/// Converts an instance of order field into an enumerable list of fields.
/// </summary>
/// <param name="orderField">The order field instance to be converted.</param>
/// <param name="dbSetting">The currently in used <see cref="IDbSetting"/> object.</param>
/// <returns>An enumerable list of fields.</returns>
public static string AsField(this OrderField orderField,
IDbSetting dbSetting)
{
return(AsField(orderField, null, dbSetting));
}
public void PostRetrunOrder(OrderField order)
{
_orderBlock.Post(new TradingEvent(ExecType.ExecOrderStatus, order));
}
public OnRspQryOrderEventArgs(ref OrderField order, int size1, bool bIsLast)
{
this.order = order;
this.size1 = size1;
this.bIsLast = bIsLast;
}
private void OnOrderReceived(object sender, OrderField order, bool isLast)
{
Provider.OnMessage(order);
}
/// <summary>
/// Converts an instance of an object into an enumerable list of order fields.
/// </summary>
/// <param name="obj">The object to be converted.</param>
/// <param name="dbSetting">The database setting that is currently in used.</param>
/// <returns>An enumerable list of order fields.</returns>
internal static IEnumerable <OrderField> AsOrderFields(this object obj,
IDbSetting dbSetting)
{
return(OrderField.Parse(obj, dbSetting));
}
protected virtual void OnRtnOrder(object sender, OrderField order)
{
Provider.OnMessage(order);
}
private static void TestAllOperations()
{
// Repository
var repository = new DbRepository <SqlConnection>(RepoDbConnectionString);
// Count
//Console.WriteLine($"Counting Person Records: {repository.Count<Person>()}");
//Console.WriteLine($"Counting Animal Records: {repository.Count<Animal>()}");
// BatchQuery
Console.WriteLine("BatchQuery Person");
var batchQueryResult = repository.BatchQuery <Person>(0, 1000, OrderField.Parse(new { Id = Order.Descending }));
// Query 100K
Console.WriteLine("Query Person: 100K");
var queryResult = repository.Query <Person>(new
{
Id = new
{
Operation = Operation.GreaterThan,
Value = 100
}
}, top: 1000);
// BulkInsert
Console.WriteLine("BulkInsert Person: 100K");
var bulkInsertResult = repository.BulkInsert(queryResult);
// Insert with Guid Primary Key
Console.WriteLine("Insert with Guid PrimaryKey");
var animalId = repository.Insert(new Animal()
{
Id = Guid.NewGuid(),
Name = $"Name: {Guid.NewGuid().ToString()}",
Address = $"Address: {Guid.NewGuid().ToString()}",
DateInserted = DateTime.UtcNow,
DateUpdated = DateTime.UtcNow
});
// Verify
Console.WriteLine($"Verify Insert with Guid PrimaryKey: {animalId}");
var animal = repository.Query <Animal>(animalId).FirstOrDefault();
if (animal == null)
{
throw new NullReferenceException("Animal is null.");
}
// Insert with Identity PrimaryKey
Console.WriteLine("Insert with Identity PrimaryKey");
var personId = repository.Insert(new Person()
{
Name = $"Name: {Guid.NewGuid().ToString()}",
Address = $"Address: {Guid.NewGuid().ToString()}",
DateInserted = DateTime.UtcNow,
DateOfBirth = DateTime.UtcNow.Date.AddYears(-32),
DateUpdated = DateTime.UtcNow,
Worth = new Random().Next(30000, 60000)
});
// Verify
Console.WriteLine($"Verify Insert with Identity PrimaryKey: {personId}");
var person = repository.Query <Person>(personId).FirstOrDefault();
if (person == null)
{
throw new NullReferenceException("Person is null.");
}
// Check InlineInsert with Guid
Console.WriteLine($"InlineInsert Animal");
animalId = repository.InlineInsert <Animal>(new
{
Id = Guid.NewGuid(),
Name = $"NAME-{Guid.NewGuid().ToString()} - InlineInsert",
Address = $"ADDR-{Guid.NewGuid().ToString()} - InlineInsert"
});
// Verify
Console.WriteLine($"Verify InlineInsert with Guid PrimaryKey: {animalId}");
animal = repository.Query <Animal>(animalId).FirstOrDefault();
if (animal == null)
{
throw new NullReferenceException("Animal is null.");
}
// Check InlineInsert with Identity
Console.WriteLine($"InlineInsert with Identity PrimaryKey");
personId = repository.InlineInsert <Person>(new
{
Name = $"NAME-{Guid.NewGuid().ToString()} - InlineInsert",
Address = $"ADDR-{Guid.NewGuid().ToString()} - InlineInsert"
});
// Verify
Console.WriteLine($"Verify Insert with Identity PrimaryKey: {personId}");
person = repository.Query <Person>(personId).FirstOrDefault();
if (person == null)
{
throw new NullReferenceException("Person is null.");
}
// InlineUpdate
Console.WriteLine("InlineUpdate with Guid PrimaryKey");
var affectedRows = repository.InlineUpdate <Animal>(new
{
Name = $"NAME-{Guid.NewGuid().ToString()} - InlineUpdate",
Address = $"ADDR-{Guid.NewGuid().ToString()} - InlineUpdate"
},
new
{
Id = animalId
});
// Verify
Console.WriteLine($"Verify InlineUpdate with Guid PrimaryKey: {animalId}");
if (affectedRows <= 0)
{
throw new Exception("No rows has been affected by the inline update.");
}
animal = repository.Query <Animal>(animalId).FirstOrDefault();
if (animal == null)
{
throw new NullReferenceException("Animal is null.");
}
// InlineUpdate
Console.WriteLine("InlineUpdate with Identity PrimaryKey");
affectedRows = repository.InlineUpdate <Person>(new
{
Name = $"NAME-{Guid.NewGuid().ToString()} - InlineUpdate",
Address = $"ADDR-{Guid.NewGuid().ToString()} - InlineUpdate"
},
new
{
Id = personId
});
// Verify
Console.WriteLine($"Verify InlineUpdate with Identity PrimaryKey: {personId}");
if (affectedRows <= 0)
{
throw new Exception("No rows has been affected by the inline update.");
}
person = repository.Query <Person>(personId).FirstOrDefault();
if (person == null)
{
throw new NullReferenceException("Person is null.");
}
// Check InlineMerge
Console.WriteLine($"InlineMerge with Guid PrimaryKey: {animalId}");
affectedRows = repository.InlineMerge <Animal>(new
{
Id = animalId,
Name = $"{animal.Name} - InlineMerge",
Address = $"{animal.Name} - InlineMerge"
});
// Verify
Console.WriteLine($"Verify InlineMerge with Guid PrimaryKey: {animalId}");
if (affectedRows <= 0)
{
throw new Exception("No rows has been affected by the inline merge.");
}
animal = repository.Query <Animal>(animalId).FirstOrDefault();
if (animal == null)
{
throw new NullReferenceException("Animal is null.");
}
// Check InlineMerge
Console.WriteLine($"InlineMerge with Identity PrimaryKey: {personId}");
affectedRows = repository.InlineMerge <Person>(new
{
Id = personId,
Name = $"{person.Name} - InlineMerge",
Address = $"{person.Name} - InlineMerge"
});
// Verify
Console.WriteLine($"Verify InlineMerge with Identity PrimaryKey: {personId}");
if (affectedRows <= 0)
{
throw new Exception("No rows has been affected by the inline merge.");
}
person = repository.Query <Person>(personId).FirstOrDefault();
if (person == null)
{
throw new NullReferenceException("Person is null.");
}
// Update
Console.WriteLine($"Update Person: {personId}");
person.Name = $"Name: {Guid.NewGuid().ToString()} (Updated)";
person.Address = $"Address: {Guid.NewGuid().ToString()} (Updated)";
person.DateUpdated = DateTime.UtcNow;
person.DateOfBirth = DateTime.UtcNow;
affectedRows = repository.Update(person);
// Verify
Console.WriteLine($"Verify Person after Update: {personId}");
if (affectedRows <= 0)
{
throw new Exception("No rows has been affected by the update.");
}
person = repository.Query <Person>(personId).FirstOrDefault();
if (person == null)
{
throw new NullReferenceException("Person is null.");
}
// Merge
Console.WriteLine($"Merge: {personId}");
person.Name = $"{Guid.NewGuid().ToString()} (Merged)";
person.Address = $"Address: {Guid.NewGuid().ToString()} (Merged)";
person.DateUpdated = DateTime.UtcNow;
affectedRows = repository.Merge(person, Field.Parse(new { person.Id }));
// Verify
Console.WriteLine($"Query Person After Merge: {personId}");
if (affectedRows <= 0)
{
throw new Exception("No rows has been affected by the merge.");
}
person = repository.Query <Person>(personId).FirstOrDefault();
if (person == null)
{
throw new NullReferenceException("Person is null.");
}
// Delete
Console.WriteLine($"Delete Person: {personId}");
affectedRows = repository.Delete <Person>(personId);
// Verify
Console.WriteLine($"Verify Person After Delete: {personId}");
if (affectedRows <= 0)
{
throw new Exception("No rows has been affected by the delete.");
}
person = repository.Query <Person>(personId).FirstOrDefault();
if (person != null)
{
throw new NullReferenceException("Person should be null. We have just deleted it.");
}
// Count
Console.WriteLine($"Person Records: {repository.Count<Person>()}");
Console.WriteLine($"Animal Records: {repository.Count<Animal>()}");
// Dispose
repository.Dispose();
}
public void NewOrder()
{
_Order = new OrderField();
}
/// <summary>
/// Converts an instance of order field into an enumerable list of order fields.
/// </summary>
/// <param name="orderField">The order field instance to be converted.</param>
/// <returns>An enumerable list of order fields.</returns>
public static IEnumerable <OrderField> AsEnumerable(this OrderField orderField)
{
return(new[] { orderField });
}
public void ThrowExceptionOnOrderFieldIfTheParseLinqExpressionHasNoProperty()
{
// Act/Assert
OrderField.Parse <OrderFieldTestClass>(p => "A", Order.Ascending);
}
/// <summary>
/// Converts an instance of order field into an stringified alias-formatted string.
/// </summary>
/// <param name="orderField">The order field to be converted.</param>
/// <param name="alias">The alias to be used for conversion.</param>
/// <returns>A string value for the stringified alias-formatted converted string.</returns>
internal static string AsAliasField(this OrderField orderField, string alias)
{
return($"{alias}.[{orderField.Name}] {orderField.GetOrderText()}");
}
private void OnRtnOrder_callback(object sender, ref OrderField order)
{
OrderField field = order;
OrderClass cls = new OrderClass();
cls.InstrumentName = field.InstrumentName();
cls.Symbol = field.Symbol;
cls.InstrumentID = field.InstrumentID;
cls.ExchangeID = field.ExchangeID;
cls.ClientID = field.ClientID;
cls.AccountID = field.AccountID;
cls.Side = (int)field.Side;
cls.Side_String = Enum <XAPI.OrderSide> .ToString(field.Side);
cls.Qty = field.Qty;
cls.Price = field.Price;
cls.OpenClose = (int)field.OpenClose;
cls.OpenClose_String = Enum <XAPI.OpenCloseType> .ToString(field.OpenClose);
cls.HedgeFlag = (int)field.HedgeFlag;
cls.HedgeFlag_String = Enum <XAPI.HedgeFlagType> .ToString(field.HedgeFlag);
cls.Date = field.Date;
cls.Time = field.Time;
cls.ID = field.ID;
cls.OrderID = field.OrderID;
cls.LocalID = field.LocalID;
cls.Type = (int)field.Type;
cls.Type_String = Enum <XAPI.OrderType> .ToString(field.Type);
cls.StopPx = field.StopPx;
cls.TimeInForce = (int)field.TimeInForce;
cls.TimeInForce_String = Enum <XAPI.TimeInForce> .ToString(field.TimeInForce);
cls.Status = (int)field.Status;
cls.Status_String = Enum <XAPI.OrderStatus> .ToString(field.Status);
cls.ExecType = (int)field.ExecType;
cls.ExecType_String = Enum <XAPI.ExecType> .ToString(field.ExecType);
cls.LeavesQty = field.LeavesQty;
cls.CumQty = field.CumQty;
cls.AvgPx = field.AvgPx;
cls.XErrorID = field.XErrorID;
cls.RawErrorID = field.RawErrorID;
cls.Text = field.Text();
cls.ReserveInt32 = field.ReserveInt32;
cls.ReserveChar64 = field.ReserveChar64;
if (null == OnRtnOrder)
{
QueueData qd = new QueueData();
qd.Type = (int)ResponeType.OnRtnOrder;
qd.Type_String = Enum <XAPI.ResponeType> .ToString(ResponeType.OnRtnOrder);
qd.Sender = this;
qd.Data1 = cls;
MessageQueue.Enqueue(qd);
}
else
{
OnRtnOrder(this, ref cls);
}
}
private void OnRspQryOrder_callback(object sender, ref OrderField order, int size1, bool bIsLast)
{
if (null == OnRspQryOrder)
return;
OrderClass cls = null;
if (size1 > 0)
{
OrderField field = order;
cls = new OrderClass();
cls.InstrumentName = field.InstrumentName();
cls.Symbol = field.Symbol;
cls.InstrumentID = field.InstrumentID;
cls.ExchangeID = field.ExchangeID;
cls.ClientID = field.ClientID;
cls.AccountID = field.AccountID;
cls.Side = (int) field.Side;
cls.Side_String = Enum<XAPI.OrderSide>.ToString(field.Side);
cls.Qty = field.Qty;
cls.Price = field.Price;
cls.OpenClose = (int) field.OpenClose;
cls.OpenClose_String = Enum<XAPI.OpenCloseType>.ToString(field.OpenClose);
cls.HedgeFlag = (int) field.HedgeFlag;
cls.HedgeFlag_String = Enum<XAPI.HedgeFlagType>.ToString(field.HedgeFlag);
cls.Date = field.Date;
cls.Time = field.Time;
cls.ID = field.ID;
cls.OrderID = field.OrderID;
cls.LocalID = field.LocalID;
cls.Type = (int) field.Type;
cls.Type_String = Enum<XAPI.OrderType>.ToString(field.Type);
cls.StopPx = field.StopPx;
cls.TimeInForce = (int) field.TimeInForce;
cls.TimeInForce_String = Enum<XAPI.TimeInForce>.ToString(field.TimeInForce);
cls.Status = (int) field.Status;
cls.Status_String = Enum<XAPI.OrderStatus>.ToString(field.Status);
cls.ExecType = (int) field.ExecType;
cls.ExecType_String = Enum<XAPI.ExecType>.ToString(field.ExecType);
cls.LeavesQty = field.LeavesQty;
cls.CumQty = field.CumQty;
cls.AvgPx = field.AvgPx;
cls.XErrorID = field.XErrorID;
cls.RawErrorID = field.RawErrorID;
cls.Text = field.Text();
cls.ReserveInt32 = field.ReserveInt32;
cls.ReserveChar64 = field.ReserveChar64;
}
if (null == OnRspQryOrder)
{
QueueData qd = new QueueData();
qd.Type = (int)ResponeType.OnRspQryOrder;
qd.Type_String = Enum<XAPI.ResponeType>.ToString(ResponeType.OnRspQryOrder);
qd.Sender = this;
qd.Data1 = cls;
qd.Data2 = size1;
qd.Data3 = bIsLast;
MessageQueue.Enqueue(qd);
}
else
{
OnRspQryOrder(this, ref cls, size1, bIsLast);
}
}
public void TestBatchQueryWithClassHandler()
{
// Setup
var tables = CreateClassHandlerIdentityTables(10).AsList();
using (var connection = new SqlConnection(Database.ConnectionStringForRepoDb))
{
// Act
connection.InsertAll(tables);
// Setup
var handler = ClassHandlerCache.Get <ClassHandlerIdentityTableClassHandler>(typeof(ClassHandlerIdentityTable));
handler.Reset();
// Act
var result = connection.BatchQuery <ClassHandlerIdentityTable>(page: 0,
rowsPerBatch: 10,
orderBy: OrderField.Parse(new { Id = Order.Ascending }),
where : (object)null);
// Assert
Assert.AreEqual(tables.Count, handler.GetMethodCallCount);
Assert.AreEqual(tables.Count, result.Count());
result.AsList().ForEach(item =>
{
var target = tables.First(t => t.Id == item.Id);
Helper.AssertPropertiesEquality(target, item);
});
}
}
/// <summary>
/// Converts an instance of order field into an enumerable list of fields.
/// </summary>
/// <param name="orderField">The order field instance to be converted.</param>
/// <returns>An enumerable list of fields.</returns>
internal static string AsField(this OrderField orderField)
{
return(string.Concat(orderField.Name, " ", orderField.GetOrderText()));
}
public void ThrowExceptionOnBatchQueryWithClassHandlerWithDifferentModel()
{
// Setup
var tables = Helper.CreateIdentityTables(10).AsList();
using (var connection = new SqlConnection(Database.ConnectionStringForRepoDb))
{
// Act
connection.InsertAll(tables);
// Setup
var handler = ClassHandlerCache.Get <ClassHandlerTestModelClassHandler>(typeof(ClassHandlerIdentityTableWithTestModel));
// Act
connection.BatchQuery <ClassHandlerIdentityTableWithTestModel>(page: 0,
rowsPerBatch: 10,
orderBy: OrderField.Parse(new { Id = Order.Ascending }),
where : (object)null);
}
}
protected virtual IOrderFieldItemVM SetupOrderFieldItem(OrderField model)
{
return(new OrderFieldItemVM(model));
}
public OnRtnOrderEventArgs(ref OrderField order)
{
this.order = order;
}
private void OnRspQryOrder_callback(object sender, [In] ref OrderField order, int size1, bool bIsLast)
{
if (null == OnRspQryOrder)
{
return;
}
OrderClass cls = new OrderClass();
if (size1 > 0)
{
OrderField field = order;
cls.InstrumentName = field.InstrumentName();
cls.Symbol = field.Symbol;
cls.InstrumentID = field.InstrumentID;
cls.ExchangeID = field.ExchangeID;
cls.ClientID = field.ClientID;
cls.AccountID = field.AccountID;
cls.Side = (int)field.Side;
cls.Side_String = Enum <XAPI.OrderSide> .ToString(field.Side);
cls.Qty = field.Qty;
cls.Price = field.Price;
cls.OpenClose = (int)field.OpenClose;
cls.OpenClose_String = Enum <XAPI.OpenCloseType> .ToString(field.OpenClose);
cls.HedgeFlag = (int)field.HedgeFlag;
cls.HedgeFlag_String = Enum <XAPI.HedgeFlagType> .ToString(field.HedgeFlag);
cls.Date = field.Date;
cls.Time = field.Time;
cls.ID = field.ID;
cls.OrderID = field.OrderID;
cls.LocalID = field.LocalID;
cls.Type = (int)field.Type;
cls.Type_String = Enum <XAPI.OrderType> .ToString(field.Type);
cls.StopPx = field.StopPx;
cls.TimeInForce = (int)field.TimeInForce;
cls.TimeInForce_String = Enum <XAPI.TimeInForce> .ToString(field.TimeInForce);
cls.Status = (int)field.Status;
cls.Status_String = Enum <XAPI.OrderStatus> .ToString(field.Status);
cls.ExecType = (int)field.ExecType;
cls.ExecType_String = Enum <XAPI.ExecType> .ToString(field.ExecType);
cls.LeavesQty = field.LeavesQty;
cls.CumQty = field.CumQty;
cls.AvgPx = field.AvgPx;
cls.XErrorID = field.XErrorID;
cls.RawErrorID = field.RawErrorID;
cls.Text = field.Text();
cls.ReserveInt32 = field.ReserveInt32;
cls.ReserveChar64 = field.ReserveChar64;
cls.PortfolioID1 = field.PortfolioID1;
cls.PortfolioID2 = field.PortfolioID2;
cls.PortfolioID3 = field.PortfolioID3;
cls.Business = (int)field.Business;
cls.Business_String = Enum <XAPI.BusinessType> .ToString(field.Business);
}
if (null == OnRspQryOrder)
{
QueueData qd = new QueueData();
qd.Type = (int)ResponseType.OnRspQryOrder;
qd.Type_String = Enum <XAPI.ResponseType> .ToString(ResponseType.OnRspQryOrder);
qd.Sender = this;
qd.Data1 = cls;
qd.Data2 = size1;
qd.Data3 = bIsLast;
MessageQueue.Enqueue(qd);
}
else
{
OnRspQryOrder(this, cls, size1, bIsLast);
}
}
private void OnRspQryOrder_callback(object sender, ref OrderField order, int size1, bool bIsLast)
{
if (null != OnRspQryOrder)
{
OnRspQryOrder(this, new OnRspQryOrderEventArgs(ref order, size1, bIsLast));
}
}
public OnRtnOrderEventArgs(ref OrderField order)
{
this.order = order;
}
internal void OnMessage(OrderField field)
{
_processor.PostRetrunOrder(field);
}
