Couchbaseの接続

web.configファイルの増加

CbManagerカテゴリを増やします。

パブリッククラスCbManager
{
プライベート静的IClusterクラスタ{取得します。セットする; }
プライベート静的IBucket tradeBucket {得ます。セットする; }
プライベート静的IBucket sessionBucket {得ます。セットする; }

/// <要約>
///初始化のCouchbase;
///のWeb.Config配置のAppSettings [ "CouchBaseSection"]、如果没有配置、默认"couchbaseClients / Couchbaseの";
/// tradeBucketName默认为"GuotaiTrading";
/// sessionBucketName默认为"gtSessions";
/// </要約>
パブリック静的ボイドは、init（）
{
ストリングstrSection = ConfigurationManager.AppSettings [ "CouchBaseSection"]。
strSection = strSection == nullの？"couchbaseClients / Couchbaseの"：strSection。
文字列tradeBucketName = "GuotaiTrading"。
文字列sessionBucketName = "gtSessions"。
（！string.IsNullOrWhiteSpace（strSection））の場合
{
クラスタ=新しいクラスタ（strSection）。
（cluster.Configuration場合。

VAR strPassword = cluster.Configuration.BucketConfigs [tradeBucketName]みましょう。パスワード。
IF（string.IsNullOrWhiteSpace（strPassword）！）
{
tradeBucket = cluster.OpenBucket（tradeBucketName、strPassword）。
}
他
{
tradeBucket = cluster.OpenBucket（tradeBucketName）。
}
}
もし（cluster.Configuration.BucketConfigs.ContainsKey（sessionBucketName））
{
VAR strPassword = cluster.Configuration.BucketConfigs [sessionBucketName]みましょう。パスワード。
IF（string.IsNullOrWhiteSpace（strPassword）！）
{
sessionBucket = cluster.OpenBucket（sessionBucketName、strPassword）。
}
他
{
sessionBucket = cluster.OpenBucket（sessionBucketName）。
}
}
}
}

公共の静的な無効シャットダウン（）
{
場合（！tradeBucket = NULL）
{
cluster.CloseBucket（tradeBucket）。
}
IF（！sessionBucket = NULL）
{
cluster.CloseBucket（sessionBucket）。
}
}

#region类内调用的私有方法
Tタスク<T> BaseGetAsync <T>（IBucketバケット、文字列ID）非同期プライベート静的：クラス
{
VARのQueryResultではは= bucket.GetAsyncを<T>（ID）を待ちます。
場合（！QueryResultでは= NULL && queryResult.Successは）
{
queryResult.Valueを返します。
}
はnullを返します。
}

プライベート静的T BaseGet T <T>（IBucketバケット、文字列ID）：クラス
{
VAR QueryResultでは= bucket.Get <T>（ID）。
場合（！QueryResultでは= NULL && queryResult.Successは）
{
queryResult.Valueを返します。
}
はnullを返します。
}

プライベート静的非同期タスク<ブール> BaseUpsertAsync <T>（？IBucketバケット、文字列キー、T値、ULONG CAS = NULL、のTimeSpan満了し= NULL）
{
試みる
{
IOperationResult <T>結果。
IF（！CAS = NULL &&満了する== NULL）
{
結果=はbucket.UpsertAsync（キー、値、cas.Value）を待ちます。
}
そうであれば（期限切れになる= NULL && CAS == NULL！）
{
結果= bucket.UpsertAsync（キー、値、expires.Value）を待ちます。
}
そうであれば（期限切れになる= NULL && CAS = NULL！）
{
結果= bucket.UpsertAsync（キー、値、cas.Value、expires.Value）を待ちます。
}
他
{
結果= bucket.UpsertAsync（キー、値）を待ちます。
}
戻り結果。
}
キャッチ（例外例）
{
Logger.LogError（ "UpsertAsync障害、例：" + ex.ToString（））。
falseを返します。
}
}

プライベート静的ブールBaseUpsert <T>（IBucketバケット、文字列キー、T値、のTimeSpan？=ヌルを満了したが）
{
しようと
{
ヌル==期限が切れる= VAR結果を？bucket.Upsert（キー、値）：bucket.Upsert（キー、値、expires.Value）。
result.Successを返します。
}
キャッチ（例外例）
{
Logger.LogError（ "アップサート障害、例：" + ex.ToString（））。
falseを返します。
}
}

タスク非同期プライベート静的<ブール> BaseInsertAsync <T>（IBucketバケット、文字列キー、T値、TimeSpanのは？=ヌルを満了する）
{
しようと
{
ヌル==期限が切れる= VAR結果を？待つbucket.InsertAsync（キー、値）：bucket.InsertAsync（キー、値、expires.Value）を待ちます。
result.Successを返します。
}
キャッチ（例外例）
{
Logger.LogError（ "InsertAsync障害、例：" + ex.ToString（））。
falseを返します。
}
}

