c# - 有没有更好的方法来使用 MVVM 模式更新 WPF 中 VisualCollection 主机中的 DrawingVisual？

Question

我正在 WPF 中开发一个项目，该项目每秒更新 View 高达 30 次。据我所知，我正在使用 MVVM 模式，并且对目前的结果相当满意。但是我想知道是否有更有效的方法来更新我的主机容器中 VisualCollection 中的 DrawingVisuals。在我的 View 模型中的每个属性更改中，我都在查找、删除然后为该 View 模型重新添加一个新的 DrawingVisual。对于不断移动的对象，我觉得应该有更好的方法，例如将 DrawingVisuals 本身直接绑定(bind)到 View 模型的属性，但那会是什么样子呢？随着模拟中模型数量的增加，我需要确保我有一个简化的更新工作流程。我开始关注这里的示例:http://msdn.microsoft.com/en-us/library/ms742254.aspx

我故意避免 DependencyProperties 并将 UserControls 绑定(bind)到每个 View 模型，因为我需要一个非常高效的绘图 Canvas (因此使用下面的 QuickCanvas)。因此，除了设计主 UI 和连接按钮和命令外，我几乎不需要 XAML。请询问是否有什么不清楚的地方，或者我遗漏了一些重要的东西。谢谢!

视觉宿主容器( View ):

public partial class QuickCanvas : FrameworkElement
{
    private readonly VisualCollection _visuals;
    private readonly Dictionary<Guid, DrawingVisual> _visualDictionary;

    public static readonly DependencyProperty ItemsSourceProperty =
        DependencyProperty.Register("ItemsSource", typeof(ObservableNotifiableCollection<IVisualModel>),
        typeof(QuickCanvas),
        new PropertyMetadata(OnItemsSourceChanged));

    public QuickCanvas()
    {
        InitializeComponent();
        _visuals = new VisualCollection(this);
        _visualDictionary = new Dictionary<Guid, DrawingVisual>();
    }

    public ObservableNotifiableCollection<IVisualModel> ItemsSource
    {
        set { SetValue(ItemsSourceProperty, value); }
        get { return (ObservableNotifiableCollection<IVisualModel>)GetValue(ItemsSourceProperty); }
    }

    protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
    {
        base.OnPropertyChanged(e);
        if (e.Property.Name == "Width" || e.Property.Name == "Height" || e.Property.Name == "Center")
        {
            UpdateVisualChildren();
        }
    }

    private void UpdateVisualChildren()
    {
        if (ItemsSource == null || _visuals.Count == 0) return;

        foreach (var model in ItemsSource)
        {
            var visual = FindVisualForModel(model);
            if (visual != null)
            {
                UpdateVisualFromModel(visual, model);
            }
        }
    }

    private void UpdateVisualPairFromModel(DrawingVisual visual, IVisualModel model)
    {
        visual.Transform = ApplyVisualTransform(visual.Transform, model);
    }

    private static void OnItemsSourceChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
    {
        (obj as QuickCanvas).OnItemsSourceChanged(args);
    }

    private void OnItemsSourceChanged(DependencyPropertyChangedEventArgs args)
    {
        _visuals.Clear();

        if (args.OldValue != null)
        {
            var models = args.OldValue as ObservableNotifiableCollection<IVisualModel>;
            models.CollectionCleared -= OnCollectionCleared;
            models.CollectionChanged -= OnCollectionChanged;
            models.ItemPropertyChanged -= OnItemPropertyChanged;
        }

        if (args.NewValue != null)
        {
            var models = args.NewValue as ObservableNotifiableCollection<IVisualModel>;
            models.CollectionCleared += OnCollectionCleared;
            models.CollectionChanged += OnCollectionChanged;
            models.ItemPropertyChanged += OnItemPropertyChanged;

            CreateVisualChildren(models);
        }
    }

    private void OnCollectionCleared(object sender, EventArgs args)
    {
        _visuals.Clear();
        _visualDictionary.Clear();
    }

