“Динамический” тип может варьироваться безопасно по <динамичному> универсальному набору?

Хорошо, вместо того, чтобы ждать ответа, я запустил Visual Studio 2010 beta 2, и эта тестовая программа работает хорошо:

class Foo
{
    public string foo = "Foo!";
}
class Bar
{
    public int bar = 42;
}

class Program
{
    static void Main(string[] args)
    {
        var test = new List<dynamic>();
        test.Add(new Foo());
        test.Add(new Bar());

        Console.WriteLine(test[0].foo.Substring(0,3));
        Console.WriteLine(test[1].bar.ToString("000"));

        Console.ReadKey(true);
    }
}

Я хотел убедиться, что не только я проверил свойства с разными именами, но они также имеют разные типы и что я использовал функции в каждом типе, которые несовместимы друг с другом. Это , кажется, предполагает, что если что-либо кэшировано, среда выполнения достаточно умна, чтобы знать, когда использовать кэш, а когда нет. Я все еще хотел бы услышать, знает ли кто-нибудь краевое дело, где это может не держаться, или более авторитетный комментарий о том, почему это произойдет.

У вас есть различные причины для все еще большого размера git репо после git gc , так как он не удаляет все свободные объекты .

Я подробно описываю эти причины в « уменьшите размер репозитория git »

Но одним из трюков для проверки в вашем случае было бы клонировать ваше «очищенное» репо Git и посмотреть, имеет ли клон соответствующий размер.

(«» очищенное «репо» быть то, где вы применили фильтр-ветвь , а затем gc и обрезку )

Вы можете думать о динамике как просто синтаксическом сахаре для записи всех вызовов метода с помощью Reflection and MethodInfo.Invoke () - под капотом он работает не совсем так, но вы можете думать о том, что он работает таким образом, со всеми «вызывающими 1000 методов/сек через dynamic = > убитый perf» соображений, которые идут с ним.

Список Список / , он может просто увидеть объект . Динамика в основном в глазах смотрящего - то есть COLLING код; Под капотом это «объект плюс немного сахара». Так что вы не должны видеть никаких проблем здесь.

Доказательство:

    static void Main()
    {
        Console.WriteLine(IsObject<int>()); // false
        Console.WriteLine(IsObject<object>()); // true
        Console.WriteLine(IsObject<dynamic>()); // true
        Console.WriteLine(IsObject<string>()); // false
    }
    static bool IsObject<T>()
    {
        return typeof(T) == typeof(object);
    }

Проблема заключается в том, что требуется связать некоторые данные с типами, а не с экземплярами типов. Я не уверен, что в C # есть правильный способ сделать это, но одна из возможностей - использование статического словаря < Type, последовательность [] > на BaseRecord . Ниже приведен пример, который можно устранить, добавив некоторые общие статические членов на BaseRecord для инициализации/доступа к именам записей (и добавления проверки ошибок...):

using System;
using System.Collections.Generic;

namespace Records
{
    public class BaseRecord
    {
        public bool isDirty;
        public object[] itemArray;

        public static Dictionary<Type, string[]> columnNames = new Dictionary<Type, string[]>();
    }

    public class PeopleRec : BaseRecord
    {
        static PeopleRec()
        {
            string[] names = new string[2];
            names[0] = "FIRST_NAME";
            names[1] = "LAST_NAME";
            BaseRecord.columnNames[typeof(PeopleRec)] = names;
        }
    }

    public class DoWork<T> where T : BaseRecord
    {
        public void DisplayColumnNames()
        {
            foreach (string s in BaseRecord.columnNames[typeof(T)])
                Console.WriteLine("{0}", s);
        }

        public void DisplayItem(T t)
        {
            for (int i = 0; i < t.itemArray.Length; i++)
            {
                Console.WriteLine("{0}: {1}", BaseRecord.columnNames[typeof(T)][i], t.itemArray[i]);
            }
        }
    }

    class Program
    {
        public static void Main()
        {
            PeopleRec p = new PeopleRec
            {
                itemArray = new object[] { "Joe", "Random" }
            };

            DoWork<PeopleRec> w = new DoWork<PeopleRec>();
            w.DisplayColumnNames();
            w.DisplayItem(p);
        }
    }
}

$ div- > get _ parent _ node () ;//К сожалению, такой функции нет.

Обратите внимание, что для этого можно расширить SimpleXML. Например:

class my_xml extends SimpleXMLElement
{
    public function get_parent_node()
    {
        return current($this->xpath('parent::*'));
    }
}

Теперь все, что нужно сделать, это изменить код, используемый для создания SimpleXMLElement в первую очередь:

$foo = new SimpleXMLElement('<foo/>');
// becomes
$foo = new my_xml('<foo/>');

$foo = simplexml_load_string('<foo/>');
// becomes
$foo = simplexml_load_string('<foo/>', 'my_xml');

$foo = simplexml_load_file('foo.xml');
// becomes
$foo = simplexml_load_file('foo.xml', 'my_xml');

Лучше всего то, что SimpleXML автоматически и прозрачно возвращает объекты my _ xml для этого документа, так что не нужно ничего менять, что делает метод get _ parent _ node () цепным:

// returns $grandchild's parent's parent
$grandchild->get_parent_node()->get_parent_node();

Хорошо, вместо того, чтобы ждать ответа, я запустил Visual Studio 2010 бета-версию 2, и эта тестовая программа работает нормально:

class Foo
{
    public string foo = "Foo!";
}
class Bar
{
    public int bar = 42;
}

class Program
{
    static void Main(string[] args)
    {
        var test = new List<dynamic>();
        test.Add(new Foo());
        test.Add(new Bar());

        Console.WriteLine(test[0].foo.Substring(0,3));
        Console.WriteLine(test[1].bar.ToString("000"));

        Console.ReadKey(true);
    }
}

Я хотел убедиться, что я не только проверял свойства с разными именами, но и имел разные типы и что я использовал в каждом типе несовместимые друг с другом функции. Это , кажется, предполагает, что если что-либо кэшировано, среда выполнения достаточно умна, чтобы знать, когда использовать кэш, а когда нет. Я все еще хотел бы услышать, знает ли кто-нибудь краевое дело, где это может не держаться, или более авторитетный комментарий о том, почему это произойдет.