public void NotifyRetweeted(TwitterUser source, TwitterStatus original, TwitterStatus retweet)
 {
     if (!_proxy.NotifyRetweeted(source, original, retweet) && this.Next != null)
     {
         this.Next.NotifyRetweeted(source, original, retweet);
     }
 }

 public void NotifyUnblocked(TwitterUser source, TwitterUser target)
 {
     if (!_proxy.NotifyUnblocked(source, target) && this.Next != null)
     {
         this.Next.NotifyUnblocked(source, target);
     }
 }

 public void NotifyUnfavorited(TwitterUser source, TwitterStatus status)
 {
     if (!_proxy.NotifyUnfavorited(source, status) && this.Next != null)
     {
         this.Next.NotifyUnfavorited(source, status);
     }
 }

 public void NotifyUnblocked(TwitterUser source, TwitterUser target)
 {
     if (Next != null)
     {
         Next.NotifyUnblocked(source, target);
     }
 }

 public void NotifyRetweeted(TwitterUser source, TwitterStatus status)
 {
     if (Next != null)
     {
         Next.NotifyRetweeted(source, status);
     }
 }

 public void NotifyFavorited(TwitterUser source, TwitterStatus status)
 {
     if (!_proxy.NotifyFavorited(source, status))
     {
         Next?.NotifyFavorited(source, status);
     }
 }

 public void NotifyRetweeted(TwitterUser source, TwitterStatus status)
 {
     if (_proxy.NotifyRetweeted(source, status) && this.Next != null)
     {
         this.Next.NotifyRetweeted(source, status);
     }
 }

 public void NotifyUnmuted(TwitterUser source, TwitterUser target)
 {
     if (!_proxy.NotifyUnmuted(source, target))
     {
         Next?.NotifyUnmuted(source, target);
     }
 }

 public void NotifyFollowed(TwitterUser source, TwitterUser target)
 {
     if (_proxy.NotifyFollowed(source, target) && this.Next != null)
     {
         this.Next.NotifyFollowed(source, target);
     }
 }

 public void NotifyRetweeted(TwitterUser source, TwitterStatus original, TwitterStatus retweet)
 {
     if (Setting.Accounts.Contains(source.Id) ||
         Setting.Accounts.Contains(original.User.Id))
     {
         BackstageModel.RegisterEvent(new RetweetedEvent(source, original));
     }
 }

 public UserViewModel(TwitterUser user)
 {
     this.Model = UserModel.Get(user);
     this.CompositeDisposable.Add(new CompositeDisposable(
         new EventListener<Action<TimelineIconResolution>>(
             h => Setting.IconResolution.ValueChanged += h,
             h => Setting.IconResolution.ValueChanged -= h,
             _ => this.RaisePropertyChanged(() => ProfileImageUriOptimized))));
 }

 public RelationControlViewModel(UserInfoViewModel parent, TwitterAccount source, TwitterUser target)
 {
     this._parent = parent;
     this._source = source;
     this._target = target;
     var rds = source.RelationData;
     this.IsFollowing = rds.IsFollowing(target.Id);
     this.IsFollowedBack = rds.IsFollowedBy(target.Id);
     this.IsBlocking = rds.IsBlocking(target.Id);
     Task.Run(() => this.GetFriendship(rds));
 }

 public BackstageAccountModel(TwitterAccount account)
 {
     this._account = account;
     this.UpdateConnectionState();
     StoreHelper.GetUser(this._account.Id)
         .Subscribe(
             u =>
             {
                 _user = u;
                 this.RaiseTwitterUserChanged();
             },
             ex => BackstageModel.RegisterEvent(
                 new OperationFailedEvent("アカウント情報を取得できません(@" + _account.UnreliableScreenName + ")", ex)));
 }

 public BackstageAccountModel(TwitterAccount account)
 {
     this._account = account;
     this.UpdateConnectionState();
     StoreHelper.GetUser(this._account.Id)
                .Subscribe(
                    u =>
                    {
                        _user = u;
                        this.OnTwitterUserChanged();
                    },
                    ex => BackstageModel.RegisterEvent(
                        new OperationFailedEvent("Could not receive user account: " +
                                                 this._account.UnreliableScreenName +
                                                 " - " + ex.Message)));
 }

 public TwitterList(dynamic json)
 {
     Id = Int64.Parse(json.id_str);
     User = new TwitterUser(json.user);
     Name = json.name;
     FullName = json.full_name;
     Uri = new Uri(TwitterListUriPrefix + json.uri);
     Slug = json.slug;
     ListMode = String.Equals(json.mode, "public", StringComparison.InvariantCultureIgnoreCase)
                    ? ListMode.Public
                    : ListMode.Private;
     Description = json.description;
     MemberCount = (long)json.member_count;
     SubscriberCount = (long)json.subscriber_count;
     CreatedAt = ((string)json.created_at).ParseDateTime(ParsingExtension.TwitterDateTimeFormat);
 }

 public BackstageAccountModel(TwitterAccount account)
 {
     this._account = account;
     this.UpdateConnectionState();
     StoreHelper.GetUser(this._account.Id)
                .Subscribe(
                    u =>
                    {
                        _user = u;
                        this.RaiseTwitterUserChanged();
                    },
                    ex => BackstageModel.RegisterEvent(new OperationFailedEvent(
                        BackstageResources.GetAccountInfoFailedFormat.SafeFormat(
                            "@" + _account.UnreliableScreenName),
                        ex)));
 }

 public BackstageAccountModel(TwitterAccount account)
 {
     this._account = account;
     this.UpdateConnectionState();
     Task.Run(async () =>
     {
         try
         {
             _user = await StoreHelper.GetUserAsync(this._account.Id);
             this.RaiseTwitterUserChanged();
         }
         catch (Exception ex)
         {
             BackstageModel.RegisterEvent(new OperationFailedEvent(
                 BackstageResources.GetAccountInfoFailedFormat.SafeFormat("@" + _account.UnreliableScreenName),
                 ex));
         }
     });
 }

 public UnknownEvent(TwitterUser source, string evstr)
     : base(source, source)
 {
     _evstr = evstr;
 }

        public async void AddRetweetedUser(TwitterUser user)
        {
            if (Status.RetweetedOriginal != null)
            {
                var status = await Get(Status.RetweetedOriginal).ConfigureAwait(false);
                status.AddRetweetedUser(user);
            }
            else
            {
                var added = false;
                lock (_retweetedsLock)
                {
                    if (!_retweetedUsersDic.ContainsKey(user.Id))
                    {
                        _retweetedUsersDic.Add(user.Id, user);
                        Status.RetweetedUsers = Status.RetweetedUsers.Guard()
                                                      .Append(user.Id)
                                                      .Distinct()
                                                      .ToArray();
                        added = true;
                    }
                }
                if (added)
                {
                    _retweetedUsers.Add(user);
#pragma warning disable 4014
                    StatusProxy.AddRetweeter(Status.Id, user.Id);
                    StatusBroadcaster.Republish(this);
#pragma warning restore 4014
                }
            }
        }

 public void NotifyUserUpdated(TwitterUser source)
 {
     // do nothing, currently.
 }