.NET извлекла бы выгоду из “именованных анонимных” типов?
Детали в link помогли мне решить это как шарм.
Просто прокомментировал get_msvcr() в cygwinccompiler.py.
(не забудьте также прокомментировать else)
6 ответов
На самом деле существует "взлом", который можно сделать для возвращения анонимного типа из метода. Рассмотрите это:
public object MyMethod()
{
var myNewObject = new
{
stringProperty = "Hello, World!",
intProperty = 1337,
boolProperty = false
};
return myNewObject;
}
public T Cast<T>(object obj, T type)
{
return (T)obj;
}
можно теперь сделать это:
var obj = MyMethod();
var myNewObj = Cast(obj, new { stringProperty = "", intProperty = 0, boolProperty = false });
myNewObj теперь будет объектом того же Типа как анонимный тип.
ИМХО, коренная проблема не имеет ничего общего с анонимными типами, но объявление класса слишком многословно.
Вариант 1:
Если бы вы могли объявить класс следующим образом:
public class MyClass
{ properties={ int Number, int Square, int Absolute, IEnumerable<int> Range } }
или другим таким же быстрым способом (как пример кортежа), тогда вы не чувствовал бы необходимости делать хакерские вещи с анонимными типами только для того, чтобы сохранить какой-то код.
Когда в C # 5 появится «компилятор как услуга», мы надеемся, что он хорошо поработает над его интеграцией, и мы сможем использовать метапрограммирование для четкого решения подобных проблем. Вечеринка, как в 1958 году!
Вариант 2:
В качестве альтернативы, в C # 4 вы можете просто передать анонимный тип как dynamic и избежать всех кастований. , Конечно, это может привести к ошибкам во время выполнения, если вы переименуете переменную и т. Д.
Вариант 3:
Если бы C # реализовывал дженерики так же, как C ++, то вы могли бы передавать анонимный тип в метод, при условии, что он имел правильные члены Это просто скомпилировать. Вы получите все преимущества безопасности статического типа и ни одного из недостатков. Каждый раз, когда мне приходится печатать where T : ISomething на C #, я раздражаюсь, что они этого не сделали!
Что Вы описываете (названный анонимными типами), в основном "типы"кортеж"".
я думаю, что они были бы хорошим дополнением к C#.
, Если бы я разрабатывал такую функцию C#, я представил бы его с помощью синтаксиса как это:
tuple<int x, int y>
так, чтобы Вы могли сделать:
public tuple<int x, int y> GetStuff()
{
}
я тогда изменил бы определение анонимных типов, так, чтобы:
new { x = 2, y = 2}
имел tuple<int x, int y>, поскольку это - тип, а не анонимный тип.
Получение это работать с текущим CLR немного хитро, потому что, как только можно назвать анонимный тип в общедоступных подписях, необходимо быть в состоянии объединить их через отдельно скомпилированные блоки. Это может быть выполнено путем встраивания "конструктора модуля" в любом блоке, который использует тип "кортеж". См. это сообщение для примера.
единственный недостаток к тому подходу - то, что он не уважает "ленивую" модель CLR за поколение типа. Это означает, что блоки, которые используют много отличных типов "кортеж", могли бы испытать немного более медленные типы загрузки. Лучший подход должен был бы добавить поддержку типов "кортеж" непосредственно к CLR.
, Но, кроме изменения CLR, я думаю, что подход конструктора модуля является лучшим способом сделать что-то вроде этого.
Мне бы понравилась эта функция, я много раз хотел этого.
Хорошим примером является обработка XML. Вы анализируете их, возвращаете объект, но затем вам нужно сделать конкретную версию объекта для отправки обратно вызывающей стороне. Много раз вы получаете XML, который довольно сильно меняется и требует много классов для его обработки. Разве не было бы замечательно, если бы вы могли просто построить объект, используя LinqToXml в качестве переменной, а затем просто вернуть это?
Не могли бы вы создать интерфейс со свойствами FirstName и LastName и использовать его?
Требуемая вам языковая функция:
public var GetMe()
{
return new { FirstName = "John", LastName = "Smith" };
}
То есть var будет допустимым как тип, возвращаемый методом, и компилятор определит фактический тип из того, что вернулся. Затем вам нужно будет сделать это на сайте вызова:
var me = GetMe();
Любые два анонимных типа с членами одного типа будут одного типа, поэтому, если вы напишете другие функции, возвращающие один и тот же шаблон, они будут иметь один и тот же тип. Для любых типов A и B, где B имеет подмножество членов A, тогда A совместим по присвоению с B (B похож на базовый класс A). Если вы написали:
public var GetMeFrom(var names)
{
return new { FirstName = names["First"], LastName = names["Last"] };
}
Компилятор фактически определил бы это как универсальный метод с двумя параметрами типа, T1 - это тип имен, а T2 - тип, возвращаемый индексатором на T1 , принимающий строку. T1 будет ограничен, так что у него должен быть индексатор, который принимает строку. И на сайте вызова вы просто передадите все, что имеет индексатор, который принял строку и вернул любой тип, который вам нравится , и это определит тип FirstName и LastName в типе, возвращаемом GetMeFrom .
Таким образом, вывод типа должен все это выяснить за вас, автоматически фиксируя любые ограничения типа, которые можно обнаружить из кода.