    private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs args)
    {
        if (args.OldItems != null)
            RemoveVisualChildren(args.OldItems);

        if (args.NewItems != null)
            CreateVisualChildren(args.NewItems);
    }

    private void OnItemPropertyChanged(object sender, ItemPropertyChangedEventArgs args)
    {
        var model = args.Item as IVisualModel;
        if (model == null)
            throw new ArgumentException("args.Item was expected to be of type IVisualModel but was not.");
        //TODO is there a better way to update without having to add/remove visuals?
        var visual = FindVisualForModel(model);
        _visuals.Remove(visual);
        visual = CreateVisualFromModel(model);
        _visuals.Add(visual);
        _visualDictionary[model.Id] = visual;**
    }

    private DrawingVisual FindVisualForModel(IVisualModel model)
    {
        return _visualDictionary[model.Id];
    }

    private void CreateVisualChildren(IEnumerable models)
    {
        foreach (IVisualModel model in models)
        {
            var visual = CreateVisualFromModel(model);
            _visuals.Add(visual);
            _visuals.Add(visual);
            _visualDictionary.Add(model.Id, visual);
        }
    }

    private DrawingVisual CreateVisualFromModel(IVisualModel model)
    {
        var visual = model.GetVisual();
        UpdateVisualFromModel(visual, model);
        return visual;
    }

    private void RemoveVisualChildren(IEnumerable models)
    {
        foreach (IVisualModel model in models)
        {
            var visual = FindVisualForModel(model);
            if (visual != null)
            {
                _visuals.Remove(visual);
                _visualDictionary.Remove(model.Id);
            }
        }
    }

    protected override int VisualChildrenCount
    {
        get
        {
            return _visuals.Count;
        }
    }

    protected override Visual GetVisualChild(int index)
    {
        if (index < 0 || index >= _visuals.Count)
            throw new ArgumentOutOfRangeException("index");

        return _visuals[index];
    }
}

IVisualModel 实现:

public class VehicleViewModel : IVisualModel
{
    private readonly Vehicle _vehicle;
    private readonly IVisualFactory<VehicleViewmodel> _visualFactory;
    private readonly IMessageBus _messageBus;

    public VehicleViewmodel(Vehicle vehicle, IVisualFactory<VehicleViewmodel> visualFactory, IMessageBus messageBus)
    {
        _vehicle = vehicle;
        _visualFactory = visualFactory;
        _messageBus = messageBus;
        _messageBus.Subscribe<VehicleMovedMessage>(VehicleMoveHandler, Dispatcher.CurrentDispatcher);
        Id = Guid.NewGuid();
    }

    public void Dispose()
    {
        _messageBus.Unsubscribe<VehicleMovedMessage>(VehicleMoveHandler);
    }

    private void VehicleMoveHandler(VehicleMovedMessage message)
    {
        if (message.Vehicle.Equals(_vehicle))
            OnPropertyChanged("");
    }

    public Guid Id { get; private set; }
    public Point Anchor { get { return _vehicle.Position; } }
    public double Rotation { get { return _vehicle.Orientation; } }

    public DrawingVisual GetVisual()
    {
        return _visualFactory.Create(this);
    }

    public double Width { get { return _vehicle.VehicleType.Width; } }
    public double Length { get { return _vehicle.VehicleType.Length; } }

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        var handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }
}

一个 IVisualFactory 实现:

public class VehicleVisualFactory : IVisualFactory<VehicleViewModel>
{
    private readonly IDictionary<string, Pen> _pens;
    private readonly IDictionary<string, Brush> _brushes;

    public VehicleVisualFactory(IDictionary<string, Pen> pens, IDictionary<string, Brush> brushes)
    {
        _pens = pens;
        _brushes = brushes;
    }

    public DrawingVisual Create(VehicleViewmodel viewModel)
    {
        var result = new DrawingVisual();
        using (var context = result.RenderOpen())
        {
            context.DrawRectangle(_brushes["VehicleGreen"], _pens["VehicleDarkGreen"],
                new Rect(-viewModel.Width / 2, -viewModel.Length / 2, viewModel.Width, viewModel.Length));
        }
        return result;
    }
}

Answer 1

我在阅读您的帖子时发现您的方法非常有趣且巧妙。我已经对 wpf 和“实时”问题进行了一些实验，以下是我可以从自己的经验中得到的一些东西:

• 我不会建议您对 View 模型使用完整的绑定(bind) View ，尤其是在车辆数量不同的情况下的车辆属性。确实，绑定(bind)机制非常非常快......只有在初始化之后。初始化确实很慢。因此，如果您倾向于使用这种机制，我建议您使用池来尽可能避免绑定(bind)分配。关于你的外观问题……我想所有与绑定(bind)相关的事情都会在你的车辆工厂中用 c# ( http://msdn.microsoft.com/en-us/library/ms742863.aspx ) 执行？

• 我的第二点是半线索半问题:您是否考虑过使用 MVVM 之外的另一种架构模式？我可以在您的代码中看到您已经实现了很多与 View / View 模型同步相关的事情。 MVVM 是一种结构，由于 ViewModel 原理，它可以轻松地将高度交互的 View 与数据层连接和分离。游戏架构通常不倾向于将相同的关注点与表单应用程序分开，主要是因为性能、可扩展性和模块化问题不是相同的挑战。这就是为什么我想知道如果您的目标是获得最佳性能 -> 意味着一层应用程序和代理中的多层，那么经典的 getInputs/think/draw vehicule 对象是否不是一个好方法。

希望对您有所帮助。如果有些观点您不理解或者您只是不同意，请不要犹豫。请告知我们，我对您将做出的选择非常感兴趣!