C# GroupMember类代码示例

 public void Register(GroupMember member)
 {
     if (! members.Contains(member)) {
         count++;
         members.Add(member);
     }
 }

        /// <summary>
        /// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
        /// </summary>
        /// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
        protected override void OnLoad( EventArgs e )
        {
            base.OnLoad( e );

            if ( !Page.IsPostBack )
            {
                string groupId = PageParameter( "GroupId" );
                string groupMemberId = PageParameter( "GroupMemberId" );
                if ( !string.IsNullOrWhiteSpace( groupMemberId ) )
                {
                    if ( string.IsNullOrWhiteSpace( groupId ) )
                    {
                        ShowDetail( "GroupMemberId", int.Parse( groupMemberId ) );
                    }
                    else
                    {
                        ShowDetail( "GroupMemberId", int.Parse( groupMemberId ), int.Parse( groupId ) );
                    }
                }
                else
                {
                    upDetail.Visible = false;
                }
            }
            else
            {
                var groupMember = new GroupMember { GroupId = hfGroupId.ValueAsInt() };
                if ( groupMember != null )
                {
                    groupMember.LoadAttributes();
                    phAttributes.Controls.Clear();
                    Rock.Attribute.Helper.AddEditControls( groupMember, phAttributes, false );
                }
            }
        }

 /// <summary>
 /// Builds and returns the GroupMember object.
 /// </summary>
 /// <returns>the GroupMember object</returns>
 public GroupMember Build()
 {
     GroupMember groupMember = new GroupMember
     {
         Email = this.email
     };
     return groupMember;
 }

 public void DeleteGroupMember(GroupMember groupMember)
 {
     using (SPKTDataContext dc = conn.GetContext())
     {
         dc.GroupMembers.Attach(groupMember, true);
         dc.GroupMembers.DeleteOnSubmit(groupMember);
         dc.SubmitChanges();
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="GroupMemberPlacedElsewhereTransaction" /> class.
 /// </summary>
 /// <param name="groupMember">The group member of the current group they are in (before being deleted and processed) </param>
 /// <param name="note">The note.</param>
 /// <param name="trigger">The GroupMemberWorkflowTrigger.</param>
 public GroupMemberPlacedElsewhereTransaction( GroupMember groupMember, string note, GroupMemberWorkflowTrigger trigger )
 {
     this.Trigger = trigger;
     this.GroupId = groupMember.GroupId;
     this.PersonId = groupMember.PersonId;
     this.GroupMemberStatusName = groupMember.GroupMemberStatus.ConvertToString();
     this.GroupMemberRoleName = groupMember.GroupRole.ToString();
     groupMember.LoadAttributes();
     this.GroupMemberAttributeValues = groupMember.AttributeValues.ToDictionary( k => k.Key, v => v.Value.Value );
     this.Note = note;
 }

 public static void UpdateCharacterGroup(GroupMember pMember)
 {
     using (var client = Program.DatabaseManager.GetClient())
     {
         string q = string.Format(UpdateCharacterGroupQuery,
                     pMember.Group.Id,
                     pMember.Role == GroupRole.Master,
                     pMember.Character.ID);
         client.ExecuteQuery(q);
     }
 }

 /*
 This needs to be static because if the Group is destroyed before
 all of its members, then it might be inadvertently recreated.
   */
 public static void Deregister(GroupMember member)
 {
     var o = GameObject.Find(member.groupName);
     if (o != null) {
         Group group = Group.GetGroup(member.groupName);
         if (group.members.Contains(member)) {
             group.count--;
             group.members.Remove(member);
         }
     }
 }

        internal static GroupMemberEntity GroupMember(GroupMember ent)
        {
            GroupMemberEntity data = new GroupMemberEntity();

            data.groupMemberId = ent.Id;
            data.groupFK = ent.GroupFK;
            data.memberFK = ent.MemberFK;
            data.isAdmin = ent.IsAdmin;
            data.updateTimestamp = ent.UpdateTimestamp;
            data.updatePersonFK = ent.UpdatePersonFK;

            return data;
        }

 public void RequestMembership()
 {
     if (_webContext.CurrentUser != null)
     {
         GroupMember gm = new GroupMember();
         gm.AccountID = _webContext.CurrentUser.AccountID;
         gm.GroupID = _webContext.GroupID;
         gm.CreateDate = DateTime.Now;
         gm.IsAdmin = false;
         gm.IsApproved = false;
         _groupMemberRepository.SaveGroupMember(gm);
         ShowMessage("Yêu cầu thành công!Cảm ơn bạn đã quan tâm đến nhóm! Chờ Admin Group chấp nhận yêu cầu của bạn");
     }
 }

        public GroupMember InviteMember( GroupId groupId, GroupMember groupMember ) {
            string path = template.UrlFor (UrlTemplate.GROUPS_MEMBER_PATH)
				.Replace("{groupId}", groupId.Id )
                .Build ();
			Silanis.ESL.API.GroupMember apiGroupMember = new GroupMemberConverter(groupMember).ToAPIGroupMember();
            try {
				string json = JsonConvert.SerializeObject (apiGroupMember, settings);
                string response = restClient.Post(path, json);              
				Silanis.ESL.API.GroupMember apiResponse = JsonConvert.DeserializeObject<Silanis.ESL.API.GroupMember> (response);
				return new GroupMemberConverter( apiResponse ).ToSDKGroupMember();
            } catch (Exception e) {
                throw new EslException ("Could not create a new package." + " Exception: " + e.Message);
            }
        }

        public Contracts.GenericListResult<Contracts.SmallGroupMember> GetSmallGroupMembers(int groupID, int start, int max)
        {
            Contracts.GenericListResult<Contracts.SmallGroupMember> list = new Contracts.GenericListResult<Contracts.SmallGroupMember>();
            Contracts.SmallGroupMemberMapper mapper = new Contracts.SmallGroupMemberMapper();
            Group group = new Group(groupID);
            GroupMember leader = new GroupMember(groupID, group.Leader);
            leader.Role = new Lookup(new Guid("029B270C-7B7A-499F-8006-CC3211C91E95"));
            group.Members.Add(leader);

            Boolean accessDenied = false;
            // If this person isn't the outright leader and they don't have view access
            if (group.Leader.PersonID != ArenaContext.Current.Person.PersonID &&
                RestApi.GroupClusterOperationAllowed(ArenaContext.Current.Person.PersonID, group.GroupClusterID, OperationType.View) == false) {

                accessDenied = true;

                // Do a deeper dive into each member of the group
                foreach(GroupMember gm in group.Members) {
                    if (gm.Active && gm.Role.Value == "Leader")
                    {
                        accessDenied = false;
                        break;
                    }
                }
            }
            if (accessDenied) {
                throw new Exception("Access denied.");
            }

            list.Start = start;
            list.Max = max;
            list.Total = group.Members.Count;
            list.Items = new List<Contracts.SmallGroupMember>();

            int i;
            for (i = start; i < group.Members.Count && (max <= 0 || i < (start + max)); i++)
            {
                list.Items.Add(mapper.FromArena(group.Members[i]));
            }

            return list;
        }

        private void ReceiveBadgeList(GroupMember member)
        {
            uint count = 0;
            if (!currentUsers.TryGetValue(member.Group, out count))
            {
                currentUsers.Add(member.Group, 1);

                ServerMessage message = PacketHandelingManager.GetRecycledItem(OutputCode.SendGroup);
                message.AddInt32(1);
                message.AddUInt32(member.Group.ID);
                message.AddString(member.Group.image);
                broadcaster.SendMessage(message);
            }
            else
            {
                currentUsers[member.Group] = ++count;
            }

            GameClient client = ButterflyEnvironment.GetGame().GetClientManager().GetClient(member.data.Id);
            if (client != null)
                client.SendMessage(SerializeList());
        }

            public override void Init(StoC_0x16_VariousUpdate pak)
            {
                groupMembers = new GroupMember[pak.SubCount];

                m_oids = new ushort[pak.SubCount];
                for (int i = 0; i < pak.SubCount; i++)
                {
                    GroupMember member = new GroupMember();

                    member.level = pak.ReadByte();
                    member.health = pak.ReadByte();
                    member.mana = pak.ReadByte();
                    member.endurance = pak.ReadByte(); // new in 1.69
                    member.status = pak.ReadByte();
                    member.oid = pak.ReadShort();
                    member.name = pak.ReadPascalString();
                    member.classname = pak.ReadPascalString();
                    m_oids[i] = member.oid;

                    groupMembers[i] = member;
                }
            }

        /// <summary>
        /// Adds the group member.
        /// </summary>
        /// <param name="familyGroup">The family group.</param>
        /// <param name="person">The person.</param>
        /// <returns></returns>
        protected GroupMember AddGroupMember( int familyGroupId, Person person )
        {
            var rockContext = new RockContext();

            GroupMember groupMember = new GroupMember();
            groupMember.IsSystem = false;
            groupMember.GroupId = familyGroupId;
            groupMember.PersonId = person.Id;
            if ( person.Age >= 18 )
            {
                groupMember.GroupRoleId = new GroupTypeRoleService( rockContext ).Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ).Id;
            }
            else
            {
                groupMember.GroupRoleId = new GroupTypeRoleService( rockContext ).Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD ) ).Id;
            }

            GroupMemberService groupMemberService = new GroupMemberService( rockContext );
            groupMemberService.Add( groupMember );
            rockContext.SaveChanges();

            return groupMember;
        }

        private void UserLeaving(GroupMember member)
        {
            // unload fix

            uint count = 0;

            if (currentUsers != null)
            {
                if (member != null)
                {
                    if (member.Group != null)
                    {
                        if (currentUsers.TryGetValue(member.Group, out count))
                        {
                            if (count > 1)
                                currentUsers[member.Group] = --count;
                            else
                                currentUsers.Remove(member.Group);
                        }
                    }
                }
            }
        }