プライベート静的ブールBaseDelete（IBucketバケット、文字列キー）
{
しようと
{
VARの結果= bucket.Remove（キー）;
result.Successを返します。
}
キャッチ（例外例）
{
Logger.LogErrorは（ "失敗削除EX：" + ex.ToString（））。
falseを返します。
}
}

プライベート静的BaseTouch（IBucketバケット、文字列ID、TimeSpanの有効期限が切れる）BOOL
{
しようと
{
VARの結果= bucket.Touch（IDは、有効期限が切れます）。
result.Successを返します。
}
キャッチ（例外例）
{
Logger.LogError（ "BaseTouch障害、例：" + ex.ToString（））。
falseを返します。
}
}

#endregion

#region tradeBucket CRUD

#region生成TXID
/// <要約>
///获取唯一交易序号
/// </要約>
/// <戻る> </戻り>
公共非同期静的タスク<ULONG> GetTxId（）
{
VAR結果=待つtradeBucket .IncrementAsync（ "MT4_TransactionCounter"、1、1）。
result.Valueを返します。
}

#endregion

プライベート静的Couchbase.Views.IViewQuery UnionQuery（文字列designDoc、文字列たviewName、オブジェクトstartKey = nullを、オブジェクトendKey = nullで、int型のページ= 1、INT pageLimit = 50、SORTTYPE SORTTYPE = SortType.desc、BOOL forceUpdate = falseを、BOOL reduceFlag = ？偽、INT groupLevel = NULL）
{
VARビュー= tradeBucket.CreateQuery（designDoc、たviewName）。
ビュー= view.Reduce（reduceFlag）。
IF（SORTTYPE == SortType.desc）
{
IF（！endKey = NULL）
ビュー= view.StartKey（endKey）。
（もし！startKey = null）の
ビュー= view.EndKey（startKey）。
view.Desc（）;
}
他
{
IF（！startKey = NULL）
ビュー= view.StartKey（startKey）。
（endKey！= null）の場合
ビュー= view.EndKey（endKey）。
}

IF（forceUpdate）
ビュー= view.Stale（Couchbase.Views.StaleState.False）。

（pageLimit> 0）であれば
{
; .Limit（pageLimit） -ビュー= view.Skip（1）* pageLimit（ページ）
}
IF（！reduceFlag && groupLevel = NULL）
ビュー= view.GroupLevel（groupLevel.Value）。
ビューを返します。
}

/// <要約>
///异步查询ビュー
/// </要約>
/// <typeparam名= "T"> </ typeparam>
/// <PARAM NAME = "designDoc"> </ param>の
/ //ます。<param name = "ビュー名"> </ param>の
/// <PARAM NAME = "StartKey"> </ param>の
/// <PARAM NAME = "EndKey"> </ param>の
///の<paramの名前= "ページ"> </ param>の
/// <PARAM NAME = "pageLimit"> </ param>の
/// <PARAM NAME = "forceUpdate">是否强制刷新</ param>の
/// <リターン> </リターン>
タスク<リスト<T >> QueryAsync <T>（文字列designDoc、文字列たviewName、オブジェクトstartKey = nullの非同期のpublic static、オブジェクトendKey = nullを、INTページ= 1、INT pageLimit = 50、SORTTYPE SORTTYPE = SortType.desc、BOOL forceUpdate =偽、BOOL reduceFlag =偽）T：）（新規
{
VARビュー= UnionQuery（designDoc、たviewName、startKey、endKey、ページ、pageLimit、SORTTYPE、forceUpdate、reduceFlag）。
VARクエリ= tradeBucket.QueryAsync <オブジェクト>（ビュー）を待ちます。
リスト<T> resultList =新しいリスト<T>（）;
IF（！query.Success && query.Values = NULL）
{
foreachの（query.RowsにおけるVAR行）
{
VAR結果=のawait tradeBucket.GetAsync <T>（row.Id）。
IF（result.Success）
resultList.Add（result.Value）。
}
}
戻りresultList。
}

