From 7cdbe93dca65f544290f6e6fb2698bbfc9987963 Mon Sep 17 00:00:00 2001 From: gaofei1985 <181547018@qq.com> Date: Wed, 10 Apr 2024 09:15:17 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- SGGL/Model/Model.cs | 937 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 937 insertions(+) diff --git a/SGGL/Model/Model.cs b/SGGL/Model/Model.cs index 1b4057bf..e34cd964 100644 --- a/SGGL/Model/Model.cs +++ b/SGGL/Model/Model.cs @@ -2042,6 +2042,9 @@ namespace Model partial void InsertRun_ScheduleSetUp(Run_ScheduleSetUp instance); partial void UpdateRun_ScheduleSetUp(Run_ScheduleSetUp instance); partial void DeleteRun_ScheduleSetUp(Run_ScheduleSetUp instance); + partial void InsertRunning_LogManagement(Running_LogManagement instance); + partial void UpdateRunning_LogManagement(Running_LogManagement instance); + partial void DeleteRunning_LogManagement(Running_LogManagement instance); partial void InsertSafetyData_SafetyData(SafetyData_SafetyData instance); partial void UpdateSafetyData_SafetyData(SafetyData_SafetyData instance); partial void DeleteSafetyData_SafetyData(SafetyData_SafetyData instance); @@ -8041,6 +8044,14 @@ namespace Model } } + public System.Data.Linq.Table Running_LogManagement + { + get + { + return this.GetTable(); + } + } + public System.Data.Linq.Table SafetyData_SafetyData { get @@ -314683,6 +314694,932 @@ namespace Model } } + [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Running_LogManagement")] + public partial class Running_LogManagement : INotifyPropertyChanging, INotifyPropertyChanged + { + + private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty); + + private string _RunningId; + + private string _ProjectId; + + private string _InstallationId; + + private string _ProcessesId; + + private string _SystemId; + + private string _JobNo; + + private string _ShiftType; + + private string _ShiftUser; + + private string _SuccessionUser; + + private System.Nullable _StartData; + + private System.Nullable _EndData; + + private System.Nullable _IsDesalinated; + + private string _DesalinatedSituation; + + private string _DesalinatedRemarks; + + private System.Nullable _IsLoop; + + private string _LoopSituation; + + private string _LoopRemarks; + + private System.Nullable _IsSteam; + + private string _SteamSituation; + + private string _SteamRemarks; + + private System.Nullable _IsAirCompression; + + private string _AirCompressionSituation; + + private string _AirCompressionRemarks; + + private System.Nullable _IsCompoundAmmonia; + + private string _CompoundAmmoniaSituation; + + private string _CompoundAmmoniaRemarks; + + private System.Nullable _IsUrea; + + private string _UreaSituation; + + private string _UreaRemarks; + + private string _HandoverCare; + + private string _OperationReason; + + private string _OperationHandle; + + private string _MaintenanceReason; + + private string _MaintenanceHandle; + + private string _AddUser; + + private System.Nullable _AddTime; + + private System.Nullable _Sort; + + #region 可扩展性方法定义 + partial void OnLoaded(); + partial void OnValidate(System.Data.Linq.ChangeAction action); + partial void OnCreated(); + partial void OnRunningIdChanging(string value); + partial void OnRunningIdChanged(); + partial void OnProjectIdChanging(string value); + partial void OnProjectIdChanged(); + partial void OnInstallationIdChanging(string value); + partial void OnInstallationIdChanged(); + partial void OnProcessesIdChanging(string value); + partial void OnProcessesIdChanged(); + partial void OnSystemIdChanging(string value); + partial void OnSystemIdChanged(); + partial void OnJobNoChanging(string value); + partial void OnJobNoChanged(); + partial void OnShiftTypeChanging(string value); + partial void OnShiftTypeChanged(); + partial void OnShiftUserChanging(string value); + partial void OnShiftUserChanged(); + partial void OnSuccessionUserChanging(string value); + partial void OnSuccessionUserChanged(); + partial void OnStartDataChanging(System.Nullable value); + partial void OnStartDataChanged(); + partial void OnEndDataChanging(System.Nullable value); + partial void OnEndDataChanged(); + partial void OnIsDesalinatedChanging(System.Nullable value); + partial void OnIsDesalinatedChanged(); + partial void OnDesalinatedSituationChanging(string value); + partial void OnDesalinatedSituationChanged(); + partial void OnDesalinatedRemarksChanging(string value); + partial void OnDesalinatedRemarksChanged(); + partial void OnIsLoopChanging(System.Nullable value); + partial void OnIsLoopChanged(); + partial void OnLoopSituationChanging(string value); + partial void OnLoopSituationChanged(); + partial void OnLoopRemarksChanging(string value); + partial void OnLoopRemarksChanged(); + partial void OnIsSteamChanging(System.Nullable value); + partial void OnIsSteamChanged(); + partial void OnSteamSituationChanging(string value); + partial void OnSteamSituationChanged(); + partial void OnSteamRemarksChanging(string value); + partial void OnSteamRemarksChanged(); + partial void OnIsAirCompressionChanging(System.Nullable value); + partial void OnIsAirCompressionChanged(); + partial void OnAirCompressionSituationChanging(string value); + partial void OnAirCompressionSituationChanged(); + partial void OnAirCompressionRemarksChanging(string value); + partial void OnAirCompressionRemarksChanged(); + partial void OnIsCompoundAmmoniaChanging(System.Nullable value); + partial void OnIsCompoundAmmoniaChanged(); + partial void OnCompoundAmmoniaSituationChanging(string value); + partial void OnCompoundAmmoniaSituationChanged(); + partial void OnCompoundAmmoniaRemarksChanging(string value); + partial void OnCompoundAmmoniaRemarksChanged(); + partial void OnIsUreaChanging(System.Nullable value); + partial void OnIsUreaChanged(); + partial void OnUreaSituationChanging(string value); + partial void OnUreaSituationChanged(); + partial void OnUreaRemarksChanging(string value); + partial void OnUreaRemarksChanged(); + partial void OnHandoverCareChanging(string value); + partial void OnHandoverCareChanged(); + partial void OnOperationReasonChanging(string value); + partial void OnOperationReasonChanged(); + partial void OnOperationHandleChanging(string value); + partial void OnOperationHandleChanged(); + partial void OnMaintenanceReasonChanging(string value); + partial void OnMaintenanceReasonChanged(); + partial void OnMaintenanceHandleChanging(string value); + partial void OnMaintenanceHandleChanged(); + partial void OnAddUserChanging(string value); + partial void OnAddUserChanged(); + partial void OnAddTimeChanging(System.Nullable value); + partial void OnAddTimeChanged(); + partial void OnSortChanging(System.Nullable value); + partial void OnSortChanged(); + #endregion + + public Running_LogManagement() + { + OnCreated(); + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RunningId", DbType="VarChar(50) NOT NULL", CanBeNull=false, IsPrimaryKey=true)] + public string RunningId + { + get + { + return this._RunningId; + } + set + { + if ((this._RunningId != value)) + { + this.OnRunningIdChanging(value); + this.SendPropertyChanging(); + this._RunningId = value; + this.SendPropertyChanged("RunningId"); + this.OnRunningIdChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProjectId", DbType="VarChar(50)")] + public string ProjectId + { + get + { + return this._ProjectId; + } + set + { + if ((this._ProjectId != value)) + { + this.OnProjectIdChanging(value); + this.SendPropertyChanging(); + this._ProjectId = value; + this.SendPropertyChanged("ProjectId"); + this.OnProjectIdChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_InstallationId", DbType="VarChar(50)")] + public string InstallationId + { + get + { + return this._InstallationId; + } + set + { + if ((this._InstallationId != value)) + { + this.OnInstallationIdChanging(value); + this.SendPropertyChanging(); + this._InstallationId = value; + this.SendPropertyChanged("InstallationId"); + this.OnInstallationIdChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProcessesId", DbType="VarChar(50)")] + public string ProcessesId + { + get + { + return this._ProcessesId; + } + set + { + if ((this._ProcessesId != value)) + { + this.OnProcessesIdChanging(value); + this.SendPropertyChanging(); + this._ProcessesId = value; + this.SendPropertyChanged("ProcessesId"); + this.OnProcessesIdChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SystemId", DbType="VarChar(50)")] + public string SystemId + { + get + { + return this._SystemId; + } + set + { + if ((this._SystemId != value)) + { + this.OnSystemIdChanging(value); + this.SendPropertyChanging(); + this._SystemId = value; + this.SendPropertyChanged("SystemId"); + this.OnSystemIdChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobNo", DbType="VarChar(50)")] + public string JobNo + { + get + { + return this._JobNo; + } + set + { + if ((this._JobNo != value)) + { + this.OnJobNoChanging(value); + this.SendPropertyChanging(); + this._JobNo = value; + this.SendPropertyChanged("JobNo"); + this.OnJobNoChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ShiftType", DbType="VarChar(50)")] + public string ShiftType + { + get + { + return this._ShiftType; + } + set + { + if ((this._ShiftType != value)) + { + this.OnShiftTypeChanging(value); + this.SendPropertyChanging(); + this._ShiftType = value; + this.SendPropertyChanged("ShiftType"); + this.OnShiftTypeChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ShiftUser", DbType="VarChar(50)")] + public string ShiftUser + { + get + { + return this._ShiftUser; + } + set + { + if ((this._ShiftUser != value)) + { + this.OnShiftUserChanging(value); + this.SendPropertyChanging(); + this._ShiftUser = value; + this.SendPropertyChanged("ShiftUser"); + this.OnShiftUserChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SuccessionUser", DbType="VarChar(50)")] + public string SuccessionUser + { + get + { + return this._SuccessionUser; + } + set + { + if ((this._SuccessionUser != value)) + { + this.OnSuccessionUserChanging(value); + this.SendPropertyChanging(); + this._SuccessionUser = value; + this.SendPropertyChanged("SuccessionUser"); + this.OnSuccessionUserChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartData", DbType="DateTime")] + public System.Nullable StartData + { + get + { + return this._StartData; + } + set + { + if ((this._StartData != value)) + { + this.OnStartDataChanging(value); + this.SendPropertyChanging(); + this._StartData = value; + this.SendPropertyChanged("StartData"); + this.OnStartDataChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndData", DbType="DateTime")] + public System.Nullable EndData + { + get + { + return this._EndData; + } + set + { + if ((this._EndData != value)) + { + this.OnEndDataChanging(value); + this.SendPropertyChanging(); + this._EndData = value; + this.SendPropertyChanged("EndData"); + this.OnEndDataChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsDesalinated", DbType="Int")] + public System.Nullable IsDesalinated + { + get + { + return this._IsDesalinated; + } + set + { + if ((this._IsDesalinated != value)) + { + this.OnIsDesalinatedChanging(value); + this.SendPropertyChanging(); + this._IsDesalinated = value; + this.SendPropertyChanged("IsDesalinated"); + this.OnIsDesalinatedChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DesalinatedSituation", DbType="VarChar(1000)")] + public string DesalinatedSituation + { + get + { + return this._DesalinatedSituation; + } + set + { + if ((this._DesalinatedSituation != value)) + { + this.OnDesalinatedSituationChanging(value); + this.SendPropertyChanging(); + this._DesalinatedSituation = value; + this.SendPropertyChanged("DesalinatedSituation"); + this.OnDesalinatedSituationChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DesalinatedRemarks", DbType="VarChar(1000)")] + public string DesalinatedRemarks + { + get + { + return this._DesalinatedRemarks; + } + set + { + if ((this._DesalinatedRemarks != value)) + { + this.OnDesalinatedRemarksChanging(value); + this.SendPropertyChanging(); + this._DesalinatedRemarks = value; + this.SendPropertyChanged("DesalinatedRemarks"); + this.OnDesalinatedRemarksChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsLoop", DbType="Int")] + public System.Nullable IsLoop + { + get + { + return this._IsLoop; + } + set + { + if ((this._IsLoop != value)) + { + this.OnIsLoopChanging(value); + this.SendPropertyChanging(); + this._IsLoop = value; + this.SendPropertyChanged("IsLoop"); + this.OnIsLoopChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LoopSituation", DbType="VarChar(1000)")] + public string LoopSituation + { + get + { + return this._LoopSituation; + } + set + { + if ((this._LoopSituation != value)) + { + this.OnLoopSituationChanging(value); + this.SendPropertyChanging(); + this._LoopSituation = value; + this.SendPropertyChanged("LoopSituation"); + this.OnLoopSituationChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LoopRemarks", DbType="VarChar(1000)")] + public string LoopRemarks + { + get + { + return this._LoopRemarks; + } + set + { + if ((this._LoopRemarks != value)) + { + this.OnLoopRemarksChanging(value); + this.SendPropertyChanging(); + this._LoopRemarks = value; + this.SendPropertyChanged("LoopRemarks"); + this.OnLoopRemarksChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsSteam", DbType="Int")] + public System.Nullable IsSteam + { + get + { + return this._IsSteam; + } + set + { + if ((this._IsSteam != value)) + { + this.OnIsSteamChanging(value); + this.SendPropertyChanging(); + this._IsSteam = value; + this.SendPropertyChanged("IsSteam"); + this.OnIsSteamChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SteamSituation", DbType="VarChar(1000)")] + public string SteamSituation + { + get + { + return this._SteamSituation; + } + set + { + if ((this._SteamSituation != value)) + { + this.OnSteamSituationChanging(value); + this.SendPropertyChanging(); + this._SteamSituation = value; + this.SendPropertyChanged("SteamSituation"); + this.OnSteamSituationChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SteamRemarks", DbType="VarChar(1000)")] + public string SteamRemarks + { + get + { + return this._SteamRemarks; + } + set + { + if ((this._SteamRemarks != value)) + { + this.OnSteamRemarksChanging(value); + this.SendPropertyChanging(); + this._SteamRemarks = value; + this.SendPropertyChanged("SteamRemarks"); + this.OnSteamRemarksChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAirCompression", DbType="Int")] + public System.Nullable IsAirCompression + { + get + { + return this._IsAirCompression; + } + set + { + if ((this._IsAirCompression != value)) + { + this.OnIsAirCompressionChanging(value); + this.SendPropertyChanging(); + this._IsAirCompression = value; + this.SendPropertyChanged("IsAirCompression"); + this.OnIsAirCompressionChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AirCompressionSituation", DbType="VarChar(1000)")] + public string AirCompressionSituation + { + get + { + return this._AirCompressionSituation; + } + set + { + if ((this._AirCompressionSituation != value)) + { + this.OnAirCompressionSituationChanging(value); + this.SendPropertyChanging(); + this._AirCompressionSituation = value; + this.SendPropertyChanged("AirCompressionSituation"); + this.OnAirCompressionSituationChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AirCompressionRemarks", DbType="VarChar(1000)")] + public string AirCompressionRemarks + { + get + { + return this._AirCompressionRemarks; + } + set + { + if ((this._AirCompressionRemarks != value)) + { + this.OnAirCompressionRemarksChanging(value); + this.SendPropertyChanging(); + this._AirCompressionRemarks = value; + this.SendPropertyChanged("AirCompressionRemarks"); + this.OnAirCompressionRemarksChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsCompoundAmmonia", DbType="Int")] + public System.Nullable IsCompoundAmmonia + { + get + { + return this._IsCompoundAmmonia; + } + set + { + if ((this._IsCompoundAmmonia != value)) + { + this.OnIsCompoundAmmoniaChanging(value); + this.SendPropertyChanging(); + this._IsCompoundAmmonia = value; + this.SendPropertyChanged("IsCompoundAmmonia"); + this.OnIsCompoundAmmoniaChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CompoundAmmoniaSituation", DbType="VarChar(1000)")] + public string CompoundAmmoniaSituation + { + get + { + return this._CompoundAmmoniaSituation; + } + set + { + if ((this._CompoundAmmoniaSituation != value)) + { + this.OnCompoundAmmoniaSituationChanging(value); + this.SendPropertyChanging(); + this._CompoundAmmoniaSituation = value; + this.SendPropertyChanged("CompoundAmmoniaSituation"); + this.OnCompoundAmmoniaSituationChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CompoundAmmoniaRemarks", DbType="VarChar(1000)")] + public string CompoundAmmoniaRemarks + { + get + { + return this._CompoundAmmoniaRemarks; + } + set + { + if ((this._CompoundAmmoniaRemarks != value)) + { + this.OnCompoundAmmoniaRemarksChanging(value); + this.SendPropertyChanging(); + this._CompoundAmmoniaRemarks = value; + this.SendPropertyChanged("CompoundAmmoniaRemarks"); + this.OnCompoundAmmoniaRemarksChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsUrea", DbType="Int")] + public System.Nullable IsUrea + { + get + { + return this._IsUrea; + } + set + { + if ((this._IsUrea != value)) + { + this.OnIsUreaChanging(value); + this.SendPropertyChanging(); + this._IsUrea = value; + this.SendPropertyChanged("IsUrea"); + this.OnIsUreaChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UreaSituation", DbType="VarChar(1000)")] + public string UreaSituation + { + get + { + return this._UreaSituation; + } + set + { + if ((this._UreaSituation != value)) + { + this.OnUreaSituationChanging(value); + this.SendPropertyChanging(); + this._UreaSituation = value; + this.SendPropertyChanged("UreaSituation"); + this.OnUreaSituationChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UreaRemarks", DbType="VarChar(1000)")] + public string UreaRemarks + { + get + { + return this._UreaRemarks; + } + set + { + if ((this._UreaRemarks != value)) + { + this.OnUreaRemarksChanging(value); + this.SendPropertyChanging(); + this._UreaRemarks = value; + this.SendPropertyChanged("UreaRemarks"); + this.OnUreaRemarksChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HandoverCare", DbType="VarChar(1000)")] + public string HandoverCare + { + get + { + return this._HandoverCare; + } + set + { + if ((this._HandoverCare != value)) + { + this.OnHandoverCareChanging(value); + this.SendPropertyChanging(); + this._HandoverCare = value; + this.SendPropertyChanged("HandoverCare"); + this.OnHandoverCareChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OperationReason", DbType="VarChar(1000)")] + public string OperationReason + { + get + { + return this._OperationReason; + } + set + { + if ((this._OperationReason != value)) + { + this.OnOperationReasonChanging(value); + this.SendPropertyChanging(); + this._OperationReason = value; + this.SendPropertyChanged("OperationReason"); + this.OnOperationReasonChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OperationHandle", DbType="VarChar(1000)")] + public string OperationHandle + { + get + { + return this._OperationHandle; + } + set + { + if ((this._OperationHandle != value)) + { + this.OnOperationHandleChanging(value); + this.SendPropertyChanging(); + this._OperationHandle = value; + this.SendPropertyChanged("OperationHandle"); + this.OnOperationHandleChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MaintenanceReason", DbType="VarChar(1000)")] + public string MaintenanceReason + { + get + { + return this._MaintenanceReason; + } + set + { + if ((this._MaintenanceReason != value)) + { + this.OnMaintenanceReasonChanging(value); + this.SendPropertyChanging(); + this._MaintenanceReason = value; + this.SendPropertyChanged("MaintenanceReason"); + this.OnMaintenanceReasonChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MaintenanceHandle", DbType="VarChar(1000)")] + public string MaintenanceHandle + { + get + { + return this._MaintenanceHandle; + } + set + { + if ((this._MaintenanceHandle != value)) + { + this.OnMaintenanceHandleChanging(value); + this.SendPropertyChanging(); + this._MaintenanceHandle = value; + this.SendPropertyChanged("MaintenanceHandle"); + this.OnMaintenanceHandleChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AddUser", DbType="VarChar(50)")] + public string AddUser + { + get + { + return this._AddUser; + } + set + { + if ((this._AddUser != value)) + { + this.OnAddUserChanging(value); + this.SendPropertyChanging(); + this._AddUser = value; + this.SendPropertyChanged("AddUser"); + this.OnAddUserChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AddTime", DbType="DateTime")] + public System.Nullable AddTime + { + get + { + return this._AddTime; + } + set + { + if ((this._AddTime != value)) + { + this.OnAddTimeChanging(value); + this.SendPropertyChanging(); + this._AddTime = value; + this.SendPropertyChanged("AddTime"); + this.OnAddTimeChanged(); + } + } + } + + [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Sort", DbType="Int")] + public System.Nullable Sort + { + get + { + return this._Sort; + } + set + { + if ((this._Sort != value)) + { + this.OnSortChanging(value); + this.SendPropertyChanging(); + this._Sort = value; + this.SendPropertyChanged("Sort"); + this.OnSortChanged(); + } + } + } + + public event PropertyChangingEventHandler PropertyChanging; + + public event PropertyChangedEventHandler PropertyChanged; + + protected virtual void SendPropertyChanging() + { + if ((this.PropertyChanging != null)) + { + this.PropertyChanging(this, emptyChangingEventArgs); + } + } + + protected virtual void SendPropertyChanged(String propertyName) + { + if ((this.PropertyChanged != null)) + { + this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); + } + } + } + [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.SafetyData_SafetyData")] public partial class SafetyData_SafetyData : INotifyPropertyChanging, INotifyPropertyChanged {