Akka.Cluster.ClusterEvent.CurrentClusterState.Copy C# (CSharp) Method

Copy() public method

Creates a deep copy of the CurrentClusterState and optionally allows you to specify different values for the outgoing objects
public Copy ( ImmutableSortedSet members = null, ImmutableHashSet unreachable = null, ImmutableHashSet
seenBy = null, Akka.Actor.Address leader = null, Address>.ImmutableDictionary roleLeaderMap = null ) : CurrentClusterState
members ImmutableSortedSet
unreachable ImmutableHashSet
seenBy ImmutableHashSet
leader Akka.Actor.Address
roleLeaderMap Address>.ImmutableDictionary
return CurrentClusterState
            public CurrentClusterState Copy(ImmutableSortedSet<Member> members = null,
                ImmutableHashSet<Member> unreachable = null,
                ImmutableHashSet<Address> seenBy = null,
                Address leader = null,
                ImmutableDictionary<string, Address> roleLeaderMap = null)
            {
                return new CurrentClusterState(members ?? _members,
                    unreachable ?? _unreachable,
                    seenBy ?? _seenBy,
                    leader ?? (_leader != null ? (Address)_leader.Clone() : null),
                    roleLeaderMap ?? _roleLeaderMap);
            }
        }

Usage Example

Esempio n. 1
0
            public EventBusListener(Cluster cluster, ClusterReadView readView)
            {
                _cluster  = cluster;
                _readView = readView;

                Receive <ClusterEvent.IClusterDomainEvent>(clusterDomainEvent =>
                {
                    clusterDomainEvent.Match()
                    .With <ClusterEvent.SeenChanged>(changed =>
                    {
                        State = State.Copy(seenBy: changed.SeenBy);
                    })
                    .With <ClusterEvent.ReachabilityChanged>(changed =>
                    {
                        _readView._reachability = changed.Reachability;
                    })
                    .With <ClusterEvent.MemberRemoved>(removed =>
                    {
                        State = State.Copy(members: State.Members.Remove(removed.Member),
                                           unreachable: State.Unreachable.Remove(removed.Member));
                    })
                    .With <ClusterEvent.UnreachableMember>(member =>
                    {
                        // replace current member with new member (might have different status, only address is used in == comparison)
                        State = State.Copy(unreachable: State.Unreachable.Remove(member.Member).Add(member.Member));
                    })
                    .With <ClusterEvent.ReachableMember>(member =>
                    {
                        State = State.Copy(unreachable: State.Unreachable.Remove(member.Member));
                    })
                    .With <ClusterEvent.IMemberEvent>(memberEvent =>
                    {
                        var newUnreachable = State.Unreachable;
                        // replace current member with new member (might have different status, only address is used in == comparison)
                        if (State.Unreachable.Contains(memberEvent.Member))
                        {
                            newUnreachable = State.Unreachable.Remove(memberEvent.Member).Add(memberEvent.Member);
                        }
                        State = State.Copy(
                            members: State.Members.Remove(memberEvent.Member).Add(memberEvent.Member),
                            unreachable: newUnreachable);
                    })
                    .With <ClusterEvent.LeaderChanged>(changed =>
                    {
                        State = State.Copy(leader: changed.Leader);
                    })
                    .With <ClusterEvent.RoleLeaderChanged>(changed =>
                    {
                        State = State.Copy(roleLeaderMap: State.RoleLeaderMap.SetItem(changed.Role, changed.Leader));
                    })
                    .With <ClusterEvent.CurrentInternalStats>(stats =>
                    {
                        readView._latestStats = stats;
                    })
                    .With <ClusterEvent.ClusterShuttingDown>(_ => { });
                });

                Receive <ClusterEvent.CurrentClusterState>(state =>
                {
                    State = state;
                });
            }
ClusterEvent.CurrentClusterState