パブリック静的リスト<T>クエリ<T>（文字列designDoc、文字列たviewName、オブジェクトstartKey = nullを、オブジェクトendKey = nullで、int型のページ= 1、INT pageLimit = 50、SORTTYPE SORTTYPE = SortType.desc、BOOL forceUpdate = falseを、BOOL reduceFlag =偽）ここで、T：新しい（）
{
VARビュー= UnionQuery（designDoc、たviewName、startKey、endKey、ページ、pageLimit、SORTTYPE、forceUpdate、reduceFlag）。
VARクエリ= tradeBucket.Query <オブジェクト>（図）。
リスト<T> resultList =新しいリスト<T>（）;
IF（！query.Success && query.Values = NULL）
{
foreachの（query.RowsにおけるVAR行）
{
VAR結果= tradeBucket.Get <T>（row.Id）。
IF（result.Success）
resultList.Add（result.Value）。
}
}
戻りresultList。

タスク非同期パブリック静的<ConcurrentBag <T >> QueryParallelAsync <T>（文字列designDoc、ストリングたviewName、オブジェクトstartKey =ヌル、オブジェクトendKey =ヌル、INTページ= 1、INT pageLimit = 50、SORTTYPE SORTTYPE = SortType.desc、BOOL forceUpdate =偽、BOOL reduceFlag =偽）ここで、T：新しい（）
{
VARビュー= UnionQuery（designDoc、たviewName、startKey、endKey、ページ、pageLimit、SORTTYPE、forceUpdate、reduceFlag）。
VARクエリ= tradeBucket.QueryAsync <オブジェクト>（ビュー）を待ちます。
ConcurrentBag <T> resultList =新しいConcurrentBag <T>（）;
（もし！query.Success && query.Values = NULL）
{
ParallelOptionsオプション=新しいParallelOptions（）;
options.MaxDegreeOfParallelism = 4。
Parallel.ForEach（query.Rows、オプション、（アイテム）=>
{
VAR結果= tradeBucket.Get <T>（item.Id）。
IF（result.Success）
resultList.Add（result.Value）。
}）;
}
戻りresultList。
}

forceUpdate、reduceFlag）。VARクエリ= tradeBucket.QueryAsync <オブジェクト>（ビュー）を待ちます。query.Rows.Countを返します（）;

}

パブリックstatic int型QueryCount（文字列designDoc、ストリングたviewName、オブジェクトstartKey =ヌル、オブジェクトendKey =ヌル、BOOL forceUpdate =偽、BOOL reduceFlag = FALSE）
{
VARビュー= UnionQuery（designDoc、たviewName、startKey、endKey、1、0、SORTTYPE .ASC、forceUpdate、reduceFlag）。
VARクエリ= tradeBucket.Query <オブジェクト>（図）。
query.Rows.Countを返します（）;
}

int型？groupLevel = NULL） { VARビュー= UnionQuery（designDoc、たviewName、startKey、endKey、1、0、SortType.asc、forceUpdate、reduceFlag、groupLevel）。

VARクエリ= tradeBucket.QueryAsync <オブジェクト>（ビュー）を待ちます。
int型のカウント= 0;
（もし！query.Success && query.Values = NULL && query.Values.Count（）> 0）
{
カウント= int.Parse（。query.Values.FirstOrDefault（）のToString（））;
}
カウントを返します。
}

BOOL reduceFlag = trueの場合、int型？groupLevel = NULL） {

VARビュー= UnionQuery（designDoc、たviewName、startKey、endKey、1、0、SortType.asc、forceUpdate、reduceFlag、groupLevel）。
VARクエリ=待つtradeBucket.QueryAsync <JOBJECT>（図）です。
JTokenトン= NULL;
int型のカウント= 0;
（もし！query.Success && query.Values = NULL && query.Values.Count（）> 0）
{
query.Values.FirstOrDefault（）TryGetValue（トンアウト"カウント"、）。
カウント= int.Parse（t.ToString（））;
}
カウントを返します。
}

BOOL reduceFlag = trueの場合、int型？groupLevel = NULL） {

VARビュー= UnionQuery（designDoc、たviewName、startKey、endKey、1、0、SortType.asc、forceUpdate、reduceFlag、groupLevel）。
VARクエリ=待つtradeBucket.QueryAsync <JOBJECT>（図）です。
JTokenトン= NULL;
小数の合計= 0;
（もし！query.Success && query.Values = NULL && query.Values.Count（）> 0）
{
query.Values.FirstOrDefault（）TryGetValue（トンうち"合計"、）。
和= decimal.Parse（t.ToString（））。
}
の和を返します。
}

/// <要約>
///异步查询返回ViewRow
/// </要約>
/// <PARAM NAME = "designDoc"> </ param>の
/// <PARAM NAME = "たviewName"> </ param>の
/// <PARAM NAME = "startKey"> </ param>の
/// <PARAM NAME = "endKey"> </ param>の
/// <PARAM NAME = "ページ"> </ param>の
/// <PARAM名前= "pageLimit"> </ param>の
/// <PARAM NAME = "SORTTYPE"> </ param>の
/// <PARAM NAME = "forceUpdate"> </ param>の
/// <PARAM NAME = "reduceFlag" > </ param>の
/// <リターン> </リターン>
タスク<IEnumerableを<Couchbase.Views.ViewRow <オブジェクト>>> QueryRowsAsync（文字列designDoc、ストリングたviewName、オブジェクトstartKey =ヌル、オブジェクトendKey =ヌル、INTページ= 1、INT pageLimit = 50、SORTTYPE SORTTYPE = SORTTYPE非同期パブリック静的。 DESC、BOOL forceUpdate =偽、BOOL reduceFlag = FALSE）
{
VARビュー= UnionQuery（designDoc、たviewName、startKey、endKey、ページ、pageLimit、SORTTYPE、forceUpdate、reduceFlag）。
VARクエリ= tradeBucket.QueryAsync <オブジェクト>（ビュー）を待ちます。
（もし！query.Success && query.Values = NULL）
{
query.Rowsを返します。
}
はnullを返します。
}

