C# PortType类代码示例

 public Port(ComponentBase parentFunclet, int x, int y, PortType pType)
 {
     area = new Rectangle(x, y, Config.PORT_D, Config.PORT_D);
     this.pType = pType;
     this.parentComponent = parentFunclet;
     this.ComponentType = ComponentType.Port;
 }

 public PortId(string owningNode, int portIndex, PortType type)
     : this()
 {
     this.OwningNode = owningNode;
     this.PortIndex = portIndex;
     this.PortType = type;
 }

 public PortUtil(string usbVid, string usbPid, string endpointId)
 {
     Int32 vid = Int32.Parse(usbVid, NumberStyles.HexNumber);
     Int32 pid = Int32.Parse(usbPid, NumberStyles.HexNumber);
     _usbFinder = new UsbDeviceFinder(vid, pid);
     _endpointId = GetEndpointId(endpointId);
     _portType = PortType.USB;
 }

 public static IClientPort Create(PortType type)
 {
     switch (type)
     {
         case PortType.Serial: return new Implementation.Client.Serial();
         default: throw new NotImplementedException();
     }
 }

 public dynPortModel(int index, PortType portType, dynNodeModel owner, string name)
 {
     Index = index;
     IsConnected = false;
     PortType = portType;
     Owner = owner;
     PortName = name;
 }

 /// <summary>
 /// Factory method to create a connector.  Checks to make sure that the start and end ports are valid, 
 /// otherwise returns null.
 /// </summary>
 /// <param name="start">The port where the connector starts</param>
 /// <param name="end">The port where the connector ends</param>
 /// <param name="startIndex"></param>
 /// <param name="endIndex"></param>
 /// <param name="portType"></param>
 /// <returns>The valid connector model or null if the connector is invalid</returns>
 internal static ConnectorModel Make(WorkspaceModel workspaceModel, NodeModel start, NodeModel end, int startIndex, int endIndex, PortType portType)
 {
     if (workspaceModel != null && start != null && end != null && start != end && startIndex >= 0
         && endIndex >= 0 && start.OutPorts.Count > startIndex && end.InPorts.Count > endIndex )
     {
         return new ConnectorModel(workspaceModel, start, end, startIndex, endIndex, portType);
     }
     
     return null;
 }

 /// <summary>
 /// Factory method to create a connector.  Checks to make sure that the start and end ports are valid, 
 /// otherwise returns null.
 /// </summary>
 /// <param name="start">The port where the connector starts</param>
 /// <param name="end">The port where the connector ends</param>
 /// <param name="startIndex"></param>
 /// <param name="endIndex"></param>
 /// <param name="portType"></param>
 /// <returns>The valid connector model or null if the connector is invalid</returns>
 public static ConnectorModel Make(NodeModel start, NodeModel end, int startIndex, int endIndex, PortType portType)
 {
     if (start != null && end != null && start != end && startIndex >= 0
         && endIndex >= 0 && start.OutPorts.Count > startIndex && end.InPorts.Count > endIndex )
     {
         return new ConnectorModel(start, end, startIndex, endIndex, portType);
     }
     
     return null;
 }

 internal unsafe Port(UnsafeStructs.jack_client_t*jackClient, int index, Direction direction, PortType portType, string nameFormat)
 {
     if (nameFormat == null) {
         nameFormat = "{type}{direction}_{index}";
     }
     _jackClient = jackClient;
     Direction = direction;
     Name = CreateName (nameFormat, index, direction, portType);
     PortType = portType;
     _port = RegisterPort (direction, portType);
 }

 public ScheminPort(Stream stream, PortType type)
 {
     this.Type = type;
     if (type == PortType.InputPort)
     {
         this.InputStream = new StreamReader(stream, Encoding.UTF8);
     }
     else
     {
         this.OutputStream = new StreamWriter(stream, Encoding.UTF8);
     }
 }

        private ConnectorModel(WorkspaceModel workspaceModel, NodeModel start, NodeModel end, int startIndex, int endIndex, PortType portType)
        {
            this.workspaceModel = workspaceModel;

            pStart = start.OutPorts[startIndex];

            PortModel endPort = null;

            if (portType == PortType.INPUT)
                endPort = end.InPorts[endIndex];

            pStart.Connect(this);
            this.Connect(endPort);
        }

        private ConnectorModel(NodeModel start, NodeModel end, int startIndex, int endIndex, PortType portType)
        {
            //Stopwatch sw = new Stopwatch();
            //sw.Start();
            pStart = start.OutPorts[startIndex];

            PortModel endPort = null;

            if (portType == PortType.INPUT)
                endPort = end.InPorts[endIndex];

            pStart.Connect(this);
            this.Connect(endPort);
            //sw.Stop();
            //Debug.WriteLine(string.Format("{0} elapsed for constructing connector.", sw.Elapsed));
        }

        internal void BeginConnection(Guid nodeId, int portIndex, PortType portType)
        {
            int index = portIndex;
            bool isInPort = portType == PortType.INPUT;

            NodeModel node = _model.GetModelInternal(nodeId) as NodeModel;
            PortModel portModel = isInPort ? node.InPorts[index] : node.OutPorts[index];

            // Test if port already has a connection, if so grab it and begin connecting
            // to somewhere else (we don't allow the grabbing of the start connector).
            if (portModel.Connectors.Count > 0 && portModel.Connectors[0].Start != portModel)
            {
                // Define the new active connector
                var c = new ConnectorViewModel(portModel.Connectors[0].Start);
                this.SetActiveConnector(c);

                // Disconnect the connector model from its start and end ports
                // and remove it from the connectors collection. This will also
                // remove the view model.
                ConnectorModel connector = portModel.Connectors[0];
                if (_model.Connectors.Contains(connector))
                {
                    List<ModelBase> models = new List<ModelBase>();
                    models.Add(connector);
                    _model.RecordAndDeleteModels(models);
                    connector.NotifyConnectedPortsOfDeletion();
                }
            }
            else
            {
                try
                {
                    // Create a connector view model to begin drawing
                    var connector = new ConnectorViewModel(portModel);
                    this.SetActiveConnector(connector);
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex.Message);
                }
            }
        }

 public static int GetPort(PortType portType)
 {
     var port = 0;
     switch (portType)
     {
         case PortType.Level1:
             port = 5009;
             break;
         case PortType.Lookup:
             port = 9100;
             break;
         case PortType.Level2:
             port = 9200;
             break;
         case PortType.Admin:
             port = 9300;
             break;
     }
     return port;
 }

        public dynPort(int index, PortType portType, dynNodeUI owner, string name)
        {
            InitializeComponent();

            Index = index;

            this.MouseEnter += delegate { foreach (var c in connectors) c.Highlight(); };
            this.MouseLeave += delegate { foreach (var c in connectors) c.Unhighlight(); };

            IsConnected = false;

            PortType = portType;
            Owner = owner;
            PortName = name;

            portGrid.DataContext = this;
            portNameTb.DataContext = this;
            toolTipText.DataContext = this;
            ellipse1Dot.DataContext = this;
            ellipse1.DataContext = Owner;

            portGrid.Loaded += new RoutedEventHandler(portGrid_Loaded);
        }

 public MakeConnectionCommand(Guid nodeId, int portIndex, PortType portType, Mode mode)
 {
     NodeId = nodeId;
     PortIndex = portIndex;
     Type = portType;
     ConnectionMode = mode;
 }