reference.cs

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

        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class IssuesDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnIssueID;
            
            private DataColumn columnStafferID;
            
            private DataColumn columnIssueTypeID;
            
            private DataColumn columnTitle;
            
            private DataColumn columnDescription;
            
            private DataColumn columnDateOpened;
            
            private DataColumn columnDateClosed;
            
            private DataColumn columnIsOpen;
            
            private DataColumn columnDateModified;
            
            private DataColumn columnUserName;
            
            private DataColumn columnDisplayName;
            
            private DataColumn columnIssueType;
            
            private DataColumn columnHasConflicts;
            
            private DataColumn columnIsRead;
            
            internal IssuesDataTable() : 
                    base("Issues") {
                this.InitClass();
            }
            
            internal IssuesDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn IssueIDColumn {
                get {
                    return this.columnIssueID;
                }
            }
            
            internal DataColumn StafferIDColumn {
                get {
                    return this.columnStafferID;
                }
            }
            
            internal DataColumn IssueTypeIDColumn {
                get {
                    return this.columnIssueTypeID;
                }
            }
            
            internal DataColumn TitleColumn {
                get {
                    return this.columnTitle;
                }
            }
            
            internal DataColumn DescriptionColumn {
                get {
                    return this.columnDescription;
                }
            }
            
            internal DataColumn DateOpenedColumn {
                get {
                    return this.columnDateOpened;
                }
            }
            
            internal DataColumn DateClosedColumn {
                get {
                    return this.columnDateClosed;
                }
            }
            
            internal DataColumn IsOpenColumn {
                get {
                    return this.columnIsOpen;
                }
            }
            
            internal DataColumn DateModifiedColumn {
                get {
                    return this.columnDateModified;
                }
            }
            
            internal DataColumn UserNameColumn {
                get {
                    return this.columnUserName;
                }
            }
            
            internal DataColumn DisplayNameColumn {
                get {
                    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 IssuesRow this[int index] {
                get {
                    return ((IssuesRow)(this.Rows[index]));
                }
            }
            
            public event IssuesRowChangeEventHandler IssuesRowChanged;
            
            public event IssuesRowChangeEventHandler IssuesRowChanging;
            
            public event IssuesRowChangeEventHandler IssuesRowDeleted;
            
            public event IssuesRowChangeEventHandler IssuesRowDeleting;
            
            public void AddIssuesRow(IssuesRow row) {
                this.Rows.Add(row);
            }
            
            public IssuesRow AddIssuesRow(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) {
                IssuesRow rowIssuesRow = ((IssuesRow)(this.NewRow()));
                rowIssuesRow.ItemArray = new object[] {
                        null,
                        StafferID,
                        IssueTypeID,
                        Title,
                        Description,
                        DateOpened,
                        DateClosed,
                        IsOpen,
                        DateModified,
                        UserName,
                        DisplayName,
                        IssueType,
                        HasConflicts,
                        IsRead};
                this.Rows.Add(rowIssuesRow);
                return rowIssuesRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                IssuesDataTable cln = ((IssuesDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new IssuesDataTable();
            }
            
            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 IssuesRow NewIssuesRow() {
                return ((IssuesRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new IssuesRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(IssuesRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.IssuesRowChanged != null)) {
                    this.IssuesRowChanged(this, new IssuesRowChangeEvent(((IssuesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.IssuesRowChanging != null)) {
                    this.IssuesRowChanging(this, new IssuesRowChangeEvent(((IssuesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.IssuesRowDeleted != null)) {
                    this.IssuesRowDeleted(this, new IssuesRowChangeEvent(((IssuesRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.IssuesRowDeleting != null)) {
                    this.IssuesRowDeleting(this, new IssuesRowChangeEvent(((IssuesRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveIssuesRow(IssuesRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class IssuesRow : DataRow {
            
            private IssuesDataTable tableIssues;
            
            internal IssuesRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableIssues = ((IssuesDataTable)(this.Table));