Invert.Core.GraphDesigner.DiagramViewModel.RefreshConnectors C# (CSharp) Method

        public void RefreshConnectors()
        {
            if (IsLoading) return;
            var remove = GraphItems.OfType<ConnectionViewModel>().ToArray();
            foreach (var item in remove) GraphItems.Remove(item);


            var strategies = InvertGraphEditor.ConnectionStrategies;

            var outputs = GraphItems.OfType<ConnectorViewModel>().Where(p=>p.Direction == ConnectorDirection.Output).ToArray();
            var inputs = GraphItems.OfType<ConnectorViewModel>().Where(p => p.Direction != ConnectorDirection.Output).ToArray();

            foreach (var output in outputs)
            {
                foreach (var input in inputs)
                {
                    foreach (var strategy in strategies)
                    {
                        if (strategy.IsConnected(output, input))
                        {
                            var strategy1 = strategy;
                            var output1 = output;
                            var input1 = input;
                            output.HasConnections = true;
                            input.HasConnections = true;
                            GraphItems.Add(new ConnectionViewModel(this)
                            {
                                ConnectorA = output,
                                ConnectorB = input,
                                Color = strategy.ConnectionColor,
                                DataObject = output.DataObject, 
                                Remove = (a) =>
                                {
                                    //a.Remove(a);
                                    strategy1.Remove(output1, input1);
                                }
                            });
                        }
                    }
                }
            }
            var connectors = GraphItems.OfType<ConnectorViewModel>().ToArray();

            foreach (var connection in CurrentRepository.All<ConnectionData>())
            {

                ConnectorViewModel startConnector = null;
                ConnectorViewModel endConnector = null;

                for (int i = 0; i < connectors.Length; i++)
                {
                    if (startConnector != null && endConnector != null) break;
                    var p = connectors[i];
                    if (p.Direction == ConnectorDirection.Output && p.Identifier == connection.OutputIdentifier)
                        startConnector = p;
                    else if (p.Direction == ConnectorDirection.Input && p.Identifier == connection.InputIdentifier)
                        endConnector = p;
                }

//                var startConnector = connectors.FirstOrDefault(p =>  p.Direction == ConnectorDirection.Output && p.Identifier == connection.OutputIdentifier);
//                var endConnector = connectors.FirstOrDefault(p => p.Direction == ConnectorDirection.Input && p.Identifier == connection.InputIdentifier);


                if (startConnector == null || endConnector == null) continue;

                var vm = endConnector.ConnectorFor.DataObject as IDiagramNodeItem;


                startConnector.HasConnections = true;
                endConnector.HasConnections = true;
                var connection1 = connection;
                GraphItems.Add(new ConnectionViewModel(this)
                {
                    ConnectorA = endConnector,
                    ConnectorB = startConnector,
                    Color = startConnector.Color,
                    DataObject = connection,
                    Remove = (a) =>
                    {
                        GraphData.RemoveConnection(a.ConnectorB.DataObject as IConnectable, a.ConnectorA.DataObject as IConnectable);
                    }
                });
            }
            //var endTime = DateTime.Now;
            //var diff = new TimeSpan(endTime.Ticks - startTime.Ticks);
            //Debug.Log(string.Format("{0} took {1} seconds {2} milliseconds", "New Strategy", diff.Seconds, diff.Milliseconds));

            //var connections = new List<ConnectionViewModel>();
            //var connectorInfo = new ConnectorInfo(connectors.ToArray(), this, CurrentRepository);
            //foreach (var strategy in InvertGraphEditor.ConnectionStrategies)
            //{
            //    var startTime = DateTime.Now;
            //    strategy.GetConnections(connections, connectorInfo);
            //    var endTime = DateTime.Now;
            //    var diff = new TimeSpan(endTime.Ticks - startTime.Ticks);
            //    Debug.Log(string.Format("{0} took {1} seconds {2} milliseconds", strategy.GetType().Name, diff.Seconds, diff.Milliseconds));
            //}

            //foreach (var item in connections)
            //{
            //    GraphItems.Add(item);
            //    item.ConnectorA.HasConnections = true;
            //    item.ConnectorB.HasConnections = true;
            //}
        }

 public override void DataObjectChanged()
 {
     base.DataObjectChanged();
     DiagramViewModel.ClearConnectors(Connectors);
     GetConnectors(Connectors);
     DiagramViewModel.AddConnectors(Connectors);
     DiagramViewModel.RefreshConnectors();
 }