public MainPageViewModel(
CoresViewModel coresViewModel,
CpuViewModel cpuViewModel,
RamViewModel ramViewModel,
GpuViewModel gpuViewModel,
GpuClocksViewModel gpuClocksViewModel,
VRamViewModel vRamViewModel,
GpuLoadsViewModel gpuLoadsViewModel,
SettingsViewModel settingsViewModel)
{
ArgumentMust.NotBeNull(() => coresViewModel);
ArgumentMust.NotBeNull(() => cpuViewModel);
ArgumentMust.NotBeNull(() => ramViewModel);
ArgumentMust.NotBeNull(() => gpuViewModel);
ArgumentMust.NotBeNull(() => gpuClocksViewModel);
ArgumentMust.NotBeNull(() => vRamViewModel);
ArgumentMust.NotBeNull(() => gpuLoadsViewModel);
ArgumentMust.NotBeNull(() => settingsViewModel);
CoresViewModel = coresViewModel;
CpuViewModel = cpuViewModel;
RamViewModel = ramViewModel;
GpuViewModel = gpuViewModel;
GpuClocksViewModel = gpuClocksViewModel;
VRamViewModel = vRamViewModel;
GpuLoadsViewModel = gpuLoadsViewModel;
SettingsViewModel = settingsViewModel;
}
public ActionResult Gpu(int computerId, int selectedGpu)
{
var cr = new ComputerRepo(new ComputerMssql());
var gr = new GpuRepo(new GpuMssql());
var gvm = new GpuViewModel(cr.GetById(computerId), gr.GetAll(), selectedGpu);
return(View(gvm));
}
async void OnCancelClicked()
{
_editing = false;
if (_creating)
{
NavigationManager.ToBaseRelativePath("admin/document_people");
return;
}
_model = await Service.GetAsync(Id);
SetCheckboxes();
StateHasChanged();
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (_loaded)
{
return;
}
_loaded = true;
_creating = NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/gpus/create", StringComparison.InvariantCulture);
if (Id <= 0 &&
!_creating)
{
return;
}
_companies = await CompaniesService.GetAsync();
_model = _creating ? new GpuViewModel() : await Service.GetAsync(Id);
_resolutions = await ResolutionsService.GetAsync();
_gpuResolutions = await ResolutionsByGpuService.GetByGpu(Id);
_authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
_editing = _creating || NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/gpus/edit/", StringComparison.InvariantCulture);
if (_editing)
{
SetCheckboxes();
}
StateHasChanged();
}
public void SetData(GpuProfilesJsonDb data)
{
_data = data;
if (data != null)
{
string iconName;
GpuType gpuType = _minerClientVm.GpuType;
if (gpuType == GpuType.Empty)
{
gpuType = data.GpuType;
}
IsEnabled = data.Gpus != null && data.Gpus.Length != 0;
RedText = "超频有风险，操作需谨慎";
switch (_minerClientVm.GpuType)
{
case GpuType.NVIDIA:
iconName = "Icon_Nvidia";
GpuIconFill = "Red";
break;
case GpuType.AMD:
iconName = "Icon_Amd";
GpuIconFill = "Green";
break;
case GpuType.Empty:
default:
iconName = "Icon_GpuEmpty";
GpuIconFill = "Gray";
break;
}
GpuIcon = AppUtil.GetResource <Geometry>(iconName);
foreach (var coinVm in AppRoot.CoinVms.MainCoins)
{
var coinOverClock = data.CoinOverClocks.FirstOrDefault(a => a.CoinId == coinVm.Id);
var gpuProfiles = data.GpuProfiles.Where(a => a.CoinId == coinVm.Id).ToArray();
if (coinOverClock == null)
{
coinOverClock = new CoinOverClockData()
{
CoinId = coinVm.Id,
IsOverClockEnabled = false,
IsOverClockGpuAll = true
};
}
coinVm.IsOverClockEnabled = coinOverClock.IsOverClockEnabled;
coinVm.IsOverClockGpuAll = coinOverClock.IsOverClockGpuAll;
List <GpuProfileViewModel> gpuProfileVms = new List <GpuProfileViewModel>();
GpuProfileViewModel gpuAllProfileVm = null;
#region
foreach (var gpu in data.Gpus.OrderBy(a => a.Index))
{
var gpuProfile = gpuProfiles.FirstOrDefault(a => a.Index == gpu.Index);
if (gpuProfile == null)
{
gpuProfile = new GpuProfileData(coinVm.Id, gpu.Index);
}
var gpuVm = new GpuViewModel(gpu, data.Gpus);
if (gpu.Index == NTMinerContext.GpuAllId)
{
gpuAllProfileVm = new GpuProfileViewModel(gpuProfile, gpuVm);
}
else
{
gpuProfileVms.Add(new GpuProfileViewModel(gpuProfile, gpuVm));
}
}
if (gpuAllProfileVm == null)
{
gpuAllProfileVm = new GpuProfileViewModel(
new GpuProfileData(coinVm.Id, NTMinerContext.GpuAllId), new GpuViewModel(new GpuData {
GpuType = gpuType,
Index = NTMinerContext.GpuAllId,
Name = "All"
}, data.Gpus));
}
#endregion
coinVm.GpuAllProfileVm = gpuAllProfileVm;
coinVm.GpuProfileVms = gpuProfileVms;
}
}
}
private GpuProfileViewModel GetGpuProfileVm(Guid coinId, GpuViewModel gpuVm)
{
IGpuProfile data = NTMinerRoot.Instance.GpuProfileSet.GetGpuProfile(coinId, gpuVm.Index);
return(new GpuProfileViewModel(data, gpuVm));
}
private GpuViewModels()
{
if (WpfUtil.IsInDesignMode)
{
return;
}
foreach (var gpu in NTMinerContext.Instance.GpuSet.AsEnumerable())
{
_gpuVms.Add(gpu.Index, new GpuViewModel(gpu));
}
if (_gpuVms.ContainsKey(NTMinerContext.GpuAllId))
{
_gpuAllVm = _gpuVms[NTMinerContext.GpuAllId];
}
else
{
_gpuAllVm = new GpuViewModel(Gpu.GpuAll);
}
BuildEventPath <EPriceChangedEvent>("电价变更后更新电费显示", LogEnum.DevConsole,
path: message => {
foreach (var gpuVm in _gpuVms.Values)
{
gpuVm.OnPropertyChanged(nameof(GpuViewModel.EChargeText));
}
GpuSpeedVms.OnPropertyChanged(nameof(GpuSpeedViewModels.ProfitCnyPerDayText));
}, location: this.GetType());
BuildEventPath <MaxTempChangedEvent>("高温红色阈值变更后更新显卡温度颜色", LogEnum.DevConsole,
path: message => {
foreach (var gpuVm in _gpuVms.Values)
{
gpuVm.OnPropertyChanged(nameof(GpuViewModel.TemperatureForeground));
}
}, location: this.GetType());
BuildEventPath <PowerAppendChangedEvent>("功耗补偿变更后更新功耗显示", LogEnum.DevConsole,
path: message => {
foreach (var gpuVm in _gpuVms.Values)
{
gpuVm.OnPropertyChanged(nameof(GpuViewModel.PowerUsageWText));
}
GpuSpeedVms.OnPropertyChanged(nameof(GpuSpeedViewModels.ProfitCnyPerDayText));
}, location: this.GetType());
BuildEventPath <GpuStateChangedEvent>("显卡状态变更后刷新VM内存", LogEnum.None,
path: message => {
if (_gpuVms.ContainsKey(message.Source.Index))
{
GpuViewModel vm = _gpuVms[message.Source.Index];
vm.Temperature = message.Source.Temperature;
vm.MemTemperature = message.Source.MemTemperature;
vm.FanSpeed = message.Source.FanSpeed;
vm.PowerUsage = message.Source.PowerUsage;
vm.CoreClockDelta = message.Source.CoreClockDelta;
vm.MemoryClockDelta = message.Source.MemoryClockDelta;
vm.CoreClockDeltaMin = message.Source.CoreClockDeltaMin;
vm.CoreClockDeltaMax = message.Source.CoreClockDeltaMax;
vm.MemoryClockDeltaMin = message.Source.MemoryClockDeltaMin;
vm.MemoryClockDeltaMax = message.Source.MemoryClockDeltaMax;
vm.CurrentMemoryTimingLevel = message.Source.CurrentMemoryTimingLevel;
vm.Cool = message.Source.Cool;
vm.CoolMin = message.Source.CoolMin;
vm.CoolMax = message.Source.CoolMax;
vm.PowerCapacity = message.Source.PowerCapacity;
vm.PowerMin = message.Source.PowerMin;
vm.PowerMax = message.Source.PowerMax;
vm.TempLimit = message.Source.TempLimit;
vm.TempLimitDefault = message.Source.TempLimitDefault;
vm.TempLimitMax = message.Source.TempLimitMax;
vm.TempLimitMin = message.Source.TempLimitMin;
vm.CoreVoltage = message.Source.CoreVoltage;
vm.MemoryVoltage = message.Source.MemoryVoltage;
vm.VoltMin = message.Source.VoltMin;
vm.VoltMax = message.Source.VoltMax;
vm.VoltDefault = message.Source.VoltDefault;
if (_gpuAllVm != null)
{
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.TemperatureText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.MemTemperatureText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.FanSpeedText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.PowerUsageWText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.CoreClockDeltaMText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.MemoryClockDeltaMText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.CoreClockDeltaMinMaxMText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.MemoryClockDeltaMinMaxMText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.CoolMinMaxText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.PowerMinMaxText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.TempLimitMinMaxText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.EChargeText));
GpuSpeedVms.OnPropertyChanged(nameof(GpuSpeedViewModels.ProfitCnyPerDayText));
}
UpdateMinMax();
}
}, location: this.GetType());
}
private GpuViewModels()
{
#if DEBUG
NTStopwatch.Start();
#endif
if (WpfUtil.IsInDesignMode)
{
return;
}
foreach (var gpu in NTMinerRoot.Instance.GpuSet.AsEnumerable())
{
_gpuVms.Add(gpu.Index, new GpuViewModel(gpu));
}
if (_gpuVms.ContainsKey(NTMinerRoot.GpuAllId))
{
_gpuAllVm = _gpuVms[NTMinerRoot.GpuAllId];
}
else
{
_gpuAllVm = new GpuViewModel(Gpu.GpuAll);
}
AddEventPath <EPriceChangedEvent>("电价变更后更新电费显示", LogEnum.DevConsole,
action: message => {
foreach (var gpuVm in _gpuVms.Values)
{
gpuVm.OnPropertyChanged(nameof(GpuViewModel.EChargeText));
}
AppContext.Instance.GpuSpeedVms.OnPropertyChanged(nameof(GpuSpeedViewModels.ProfitCnyPerDayText));
}, location: this.GetType());
AddEventPath <MaxTempChangedEvent>("高温红色阈值变更后更新显卡温度颜色", LogEnum.DevConsole,
action: message => {
foreach (var gpuVm in _gpuVms.Values)
{
gpuVm.OnPropertyChanged(nameof(GpuViewModel.TemperatureForeground));
}
}, location: this.GetType());
AddEventPath <PowerAppendChangedEvent>("功耗补偿变更后更新功耗显示", LogEnum.DevConsole,
action: message => {
foreach (var gpuVm in _gpuVms.Values)
{
gpuVm.OnPropertyChanged(nameof(GpuViewModel.PowerUsageWText));
}
AppContext.Instance.GpuSpeedVms.OnPropertyChanged(nameof(GpuSpeedViewModels.ProfitCnyPerDayText));
}, location: this.GetType());
AddEventPath <GpuStateChangedEvent>("显卡状态变更后刷新VM内存", LogEnum.None,
action: message => {
if (_gpuVms.ContainsKey(message.Target.Index))
{
GpuViewModel vm = _gpuVms[message.Target.Index];
vm.Temperature = message.Target.Temperature;
vm.FanSpeed = message.Target.FanSpeed;
vm.PowerUsage = message.Target.PowerUsage;
vm.CoreClockDelta = message.Target.CoreClockDelta;
vm.MemoryClockDelta = message.Target.MemoryClockDelta;
vm.CoreClockDeltaMin = message.Target.CoreClockDeltaMin;
vm.CoreClockDeltaMax = message.Target.CoreClockDeltaMax;
vm.MemoryClockDeltaMin = message.Target.MemoryClockDeltaMin;
vm.MemoryClockDeltaMax = message.Target.MemoryClockDeltaMax;
vm.Cool = message.Target.Cool;
vm.CoolMin = message.Target.CoolMin;
vm.CoolMax = message.Target.CoolMax;
vm.PowerCapacity = message.Target.PowerCapacity;
vm.PowerMin = message.Target.PowerMin;
vm.PowerMax = message.Target.PowerMax;
vm.TempLimit = message.Target.TempLimit;
vm.TempLimitDefault = message.Target.TempLimitDefault;
vm.TempLimitMax = message.Target.TempLimitMax;
vm.TempLimitMin = message.Target.TempLimitMin;
vm.CoreVoltage = message.Target.CoreVoltage;
vm.MemoryVoltage = message.Target.MemoryVoltage;
vm.VoltMin = message.Target.VoltMin;
vm.VoltMax = message.Target.VoltMax;
vm.VoltDefault = message.Target.VoltDefault;
if (_gpuAllVm != null)
{
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.TemperatureText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.FanSpeedText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.PowerUsageWText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.CoreClockDeltaMText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.MemoryClockDeltaMText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.CoreClockDeltaMinMaxMText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.MemoryClockDeltaMinMaxMText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.CoolMinMaxText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.PowerMinMaxText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.TempLimitMinMaxText));
_gpuAllVm.OnPropertyChanged(nameof(_gpuAllVm.EChargeText));
AppContext.Instance.GpuSpeedVms.OnPropertyChanged(nameof(GpuSpeedViewModels.ProfitCnyPerDayText));
}
UpdateMinMax();
}
}, location: this.GetType());
#if DEBUG
var elapsedMilliseconds = NTStopwatch.Stop();
if (elapsedMilliseconds.ElapsedMilliseconds > NTStopwatch.ElapsedMilliseconds)
{
Write.DevTimeSpan($"耗时{elapsedMilliseconds} {this.GetType().Name}.ctor");
}
#endif
}
void ModalClosing(ModalClosingEventArgs obj) => _gpu = null;
void ShowModal(int itemId)
{
_gpu = _gpus.FirstOrDefault(n => n.Id == itemId);
_frmDelete.Show();
}
async void OnSaveClicked()
{
if (_unknownCompany)
{
_model.CompanyId = null;
}
else if (_model.CompanyId < 0)
{
return;
}
if (_unknownModelCode)
{
_model.ModelCode = null;
}
else if (string.IsNullOrWhiteSpace(_model.ModelCode))
{
return;
}
if (_unknownIntroduced)
{
_model.Introduced = null;
}
else if (_prototype)
{
_model.Introduced = new DateTime(1000, 1, 1);
}
else if (_model.Introduced >= DateTime.UtcNow.Date)
{
return;
}
if (_unknownPackage)
{
_model.Package = null;
}
else if (string.IsNullOrWhiteSpace(_model.Package))
{
return;
}
if (_unknownProcess)
{
_model.Process = null;
}
else if (string.IsNullOrWhiteSpace(_model.Process))
{
return;
}
if (_unknownProcessNm)
{
_model.ProcessNm = null;
}
else if (_model.ProcessNm < 1)
{
return;
}
if (_unknownDieSize)
{
_model.DieSize = null;
}
else if (_model.DieSize < 1)
{
return;
}
if (_unknownTransistors)
{
_model.Transistors = null;
}
else if (_model.Transistors < 0)
{
return;
}
if (_creating)
{
Id = await Service.CreateAsync(_model, (await UserManager.GetUserAsync(_authState.User)).Id);
}
else
{
await Service.UpdateAsync(_model, (await UserManager.GetUserAsync(_authState.User)).Id);
}
_editing = false;
_creating = false;
_model = await Service.GetAsync(Id);
SetCheckboxes();
StateHasChanged();
}
