C# FacebookClient.GetTaskAsync方法代码示例

        public override async System.Threading.Tasks.Task GrantCustomExtension(OAuthGrantCustomExtensionContext context)
        {
            if(context.GrantType.ToLower() == "facebook")
            {
                var fbClient = new FacebookClient(context.Parameters.Get("accesstoken"));
                dynamic mainDataResponse = await fbClient.GetTaskAsync("me", new { fields = "first_name, last_name, picture" });
                dynamic friendListResponse = await fbClient.GetTaskAsync("me/friends");
                var friendsResult = (IDictionary<string, object>)friendListResponse;
                var friendsData = (IEnumerable<object>)friendsResult["data"];
                var friendsIdList = new List<string>();
                foreach (var item in friendsData)
                {
                    var friend = (IDictionary<string, object>)item;
                    friendsIdList.Add((string)friend["id"]);
                }
                User user = await CreateOrUpdateUser(mainDataResponse.id, mainDataResponse.first_name, mainDataResponse.last_name, mainDataResponse.picture.data.url, friendsIdList);
                
                var identity = new ClaimsIdentity(context.Options.AuthenticationType);
                identity.AddClaim(new Claim(_fbIdKey, mainDataResponse.id));
                identity.AddClaim(new Claim(_idKey, user.Id.ToString()));

                await base.GrantCustomExtension(context);
                context.Validated(identity);
            }
            return;
        }

        // GET: Facebook
        public async Task<ActionResult> Index()
        {
            var access_token = HttpContext.Items["access_token"].ToString();
            if(access_token != null)
            {
                try
                {
                    var appsecret_proof = access_token.GenerateAppSecretProof();

                    var fb = new FacebookClient(access_token);
                    //Get current user's profile
                    dynamic myInfo =
                        await fb.GetTaskAsync("me?fields=first_name,last_name,link,locale,email,name,birthday,gender,location,bio,age_range".GraphAPICall(appsecret_proof));

                    //var facebookProfile = DynamicExtension.ToStatic<FacebookProfileViewModel>(myInfo);

                    //get curent profile
                    dynamic profileImgResult =
                        await fb.GetTaskAsync("{0}/picture?width=200&height=200&redirect=false".GraphAPICall((string)myInfo.id, appsecret_proof));
                    //facebookProfile.ImageUrl = profileImgResult.data.url;
                    var facebookProfile = new FacebookProfileViewModel()
                    {
                        
                    }
                }
                catch (Exception)
                {
                    
                    throw;
                }
            }
        }

        public async void ContinueWithWebAuthenticationBroker(WebAuthenticationBrokerContinuationEventArgs args)
        {
            ObjFBHelper.ContinueAuthentication(args);
            if (ObjFBHelper.AccessToken != null)
            {
                fbclient = new Facebook.FacebookClient(ObjFBHelper.AccessToken);

                //Fetch facebook UserProfile:
                dynamic result = await fbclient.GetTaskAsync("me");
                string id = result.id;
                string email = result.email;
                string FBName = result.name;

                IsLoggedIn = true;
                btnFBLogin.Content = "Log out";
                txtBlockContent.Text = "You're now logged in as " + FBName;

                var msgDialog = new MessageDialog("Hello, " + FBName, "Login successful");
                await msgDialog.ShowAsync();
            }
            else
            {
                var msgDialog = new MessageDialog("Check your credentials and try again", "Login failed");
                await msgDialog.ShowAsync();
            }
        }

        public int ProcessFbOathResult(FacebookOAuthResult oauthResult)
        {
            var resultCode = 0;
            var accessToken = oauthResult.AccessToken;
            App.ViewModel.UserPreference.AccessKey = accessToken;
            var fbS = new FacebookClient(accessToken);

            fbS.GetCompleted += (o, res) =>
                                    {
                                        if (res.Error != null)
                                        {
                                            resultCode = 1;
                                            return;
                                        }

                                        var result = (IDictionary<string, object>) res.GetResultData();
                                        App.ViewModel.UserPreference.FbUserId = (string) result["id"];
                                        App.ViewModel.UserPreference.Name = (string) result["name"];
                                        App.ViewModel.LoadData(true);
                                        App.ViewModel.SaveSettings();
                                        Dispatcher.BeginInvoke(() =>
                                                                   {
                                                                       facebookImage.Source =
                                                                           App.ViewModel.UserPreference.UserImage;
                                                                       name.Text = App.ViewModel.UserPreference.Name;
                                                                   });
                                    };

            fbS.GetTaskAsync("me");
            return resultCode;
        }

        /// <summary>
        /// Get the loged in user info based on the access token
        /// </summary>
        /// <param name="accessToken">Login returned access token</param>
        /// <returns>a dictionary with the user info values.</returns>
        public async Task<IDictionary<string, object>> GetLogedUserInfoAsync(string accessToken)
        {
            _fb = new FacebookClient(accessToken);

            return (IDictionary<string, object>)await _fb.GetTaskAsync("me");

        }

        public override async Task GrantCustomExtension(OAuthGrantCustomExtensionContext context)
        {
            if (context.GrantType.ToLower() == "facebook")
            {
                var fbClient = new FacebookClient(context.Parameters.Get("accesstoken"));

                dynamic response = await fbClient.GetTaskAsync("me", new { fields = "email, first_name, last_name" });
                
                string id = response.id;
                string email = response.email;
                string firstname = response.first_name;
                string lastname = response.last_name;
                // place your own logic to lookup and/or create users....

                // your choice of claims...
                var identity = new ClaimsIdentity(context.Options.AuthenticationType);
                identity.AddClaim(new Claim("sub", $"{firstname} {lastname}"));
                identity.AddClaim(new Claim("role", id));

                await base.GrantCustomExtension(context);
                context.Validated(identity);

            }            
            return;
        }

        private void LoadFacebookData()
        {
            var fb = new FacebookClient(App.FacebookAccessToken);
            fb.GetCompleted += (o, e) =>
            {
                if (e.Error != null)
                {

                }

                var result = (IDictionary<string, object>)e.GetResultData();

                Dispatcher.BeginInvoke(() =>
                    {
                        var profilePictureUrl = string.Format("https://graph.facebook.com/{0}/picture?type={1}&access_token={2}", App.FacebookId, "square", App.FacebookAccessToken);

                        ProfilePicture.Source = new BitmapImage(new Uri(profilePictureUrl));
                        FirstNameBox.Text = result["first_name"].ToString();
                        LastNameBox.Text = result["last_name"].ToString();
                        if (result["gender"].ToString().ToLower() == "male")
                            GenderPicker.SelectedIndex = 1;

                        var location = (IDictionary<string, object>)result["location"];
                        LocationBox.Text = location["name"].ToString();
                        //var favoriteteams = (List<IDictionary<string, object>>)result["favorite_teams"];
                    }

                    );
            };

            fb.GetTaskAsync("me");
        }

        /// <summary>
        /// Setups the application link.
        /// </summary>
        public static void Setup()
        {
            _app = new FacebookClient();
            _app.AppId = "223453524434397";
            _app.AppSecret = "3b6769b53e52b0d122d2572950d770bd";

            dynamic parameters = new ExpandoObject();
            parameters.client_id = _app.AppId;
            parameters.client_secret = _app.AppSecret;
            parameters.grant_type = "client_credentials";

            Task<Object> connect = _app.GetTaskAsync("https://graph.facebook.com/oauth/access_token", parameters);
            connect.ContinueWith(task => {
                try
                {
                    // Save the access token
                    _app.AccessToken = JObject.Parse(task.Result.ToString()).Value<String>("access_token");
                    Connection |= FacebookState.Connected;
                }
                catch (AggregateException aex)
                {
                    aex.Handle(e =>
                    {
                        if (e is FacebookOAuthException)
                        {

                        }

                        return true;
                    });
                }
            });
        }

        private async Task GetExtendedToken()
        {
            try
            {
                var accessToken = settings.Get<string>(FACEBOOK_TOKEN_SETTING);
                if (!string.IsNullOrEmpty(accessToken))
                {
                    var facebookClient = new FacebookClient(accessToken);
                    dynamic parameters = new ExpandoObject();
                    parameters.client_id = APP_ID;
                    parameters.client_secret = APP_SECRET;
                    parameters.grant_type = "fb_exchange_token";
                    parameters.fb_exchange_token = accessToken;
                    //parameters.redirect_uri = "https://www.facebook.com/connect/login_success.html";

                    dynamic tokenResponse = await facebookClient.GetTaskAsync("oauth/access_token",parameters);
                    if (!string.IsNullOrEmpty(tokenResponse.access_token))
                    {
                        settings.Set<string>(FACEBOOK_TOKEN_SETTING, tokenResponse.access_token);
                        settings.Set(FACEBOOK_TOKEN_EXPIRES_AT_SETTING, DateTime.UtcNow.AddSeconds((int)tokenResponse.expires).ToFileTimeUtc());
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

 public static void API(
     string endpoint,
     HttpMethod method,
     FacebookDelegate callback)
 {
     if (method != HttpMethod.GET) throw new NotImplementedException();
     Task.Run(async () =>
     {
         FacebookClient fb = new FacebookClient(_fbSessionClient.CurrentAccessTokenData.AccessToken);
         FBResult fbResult = null;
         try
         {
             var apiCall = await fb.GetTaskAsync(endpoint, null);
             if (apiCall != null)
             {
                 fbResult = new FBResult();
                 fbResult.Text = apiCall.ToString();
                 fbResult.Json = apiCall as JsonObject;
             }
         }
         catch (Exception ex)
         {
             fbResult = new FBResult();
             fbResult.Error = ex.Message;
         }
         if (callback != null)
         {
             Utils.RunOnUnityAppThread(() => { callback(fbResult); });
         }
     });
 }

        public async Task<HttpResponseMessage> Login(string authToken)
        {
            var fb = new FacebookClient(authToken);
            fb.AppSecret = Environment.GetEnvironmentVariable("FacebookSecret");
            dynamic result = await fb.GetTaskAsync("me");
            var existingUser = (User)await _userService.GetUser(result.id);
            if (existingUser == null)
            {
                var newUser = await _userService.CreateUser(new User
                {
                    Id = Guid.NewGuid(),
                    FacebookId = result.id.ToString(),
                    FacebookToken = authToken,
                    Name = result.name.ToString(),
                    UpdatedAt = DateTime.Now
                });
                
                return Request.CreateResponse(HttpStatusCode.OK, newUser);
            }

            existingUser.Name = result.name.ToString();
            existingUser.FacebookToken = authToken;
            existingUser.UpdatedAt = DateTime.Now;

            var updatedUser = await _userService.UpdateUser(existingUser);

            return Request.CreateResponse(HttpStatusCode.OK, updatedUser);
        }

        private void LoadUserInfo()
        {
            var fb = new FacebookClient(App.AccessToken);

            fb.GetCompleted += (o, e) =>
            {
                if (e.Error != null)
                {
                    Dispatcher.BeginInvoke(() => MessageBox.Show(e.Error.Message));
                    return;
                }

                var result = (IDictionary<string, object>)e.GetResultData();

                Dispatcher.BeginInvoke(() =>
                {
                    var profilePictureUrl = string.Format("https://graph.facebook.com/{0}/picture?type={1}&access_token={2}", App.FacebookId, "square", App.AccessToken);

                    this.MyImage.Source = new BitmapImage(new Uri(profilePictureUrl));
                    this.MyName.Text = String.Format("{0} {1}", (string)result["first_name"], (string)result["last_name"]);
                });
            };

            fb.GetTaskAsync("me");
        }

        private async void OnFacebookAuthenticationFinished(AccessTokenData session)
        {
            // here the authentication succeeded callback will be received.
            // put your login logic here
            try
            {
                FacebookClient client = new FacebookClient(session.AccessToken);

                //Graph request and result
                dynamic result = await client.GetTaskAsync("me");

                //Getting current user from graph request result
                var currentUser = new Facebook.Client.GraphUser(result);

                //Do something with current user data
                var fad = new FacebookAccountData()
                {
                    SocialNetworkId = currentUser.Id,
                    Name = currentUser.Name,
                    LastName = currentUser.LastName,
                    FirstName = currentUser.FirstName,
                    Email = "",
                    Link = currentUser.Link,
                    MiddleName = currentUser.MiddleName
                };
            }
            catch (Exception ex)
            {
                //Handle exception
            }
        }

        private async System.Threading.Tasks.Task RetriveUserInfo(AccessTokenData accessToken)
        {
            var client = new Facebook.FacebookClient(accessToken.AccessToken);

			dynamic result = null;
			bool failed = false;
			try
			{
				result = await client.GetTaskAsync("me?fields=id,birthday,first_name,last_name,middle_name,gender");
			}
			catch(Exception e)
			{
				failed = true;
			}
			if(failed)
			{
				MessageDialog dialog = new MessageDialog("Facebook is not responding to our authentication request. Sorry.");
				await dialog.ShowAsync();

				throw new Exception("Windows phone does not provide an exit function, so we have to crash the app.");
			}
            string fullName = string.Join(" ", new[] { result.first_name, result.middle_name, result.last_name });
            string preferredName = result.last_name;
            bool? gender = null;
            if (result.gender == "female")
            {
                gender = true;
            }
            else if (result.gender == "male")
            {
                gender = false;
            }
            DateTime birthdate = DateTime.UtcNow - TimeSpan.FromDays(365 * 30);
            if (result.birthday != null)
            {
                birthdate = DateTime.Parse(result.birthday);
            }

            var currentUser = new Facebook.Client.GraphUser(result);

            long facebookId = long.Parse(result.id);

            UserState.ActiveAccount = await Api.Do.AccountFacebook(facebookId);
            if (UserState.ActiveAccount == null)
            {
                Frame.Navigate(typeof(CreatePage), new CreatePage.AutofillInfo
                    {
                        SocialId = facebookId,
						Authenticator = Authenticator.Facebook,
                        Birthdate = birthdate,
                        FullName = fullName,
                        Gender = gender,
                        PreferredName = preferredName
                    });
            }
            else
            {
                Frame.Navigate(typeof(MainPage), UserState.CurrentId);
            }
        }

        async private void graphCallButton_Click(object sender, RoutedEventArgs e)
        {
            FacebookClient fb = new FacebookClient(Session.ActiveSession.CurrentAccessTokenData.AccessToken);

            dynamic friendsTaskResult = await fb.GetTaskAsync("/me/friends");

            MessageBox.Show("Graph Request for /me/friends: " +
                friendsTaskResult.ToString());
        }