public void TestDecimal128Shell()
{
var tests = new TestData <Decimal128>[]
{
new TestData <Decimal128>(Decimal128.Parse("0"), "NumberDecimal(\"0\")"),
new TestData <Decimal128>(Decimal128.Parse("0.0"), "NumberDecimal(\"0.0\")"),
new TestData <Decimal128>(Decimal128.Parse("0.0005"), "NumberDecimal(\"0.0005\")"),
new TestData <Decimal128>(Decimal128.Parse("0.5"), "NumberDecimal(\"0.5\")"),
new TestData <Decimal128>(Decimal128.Parse("1.0"), "NumberDecimal(\"1.0\")"),
new TestData <Decimal128>(Decimal128.Parse("1.5"), "NumberDecimal(\"1.5\")"),
new TestData <Decimal128>(Decimal128.Parse("1.5E+40"), "NumberDecimal(\"1.5E+40\")"),
new TestData <Decimal128>(Decimal128.Parse("1.5E-40"), "NumberDecimal(\"1.5E-40\")"),
new TestData <Decimal128>(Decimal128.Parse("1234567890.1234568E+123"), "NumberDecimal(\"1.2345678901234568E+132\")"),
new TestData <Decimal128>(Decimal128.Parse("NaN"), "NumberDecimal(\"NaN\")"),
new TestData <Decimal128>(Decimal128.Parse("-Infinity"), "NumberDecimal(\"-Infinity\")"),
new TestData <Decimal128>(Decimal128.Parse("Infinity"), "NumberDecimal(\"Infinity\")")
};
foreach (var test in tests)
{
var json = new BsonDecimal128(test.Value).ToJson();
Assert.Equal(test.Expected, json);
Assert.Equal(test.Value, BsonSerializer.Deserialize <Decimal128>(json));
}
}
public void TestDecimal128Strict()
{
var tests = new TestData <Decimal128>[]
{
new TestData <Decimal128>(Decimal128.Parse("0"), "{ \"$numberDecimal\" : \"0\" }"),
new TestData <Decimal128>(Decimal128.Parse("0.0"), "{ \"$numberDecimal\" : \"0.0\" }"),
new TestData <Decimal128>(Decimal128.Parse("0.0005"), "{ \"$numberDecimal\" : \"0.0005\" }"),
new TestData <Decimal128>(Decimal128.Parse("0.5"), "{ \"$numberDecimal\" : \"0.5\" }"),
new TestData <Decimal128>(Decimal128.Parse("1.0"), "{ \"$numberDecimal\" : \"1.0\" }"),
new TestData <Decimal128>(Decimal128.Parse("1.5"), "{ \"$numberDecimal\" : \"1.5\" }"),
new TestData <Decimal128>(Decimal128.Parse("1.5E+40"), "{ \"$numberDecimal\" : \"1.5E+40\" }"),
new TestData <Decimal128>(Decimal128.Parse("1.5E-40"), "{ \"$numberDecimal\" : \"1.5E-40\" }"),
new TestData <Decimal128>(Decimal128.Parse("1234567890.1234568E+123"), "{ \"$numberDecimal\" : \"1.2345678901234568E+132\" }"),
new TestData <Decimal128>(Decimal128.Parse("NaN"), "{ \"$numberDecimal\" : \"NaN\" }"),
new TestData <Decimal128>(Decimal128.Parse("-Infinity"), "{ \"$numberDecimal\" : \"-Infinity\" }"),
new TestData <Decimal128>(Decimal128.Parse("Infinity"), "{ \"$numberDecimal\" : \"Infinity\" }")
};
foreach (var test in tests)
{
var json = new BsonDecimal128(test.Value).ToJson(new JsonWriterSettings {
OutputMode = JsonOutputMode.Strict
});
Assert.Equal(test.Expected, json);
Assert.Equal(test.Value, BsonSerializer.Deserialize <Decimal128>(json));
}
}
/// <summary>
/// 还原BsonValue
/// </summary>
/// <returns></returns>
public BsonValue GetBsonValue()
{
BsonValue value = new BsonString(string.Empty);
switch (MBsonType)
{
case "BsonString":
value = new BsonString(MBsonString);
break;
case "BsonInt32":
value = new BsonInt32(MBsonInt32);
break;
case "BsonInt64":
value = new BsonInt64(MBsonInt64);
break;
case "BsonDecimal128":
value = new BsonDecimal128(MBSonDecimal128);
break;
case "BsonDateTime":
value = new BsonDateTime(MBsonDateTime);
break;
case "BsonBoolean":
value = MBsonBoolean ? BsonBoolean.True : BsonBoolean.False;
break;
}
return(value);
}
public void BsonType_should_return_expected_result()
{
var subject = new BsonDecimal128(Decimal128.Zero);
var result = subject.BsonType;
result.Should().Be(BsonType.Decimal128);
}
public void CompareTo_with_BsonValue_of_null_should_return_expected_result()
{
var subject = new BsonDecimal128(Decimal128.Zero);
var result = subject.CompareTo((BsonValue)null);
result.Should().Be(1);
}
public void constructor_should_initialize_instance(double doubleValue)
{
var value = (Decimal128)(decimal)doubleValue;
var subject = new BsonDecimal128(value);
subject.BsonType.Should().Be(BsonType.Decimal128);
subject.Value.Should().Be(value);
}
public void TestIsDecimal128()
{
BsonValue v = new BsonDecimal128(1.0M);
BsonValue s = new BsonString("");
Assert.True(v.IsDecimal128);
Assert.False(s.IsDecimal128);
}
public void BsonType_should_return_expected_result()
{
var subject = new BsonDecimal128(Decimal128.Zero);
var result = subject.BsonType;
result.Should().Be(BsonType.Decimal128);
}
public void implicit_conversion_from_Decimal128_should_return_expected_result(double doubleValue)
{
var decimal128Value = (Decimal128)(decimal)doubleValue;
BsonDecimal128 subject = decimal128Value;
subject.Value.Should().Be(decimal128Value);
}
public void CompareTo_with_BsonValue_of_null_should_return_expected_result()
{
var subject = new BsonDecimal128(Decimal128.Zero);
var result = subject.CompareTo((BsonValue)null);
result.Should().Be(1);
}
/// <summary>
/// 使用属性会发生一些MONO上的移植问题
/// </summary>
/// <returns></returns>
public BsonValue GetValue(BsonValueEx.BasicType DataType)
{
BsonValue mValue = null;
switch (DataType)
{
case BsonValueEx.BasicType.BsonString:
mValue = new BsonString(txtBsonValue.Text);
break;
case BsonValueEx.BasicType.BsonInt32:
mValue = new BsonInt32(Convert.ToInt32(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonInt64:
mValue = new BsonInt64(Convert.ToInt64(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonDecimal128:
mValue = new BsonDecimal128(Convert.ToDecimal(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonDouble:
mValue = new BsonDouble(Convert.ToDouble(txtBsonValue.Text));
break;
case BsonValueEx.BasicType.BsonDateTime:
mValue = new BsonDateTime(dateTimePicker.Value);
break;
case BsonValueEx.BasicType.BsonBoolean:
mValue = radTrue.Checked ? BsonBoolean.True : BsonBoolean.False;
break;
case BsonValueEx.BasicType.BsonArray:
case BsonValueEx.BasicType.BsonLegacyPoint:
mValue = _mBsonArray;
break;
case BsonValueEx.BasicType.BsonGeoJSON:
case BsonValueEx.BasicType.BsonDocument:
mValue = _mBsonDocument;
break;
case BsonValueEx.BasicType.BsonMaxKey:
mValue = BsonMaxKey.Value;
break;
case BsonValueEx.BasicType.BsonMinKey:
mValue = BsonMinKey.Value;
break;
case BsonValueEx.BasicType.BsonBinary:
mValue = new BsonBinaryData(Encoding.Default.GetBytes(txtBsonValue.Text));
break;
}
return(mValue);
}
public override void Handle(params object[] args)
{
//分析参数
byte[] priKey = (byte[])args[0];
decimal totalValue = (decimal)args[1];
string snapshotColl = (string)args[2];
var assetid = "";
UInt32 height = 0;
decimal sendAssetDecimals = 0;
//获取已有的所有的地址 （分段）
var count = mongoHelper.GetDataCount(Config.Ins.Snapshot_Conn, Config.Ins.Snapshot_DB, snapshotColl);
var looptime = count / 1000 + 1;
for (var i = 1; i < looptime + 1; i++)
{
Console.WriteLine("总共要循环：" + looptime + "~~现在循环到：" + i);
MyJson.JsonNode_Array Ja_addressInfo = mongoHelper.GetDataPages(Config.Ins.Snapshot_Conn, Config.Ins.Snapshot_DB, snapshotColl, "{}", 1000, i);
for (var ii = 0; ii < Ja_addressInfo.Count; ii++)
{
string txid = Ja_addressInfo[ii].AsDict()["txid"].ToString();
bool applied = Ja_addressInfo[ii].AsDict()["applied"].AsBool();
if (!string.IsNullOrEmpty(txid) && txid != "null")
{
continue;
}
if (!applied)
{
continue;
}
var sendAssetid = Ja_addressInfo[ii].AsDict()["sendAssetid"].ToString();
if (sendAssetDecimals == 0)
{
sendAssetDecimals = GetAssetInfo(sendAssetid).decimals;
}
var addr = Ja_addressInfo[ii].AsDict()["addr"].ToString();
assetid = Ja_addressInfo[ii].AsDict()["assetid"].ToString();
var send = decimal.Parse(Ja_addressInfo[ii].AsDict()["send"].AsDict()["$numberDecimal"].ToString());
height = (uint)Ja_addressInfo[ii].AsDict()["height"].AsInt();
var totoalSend = decimal.Parse(Ja_addressInfo[ii].AsDict()["totalSend"].AsDict()["$numberDecimal"].ToString());
var balance = decimal.Parse(Ja_addressInfo[ii].AsDict()["balance"].AsDict()["$numberDecimal"].ToString(), System.Globalization.NumberStyles.Float);
Send(priKey, assetid, sendAssetid, addr, balance, send, totoalSend, sendAssetDecimals, height, snapshotColl);
System.Threading.Thread.Sleep(500);
deleRuntime(((i - 1) * 1000 + ii + 1) + "/" + count);
}
}
deleResult("完成");
var snapshotCollTotal = "TotalSnapShot";
TotalSnapshot totalSnapshot = new TotalSnapshot();
totalSnapshot.assetid = assetid;
totalSnapshot.totalValue = BsonDecimal128.Create(totalValue);
totalSnapshot.snapshotColl = snapshotColl;
totalSnapshot.height = height;
mongoHelper.ReplaceData(Config.Ins.Snapshot_Conn, Config.Ins.Snapshot_DB, snapshotCollTotal, "{\"snapshotColl\":\"" + snapshotColl + "\"}", totalSnapshot);
}
public void operator_equals_with_BsonDecimal128_should_return_expected_result(double lhsDoubleValue, double rhsDoubleValue, bool expectedResult)
{
var lhs = new BsonDouble(lhsDoubleValue);
var rhs = new BsonDecimal128(double.IsNaN(rhsDoubleValue) ? Decimal128.QNaN : (Decimal128)(decimal)rhsDoubleValue);
var result = lhs == rhs;
result.Should().Be(expectedResult);
}
public void CompareTo_BsonDecimal128_should_return_expected_result(double doubleValue, double otherDoubleValue, int expectedResult)
{
var subject = new BsonDouble(doubleValue);
var other = new BsonDecimal128((Decimal128)(decimal)otherDoubleValue);
var result = subject.CompareTo(other);
result.Should().Be(expectedResult);
}
public void CompareTo_with_BsonValue_of_MinKey_should_return_expected_result()
{
var subject = new BsonDecimal128(Decimal128.Zero);
var other = (BsonValue)BsonMinKey.Value;
var result = subject.CompareTo(other);
result.Should().Be(1);
}
public void Value_should_return_expected_result(double doubleValue)
{
var value = (Decimal128)(decimal)doubleValue;
var subject = new BsonDecimal128(value);
var result = subject.Value;
result.Should().Be(value);
}
public void CompareTo_BsonDecimal128_should_return_expected_result(long int64Value, double otherDoubleValue, int expectedResult)
{
var subject = new BsonInt64(int64Value);
var other = new BsonDecimal128((Decimal128)(decimal)otherDoubleValue);
var result = subject.CompareTo(other);
result.Should().Be(expectedResult);
}
public void CompareTo_with_BsonValue_of_type_Int64_should_return_expected_result(double doubleValue, long otherInt64Value, int expectedResult)
{
var subject = new BsonDecimal128((Decimal128)(decimal)doubleValue);
var other = (BsonValue) new BsonInt64(otherInt64Value);
var result = subject.CompareTo(other);
result.Should().Be(expectedResult);
}
public void operator_equals_with_BsonDecimal128_should_return_expected_result(int lhsInt32Value, double rhsDoubleValue, bool expectedResult)
{
var lhs = new BsonInt32(lhsInt32Value);
var rhs = new BsonDecimal128((Decimal128)(decimal)rhsDoubleValue);
var result = lhs == rhs;
result.Should().Be(expectedResult);
}
public void CompareTo_with_BsonValue_of_MinKey_should_return_expected_result()
{
var subject = new BsonDecimal128(Decimal128.Zero);
var other = (BsonValue)BsonMinKey.Value;
var result = subject.CompareTo(other);
result.Should().Be(1);
}
public void TestMapBsonDecimal128()
{
var value = new BsonDecimal128(1.2M);
var bsonValue = (BsonDecimal128)BsonTypeMapper.MapToBsonValue(value);
Assert.Same(value, bsonValue);
var bsonDecimal128 = (BsonDecimal128)BsonTypeMapper.MapToBsonValue(value, BsonType.Decimal128);
Assert.Same(value, bsonDecimal128);
}
public void RawValue_should_return_expected_result(double doubleValue)
{
var value = (Decimal128)(decimal)doubleValue;
var subject = new BsonDecimal128(value);
#pragma warning disable 0618
var result = subject.RawValue;
#pragma warning restore
result.Should().Be(value);
}
public void TestIsNumeric()
{
BsonValue d128 = new BsonDecimal128(1.0M);
BsonValue d = new BsonDouble(1.0);
BsonValue i32 = new BsonInt32(1);
BsonValue i64 = new BsonInt64(1L);
BsonValue s = new BsonString("");
Assert.True(d128.IsNumeric);
Assert.True(d.IsNumeric);
Assert.True(i32.IsNumeric);
Assert.True(i64.IsNumeric);
Assert.False(s.IsDecimal128);
}
/// <summary>
/// 还原BsonValue
/// </summary>
/// <returns></returns>
public BsonValue GetBsonValue()
{
BsonValue value = new BsonString(string.Empty);
switch (mBsonType)
{
case BasicType.BsonString:
value = new BsonString(mBsonString);
break;
case BasicType.BsonInt32:
value = new BsonInt32(mBsonInt32);
break;
case BasicType.BsonInt64:
value = new BsonInt64(mBsonInt64);
break;
case BasicType.BsonDecimal128:
value = new BsonDecimal128(mBSonDecimal128);
break;
case BasicType.BsonDouble:
value = new BsonDouble(mBsonDouble);
break;
case BasicType.BsonDateTime:
value = new BsonDateTime(mBsonDateTime);
break;
case BasicType.BsonBoolean:
value = mBsonBoolean ? BsonBoolean.True : BsonBoolean.False;
break;
case BasicType.BsonMaxKey:
value = BsonMaxKey.Value;
break;
case BasicType.BsonMinKey:
value = BsonMinKey.Value;
break;
case BasicType.BsonBinary:
value = new BsonBinaryData(mBsonBinary);
break;
}
return(value);
}
private BsonValue GetValue(object value)
{
if (value is DBNull || value == null)
{
return(BsonNull.Value);
}
else if (value is string)
{
return(BsonString.Create(value));
}
else if (value is bool)
{
return(BsonBoolean.Create(value));
}
else if (value is int || value is short || value is byte)
{
return(BsonInt32.Create(value));
}
else if (value is long)
{
return(BsonInt64.Create(value));
}
else if (value is decimal)
{
return(BsonDecimal128.Create(value));
}
else if (value is double || value is float)
{
return(BsonDouble.Create(value));
}
else if (value is DateTime)
{
return(BsonDateTime.Create(value));
}
else if (value is char c)
{
return(BsonString.Create("" + c));
}
else if (value is byte[])
{
return(BsonBinaryData.Create(value));
}
else
{
return(BsonString.Create(value.ToString()));
}
}
/// <summary>
/// 使用属性会发生一些MONO上的移植问题
/// </summary>
/// <returns></returns>
public BsonValue GetValue(BsonValueEx.BasicType DataType)
{
BsonValue mValue = null;
switch (DataType)
{
case BsonValueEx.BasicType.BsonString:
mValue = new BsonString(txtBsonValue.Text);
break;
case BsonValueEx.BasicType.BsonInt32:
mValue = new BsonInt32(Convert.ToInt32(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonInt64:
mValue = new BsonInt64(Convert.ToInt64(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonDecimal128:
mValue = new BsonDecimal128(Convert.ToDecimal(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonDouble:
mValue = new BsonDouble(Convert.ToDouble(txtBsonValue.Text));
break;
case BsonValueEx.BasicType.BsonDateTime:
mValue = new BsonDateTime(dateTimePicker.Value);
break;
case BsonValueEx.BasicType.BsonBoolean:
mValue = radTrue.Checked ? BsonBoolean.True : BsonBoolean.False;
break;
case BsonValueEx.BasicType.BsonArray:
case BsonValueEx.BasicType.BsonGeo:
mValue = _mBsonArray;
break;
case BsonValueEx.BasicType.BsonDocument:
mValue = _mBsonDocument;
break;
}
return(mValue);
}
private static BsonValue GetValueDifferenceAsBsonValue(IMemberDirtyTracker memberTracker)
{
BsonValue currentValue = memberTracker.CurrentValue, originalValue = memberTracker.OriginalValue;
if (currentValue.BsonType != originalValue.BsonType)
{
throw new InvalidOperationException("BSON type of current value does not equal the original value");
}
BsonValue incrementBy;
switch (currentValue.BsonType)
{
case BsonType.Double:
incrementBy = new BsonDouble(currentValue.AsDouble - originalValue.AsDouble);
break;
case BsonType.Int32:
incrementBy = new BsonInt32(currentValue.AsInt32 - originalValue.AsInt32);
break;
case BsonType.Int64:
incrementBy = new BsonInt64(currentValue.AsInt64 - originalValue.AsInt64);
break;
case BsonType.Decimal128:
incrementBy = new BsonDecimal128(currentValue.AsDecimal - originalValue.AsDecimal);
break;
default:
throw new InvalidOperationException(
$"BSON type {memberTracker.CurrentValue.BsonType} cannot be incrementally updated");
}
return(incrementBy);
}
public void Save_ResultIsPurchaseOrderCreated_PersistsExpectedDocument(PurchaseOrderStatus status)
{
/// Arrange
// Get a purchase order created event.
var @event = new PurchaseOrderCreated(
purchaseOrderId: Guid.NewGuid(),
status: status,
vendorId: Guid.NewGuid(),
lines: Enumerable.Empty <PurchaseOrderLine>()
.Append(new PurchaseOrderLine(
productId: Guid.NewGuid(),
quantity: 14.25M,
measure: "EA",
pricePerUnit: 2.24M))
.Append(new PurchaseOrderLine(
productId: Guid.NewGuid(),
quantity: 5.5M,
measure: "FT",
pricePerUnit: 0.75M)));
// Get some next id.
var nextId = Guid.NewGuid();
// Get the expected document dictionary.
var expected = new BsonDocument()
.Add(new BsonElement("_id", BsonString.Create(nextId.ToString())))
.Add(new BsonElement("_type", BsonString.Create(nameof(PurchaseOrderCreated))))
.Add(new BsonElement(nameof(PurchaseOrderCreated.PurchaseOrderId), new BsonString(@event.PurchaseOrderId.ToString())))
.Add(new BsonElement(nameof(PurchaseOrderCreated.Status), new BsonString(Enum.GetName <PurchaseOrderStatus>(@event.Status))))
.Add(new BsonElement(nameof(PurchaseOrderCreated.VendorId), new BsonString(@event.VendorId.ToString())))
.Add(new BsonElement(nameof(PurchaseOrderCreated.Lines), new BsonArray()
.Add(new BsonDocument()
.Add(new BsonElement(nameof(PurchaseOrderLine.ProductId), BsonString.Create(@event.Lines.ElementAt(0).ProductId.ToString())))
.Add(new BsonElement(nameof(PurchaseOrderLine.Quantity), BsonDecimal128.Create(@event.Lines.ElementAt(0).Quantity)))
.Add(new BsonElement(nameof(PurchaseOrderLine.Measure), BsonString.Create(@event.Lines.ElementAt(0).Measure)))
.Add(new BsonElement(nameof(PurchaseOrderLine.PricePerUnit), BsonDecimal128.Create(@event.Lines.ElementAt(0).PricePerUnit))))
.Add(new BsonDocument()
.Add(new BsonElement(nameof(PurchaseOrderLine.ProductId), BsonString.Create(@event.Lines.ElementAt(1).ProductId.ToString())))
.Add(new BsonElement(nameof(PurchaseOrderLine.Quantity), BsonDecimal128.Create(@event.Lines.ElementAt(1).Quantity)))
.Add(new BsonElement(nameof(PurchaseOrderLine.Measure), BsonString.Create(@event.Lines.ElementAt(1).Measure)))
.Add(new BsonElement(nameof(PurchaseOrderLine.PricePerUnit), BsonDecimal128.Create(@event.Lines.ElementAt(1).PricePerUnit))))));
// Mock up a mongo client for the mongo db event store.
BsonDocument actual = null;
var collection = Mock.Create <IMongoCollection <BsonDocument> >();
Mock.Arrange(() => collection.InsertOne(Arg.IsAny <BsonDocument>(), Arg.IsAny <InsertOneOptions>(), Arg.IsAny <CancellationToken>()))
.DoInstead((BsonDocument document) => actual = document);
var database = Mock.Create <IMongoDatabase>();
Mock.Arrange(() => database.GetCollection <BsonDocument>(Arg.AnyString, Arg.IsAny <MongoCollectionSettings>()))
.Returns(collection);
var client = Mock.Create <IMongoClient>();
Mock.Arrange(() => client.GetDatabase(Arg.AnyString, Arg.IsAny <MongoDatabaseSettings>()))
.Returns(database);
/// Act
// Save the event.
MongoDBEventStore.Save(client, nextId, @event);
/// Assert
// Verify that the actual document matches the expected document.
Assert.Equal(expected, actual);
}
public void constructor_should_initialize_instance(double doubleValue)
{
var value = (Decimal128)(decimal)doubleValue;
var subject = new BsonDecimal128(value);
subject.BsonType.Should().Be(BsonType.Decimal128);
subject.Value.Should().Be(value);
}
public void operator_equals_with_BsonDecimal128_should_return_expected_result(long lhsInt64Value, double rhsDoubleValue, bool expectedResult)
{
var lhs = new BsonInt64(lhsInt64Value);
var rhs = new BsonDecimal128((Decimal128)(decimal)rhsDoubleValue);
var result = lhs == rhs;
result.Should().Be(expectedResult);
}
public void TestIsDecimal128()
{
BsonValue v = new BsonDecimal128(1.0M);
BsonValue s = new BsonString("");
Assert.True(v.IsDecimal128);
Assert.False(s.IsDecimal128);
}
public void TestMapBsonDecimal128()
{
var value = new BsonDecimal128(1.2M);
var bsonValue = (BsonDecimal128)BsonTypeMapper.MapToBsonValue(value);
Assert.Same(value, bsonValue);
var bsonDecimal128 = (BsonDecimal128)BsonTypeMapper.MapToBsonValue(value, BsonType.Decimal128);
Assert.Same(value, bsonDecimal128);
}
public void RawValue_should_return_expected_result(double doubleValue)
{
var value = (Decimal128)(decimal)doubleValue;
var subject = new BsonDecimal128(value);
#pragma warning disable 0618
var result = subject.RawValue;
#pragma warning restore
result.Should().Be(value);
}
public void SaveMongo(string key, string address, decimal score)
{
// Console.WriteLine("1");
// Console.WriteLine("SaveMongokey: {0},number: {1},score :{2}", key, address, score);
//
//
//
////
// Console.WriteLine("Settings.Default.Conn {0}", Settings.Default.Conn);
// Console.WriteLine("Settings.Default.DataBase {0}", Settings.Default.DataBase);
// Console.WriteLine("Settings.Default.Coll_Balance {0}", Settings.Default.Coll_Balance);
//Console.WriteLine("SaveMongokey: 0 {0}", Settings.Default.Conn);
// var ConnectionString = "mongodb://localhost:27017";
var client = new MongoClient(Settings.Default.Conn);
//Console.WriteLine("SaveMongokey: a");
var db = client.GetDatabase(Settings.Default.DataBase);
//Console.WriteLine("SaveMongokey: b");
var col = db.GetCollection <BsonDocument>(Settings.Default.Coll_Balance);
//Console.WriteLine("SaveMongokey: 1");
var doc = new BsonDocument()
{
{ "assetId", key }, { "address", address }, { "balance", BsonDecimal128.Create(score) }
};
var filter = new BsonDocument()
{
{ "assetId", key }, { "address", address }
};
//Console.WriteLine("SaveMongokey: 2");
var addressAssetBalance = col.FindSync(filter).ToList();
// Console.WriteLine("SaveMongokey: 443333,{0}", addressAssetBalance.Count);
if (addressAssetBalance.Count > 0)
{
col.ReplaceOne(filter, doc);
}
else
{
col.InsertOne(doc);
}
// Console.WriteLine("SaveMongokey: 444");
// Console.WriteLine("key: {0},number: {1},score :{2}", key, number, score);
// ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("127.0.0.1:6379");
//
// IDatabase db = redis.GetDatabase();
//
// db.SortedSetAdd(key, number, score);
}
/// <summary>
/// 各种基本类型的初始值
/// </summary>
/// <param name="DataType"></param>
/// <returns></returns>
public static BsonValue GetInitValue(BsonValueEx.BasicType DataType)
{
BsonValue InitValue = BsonNull.Value;
switch (DataType)
{
case BasicType.BsonString:
InitValue = new BsonString(string.Empty);
break;
case BasicType.BsonInt32:
InitValue = new BsonInt32(0);
break;
case BasicType.BsonInt64:
InitValue = new BsonInt64(0);
break;
case BasicType.BsonDecimal128:
InitValue = new BsonDecimal128(0);
break;
case BasicType.BsonDouble:
InitValue = new BsonDouble(0);
break;
case BasicType.BsonDateTime:
InitValue = new BsonDateTime(DateTime.Now);
break;
case BasicType.BsonBoolean:
InitValue = BsonBoolean.False;
break;
case BasicType.BsonArray:
InitValue = new BsonArray();
break;
case BasicType.BsonDocument:
InitValue = new BsonDocument();
break;
case BasicType.BsonLegacyPoint:
InitValue = new BsonArray() { 0, 0 };
break;
case BasicType.BsonGeoJSON:
InitValue = new BsonDocument("type", "Point");
InitValue.AsBsonDocument.Add("coordinates", new BsonArray() { 0, 0 });
break;
case BasicType.BsonMaxKey:
InitValue = BsonMaxKey.Value;
break;
case BasicType.BsonMinKey:
InitValue = BsonMinKey.Value;
break;
case BasicType.BsonBinary:
InitValue = new BsonBinaryData(new byte[0]);
break;
default:
break;
}
return InitValue;
}
/// <summary>
/// 还原BsonValue
/// </summary>
/// <returns></returns>
public BsonValue GetBsonValue()
{
BsonValue value = new BsonString(string.Empty);
switch (mBsonType)
{
case BasicType.BsonString:
value = new BsonString(mBsonString);
break;
case BasicType.BsonInt32:
value = new BsonInt32(mBsonInt32);
break;
case BasicType.BsonInt64:
value = new BsonInt64(mBsonInt64);
break;
case BasicType.BsonDecimal128:
value = new BsonDecimal128(mBSonDecimal128);
break;
case BasicType.BsonDouble:
value = new BsonDouble(mBsonDouble);
break;
case BasicType.BsonDateTime:
value = new BsonDateTime(mBsonDateTime);
break;
case BasicType.BsonBoolean:
value = mBsonBoolean ? BsonBoolean.True : BsonBoolean.False;
break;
case BasicType.BsonMaxKey:
value = BsonMaxKey.Value;
break;
case BasicType.BsonMinKey:
value = BsonMinKey.Value;
break;
case BasicType.BsonBinary:
value = new BsonBinaryData(mBsonBinary);
break;
}
return value;
}
/// <summary>
/// 各种基本类型的初始值
/// </summary>
/// <param name="DataType"></param>
/// <returns></returns>
public static BsonValue GetInitValue(BsonValueEx.BasicType DataType)
{
BsonValue InitValue = BsonNull.Value;
switch (DataType)
{
case BasicType.BsonString:
InitValue = new BsonString(string.Empty);
break;
case BasicType.BsonInt32:
InitValue = new BsonInt32(0);
break;
case BasicType.BsonInt64:
InitValue = new BsonInt64(0);
break;
case BasicType.BsonDecimal128:
InitValue = new BsonDecimal128(0);
break;
case BasicType.BsonDouble:
InitValue = new BsonDouble(0);
break;
case BasicType.BsonDateTime:
InitValue = new BsonDateTime(DateTime.Now);
break;
case BasicType.BsonBoolean:
InitValue = BsonBoolean.False;
break;
case BasicType.BsonArray:
InitValue = new BsonArray();
break;
case BasicType.BsonDocument:
InitValue = new BsonDocument();
break;
case BasicType.BsonLegacyPoint:
InitValue = new BsonArray()
{
0, 0
};
break;
case BasicType.BsonGeoJSON:
InitValue = new BsonDocument("type", "Point");
InitValue.AsBsonDocument.Add("coordinates", new BsonArray()
{
0, 0
});
break;
case BasicType.BsonMaxKey:
InitValue = BsonMaxKey.Value;
break;
case BasicType.BsonMinKey:
InitValue = BsonMinKey.Value;
break;
case BasicType.BsonBinary:
InitValue = new BsonBinaryData(new byte[0]);
break;
default:
break;
}
return(InitValue);
}
public static decimal format(BsonDecimal128 value)
{
return(value.AsDecimal);
}
public void Create_should_return_expected_result(object value)
{
var result = BsonDecimal128.Create(value);
result.Value.Should().Be(Decimal128.Zero);
}
/// <summary>
/// 使用属性会发生一些MONO上的移植问题
/// </summary>
/// <returns></returns>
public BsonValue GetValue(BsonValueEx.BasicType DataType)
{
BsonValue mValue = null;
switch (DataType)
{
case BsonValueEx.BasicType.BsonString:
mValue = new BsonString(txtBsonValue.Text);
break;
case BsonValueEx.BasicType.BsonInt32:
mValue = new BsonInt32(Convert.ToInt32(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonInt64:
mValue = new BsonInt64(Convert.ToInt64(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonDecimal128:
mValue = new BsonDecimal128(Convert.ToDecimal(NumberPick.Value));
break;
case BsonValueEx.BasicType.BsonDouble:
mValue = new BsonDouble(Convert.ToDouble(txtBsonValue.Text));
break;
case BsonValueEx.BasicType.BsonDateTime:
mValue = new BsonDateTime(dateTimePicker.Value);
break;
case BsonValueEx.BasicType.BsonBoolean:
mValue = radTrue.Checked ? BsonBoolean.True : BsonBoolean.False;
break;
case BsonValueEx.BasicType.BsonArray:
case BsonValueEx.BasicType.BsonLegacyPoint:
mValue = _mBsonArray;
break;
case BsonValueEx.BasicType.BsonGeoJSON:
case BsonValueEx.BasicType.BsonDocument:
mValue = _mBsonDocument;
break;
case BsonValueEx.BasicType.BsonMaxKey:
mValue = BsonMaxKey.Value;
break;
case BsonValueEx.BasicType.BsonMinKey:
mValue = BsonMinKey.Value;
break;
case BsonValueEx.BasicType.BsonBinary:
mValue = new BsonBinaryData(Encoding.Default.GetBytes(txtBsonValue.Text));
break;
}
return mValue;
}
public void operator_equals_with_BsonDecimal128_should_return_expected_result(double lhsDoubleValue, double rhsDoubleValue, bool expectedResult)
{
var lhs = new BsonDouble(lhsDoubleValue);
var rhs = new BsonDecimal128(double.IsNaN(rhsDoubleValue) ? Decimal128.QNaN : (Decimal128)(decimal)rhsDoubleValue);
var result = lhs == rhs;
result.Should().Be(expectedResult);
}
public static decimal format(BsonDecimal128 value)
{
return(BsonDecimalHelper.format(value));
}
public void Value_should_return_expected_result(double doubleValue)
{
var value = (Decimal128)(decimal)doubleValue;
var subject = new BsonDecimal128(value);
var result = subject.Value;
result.Should().Be(value);
}
public void TestIsNumeric()
{
BsonValue d128 = new BsonDecimal128(1.0M);
BsonValue d = new BsonDouble(1.0);
BsonValue i32 = new BsonInt32(1);
BsonValue i64 = new BsonInt64(1L);
BsonValue s = new BsonString("");
Assert.True(d128.IsNumeric);
Assert.True(d.IsNumeric);
Assert.True(i32.IsNumeric);
Assert.True(i64.IsNumeric);
Assert.False(s.IsDecimal128);
}
public void CompareTo_with_BsonValue_of_type_Int32_should_return_expected_result(double doubleValue, long otherInt64Value, int expectedResult)
{
var subject = new BsonDecimal128((Decimal128)(decimal)doubleValue);
var other = (BsonValue)new BsonInt64(otherInt64Value);
var result = subject.CompareTo(other);
result.Should().Be(expectedResult);
}
public static BsonDecimal128 format(decimal value)
{
return(BsonDecimal128.Create(value));
}
