I have implemented a project called NodeFlow. As you can see in the picture you can create multiple nodes and connect their properties with other (Function)Nodes to modify the properties and let the data flow through the nodes to create a result (in this case it is the addition and multiplication to the result 4). I implemented NodeFlow in similarity to the Node Editor in the 3D Software Blender.You can see that NodeFlow is somewhat working, but I am very unhappy about my architecture. So I decided to implement the application in a better way and it would be great if you could tell me what you think. However, I am only providing interfaces because I am right now creating the architecture of my application and I want to discuss this architecture with you.What do you need to know about the nodes?public interface INode{    string Name { get; set; }    NodeTypes Type { get; set; }    bool HasInputProperties { get; }    bool HasOutputProperties { get; }    ObservableCollection<IValueAcceptorProperty> ValueAcceptorProperty { get; set; }    ObservableCollection<IValueProviderProperty> ValueProviderProperty { get; set; }}More ExplanationsThe node is the thing you see in the picture as Constant Value: 1, Add Function and Multiply Function. Nodes contain a Name, Input and Output Properties. I called these properties in my code ValueProviderProperty and ValueAcceptorProperty because calling it Input and OutputProperty was very confusing while coding and because value providing properties (or output properties) can only be connected with value accepting properties (or input properties) you have a data flow in one direction. That means that the ValueAccpetorProperties are taking (or accepting) the value of the connected ValueProviderProperty.Propertiespublic interface IProperty{    string Name { get; set; }    PropertyDataTypes AllowedDataTypes { get; set; }    IConnector Connector { get; set; }    INode ParentNode { get; set; }    bool HasValue { get; }}public interface IValueProviderProperty : IProperty{    // This is like Variant    IPropertyValue Value { get; set; }}public interface IValueAcceptorProperty : IProperty{    // This is like Variant    IPropertyValue Value { get; }}Property Code:This implements the ValueAcceptorProperty to show how I want to use this interface. As you can see the ValueAcceptorProperty is just forwarding the Value of its ValueProviderProperty.public class ValueAcceptorProperty : IValueAcceptorProperty{    public string Name { get; set; }    public IPropertyValue Value        => this.Connector.IsConnected            ? this.Connector.Connection.ValueProviderProperty.Value            : null;    public PropertyDataTypes AllowedDataTypes { get; set; }    public IConnector Connector { get; set; }    public INode ParentNode { get; set; }    public bool HasValue => this.Value != null;}Every property has a Connector (the visual of it is the circle next to each property) and the Connectors are connected via a Connection.Connector and Connection: (These are in separated files)public interface IConnection{    IConnector ValueProviderConnector { get; set; }    IConnector ValueAcceptorConnector { get; set; }    IValueProviderProperty ValueProviderProperty { get; set; }    IValueAcceptorProperty ValueAcceptorProperty { get; set; }}public interface IConnector{    bool IsConnected { get; set; }    IConnection Connection { get; set; }}Most of the missing definitions for PropertyDataTypes and so on are enums or other data structures which are in my opinion not that important to discuss the general idea of NodeFlow.So my main Questions is: Do you think that there is a better way to model the Nodes, Properties, Connections and Connectors?If you need further information I will update this question to provide whatever you need. 
NodeFlow - How to connect Properties in a clean way?
c#