public async Task <IActionResult> OnPostAsync()
{
_context.Credentials = CredentialCache.DefaultNetworkCredentials;
if (!ModelState.IsValid)
{
return(Page());
}
_context.AddToContractCompany(ContractCompany);
_context.BeginSaveChanges(adoSave_RLMember, ContractCompany);
var company = _context.ContractCompany;
DataServiceQuery <ContractCompany> query = company;
TaskFactory <IEnumerable <ContractCompany> > taskFactory = new TaskFactory <IEnumerable <ContractCompany> >();
var kompany = await taskFactory.FromAsync(query.BeginExecute(null, null), iar => query.EndExecute(iar));
ContractCompany2 = kompany.FirstOrDefault();
_context.DeleteObject(ContractCompany2);
_context.BeginSaveChanges(adoSave_RLMember, ContractCompany2);
return(RedirectToPage("./Index"));
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
public async Task <IActionResult> OnPostAsync()
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
_context.Credentials = CredentialCache.DefaultNetworkCredentials;
if (!ModelState.IsValid)
{
return(Page());
}
var contract = _context.Contract;
DataServiceQuery <Contract> query = contract;
TaskFactory <IEnumerable <Contract> > taskFactory = new TaskFactory <IEnumerable <Contract> >();
var kontrakt = await taskFactory.FromAsync(query.BeginExecute(null, null), iar => query.EndExecute(iar));
Contract2 = kontrakt.FirstOrDefault();
_context.DeleteObject(Contract2);
_context.BeginSaveChanges(adoSave_RLMember, Contract2);
_context.AddToContract(Contract);
_context.BeginSaveChanges(adoSave_RLMember, Contract);
return(RedirectToPage("./Index"));
}
public void EditItem(string id, object itemValue)
{
DataServiceQuery <Item> query = GetQuery(id);
var tuple = new Tuple <DataServiceQuery <Item>, object>(query, itemValue);
query.BeginExecute(AsyncEditCallback, tuple);
}
void LoadMoreItems(uint count, int baseIndex)
{
BackgroundWorker worker = new BackgroundWorker();
//worker.RunWorkerAsync ();
worker.DoWork += (o, ae) =>
{
DataServiceQuery <Order> query = northwindEntity.Orders.Expand("Customer");
query = query.Skip <Order>(baseIndex).Take <Order>(50) as DataServiceQuery <Order>;
IAsyncResult ar = query.BeginExecute(null, null);
var items = query.EndExecute(ar);
var list = items.ToList();
Android.OS.Handler mainHandler = new Android.OS.Handler(Android.OS.Looper.MainLooper);
Java.Lang.Runnable myRunnable = new Java.Lang.Runnable(() =>
{
GridSource.LoadItems(list);
});
mainHandler.Post(myRunnable);
};
worker.RunWorkerCompleted += (o, ae) =>
{
IsBusy = false;
};
IsBusy = true;
worker.RunWorkerAsync();
}
/// <summary>Asynchronously loads the collection by executing a <see cref="Microsoft.OData.Client.DataServiceQuery{TElement}" />.Supported only by the WCF Data Services 5.0 client for Silverlight.</summary>
/// <param name="query">The <see cref="Microsoft.OData.Client.DataServiceQuery{TElement}" /> that, when executed, returns the entities to load into the collection.</param>
/// <exception cref="System.ArgumentException">When query is null or not a <see cref="Microsoft.OData.Client.DataServiceQuery{TElement}" />.</exception>
/// <exception cref="System.InvalidOperationException">When a previous call to <see cref="Microsoft.OData.Client.DataServiceCollection{T}.LoadAsync(System.Linq.IQueryable{T})" /> is not yet complete.</exception>
/// <remarks>This method uses the event-based async pattern.
/// The method returns immediately without waiting for the query to complete. Then it calls the handler of the
/// <see cref="LoadCompleted"/> event exactly once on the UI thread. The event will be raised regardless
/// if the query succeeded or not.
/// This class only support one asynchronous operation in flight.</remarks>
public void LoadAsync(System.Linq.IQueryable <T> query)
{
Util.CheckArgumentNull(query, "query");
DataServiceQuery <T> dsq = query as DataServiceQuery <T>;
if (dsq == null)
{
throw new ArgumentException(Strings.DataServiceCollection_LoadAsyncRequiresDataServiceQuery, nameof(query));
}
if (this.ongoingAsyncOperation != null)
{
throw new InvalidOperationException(Strings.DataServiceCollection_MultipleLoadAsyncOperationsAtTheSameTime);
}
if (this.trackingOnLoad)
{
this.StartTracking(
((DataServiceQueryProvider)dsq.Provider).Context,
null,
this.entitySetName,
this.entityChangedCallback,
this.collectionChangedCallback);
this.trackingOnLoad = false;
}
this.BeginLoadAsyncOperation(
asyncCallback => dsq.BeginExecute(asyncCallback, null),
asyncResult =>
{
QueryOperationResponse <T> response = (QueryOperationResponse <T>)dsq.EndExecute(asyncResult);
this.Load(response);
return(response);
});
}
/// <summary>
/// Adds the image button.
/// </summary>
/// <param name="lessonId">The lesson identifier.</param>
/// <param name="parent">The parent.</param>
private async void AddImageButton(int lessonId, StackPanel parent)
{
//System.Diagnostics.Debug.WriteLine("AddImageButton!");
DataServiceQuery <RESOURCE> dps = (DataServiceQuery <RESOURCE>)(ctx.RESOURCE.Where(r => r.LESSON_ID == lessonId));
TaskFactory <IEnumerable <RESOURCE> > tf = new TaskFactory <IEnumerable <RESOURCE> >();
IEnumerable <RESOURCE> resources = (await tf.FromAsync(dps.BeginExecute(null, null), iar => dps.EndExecute(iar)));
foreach (var r in resources)
{
System.Diagnostics.Debug.WriteLine(r.URL);
Image image = null;
if (r.TYPE == 2)
{
image = GenerateDocImage(r.URL);
parent.Children.Add(image);
Img_Lsn.Add(image, lessonId);
}
else if (r.TYPE == 1)
{
image = GenerateAudioImage(r.URL);
parent.Children.Add(image);
Img_Lsn.Add(image, lessonId);
}
else if (r.TYPE == 3)
{
image = GenerateAudioImage(r.URL);
parent.Children.Add(image);
Img_Lsn.Add(image, lessonId);
}
image.Tapped += ResImageTapped;
}
}
protected async Task PostAndGetShouldReturnSameEntity(UniverseEntity entity)
{
var uri = new Uri(this.BaseAddress);
const string entitySetName = "UniverseEntity";
await this.ClearRepositoryAsync(entitySetName);
var ctx = WriterClient(uri, ODataProtocolVersion.V4);
ctx.AddObject(entitySetName, entity);
await ctx.SaveChangesAsync();
// get collection of entities from repository
ctx = ReaderClient(uri, ODataProtocolVersion.V4);
DataServiceQuery <UniverseEntity> query = ctx.CreateQuery <UniverseEntity>(entitySetName);
var entities = await Task.Factory.FromAsync(query.BeginExecute(null, null), (asyncResult) =>
{
return(query.EndExecute(asyncResult));
});
var beforeUpdate = entities.ToList().First();
AssertExtension.DeepEqual(entity, beforeUpdate);
// clear repository
await this.ClearRepositoryAsync(entitySetName);
}
public void QueryHeadersViaExecuteMethod()
{
Uri baseUri = ctx.BaseUri;
// Accessing headers via DataServiceContext.Execute<> method
Uri requestUri = new Uri(baseUri.OriginalString + "/Customers('QUICK')");
var results = (QueryOperationResponse <northwindClient.Customers>)ctx.Execute <northwindClient.Customers>(requestUri);
Utils.IsSuccessResponse(results, HttpStatusCode.OK);
// assert that there is exactly one object
results.Single <northwindClient.Customers>();
// Accessing headers via DataServiceContext.BeginExecute/EndExecute method
IAsyncResult asyncResult = ctx.BeginExecute <northwindClient.Customers>(requestUri, null, null);
results = (QueryOperationResponse <northwindClient.Customers>)ctx.EndExecute <northwindClient.Customers>(asyncResult);
Utils.IsSuccessResponse(results, HttpStatusCode.OK);
// assert that there is exactly one object
results.Single <northwindClient.Customers>();
// Accessing headers via DataServiceQuery<>.Execute method
DataServiceQuery <northwindClient.Customers> query = ctx.CreateQuery <northwindClient.Customers>("Customers");
results = (QueryOperationResponse <northwindClient.Customers>)query.Execute();
Utils.IsSuccessResponse(results, HttpStatusCode.OK);
Assert.IsTrue(results.Count <northwindClient.Customers>() > 0, "expecting atleast one object");
// Accessing headers via DataServiceQuery<>.BeginExecute/EndExecute method
asyncResult = query.BeginExecute(null, null);
results = (QueryOperationResponse <northwindClient.Customers>)query.EndExecute(asyncResult);
Utils.IsSuccessResponse(results, HttpStatusCode.OK);
Assert.IsTrue(results.Count <northwindClient.Customers>() > 0, "expecting atleast one object");
}
public void PostAndGetShouldReturnSameEntity(UniverseEntity entity)
{
var uri = new Uri(this.BaseAddress);
const string entitySetName = "UniverseEntity";
this.ClearRepository(entitySetName);
var ctx = WriterClient(uri, ODataProtocolVersion.V4);
ctx.AddObject(entitySetName, entity);
ctx.SaveChangesAsync().Wait();
// get collection of entities from repository
ctx = ReaderClient(uri, ODataProtocolVersion.V4);
DataServiceQuery <UniverseEntity> query = ctx.CreateQuery <UniverseEntity>(entitySetName);
IAsyncResult asyncResult = query.BeginExecute(null, null);
asyncResult.AsyncWaitHandle.WaitOne();
var entities = query.EndExecute(asyncResult);
var beforeUpdate = entities.ToList().First();
AssertExtension.DeepEqual(entity, beforeUpdate);
// clear repository
this.ClearRepository(entitySetName);
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached. The Parameter
/// property is typically used to configure the page.</param>
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
course = e.Parameter as Course;
globalRate = 0;
attendDsq = (DataServiceQuery <ATTEND>)(from attend in ctx.ATTEND
where attend.COURSE_ID == course.ID && attend.CUSTOMER_ID == Constants.User.ID
select attend);
try
{
TaskFactory <IEnumerable <ATTEND> > tf = new TaskFactory <IEnumerable <ATTEND> >();
IEnumerable <ATTEND> attends = await tf.FromAsync(attendDsq.BeginExecute(null, null), iar => attendDsq.EndExecute(iar));
if (attends.Count() != 0)
{
enterCommentStackPanel.Visibility = Visibility.Visible;
}
}
catch
{
ShowMessageDialog();
}
commentDsq = (DataServiceQuery <COMMENT_DET>)(from comment in ctx.COMMENT_DET
where comment.COURSE_ID == course.ID
orderby comment.TIME ascending
select comment);
commentDsq.BeginExecute(OnCommentComplete, null);
}
/// <summary>
/// Handles the 1 event of the beginButton_Click control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
private async void beginButton_Click_1(object sender, RoutedEventArgs e)
{
Button bt = sender as Button;
if (bt.Content.ToString() == "Start Learning!")
{
Constants.coursing.NavigateToLecture();
}
else if (bt.Content.ToString() == "Edit Course")
{
try
{
DataServiceQuery <COURSE> dsq = (DataServiceQuery <COURSE>)(from c in ctx.COURSE
where c.ID == course.ID
select c);
TaskFactory <IEnumerable <COURSE> > tf = new TaskFactory <IEnumerable <COURSE> >();
editCourse = (await tf.FromAsync(dsq.BeginExecute(null, null), iar => dsq.EndExecute(iar))).FirstOrDefault();
}
catch
{
ShowMessageDialog("Network connection error.31");
return;
}
courseTitle.Text = editCourse.TITLE;
price.Text = editCourse.PRICE.ToString();
courseContent.Text = editCourse.INTRO;
EditCoursePopup.IsOpen = true;
}
}
/// <summary>
/// 在此页将要在 Frame 中显示时进行调用。
/// </summary>
/// <param name="e">描述如何访问此页的事件数据。Parameter
/// 属性通常用于配置页。</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
course = e.Parameter as Course;
List <object> courseInfo = e.Parameter as List <object>;
course = courseInfo[0] as Course;
DataContext = course;
if ((courseInfo[1] as string) == "attending")
{
beginButton.Content = "Start Learning!";
getLearnedPercentage();
}
else if ((courseInfo[1] as string) == "teaching")
{
beginButton.Content = "Edit Course";
}
SetStarsStackPanel(course.Rate ?? 0);
categoryDsq = (DataServiceQuery <CATEGORY>)(from category in ctx.CATEGORY select category);
categoryDsq.BeginExecute(OnCategoryComplete, null);
pgDsq = (DataServiceQuery <PARENT_GUIDE>)(from pg in ctx.PARENT_GUIDE select pg);
pgDsq.BeginExecute(OnPGComplete, null);
// getLearnedPercentage();
}
private void ShowImage()
{
DataServiceQuery <Annotation> NotesQuery = (DataServiceQuery <Annotation>) this.ThisContext
.AnnotationSet.Where <Annotation>(a => a.FileName == ImageFileName);
NotesQuery.BeginExecute(ReadNotesCompleted, NotesQuery);
}
/// <summary>
/// Initializes the popup style.
/// </summary>
private void InitializePopupStyle()
{
// 样式设置
var grids = from g in AdvanceSearchStackPanel.Children.OfType <Grid>()
where !g.Name.Equals(searchButtonsGrid.Name)
select g;
foreach (var grid in grids)
{
grid.Margin = new Thickness(10);
grid.Height = 70;
var filterTitles = from c in grid.Children.OfType <TextBlock>()
select c;
filterTitles.FirstOrDefault().FontSize = 50;
var filterContent = from c in grid.Children.OfType <TextBox>()
select c;
if (filterContent != null && filterContent.Count() != 0)
{
filterContent.FirstOrDefault().FontSize = 40;
filterContent.FirstOrDefault().Text = "";
}
}
// Category内容设置
categoryDsq = (DataServiceQuery <CATEGORY>)(from category in ctx.CATEGORY select category);
categoryDsq.BeginExecute(OnCategoryComplete, null);
SearchPopTitleText.KeyDown += AdvanceSearch_KeyDown;
SearchPopAuthorText.KeyDown += AdvanceSearch_KeyDown;
SearchPopDescriptionText.KeyDown += AdvanceSearch_KeyDown;
}
/// <summary>
/// Ons the resource complete.
/// </summary>
/// <param name="res">The resource.</param>
private void onResComplete(IAsyncResult res)
{
IEnumerable <RESOURCE> resources = resourceDsq.EndExecute(res);
RESOURCE resource = resources.FirstOrDefault();
resTypeDsq = (DataServiceQuery <RES_TYPE>)(ctx.RES_TYPE.Where(r => r.ID == resource.TYPE));
resTypeDsq.BeginExecute(onQueryComplete2, null);
}
private void ReadConfiguration()
{
int Value = 100000000; //Aspose.ImageAttach
DataServiceQuery <aspose_configuration> Configs = (DataServiceQuery <aspose_configuration>) this.ThisContext
.aspose_configurationSet.Where <aspose_configuration>(a => a.aspose_Type.Value.Value == Value);
Configs.BeginExecute(ReadConfiguration, Configs);
}
/// <summary>
/// 在此页将要在 Frame 中显示时进行调用。
/// </summary>
/// <param name="e">描述如何访问此页的事件数据。Parameter
/// 属性通常用于配置页。</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
//!!!!!!!!!!
Constants.User.SetAttendTeachNumber();
image.DataContext = Constants.User;
biggestGrid.DataContext = Constants.User;
customerDsq = (DataServiceQuery <CUSTOMER>)(from user in ctx.CUSTOMER select user);
customerDsq.BeginExecute(OnCustomerComplete, null);
}
private void EnableLicense()
{
if (LicenseWebResourceName != "")
{
DataServiceQuery <WebResource> License = (DataServiceQuery <WebResource>) this.ThisContext
.WebResourceSet.Where <WebResource>(a => a.Name == LicenseWebResourceName);
License.BeginExecute(RetrieveLicense, License);
}
}
/// <summary>
/// In this method we send a REST request to ADO.NET Data Service to request CourseGrade
/// records. We expand Person and Course so the foreign records will be returned as well
/// </summary>
private void LoadData()
{
_context = new SchoolLinqToSQLDataContext(new Uri(_schoolLinqToSQLUri));
DataServiceQuery <CourseGrade> query = (DataServiceQuery <CourseGrade>)(
from c in _context.CourseGrades.Expand("Person").Expand("Course")
select c);
query.BeginExecute(OnCourseGradeQueryComplete, query);
}
/// <summary>
/// 本方法中，发送一个异步的REST请求到ADO.NET Data Service来获得 CourseGrade 数据
/// 我们扩展了 Person 以及 Course，所以外部记录也会被返回到客户端。
/// </summary>
private void LoadData()
{
_entities = new SQLServer2005DBEntities(new Uri(_schoolLinqToEntitiesUri));
DataServiceQuery<CourseGrade> query = (DataServiceQuery<CourseGrade>)(
from c in _entities.CourseGrade.Expand("Person").Expand("Course")
select c);
query.BeginExecute(OnCourseGradeQueryComplete, query);
}
/// <summary>
/// 本方法中，我们向ADO.NET Data Service发送了一个异步的REST请求，来获得Category
/// 记录。
/// </summary>
private void LoadData()
{
_context = new SampleProjects(new Uri(_sampleUri));
DataServiceQuery <Category> query = (DataServiceQuery <Category>)(
from c in _context.Categories
select c);
query.BeginExecute(OnCategoryQueryComplete, query);
}
void FindCustomerByIDAndProcess(string customerID, Action <Customers> action)
{
DataServiceQuery <Customers> query = (DataServiceQuery <Customers>)context.Customers.Where <Customers>(customer => customer.CustomerID == customerID);
try {
query.BeginExecute(FindCustomerByIDCallback, new QueryAction(query, action));
} catch (Exception ex) {
HandleException(ex);
}
}
public static async Task <IEnumerable <TResult> > ExecuteAsync <TResult>(this DataServiceQuery <TResult> query)
{
var queryTask = Task.Factory.FromAsync <IEnumerable <TResult> >(query.BeginExecute(null, null), (asResult) =>
{
var result = query.EndExecute(asResult).ToList();
return(result);
});
return(await queryTask);
}
/// <summary>
/// Extension method to perform sync/async version of DataServiceQuery.Execute dynamically
/// </summary>
/// <typeparam name="TElement">The element type of the results</typeparam>
/// <param name="query">The query to execute</param>
/// <param name="continuation">The asynchronous continuation</param>
/// <param name="async">A value indicating whether or not to use async API</param>
/// <param name="onCompletion">A callback for when the call completes</param>
public static void Execute <TElement>(this DataServiceQuery <TElement> query, IAsyncContinuation continuation, bool async, Action <IEnumerable <TElement> > onCompletion)
{
ExceptionUtilities.CheckArgumentNotNull(query, "query");
AsyncHelpers.InvokeSyncOrAsyncMethodCall <IEnumerable <TElement> >(
continuation,
async,
() => query.Execute(),
c => query.BeginExecute(c, null),
r => query.EndExecute(r),
onCompletion);
}
public async Task OnGetAsync()
{
_nav.Credentials = CredentialCache.DefaultNetworkCredentials;
var contracts = _nav.Customer;
DataServiceQuery <Customer> query = contracts;
TaskFactory <IEnumerable <Customer> > taskFactory = new TaskFactory <IEnumerable <Customer> >();
Customer = await taskFactory.FromAsync(query.BeginExecute(null, null), iar => query.EndExecute(iar));
}
private IEnumerable <Order> ProcessOrder(DataServiceQuery <Order> queryOrder)
{
IAsyncResult resultOrder = queryOrder.BeginExecute((res) =>
{
Console.WriteLine(res);
}, null);
IEnumerable <Order> objOrder = queryOrder.EndExecute(resultOrder);
return(objOrder);
}
public static void ProcessQuery(DataViewModelBase sender, DataServiceQuery query, AsyncCallback callback)
{
if (!objectRepository.Value.Keys.Contains(query.ToString()))
{
query.BeginExecute(callback, null);
}
else
{
sender.OnCompleteSource(objectRepository.Value[query.ToString()]);
}
}
public async Task <List <FileSystemItem> > GetFiles()
{
DataServiceQuery <MS.FileServices.FileSystemItem> query = (DataServiceQuery <MS.FileServices.FileSystemItem>)
from file in apiData.Files
select file;
TaskFactory <IEnumerable <FileSystemItem> > taskFactory = new TaskFactory <IEnumerable <FileSystemItem> >();
IEnumerable <FileSystemItem> result = await taskFactory.FromAsync(query.BeginExecute(null, null), iar => query.EndExecute(iar));
return(result.ToList());
}
/// <summary>
/// Ons the get lesson complete.
/// </summary>
/// <param name="iar">The iar.</param>
private async void onGetLessonComplete(IAsyncResult iar)
{
try
{
System.Diagnostics.Debug.WriteLine("get lesson complete");
IEnumerable <LESSON> lessons = dba.lessonDsq.EndExecute(iar);
foreach (var l in lessons)
{
this.allLessons.Add(l);
//coursesData.AddCourse(Constants.CourseAvail2Course(c));
}
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
foreach (var l in this.allLessons)
{
System.Diagnostics.Debug.WriteLine(l.TITLE);
allLessonsStackPanel.Children.Add(GenerateALessonBox(l));
}
//dataCategory = coursesData.GetGroupsByCategory();
//cvs1.Source = dataCategory;
//(SemanticZoom.ZoomedOutView as ListViewBase).ItemsSource = cvs1.View.CollectionGroups;
//loadingProgressRing.IsActive = false;
});
}
catch
{
//ShowMessageDialog();
// Network Connection error.
}
try
{
resourceDic = new Dictionary <string, int>(Constants.ResourceType.Count);
for (int i = 0; i < Constants.ResourceType.Count; ++i)
{
DataServiceQuery <RES_TYPE> dps = (DataServiceQuery <RES_TYPE>)(from res_type in ctx.RES_TYPE
where res_type.DESCRIPTION.Trim() == Constants.ResourceType[i]
select res_type);
TaskFactory <IEnumerable <RES_TYPE> > tf = new TaskFactory <IEnumerable <RES_TYPE> >();
RES_TYPE resID = (await tf.FromAsync(dps.BeginExecute(null, null), result => dps.EndExecute(result))).FirstOrDefault();
resourceDic.Add(Constants.ResourceType[i], resID.ID);
}
}
catch
{
ShowMessageDialog("Network connection error!11");
return;
}
GetLearnedLessons();
}
private void GetPartSuppliers()
{
if (currentItem != null)
{
DataServiceQuery <SuppliersItem> query =
(DataServiceQuery <SuppliersItem>)context.PartSuppliers.Where(s => s.PartId == currentItem.Part.Id).Select(s => new SuppliersItem {
Title = s.Supplier.Title, DUNS = s.Supplier.DUNS, Rating = s.Supplier.Rating
});
query.BeginExecute(DisplaySuppliers, query);
}
}
