C# FSharpList类代码示例

        public override FScheme.Value Evaluate(FSharpList<FScheme.Value> args)
        {
            var min = ((FScheme.Value.Number)args[0]).Item;
            var max = ((FScheme.Value.Number)args[1]).Item;

            return FScheme.Value.NewContainer(DSCoreNodes.Domain.ByMinimumAndMaximum(min, max));
        }

        public override Value Evaluate(FSharpList<Value> args)
        {
            if (((Value.Number)args[0]).Item == 1)
            {
                if (port != null)
                {
                    bool isOpen = true;

                    if (isOpen == true)
                    {
                        if (!port.IsOpen)
                        {
                            port.Open();
                        }

                    }
                    else if (isOpen == false)
                    {
                        if (port.IsOpen)
                            port.Close();
                    }
                }
            }

            return Value.NewContainer(port); // pass the port downstream
        }

        public override FScheme.Value Evaluate(FSharpList<FScheme.Value> args)
        {
            var worksheet = (Microsoft.Office.Interop.Excel.Worksheet)((FScheme.Value.Container)args[0]).Item;

            Microsoft.Office.Interop.Excel.Range range = worksheet.UsedRange;

            int rows = range.Rows.Count;
            int cols = range.Columns.Count;

            var rowData = new List<FScheme.Value>();

            for (int r = 1; r <= rows; r++)
            {
                var row = new List<FScheme.Value>();

                for (int c = 1; c <= cols; c++)
                {
                    row.Add(FScheme.Value.NewContainer(range.Cells[r, c].Value2));
                }

                rowData.Add(FScheme.Value.NewList(Utils.SequenceToFSharpList(row)));
            }

            return FScheme.Value.NewList(Utils.SequenceToFSharpList(rowData));
        }

        public override FScheme.Value Evaluate(FSharpList<FScheme.Value> args)
        {
            var thunk = ((FScheme.Value.Function) args[0]).Item;
            var task = FScheme.MakeFuture(thunk);

            return FScheme.Value.NewContainer(task);
        }

        public override Value Evaluate(FSharpList<Value> args)
        {
            string prefix = "";

            int count = 0;

            DispatchOnUIThread(
                delegate
                {
                    //unhook the binding
                    OnRequestBindingUnhook(EventArgs.Empty);

                    Root.Children.Clear();

                    foreach (Value e in args)
                    {
                        Root.Children.Add(Process(e, count.ToString(CultureInfo.InvariantCulture), Root.ShowRawData));
                        count++;
                    }

                    //rehook the binding
                    OnRequestBindingRehook(EventArgs.Empty);
                }
                );

            //return the content that has been gathered
            return args[0]; //watch should be a 'pass through' node
        }

        //protected override void OnRunCancelled()
        //{
        //    if (delayThread != null && delayThread.IsAlive)
        //        delayThread.Abort();
        //}
        public override Value Evaluate(FSharpList<Value> args)
        {
            int delay = (int)((Value.Number)args[0]).Item;

            if (delayThread == null || !delayThread.IsAlive)
            {
                delayThread = new Thread(new ThreadStart(
                    delegate
                    {
                        Thread.Sleep(delay);

                        if (Controller.RunCancelled)
                            return;

                        while (Controller.Running)
                        {
                            Thread.Sleep(1);
                            if (Controller.RunCancelled)
                                return;
                        }

                        this.RequiresRecalc = true;
                    }
                ));

                delayThread.Start();
            }

            return Value.NewNumber(1);
        }

        public override Value Evaluate(FSharpList<Value> args)
        {
            var e = new Expression(Formula);

            var functionLookup = new Dictionary<string, Value>();

            foreach (var arg in args.Select((arg, i) => new { Value = arg, Index = i }))
            {
                var parameter = InPortData[arg.Index].NickName;
                if (arg.Value.IsFunction)
                    functionLookup[parameter] = arg.Value;
                else
                    e.Parameters[parameter] = ((Value.Number)arg.Value).Item;
            }

            e.EvaluateFunction += delegate(string name, FunctionArgs fArgs)
            {
                if (functionLookup.ContainsKey(name))
                {
                    var func = ((Value.Function)functionLookup[name]).Item;
                    fArgs.Result = ((Value.Number)func.Invoke(
                        Utils.SequenceToFSharpList(
                            fArgs.Parameters.Select<Expression, Value>(
                                p => Value.NewNumber(Convert.ToDouble(p.Evaluate())))))).Item;
                }
                else
                {
                    fArgs.HasResult = false;
                }
            };

            return Value.NewNumber(Convert.ToDouble(e.Evaluate()));
        }

        public override FScheme.Value Evaluate(FSharpList<FScheme.Value> args)
        {
            if (SelectedIndex < 0)
            {
                throw new Exception("Please select a mesh node.");
            }

            var node_name = Items[SelectedIndex].Name;

            //             if (InPorts[0].IsConnected)
            //             {
            //                 // send the to the connected node
            //                 return FScheme.Value.NewString(node_name);
            //             }

            var result = FSharpList<FScheme.Value>.Empty;

            if (OutPorts[0].IsConnected)
            {
                // get the data from the connected node
                DynamoMaya.Contract.IService s = MayaCommunication.openChannelToMaya();
                Point3DCollection vertices = s.receiveVertexPositionsFromMaya(node_name);

                foreach (Point3D v in vertices)
                {
                    XYZ pt = new XYZ(v.X, v.Y, v.Z);
                    result = FSharpList<FScheme.Value>.Cons(FScheme.Value.NewContainer(pt), result);
                }

                MayaCommunication.closeChannelToMaya(s);
            }

            return FScheme.Value.NewList(ListModule.Reverse(result));
        }

        public override Value Evaluate(FSharpList<Value> args)
        {
            Curve thisCurve = (Curve)((Value.Container)args[0]).Item;

            if (thisCurve == null)
            {
                throw new Exception("Not enough reference points to make a curve.");
            }

            Type CurveType = typeof(Autodesk.Revit.DB.Curve);

            MethodInfo[] curveInstanceMethods = CurveType.GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);

            System.String nameOfMethodApproximateByTangentArcs = "ApproximateByTangentArcs";
            List<Curve> resultArcs = null;
            var result = FSharpList<Value>.Empty;

            foreach (MethodInfo m in curveInstanceMethods)
            {
                if (m.Name == nameOfMethodApproximateByTangentArcs)
                {
                    object[] argsM = new object[0];

                    resultArcs = (List<Curve>)m.Invoke(thisCurve, argsM);

                    break;
                }
            }
            for (int indexCurve = resultArcs.Count - 1; indexCurve > -1; indexCurve--)
            {
                result = FSharpList<Value>.Cons(Value.NewContainer(resultArcs[indexCurve]), result);
            }

            return Value.NewList(result);
        }

        public override Value Evaluate(FSharpList<Value> args)
        {
            CurveLoop firstLoop = (CurveLoop)((Value.Container)args[0]).Item;
            CurveLoop secondLoop = (CurveLoop)((Value.Container)args[1]).Item;

            List<VertexPair> vertPairs = null;

            if (dynRevitSettings.Revit.Application.VersionName.Contains("2013"))
            {
                vertPairs = new List<VertexPair>();

                int i = 0;
                int nCurves1 = firstLoop.Count();
                int nCurves2 = secondLoop.Count();
                for (; i < nCurves1 && i < nCurves2; i++)
                {
                    vertPairs.Add(new VertexPair(i, i));
                }
            }

            var result = GeometryCreationUtilities.CreateBlendGeometry(firstLoop, secondLoop, vertPairs);

            solids.Add(result);

            return Value.NewContainer(result);
        }

        public override void Evaluate(FSharpList<Value> args, Dictionary<PortData, Value> outPuts)
        {
            var crv1 = (Curve)((Value.Container)args[0]).Item;
            var crv2 = (Curve)((Value.Container)args[1]).Item;

            IntersectionResultArray xsects;
            SetComparisonResult result = crv1.Intersect(crv2, out xsects);

            var xyz = FSharpList<Value>.Empty;
            var u = FSharpList<Value>.Empty;
            var v = FSharpList<Value>.Empty;

            if (xsects != null)
            {
                foreach (IntersectionResult ir in xsects)
                {
                    xyz = FSharpList<Value>.Cons(Value.NewContainer(ir.XYZPoint), xyz);
                    u = FSharpList<Value>.Cons(Value.NewNumber(ir.UVPoint.U), u);
                    v = FSharpList<Value>.Cons(Value.NewNumber(ir.UVPoint.V), v);

                }

            }

            outPuts[_vPort] = Value.NewList(v);
            outPuts[_uPort] = Value.NewList(u);
            outPuts[_xyzPort] = Value.NewList(xyz);
            outPuts[_resultPort] = Value.NewString(result.ToString());
        }

        public override Value Evaluate(FSharpList<Value> args)
        {
            var crv1 = (Curve)((Value.Container)args[0]).Item;
            var crv2 = (Curve)((Value.Container)args[1]).Item;

            IntersectionResultArray xsects = new IntersectionResultArray();
            SetComparisonResult result = crv1.Intersect(crv2, out xsects);
            var results = FSharpList<Value>.Empty;

            var xsect_results = FSharpList<Value>.Empty;
            if (xsects != null)
            {
                foreach (IntersectionResult ir in xsects)
                {
                    var xsect = FSharpList<Value>.Empty;
                    xsect = FSharpList<Value>.Cons(Value.NewNumber(ir.UVPoint.U), xsect);
                    xsect = FSharpList<Value>.Cons(Value.NewNumber(ir.UVPoint.V), xsect);
                    xsect = FSharpList<Value>.Cons(Value.NewContainer(ir.XYZPoint), xsect);
                    xsect_results = FSharpList<Value>.Cons(Value.NewList(xsect), xsect_results);

                    pts.Add(ir.XYZPoint);
                }

            }
            results = FSharpList<Value>.Cons(Value.NewList(xsect_results), results);
            results = FSharpList<Value>.Cons(Value.NewString(result.ToString()), results);

            return Value.NewList(results);
        }

        public override FScheme.Value Evaluate(FSharpList<FScheme.Value> args)
        {
            //Level elements take in one double for the z elevation (height)f
            var h = (double)((FScheme.Value.Number)args[0]).Item;
            var name = ((FScheme.Value.String)args[1]).Item;

            Autodesk.Revit.DB.Level lev;

            if (this.Elements.Any())
            {
                if (dynUtils.TryGetElement(this.Elements[0], out lev))
                {
                    lev.Elevation = h;
                    lev.Name = name;
                }
                else
                {
                    lev = this.UIDocument.Document.IsFamilyDocument
                        ? this.UIDocument.Document.FamilyCreate.NewLevel(h)
                        : this.UIDocument.Document.Create.NewLevel(h);
                    lev.Name = name;
                    this.Elements[0] = lev.Id;
                }
            }
            else
            {
                lev = this.UIDocument.Document.IsFamilyDocument
                    ? this.UIDocument.Document.FamilyCreate.NewLevel(h)
                    : this.UIDocument.Document.Create.NewLevel(h);
                lev.Name = name;
                this.Elements.Add(lev.Id);
            }

            return FScheme.Value.NewContainer(lev);
        }

 public override FScheme.Value Evaluate(FSharpList<FScheme.Value> args)
 {
     dynRevitSettings.ElementsContainers.Push(ElementsContainer);
     var result = base.Evaluate(args);
     dynRevitSettings.ElementsContainers.Pop();
     return result;
 }

        public override FScheme.Value Evaluate(FSharpList<FScheme.Value> args)
        {
            var f = ((FScheme.Value.Function)args[0]).Item;
            var x = ((FScheme.Value.Number)args[1]).Item;
            var max_its = (int) Math.Max(1, ((FScheme.Value.Number) args[2]).Item);

            var count = 0;
            var change = 1e10;
            var max_change = 1e-5;
            var h = 1e-5;

            // use newton's method
            while (count < max_its && change > max_change)
            {
                var fx = InvokeFunction(f, x);
                var fxh = InvokeFunction(f, x + h);
                var dfx = (fxh - fx)/h;

                var x1 = x - fx/dfx;
                change = x - x1;
                x = x1;

                count++;
            }

            return FScheme.Value.NewNumber(x);
        }