/// <summary>Snippet for Commit</summary>
public void Commit2()
{
// Snippet: Commit(SessionName,TransactionOptions,IEnumerable<Mutation>,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
TransactionOptions singleUseTransaction = new TransactionOptions();
IEnumerable <Mutation> mutations = new List <Mutation>();
// Make the request
CommitResponse response = spannerClient.Commit(session, singleUseTransaction, mutations);
// End snippet
}
/// <summary>Snippet for Commit</summary>
public void Commit1()
{
// Snippet: Commit(SessionName,ByteString,IEnumerable<Mutation>,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
ByteString transactionId = ByteString.CopyFromUtf8("");
IEnumerable <Mutation> mutations = new List <Mutation>();
// Make the request
CommitResponse response = spannerClient.Commit(session, transactionId, mutations);
// End snippet
}
/// <summary>Snippet for Rollback</summary>
public void Rollback()
{
// Snippet: Rollback(SessionName,ByteString,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
ByteString transactionId = ByteString.Empty;
// Make the request
spannerClient.Rollback(session, transactionId);
// End snippet
}
/// <summary>Snippet for DeleteAllContextsAsync</summary>
public async Task DeleteAllContextsResourceNamesAsync()
{
// Snippet: DeleteAllContextsAsync(SessionName, CallSettings)
// Additional: DeleteAllContextsAsync(SessionName, CancellationToken)
// Create client
ContextsClient contextsClient = await ContextsClient.CreateAsync();
// Initialize request argument(s)
SessionName parent = SessionName.FromProjectSession("[PROJECT]", "[SESSION]");
// Make the request
await contextsClient.DeleteAllContextsAsync(parent);
// End snippet
}
public string GetSessionName(int SubjectID, int CourseID)
{
string SessionName;
SqlParameter[] TopicsObj = new SqlParameter[2];
TopicsObj[0] = new SqlParameter("@SubjectID", SqlDbType.Int);
TopicsObj[0].Value = SubjectID;
TopicsObj[1] = new SqlParameter("@CourseID", SqlDbType.Int);
TopicsObj[1].Value = CourseID;
DataTable SessionNo = DAL.GetDataTable("GenerateSessionNo", TopicsObj);
SessionName = SessionNo.Rows[0]["SessionName"].ToString();
return(SessionName.Trim());
}
/// <summary>Snippet for DeleteSessionAsync</summary>
public async Task DeleteSessionAsync()
{
// Snippet: DeleteSessionAsync(SessionName,CallSettings)
// Additional: DeleteSessionAsync(SessionName,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
SessionName name = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
// Make the request
await spannerClient.DeleteSessionAsync(name);
// End snippet
}
private Transaction FindOrBeginTransaction(SessionName session, TransactionSelector selector)
{
if (selector == null)
{
return(BeginTransaction(session, SINGLE_USE, true));
}
// TODO: Check that the selected transaction actually belongs to the given session.
return(selector.SelectorCase switch
{
TransactionSelector.SelectorOneofCase.SingleUse => BeginTransaction(session, selector.SingleUse, true),
TransactionSelector.SelectorOneofCase.Begin => BeginTransaction(session, selector.Begin, false),
TransactionSelector.SelectorOneofCase.Id => TryFindTransaction(selector.Id),
_ => null,
});
public async Task GetSessionAsync()
{
// Snippet: GetSessionAsync(string,CallSettings)
// Additional: GetSessionAsync(string,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
string formattedName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString();
// Make the request
Session response = await spannerClient.GetSessionAsync(formattedName);
// End snippet
}
/// <summary>Snippet for RollbackAsync</summary>
public async Task RollbackAsync()
{
// Snippet: RollbackAsync(SessionName,ByteString,CallSettings)
// Additional: RollbackAsync(SessionName,ByteString,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
ByteString transactionId = ByteString.Empty;
// Make the request
await spannerClient.RollbackAsync(session, transactionId);
// End snippet
}
/// <summary>Snippet for CreateSessionEntityType</summary>
public void CreateSessionEntityTypeRequestObject()
{
// Snippet: CreateSessionEntityType(CreateSessionEntityTypeRequest, CallSettings)
// Create client
SessionEntityTypesClient sessionEntityTypesClient = SessionEntityTypesClient.Create();
// Initialize request argument(s)
CreateSessionEntityTypeRequest request = new CreateSessionEntityTypeRequest
{
ParentAsSessionName = SessionName.FromProjectLocationAgentSession("[PROJECT]", "[LOCATION]", "[AGENT]", "[SESSION]"),
SessionEntityType = new SessionEntityType(),
};
// Make the request
SessionEntityType response = sessionEntityTypesClient.CreateSessionEntityType(request);
// End snippet
}
/// <summary>Snippet for CreateContextAsync</summary>
public async Task CreateContextResourceNamesAsync()
{
// Snippet: CreateContextAsync(SessionName, Context, CallSettings)
// Additional: CreateContextAsync(SessionName, Context, CancellationToken)
// Create client
ContextsClient contextsClient = await ContextsClient.CreateAsync();
// Initialize request argument(s)
SessionName parent = SessionName.FromProjectSession("[PROJECT]", "[SESSION]");
Context context = new Context();
// Make the request
Context response = await contextsClient.CreateContextAsync(parent, context);
// End snippet
}
/// <summary>Snippet for DeleteAllContexts</summary>
public void DeleteAllContextsRequestObject()
{
// Snippet: DeleteAllContexts(DeleteAllContextsRequest, CallSettings)
// Create client
ContextsClient contextsClient = ContextsClient.Create();
// Initialize request argument(s)
DeleteAllContextsRequest request = new DeleteAllContextsRequest
{
ParentAsSessionName = SessionName.FromProjectSession("[PROJECT]", "[SESSION]"),
};
// Make the request
contextsClient.DeleteAllContexts(request);
// End snippet
}
/// <summary>Snippet for CreateSessionEntityTypeAsync</summary>
public async Task CreateSessionEntityTypeAsync()
{
// Snippet: CreateSessionEntityTypeAsync(SessionName,SessionEntityType,CallSettings)
// Additional: CreateSessionEntityTypeAsync(SessionName,SessionEntityType,CancellationToken)
// Create client
SessionEntityTypesClient sessionEntityTypesClient = await SessionEntityTypesClient.CreateAsync();
// Initialize request argument(s)
SessionName parent = new SessionName("[PROJECT]", "[SESSION]");
SessionEntityType sessionEntityType = new SessionEntityType();
// Make the request
SessionEntityType response = await sessionEntityTypesClient.CreateSessionEntityTypeAsync(parent, sessionEntityType);
// End snippet
}
public void Specificationhelper_CreateSessionName_Success()
{
// *** ARRANGE ***
string snField = "s=test";
SessionName expected = new SessionName("test");
// *** ACT ***
SessionName result = SpecificationHelpers.CreateSessionName(snField);
// *** ASSERT ***
string eEncoded = expected.Encode();
string rEncoded = result.Encode();
Assert.Equal(eEncoded, rEncoded);
}
/// <summary>Snippet for DetectIntentAsync</summary>
public async Task DetectIntentResourceNamesAsync()
{
// Snippet: DetectIntentAsync(SessionName, QueryInput, CallSettings)
// Additional: DetectIntentAsync(SessionName, QueryInput, CancellationToken)
// Create client
SessionsClient sessionsClient = await SessionsClient.CreateAsync();
// Initialize request argument(s)
SessionName session = SessionName.FromProjectLocationSession("[PROJECT]", "[LOCATION]", "[SESSION]");
QueryInput queryInput = new QueryInput();
// Make the request
DetectIntentResponse response = await sessionsClient.DetectIntentAsync(session, queryInput);
// End snippet
}
/// <summary>Snippet for CreateContext</summary>
public void CreateContextRequestObject()
{
// Snippet: CreateContext(CreateContextRequest, CallSettings)
// Create client
ContextsClient contextsClient = ContextsClient.Create();
// Initialize request argument(s)
CreateContextRequest request = new CreateContextRequest
{
ParentAsSessionName = SessionName.FromProjectSession("[PROJECT]", "[SESSION]"),
Context = new Context(),
};
// Make the request
Context response = contextsClient.CreateContext(request);
// End snippet
}
/// <summary>Snippet for BeginTransactionAsync</summary>
public async Task BeginTransactionAsync()
{
// Snippet: BeginTransactionAsync(SessionName,TransactionOptions,CallSettings)
// Additional: BeginTransactionAsync(SessionName,TransactionOptions,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
TransactionOptions options = new TransactionOptions();
// Make the request
Transaction response = await spannerClient.BeginTransactionAsync(session, options);
// End snippet
}
/// <summary>Snippet for ListSessionEntityTypesAsync</summary>
public async Task ListSessionEntityTypesRequestObjectAsync()
{
// Snippet: ListSessionEntityTypesAsync(ListSessionEntityTypesRequest, CallSettings)
// Create client
SessionEntityTypesClient sessionEntityTypesClient = await SessionEntityTypesClient.CreateAsync();
// Initialize request argument(s)
ListSessionEntityTypesRequest request = new ListSessionEntityTypesRequest
{
ParentAsSessionName = SessionName.FromProjectLocationAgentSession("[PROJECT]", "[LOCATION]", "[AGENT]", "[SESSION]"),
};
// Make the request
PagedAsyncEnumerable <ListSessionEntityTypesResponse, SessionEntityType> response = sessionEntityTypesClient.ListSessionEntityTypesAsync(request);
// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((SessionEntityType item) =>
{
// Do something with each item
Console.WriteLine(item);
});
// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListSessionEntityTypesResponse page) =>
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (SessionEntityType item in page)
{
// Do something with each item
Console.WriteLine(item);
}
});
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <SessionEntityType> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (SessionEntityType item in singlePage)
{
// Do something with each item
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
public QUser(string line, string columnsString)
{
UserName = line.Substring(columnsString.IndexOf("USERNAME"), columnsString.IndexOf("SESSIONNAME") - 1);
SessionName = line.Substring(columnsString.IndexOf("SESSIONNAME"), columnsString.IndexOf("ID") - columnsString.IndexOf("SESSIONNAME") - 1);
Id = line.Substring(columnsString.IndexOf("ID"), columnsString.IndexOf("STATE") - columnsString.IndexOf("ID") - 1);
State = line.Substring(columnsString.IndexOf("STATE"), columnsString.IndexOf("IDLE TIME") - columnsString.IndexOf("STATE") - 1);
IdleTime = line.Substring(columnsString.IndexOf("IDLE TIME"), columnsString.IndexOf("LOGON TIME") - columnsString.IndexOf("IDLE TIME") - 1);
LogonTime = line.Substring(columnsString.IndexOf("LOGON TIME"), line.Length - columnsString.IndexOf("LOGON TIME"));
UserName = UserName.Trim();
SessionName = SessionName.Trim();
Id = Id.Trim();
State = State.Trim().ToUpper().Equals("DISC") ? "Disconnected" : State.Trim();
IdleTime = IdleTime.Trim();
LogonTime = LogonTime.Trim();
}
private PooledSession(SessionPool.ISessionPool pool, SessionName sessionName, ByteString transactionId, ModeOneofCase transactionMode, DateTime evictionTime, long refreshTicks)
{
GaxPreconditions.CheckArgument(
(transactionId == null) == (transactionMode == ModeOneofCase.None),
nameof(transactionMode),
"Transaction mode and ID don't match.");
_pool = pool;
SessionName = GaxPreconditions.CheckNotNull(sessionName, nameof(sessionName));
TransactionId = transactionId;
TransactionMode = transactionMode;
_session = new Session {
SessionName = SessionName
};
_evictionTime = evictionTime;
_refreshTicks = refreshTicks;
}
/// <summary>Snippet for MatchIntent</summary>
public void MatchIntentRequestObject()
{
// Snippet: MatchIntent(MatchIntentRequest, CallSettings)
// Create client
SessionsClient sessionsClient = SessionsClient.Create();
// Initialize request argument(s)
MatchIntentRequest request = new MatchIntentRequest
{
SessionAsSessionName = SessionName.FromProjectLocationAgentSession("[PROJECT]", "[LOCATION]", "[AGENT]", "[SESSION]"),
QueryParams = new QueryParameters(),
QueryInput = new QueryInput(),
};
// Make the request
MatchIntentResponse response = sessionsClient.MatchIntent(request);
// End snippet
}
/// <summary>Snippet for CommitAsync</summary>
public async Task CommitAsync2()
{
// Snippet: CommitAsync(SessionName,TransactionOptions,IEnumerable<Mutation>,CallSettings)
// Additional: CommitAsync(SessionName,TransactionOptions,IEnumerable<Mutation>,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
TransactionOptions singleUseTransaction = new TransactionOptions();
IEnumerable <Mutation> mutations = new List <Mutation>();
// Make the request
CommitResponse response = await spannerClient.CommitAsync(session, singleUseTransaction, mutations);
// End snippet
}
public async Task CommitAsync1()
{
// Snippet: CommitAsync(string,ByteString,IEnumerable<Mutation>,CallSettings)
// Additional: CommitAsync(string,ByteString,IEnumerable<Mutation>,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
string formattedSession = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString();
ByteString transactionId = ByteString.CopyFromUtf8("");
IEnumerable <Mutation> mutations = new List <Mutation>();
// Make the request
CommitResponse response = await spannerClient.CommitAsync(formattedSession, transactionId, mutations);
// End snippet
}
public void DeleteAllContextsResourceNames()
{
moq::Mock <Contexts.ContextsClient> mockGrpcClient = new moq::Mock <Contexts.ContextsClient>(moq::MockBehavior.Strict);
DeleteAllContextsRequest request = new DeleteAllContextsRequest
{
ParentAsSessionName = SessionName.FromProjectSession("[PROJECT]", "[SESSION]"),
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.DeleteAllContexts(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
ContextsClient client = new ContextsClientImpl(mockGrpcClient.Object, null);
client.DeleteAllContexts(request.ParentAsSessionName);
mockGrpcClient.VerifyAll();
}
/// <summary>Snippet for ListContexts</summary>
public void ListContextsRequestObject()
{
// Snippet: ListContexts(ListContextsRequest, CallSettings)
// Create client
ContextsClient contextsClient = ContextsClient.Create();
// Initialize request argument(s)
ListContextsRequest request = new ListContextsRequest
{
ParentAsSessionName = SessionName.FromProjectSession("[PROJECT]", "[SESSION]"),
};
// Make the request
PagedEnumerable <ListContextsResponse, Context> response = contextsClient.ListContexts(request);
// Iterate over all response items, lazily performing RPCs as required
foreach (Context item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListContextsResponse page in response.AsRawResponses())
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Context item in page)
{
// Do something with each item
Console.WriteLine(item);
}
}
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <Context> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Context item in singlePage)
{
// Do something with each item
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
public void DeleteSession()
{
Mock <Spanner.SpannerClient> mockGrpcClient = new Mock <Spanner.SpannerClient>(MockBehavior.Strict);
DeleteSessionRequest expectedRequest = new DeleteSessionRequest
{
SessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteSession(expectedRequest, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
SpannerClient client = new SpannerClientImpl(mockGrpcClient.Object, null);
SessionName name = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
client.DeleteSession(name);
mockGrpcClient.VerifyAll();
}
/// <summary>Snippet for DeleteAllContextsAsync</summary>
public async Task DeleteAllContextsRequestObjectAsync()
{
// Snippet: DeleteAllContextsAsync(DeleteAllContextsRequest, CallSettings)
// Additional: DeleteAllContextsAsync(DeleteAllContextsRequest, CancellationToken)
// Create client
ContextsClient contextsClient = await ContextsClient.CreateAsync();
// Initialize request argument(s)
DeleteAllContextsRequest request = new DeleteAllContextsRequest
{
ParentAsSessionName = SessionName.FromProjectSession("[PROJECT]", "[SESSION]"),
};
// Make the request
await contextsClient.DeleteAllContextsAsync(request);
// End snippet
}
public async Task DeleteAllContextsAsync()
{
Mock <Contexts.ContextsClient> mockGrpcClient = new Mock <Contexts.ContextsClient>(MockBehavior.Strict);
DeleteAllContextsRequest expectedRequest = new DeleteAllContextsRequest
{
ParentAsSessionName = new SessionName("[PROJECT]", "[SESSION]"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteAllContextsAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
ContextsClient client = new ContextsClientImpl(mockGrpcClient.Object, null);
SessionName parent = new SessionName("[PROJECT]", "[SESSION]");
await client.DeleteAllContextsAsync(parent);
mockGrpcClient.VerifyAll();
}
public async Task DeleteSessionAsync()
{
Mock <Spanner.SpannerClient> mockGrpcClient = new Mock <Spanner.SpannerClient>(MockBehavior.Strict);
DeleteSessionRequest expectedRequest = new DeleteSessionRequest
{
SessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteSessionAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
SpannerClient client = new SpannerClientImpl(mockGrpcClient.Object, null);
SessionName name = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
await client.DeleteSessionAsync(name);
mockGrpcClient.VerifyAll();
}
public void DeleteAllContexts()
{
Mock <Contexts.ContextsClient> mockGrpcClient = new Mock <Contexts.ContextsClient>(MockBehavior.Strict);
DeleteAllContextsRequest expectedRequest = new DeleteAllContextsRequest
{
ParentAsSessionName = new SessionName("[PROJECT]", "[SESSION]"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteAllContexts(expectedRequest, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
ContextsClient client = new ContextsClientImpl(mockGrpcClient.Object, null);
SessionName parent = new SessionName("[PROJECT]", "[SESSION]");
client.DeleteAllContexts(parent);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// 设置一个Session的值
/// </summary>
/// <param name="context"></param>
/// <param name="name"></param>
/// <param name="value"></param>
public static void SessionSet(HttpContextBase context, SessionName name, object value)
{
int userID;
SessionInfo model;
SessionGet(context, out userID, out model);
Type type = model.GetType();
PropertyInfo[] pi = type.GetProperties();
foreach (var item in pi)
{
if (item.Name == name.ToString())
{
item.SetValue(model, value, null);
break;
}
}
SessionSet(context, userID, model, true);
}
/// <summary>
/// 得到Session的值
/// </summary>
/// <param name="context"></param>
/// <param name="name"></param>
/// <returns></returns>
public static object SessionGet(HttpContextBase context, SessionName name)
{
int userID;
string UserData;
SessionGet(context, out userID, out UserData);
//Type type = model.GetType();
//PropertyInfo[] pi = type.GetProperties();
//foreach (var item in pi)
//{
// if (item.Name == name.ToString())
// {
// return item.GetValue(model, null);
// }
//}
return SessionInfoOper.GetConfigValue(UserData, name);
}
/// <summary>
/// 得到配置文件的值
/// </summary>
/// <param name="str"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string GetConfigValue(string str,SessionName name)
{
return GetConfigValue(str, name.ToString());
}
/// <summary>
/// ����Session��ֵ
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
public void SessionSet(SessionName name, object value)
{
SessionOper.SessionSet(HttpContext, name, value);
}
/// <summary>
/// �õ�Session��ֵ
/// </summary>
/// <param name="context"></param>
/// <param name="name"></param>
/// <returns></returns>
public object SessionGet(SessionName name)
{
return SessionOper.SessionGet(HttpContext, name);
}
