C# 中的自动生存

Question

尝试着理解 Perl 的 Autovivification，根据它的听起来，它的工作原理似乎与 C# 中的动态类似，因为动态对象直到运行时才被分配类型，或者，我完全不在这吗？如果是这样，那么是否有一个类似的想法可以在 C# 中桥接，这是有意义的？

编辑
好吧，看来我还差得很远。那么，作为两部分问题的第二部分，C# 中是否存在概念上可比的内容？需要明确的是，我正在 C# 中寻找一个与 Autovivification 类似的概念。不必完全相同，但在概念上足够接近才能有意义。正如我之前所说，我绝不是一个 Perl 黑客或 Python 黑客，但是，我熟悉基于 C 的语言 C、C++、C#、java、javascript。我正在考虑 C# 的动态，但是，截至目前，我正在考虑基于此处信息的延迟加载（如果有帮助的话）。

Answer 1

我无法用 C# 说话，但用外行人的话来说，Perl 的自动生存是在需要时立即从未定义的值创建容器对象的过程。

尽管大多数 Perl 相当动态，但 Perl 的取消引用语法在编译时明确指定了引用的类型。这使得解释器可以在定义变量之前知道它需要从变量中得到什么。

my $var;  # undefined

# to autovivify to an array:
@$var = 1..5;  # @ here implies ARRAY
$var[4] = 5;  # square brackets imply ARRAY
$#$var;        # $# implies ARRAY (returns the last index number)

# to autovivify to a hash:

%$var = (a => 1);   # % implies HASH
$var{asdf} = 5;    # curly braces imply HASH

这个列表可能会更长，但应该可以给您一个想法。

所以基本上，当你有这样的行时：

my $var;
$var->[1]{x}[3]{asdf}

Perl 查看 -> 的右侧并看到方括号。这意味着调用者 $var 必须是数组引用。由于调用者未定义，Perl 创建一个新数组并将其引用安装到 $var 中。然后，对于每个后续解除引用，都会重复相同的过程。

