标签: ref

我想在F#对象表达式中有一个可变状态.第一种方法是使用ref单元格如下:

type PP =
    abstract member A : int

let foo =
    let a = ref 0
    { new PP with
        member x.A = 
            let ret = !a
            a := !a + 1
            ret 
    }

printfn "%A" foo.A
printfn "%A" foo.A
printfn "%A" foo.A
printfn "%A" foo.A

一种不同的方法如下:

type State(s : int) =
    let mutable intState = s
    member x.state 
        with get () = intState
        and set v = intState <- v 

[<AbstractClass>]         
type PPP(state : State) =
    abstract member …

我想B从另一个类初始化一个类型的对象A,为什么我仍然得到null？是否可以在不使用ref和out修饰符的情况下完成？

    class A
    {
        public void Initialize(B value)
        {
            if (value == null)
            {
                value = new B();
            }
        }
    }

    class B
    {

    }

    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            B b = null;
            a.Initialize(b);
        }
    }

[upd.]我认为b变量可以传递,ref因为它是类的实例.

说,我想添加两个数字的向量(在数学意义上).我自然会做类似的事情:

T[] add(T)(T[] a, T[] b) {
    assert(a.length == b.length);
    T[] res = a.dup;
    foreach (i; 0 .. a.length) {
        res[i] = a[i] + b[i];
    }
   return res;
}

嗯,没关系,但我怀疑a并b复制每一个电话,这不是很好.所以我宣布他们ref.

T[] add(T)(ref T[] a, ref T[] b) { ...

它在传递变量时效果很好,但对于测试,我使用数组实例:

assert(add([1, 2, 3], [4, 5, 6]) == [5, 7, 9]);

这失败了,因为它无法推断出数组的引用.我已经设法找到一个解决方法:

T[] add(T)(T[] a, T[] b) {
    return add(a, b);
}

这似乎解决了这个问题,但看起来相当愚蠢.什么是我的问题更好的设计？

或者把它放在较小的问题中:我是否真的必须声明参数ref以避免复制？可以编译器,因为我不修改,a并b为我优化这个？如何通过方式声明参数不可变(我尝试过immutable关键字,看起来我使用它错了)？将res在变通方法中真正复制两次,还是通过移动返回？

我正在学习使用ref,但无法理解,为什么我收到错误？

class A
{
    public void ret(ref int variable)
    {
        variable = 7;
    }

    static int Main()
    {
        int z = 5;
        ret(ref z); // Error: Need a reference on object
        Console.WriteLine(z); // it will be 7 as I understand
        return 0;
    }
}

符号是什么!在SML意味着什么？

fun polysort(_,[]) = []
| polysort(_,[x]) = [x]!
| polysort(less,xs) =
 let
  val (ys, zs) = split xs
   in
   merge(less,polysort(less,ys), polysort(less, zs))
 end;

这会扭转它还是什么？我认为这与ref有关,但我也不明白.

out 上的 msdn 文档说作为 out 传递的参数必须在函数内部分配一个值。来自网站的示例：

class OutExample
{
    static void Method(out int i)
    {
        i = 44;
    }
    static void Main()
    {
        int value;
        Method(out value);
       // value is now 44
    }
 }

根据我的理解，当声明 int "value" 时，它已经被分配了一个默认值 0（因为 int 是一个值类型并且不能为 null。）那么为什么有必要让 "Method" 修改它的值呢？

同样，如果使用“ref”而不是“out”，是否还需要初始化“value”？

有这样的问题'ref' 和 'out' 关键字有什么区别？但没有人想把 2 和 2 放在一起。

在这两种ref类型中,Reference type我能够更改对象的值,那么它们之间的区别是什么？

有人提供了答案,但对我来说仍然不清楚.

static void Main(string[] args)
{
    myclass o1 = new myclass(4,5);
    Console.WriteLine("value of i={0} and j={1}", o1.i, o1.j); //o/p=4,5

    o1.exaple(ref o1.i, ref o1.j);    //Ref type calling
    Console.WriteLine("value of i={0} and j={1}", o1.i, o1.j);// o/p=2,3
    myclass o2 = o1;
    Console.WriteLine("value of i={0} and j={1}", o2.i, o2.j);  // o/p 2,3
    o1.i = 100;
    o1.j = 200;
    Console.WriteLine("value of i={0} and j={1}", o1.i, o1.j);  //o/p=100,200
    Console.WriteLine("value of i={0} and j={1}", o2.i, o2.j); //o/p=100,200
    Console.ReadKey();
} …

以下代码无法使用C# 7.0/ Visual Studio 2017.2进行编译:

class C {
    private static readonly int s = 5;
    public static ref int Data => ref s;
}

是否存在禁止静态只读字段引用的技术原因,或者这只是一个缺失的功能？

错误消息说:

CS8162:静态只读字段不能通过引用返回.

下面的代码是解释我的问题的最小工作示例。这段代码使用Array.map生成3个Note组件，当您按Enter键时，它们将使用对DOM元素的引用清空它们上方的静态生成的Note组件。

我想要做的是改为将您打的便笺输入为空。我认为这需要为每个Note生成一个包含{id，ref}的动态数组，因此我可以将Note id传递给handleKeyDown，然后在refs数组中搜索该id并使用相应的ref来更改DOM元素。但是我在弄清楚如何真正做到这一点上遇到了麻烦。

我意识到这里没有必要使用refs，但这只是一个示例，因为我的实际代码要长得多，并调用focus（）。

import React, { Component } from "react";
import "./App.css";

class App extends Component {
  constructor() {
    super();
    this.notes = [
      { text: "Hello world 1", id: 1 },
      { text: "Hello world 2", id: 2 },
      { text: "Hello world 3", id: 3 }
    ];
    this.ref = React.createRef();
  }

  handleKeyDown = event => {
    if (event.key === "Enter") {
      event.preventDefault();
      this.ref.current.textContent = "";
    }
  };

  render() {
    return (
      <div>
        <Note
          text={"StaticNote"}
          key={0}
          id={0}
          handleKeyDown={this.handleKeyDown}
          innerRef={this.ref} …

我在 react native 中有两个组件，我无法从我的子组件中关闭一个模态。

ListTrips - 家长

ModalAddTrip - 儿童

ListTrips.js

import ModalAddTrip from './ModalAddTrip';
....
....
this.state = {
    isModalAddTripVisible: false
} 
....
handleDismissModalAddTrip = () => {
    this.setState({ isModalAddTripVisible: false });
};

closeModal() {
    this.refs.ModalAdd.handleDismissModalAddTrip();
}
....

<ModalAddTrip
    ref="ModalAdd"
    isVisible={this.state.isModalAddTripVisible}
    onBackDropPress={this.handleDismissModalAddTrip}
    closeModal={() => this.closeModal()}
    onRequestClose={this.handleDismissModalAddTrip}
/>

ModalAddTrip.js

<Modal
    isVisible={isVisible}
    onBackdropPress={onBackDropPress}
    closeModal={this.props.child}
>
<Button
    style={{ fontSize: 18, color: 'white' }}
    containerStyle={{
        padding: 8,
        marginLeft: 70,
    }}
    onPress={this.closeModal}
>

一旦我打开它，我就无法关闭它。我知道它与引用/道具有关，但我已经搞砸了几个小时，我无处可去。我正在尝试this.props.closeModal;将引用切换到子组件的方法，但它也不起作用。在 ModalAddTrip 的函数中，但这也不起作用。

任何帮助是极大的赞赏。谢谢