reference.cs

使用C#语言开发的远程监控管理平台；使用soaphead对webservice进行加密的实例

                    return this.columnDisplayName;
                }
            }
            
            internal DataColumn IssueTypeColumn {
                get {
                    return this.columnIssueType;
                }
            }
            
            internal DataColumn HasConflictsColumn {
                get {
                    return this.columnHasConflicts;
                }
            }
            
            internal DataColumn IsReadColumn {
                get {
                    return this.columnIsRead;
                }
            }
            
            public ConflictsRow this[int index] {
                get {
                    return ((ConflictsRow)(this.Rows[index]));
                }
            }
            
            public event ConflictsRowChangeEventHandler ConflictsRowChanged;
            
            public event ConflictsRowChangeEventHandler ConflictsRowChanging;
            
            public event ConflictsRowChangeEventHandler ConflictsRowDeleted;
            
            public event ConflictsRowChangeEventHandler ConflictsRowDeleting;
            
            public void AddConflictsRow(ConflictsRow row) {
                this.Rows.Add(row);
            }
            
            public ConflictsRow AddConflictsRow(int StafferID, int IssueTypeID, string Title, string Description, System.DateTime DateOpened, System.DateTime DateClosed, bool IsOpen, System.DateTime DateModified, string UserName, string DisplayName, string IssueType, bool HasConflicts, bool IsRead) {
                ConflictsRow rowConflictsRow = ((ConflictsRow)(this.NewRow()));
                rowConflictsRow.ItemArray = new object[] {
                        null,
                        StafferID,
                        IssueTypeID,
                        Title,
                        Description,
                        DateOpened,
                        DateClosed,
                        IsOpen,
                        DateModified,
                        UserName,
                        DisplayName,
                        IssueType,
                        HasConflicts,
                        IsRead};
                this.Rows.Add(rowConflictsRow);
                return rowConflictsRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                ConflictsDataTable cln = ((ConflictsDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new ConflictsDataTable();
            }
            
            internal void InitVars() {
                this.columnIssueID = this.Columns["IssueID"];
                this.columnStafferID = this.Columns["StafferID"];
                this.columnIssueTypeID = this.Columns["IssueTypeID"];
                this.columnTitle = this.Columns["Title"];
                this.columnDescription = this.Columns["Description"];
                this.columnDateOpened = this.Columns["DateOpened"];
                this.columnDateClosed = this.Columns["DateClosed"];
                this.columnIsOpen = this.Columns["IsOpen"];
                this.columnDateModified = this.Columns["DateModified"];
                this.columnUserName = this.Columns["UserName"];
                this.columnDisplayName = this.Columns["DisplayName"];
                this.columnIssueType = this.Columns["IssueType"];
                this.columnHasConflicts = this.Columns["HasConflicts"];
                this.columnIsRead = this.Columns["IsRead"];
            }
            
            private void InitClass() {
                this.columnIssueID = new DataColumn("IssueID", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIssueID);
                this.columnStafferID = new DataColumn("StafferID", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnStafferID);
                this.columnIssueTypeID = new DataColumn("IssueTypeID", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIssueTypeID);
                this.columnTitle = new DataColumn("Title", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnTitle);
                this.columnDescription = new DataColumn("Description", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnDescription);
                this.columnDateOpened = new DataColumn("DateOpened", typeof(System.DateTime), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnDateOpened);
                this.columnDateClosed = new DataColumn("DateClosed", typeof(System.DateTime), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnDateClosed);
                this.columnIsOpen = new DataColumn("IsOpen", typeof(bool), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIsOpen);
                this.columnDateModified = new DataColumn("DateModified", typeof(System.DateTime), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnDateModified);
                this.columnUserName = new DataColumn("UserName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnUserName);
                this.columnDisplayName = new DataColumn("DisplayName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnDisplayName);
                this.columnIssueType = new DataColumn("IssueType", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIssueType);
                this.columnHasConflicts = new DataColumn("HasConflicts", typeof(bool), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnHasConflicts);
                this.columnIsRead = new DataColumn("IsRead", typeof(bool), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIsRead);
                this.columnIssueID.AutoIncrement = true;
                this.columnIssueID.AllowDBNull = false;
                this.columnIssueID.ReadOnly = true;
                this.columnStafferID.AllowDBNull = false;
                this.columnIssueTypeID.AllowDBNull = false;
                this.columnTitle.AllowDBNull = false;
                this.columnDescription.AllowDBNull = false;
                this.columnDateOpened.AllowDBNull = false;
                this.columnIsOpen.AllowDBNull = false;
                this.columnDateModified.AllowDBNull = false;
                this.columnUserName.AllowDBNull = false;
                this.columnDisplayName.AllowDBNull = false;
                this.columnIssueType.AllowDBNull = false;
                this.columnHasConflicts.DefaultValue = false;
                this.columnIsRead.DefaultValue = false;
            }
            
            public ConflictsRow NewConflictsRow() {
                return ((ConflictsRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new ConflictsRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(ConflictsRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.ConflictsRowChanged != null)) {
                    this.ConflictsRowChanged(this, new ConflictsRowChangeEvent(((ConflictsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.ConflictsRowChanging != null)) {
                    this.ConflictsRowChanging(this, new ConflictsRowChangeEvent(((ConflictsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.ConflictsRowDeleted != null)) {
                    this.ConflictsRowDeleted(this, new ConflictsRowChangeEvent(((ConflictsRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.ConflictsRowDeleting != null)) {
                    this.ConflictsRowDeleting(this, new ConflictsRowChangeEvent(((ConflictsRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveConflictsRow(ConflictsRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class ConflictsRow : DataRow {
            
            private ConflictsDataTable tableConflicts;
            
            internal ConflictsRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableConflicts = ((ConflictsDataTable)(this.Table));
            }
            
            public int IssueID {
                get {
                    return ((int)(this[this.tableConflicts.IssueIDColumn]));
                }
                set {
                    this[this.tableConflicts.IssueIDColumn] = value;
                }
            }
            
            public int StafferID {
                get {
                    return ((int)(this[this.tableConflicts.StafferIDColumn]));
                }
                set {
                    this[this.tableConflicts.StafferIDColumn] = value;
                }
            }
            
            public int IssueTypeID {
                get {
                    return ((int)(this[this.tableConflicts.IssueTypeIDColumn]));
                }
                set {
                    this[this.tableConflicts.IssueTypeIDColumn] = value;
                }
            }
            
            public string Title {
                get {
                    return ((string)(this[this.tableConflicts.TitleColumn]));
                }
                set {
                    this[this.tableConflicts.TitleColumn] = value;
                }
            }
            
            public string Description {
                get {
                    return ((string)(this[this.tableConflicts.DescriptionColumn]));
                }
                set {
                    this[this.tableConflicts.DescriptionColumn] = value;
                }
            }
            
            public System.DateTime DateOpened {
                get {
                    return ((System.DateTime)(this[this.tableConflicts.DateOpenedColumn]));
                }
                set {
                    this[this.tableConflicts.DateOpenedColumn] = value;
                }
            }
            
            public System.DateTime DateClosed {
                get {
                    try {
                        return ((System.DateTime)(this[this.tableConflicts.DateClosedColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("无法获取值，因为它是 DBNull。", e);
                    }
                }
                set {
                    this[this.tableConflicts.DateClosedColumn] = value;
                }
            }
            
            public bool IsOpen {
                get {
                    return ((bool)(this[this.tableConflicts.IsOpenColumn]));
                }
                set {
                    this[this.tableConflicts.IsOpenColumn] = value;
                }
            }
            
            public System.DateTime DateModified {
                get {
                    return ((System.DateTime)(this[this.tableConflicts.DateModifiedColumn]));
                }
                set {
                    this[this.tableConflicts.DateModifiedColumn] = value;
                }
            }
            
            public string UserName {
                get {
                    return ((string)(this[this.tableConflicts.UserNameColumn]));
                }
                set {
                    this[this.tableConflicts.UserNameColumn] = value;
                }
            }
            
            public string DisplayName {
                get {
                    return ((string)(this[this.tableConflicts.DisplayNameColumn]));
                }
                set {
                    this[this.tableConflicts.DisplayNameColumn] = value;
                }
            }
            
            public string IssueType {
                get {
                    return ((string)(this[this.tableConflicts.IssueTypeColumn]));
                }
                set {
                    this[this.tableConflicts.IssueTypeColumn] = value;
                }
            }
            
            public bool HasConflicts {
                get {
                    try {
                        return ((bool)(this[this.tableConflicts.HasConflictsColumn]));
                    }
                    catch (InvalidC