所以上面这行的真正意思是：

    (((($var //= [])->[1] //= {})->{x} //= [])->[3] //= {})->{asdf};

这是相当可怕的，因此是自动生存。 （//=是perl 5.10+中定义的或赋值运算符）

更新：

根据cjm的评论，将其放入一般非perl术语中，以实现自动生存在另一种语言中，您需要一个支持通过 [...] 和 {...} 进行索引的惰性对象。当执行这些索引操作中的任何一个时，对象都会用数组或散列替换自身。每次访问该对象时，如果单元格为空，则应返回另一个惰性对象。

obj = new lazy_obj()

level1 = obj[4]   # sets obj to be an array, returns a new lazy_obj for level1

level2 = level1{asdf}  # sets level1 (and obj[4]) to a hash,
                       # returns a new lazy_obj for level2

所以基本上你需要两件事，创建一个支持数组和散列下标（或等效项）索引的对象的能力，以及一种机制，使对象可以在内存中用另一个对象替换自己（或者可以将自己锁定到一种解释，然后在内部存储新对象，

可以从以下伪代码开始：

class autoviv {
   private var content;

   method array_subscript (idx) {
       if (!content) {
           content = new Array();
       }
       if (typeof content == Array) {
            if (exists content[idx]) return content[idx];
            return content[idx] = new autoviv();
       } else {
            throw error
       }
   }

   method hash_subscript (idx) {
       if (!content) {
           content = new Hash();
       }
       if (typeof content == Hash) {
            if (exists content{idx}) return content{idx};
            return content{idx} = new autoviv();
       } else {
            throw error
       }
   }
   // overload all other access to return undefined, so that the value
   // still looks empty for code like:
   //
   // var auto = new autoviv(); 
   // if (typeof auto[4] == autoviv) {should run}
   // if (auto[4]) {should not run}
}

Answer 2

Uri Guttman 的 自动生存教程 可能会有一些用处。

基本上，它是迄今为止未受影响的聚合体和聚合体成员在第一次使用时复活的能力。

例如，我可以这样做：

#!/usr/bin/perl

use strict; use warnings;
use Data::Dumper;

my @dummy;

push @{ $dummy[0] }, split ' ', 'this that and the other';
push @{ $dummy[1] }, { qw(a b c d) };

print Dumper \@dummy;

$dummy[0] 和 $dummy[1] 在取消引用之前都不存在。

现在，如果您愿意放弃 strict （您不应该这样做），您还可以执行以下操作：

use Data::Dumper;

@$x = qw(a b c d);
print Dumper $x;

未定义的变量 $x 成为数组引用因为它正在被取消引用。

Answer 3

您可以通过创建一个 IDictionary 来实现类似自动验证的行为，它返回（并存储）一个新的 IDictionary （例如，递归地相同类型）当发生未设置键的 [] 时。这种方法在 Ruby 中的使用取得了巨大成功（一个示例）——然而，事实并非如此在静态类型语言中如此有用，因为没有办法干净地“获取”叶子值——至少在大多数现有合约（例如 IDictionary）的上下文中是这样。

随着 dynamic 的出现，这在 C# 中可能可以正常完成，但我不知道。

Answer 4

对于 C# 中字典的自动激活行为的简单实现，像这样的东西怎么样？显然这并不像 Perl 那样处理它，但我相信它具有相同的效果。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

//  The purpose of this class is to provide a dictionary with auto-vivification behaviour similar to Perl's
//  Using dict[index] will succeed regardless of whether index exists in the dictionary or not.
//  A default value can be set to be used as an initial value when the key doesn't exist in the dictionary

namespace XMLTest 
{
    class AutoDictionary<TKey,TValue> : Dictionary<TKey,TValue> {

        Object DefaultValue ;

        public AutoDictionary(Object DefaultValue) {
            this.DefaultValue = DefaultValue;
        }

        public AutoDictionary() {
            this.DefaultValue = null;
        }

        public new TValue this[TKey index] {
            get {
                try {
                    return base[index];
                }
                catch (KeyNotFoundException) {
                    base.Add(index, (TValue)DefaultValue);
                    return (TValue)DefaultValue ;
                }
            }

            set {
                try { 
                    base[index] = value ;
                }
                catch (KeyNotFoundException) {
                    base.Add(index, value);
                }
            }

        }
    }
}

Answer 5

我建议使用扩展方法而不是继承。

例如：

namespace DictionaryEx
{
    public static class Ex
    {
        public static TV Vivify<TK, TV>(this IDictionary<TK, TV> dict, TK key)
        {
            var value = default(TV);
            if (dict.TryGetValue(key, out value))
            {
                return value;
            }
            value = default(TV);
            dict[key] = value;
            return value;
        }

        public static TV Vivify<TK, TV>(this IDictionary<TK, TV> dict, TK key, TV defaultValue)
        {
            TV value;
            if (dict.TryGetValue(key, out value))
            {
                return value;
            }
            dict[key] = defaultValue;
            return defaultValue;
        }

        public static TV Vivify<TK, TV>(this IDictionary<TK, TV> dict, TK key, Func<TV> valueFactory)
        {
            TV value;
            if (dict.TryGetValue(key, out value))
            {
                return value;
            }
            value = valueFactory();
            dict[key] = value;
            return value;
        }
    }
}

Answer 6

使用索引器和 C# 4.0 动态，

class Tree
{
    private IDictionary<string, object> dict = new Dictionary<string, object>();
    public dynamic this[string key]
    {
        get { return dict.ContainsKey(key) ? dict[key] : dict[key] = new Tree(); }
        set { dict[key] = value; }
    }
}

// Test:
var t = new Tree();
t["first"]["second"]["third"] = "text";
Console.WriteLine(t["first"]["second"]["third"]);

DynamicObject 也可用于实现不同的语法，

using System;
using System.Collections.Generic;
using System.Dynamic;

class Tree : DynamicObject
{
    private IDictionary<object, object> dict = new Dictionary<object, object>();

    // for t.first.second.third syntax
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        var key = binder.Name;

        if (dict.ContainsKey(key))
            result = dict[key];
        else
            dict[key] = result = new Tree();

        return true;
    }

    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        dict[binder.Name] = value;
        return true;
    }

    // for t["first"]["second"]["third"] syntax
    public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
    {
        var key = indexes[0];

        if (dict.ContainsKey(key))
            result = dict[key];
        else
            dict[key] = result = new Tree();

        return true;
    }

    public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
    {
        dict[indexes[0]] = value;
        return true;
    }
}

// Test:
dynamic t = new Tree();
t.first.second.third = "text";
Console.WriteLine(t.first.second.third);

// or,
dynamic t = new Tree();
t["first"]["second"]["third"] = "text";
Console.WriteLine(t["first"]["second"]["third"]);