/// <まとめ>
/// CouchbaseのクエリオブジェクトのIDクエリの結果が成功ではなく、返された結果が空の場合、そうでない場合はnullを返す
/// </要約>
/// <typeParam名=「T」> </ typeParam>
/// <PARAM NAME = "ID"> </ PARAM>
/// <返し> </戻り>
パブリック静的非同期タスク<T> getAsync <T>（文字列ID）T：クラス
{
リターンBaseGetAsyncのawait <T>（tradeBucket、ID）;
}

パブリック静的TはT <T>（文字列ID）を取得します：クラス
{
BaseGet <T>（tradeBucket、ID）を返すと、
}

パブリックタスク非同期静的<GetCasModel <T >> GetCasAsync <T>（文字列ID）ここで、T：クラス
{
VARのQueryResultでは=のawait tradeBucket.GetAsync <T>（ID）。
IF（！= NULL QueryResultでは&& queryResult.Success && queryResult.Value = NULL）
{
新しいGetCasModel <T> {値= queryResult.ValueはCAS = queryResult.Cas}を返します。
}
戻り新しいGetCasModel <T>（）;
}

タスク非同期パブリック静的<ブール> UpsertCasAsync <T>（文字列キー、T値、ULONG CAS、のTimeSpanは=ヌル満了？）
{
リターン待つBaseUpsertAsync <T>（tradeBucket、キー、値、CASは、期限切れになります）。
}

タスク非同期パブリック静的<ブール> UpsertAsync <T>（？文字列キー、T値のTimeSpanは= NULLを満了した）
{
リターンBaseUpsertAsync <T>（tradeBucket、キー、値、ヌル、期限切れに）待ちます。
}

パブリック静的ブールアップサート<T>（文字列キー、T値のTimeSpanは=ヌル満了？）
{
BaseUpsert <T>（tradeBucket、キー、値、有効期限が切れる）を返します。
}

タスク<ブール> InsertAsync <T>非同期のpublic static（？文字列キーは、T値のTimeSpanは= NULLを満了した）
{
リターンBaseInsertAsync <T>（tradeBucket、キー、値、有効期限が切れる）を待ちます。
}

パブリック静的ブール削除（文字列キー）
{
BaseDelete（tradeBucket、キー）を返します。
}

パブリック静的ブールタッチ（文字列ID、のTimeSpanが期限切れになる）
{
BaseTouch（tradeBucket、ID、期限切れになる）を返します。
}

パブリック静的ブール値（文字列ID）が存在
{
戻りtradeBucket.Exists（ID）を、
}

パブリック静的非同期タスク<ブール> ExistsAsync（文字列ID）
{
戻り待つtradeBucket.ExistsAsync（ID）。
}

#endregion

#region sessionBucket增删
タスク非同期パブリック静的<T> SessionGetAsync <T> Tは、（文字列ID）：クラス
{
リターンBaseGetAsync <T>（sessionBucket、ID）を待ちます。
}

パブリック静的T SessionGet <T>（文字列ID）ここで、T：クラス
{
BaseGet <T>（sessionBucket、ID）を返します。
}

パブリック静的ブールSessionUpsert <T>（文字列キーのTimeSpanが満了するT値）
{
BaseUpsert <T>（sessionBucket、キー、値、有効期限が切れる）を返します。
}

パブリック非同期静的タスク<ブール> SessionInsert <T>（文字列キーのTimeSpanが満了するT値）
{
リターンBaseInsertAsync <T>（sessionBucket、キー、値は、有効期限が切れる）待ちます。
}

パブリック静的ブールSessionDelete（文字列キー）
{
BaseDelete（sessionBucket、キー）を返します。
}

パブリック静的ブールSessionTouch（文字列ID、のTimeSpanが期限切れになる）
{
BaseTouch（sessionBucket、ID、期限切れになる）を返します。
}

パブリック静的ブールSessionExists（文字列ID）
{
戻りsessionBucket.Exists（ID）。
}

#endregion

}

初期のCouchbase：

CbManager.Init（）;

おすすめ