Каков самый эффективный мудрый производительностью способ связать информацию с объектом 'Типа' в .NET?
Я хочу связать пользовательские данные к Типу и получить те данные во времени выполнения, ослепительно быстро.
Это - просто мое воображение моего идеального мира:
var myInfo = typeof (MyClass).GetMyInformation ();
это было бы очень быстро..., конечно, это не существует! Если бы это сделало то я не спрашивал бы. hehe ;)
Это - способ использовать пользовательские атрибуты:
var myInfo = typeof (MyClass).GetCustomAttribute ("MyInformation");
это медленно, потому что это требует поиска строки "MyInformation"
Это - способ использовать Словарь <Тип, MyInformation>:
var myInfo = myInformationDictionary [typeof (MyClass)];
Это также медленно, потому что это - все еще поиск 'typeof (MyClass)'.
Я знаю, что словарь очень быстр, но это недостаточно..., он с такой скоростью, как не называет метод. Это даже не тот же порядок скорости.
Я не говорю, что хочу, чтобы это было с такой скоростью, как вызов метода. Я хочу связать информацию с типом и получить доступ к ней максимально быстро. Я спрашиваю, существует ли лучший путь или событие лучший способ сделать его.
Какие-либо идеи??
Спасибо!
Править:
typeof (MyClass), который я упомянул во всех предыдущих отрывках, являются на самом деле переменными... Я не знаю, что это - определенный тип MyClass, это мог быть любой тип:
Введите myType = typeFromSomewhere;
т.е. MyClass в этом случае просто заявляет, что класс сделан мной, и любые другие типы, которые могли войти в эту ситуацию, также сделаны мной..., таким образом, он читает
typeof (Один из моих собственных Классов, что я не знаю ведьму, каждый - он, но это является моим наверняка),
Править: ЗАКЛЮЧЕНИЕ
Некоторые результаты проверки производительности связаны со словарями:
Dic.buckets | Dic.Count | Dic.Key | Ops(x17)/s | Avg.Time | Min.Time | Max.Time
-----------------------------------------------------------------------------
17519 | 12467 | Type | 1051538 | 0.95μs | 0.86μs | 0.42ms
919 | 912 | Type | 814862 | 1.23μs | 1.14μs | 0.46ms
1162687 | 912 | Type | 1126382 | 0.89μs | 0.81μs | 0.33ms
919 | 912 | Type | 806992 | 1.24μs | 1.16μs | 0.21ms
17 | 17 | Type | 872485 | 1.15μs | 1.06μs | 0.31ms
-----------------------------------------------------------------------------
36353 | 18160 | String | 227520 | 4.40μs | 3.98μs | 0.47ms
919 | 911 | String | 219159 | 4.57μs | 4.14μs | 0.29ms
1162687 | 911 | String | 236384 | 4.23μs | 3.82μs | 0.41ms
919 | 911 | String | 223042 | 4.49μs | 4.10μs | 0.43ms
17 | 17 | String | 229985 | 4.35μs | 3.94μs | 0.28ms
Интерфейсный вызов:
ops(x17)/s: 2896001
Average: 0.35μs
Min: 0.34μs
Max: 1.20μs
Виртуальный вызов:
ops(x17)/s: 3115254
Average: 0.32μs
Min: 0.32μs
Max: 0.65μs
Я вижу, что недооценил Словари!!!=)
Кажется, что Словарь Типа к чему-либо 3x к 4x медленнее, чем виртуальный вызов метода.
Дело обстоит не так с помощью Словаря строк. То, что - 10x к 12x медленнее, чем виртуальный вызов метода.
Таким образом, я доказал меня неправильно!
И, НЕТ я НЕ ДЕЛАЮ РАКЕТУ!!! кто-то предположил это в реве комментария =)
Спасибо все.
8 ответов
Это не просто ваш "идеальный мир", это еще и C #! Вы можете использовать методы расширения , чтобы сделать именно то, что вы предложили, сработало:
var myInfo = typeof(MyClass).GetMyInformation();
В статическом классе TypeUtilities или подобном вы должны определить следующее:
public static InfoType GetMyInformation(this Type type)
{
// Return InfoType object.
}
Что касается того, как вы на самом деле вернуть информацию о типе, что можно сделать несколькими способами. Простой блок if, статический Словарь , отражение данного типа (с использованием атрибутов / методов) или даже другие. Наилучший подход во многом зависит от контекста и вашего конкретного сценария использования.
Почему бы не использовать GetCustomAttributes (typeof (MyInformationAttribute), false) ?
ИМХО, использование атрибутов - это семантически правильный способ выражения такой информации. Просто убедитесь, что вы используете закрытый класс атрибутов, так как это улучшает производительность во время выполнения.
Тем не менее, это не составит труда и, вероятно, будет предпочтительнее либо отложить загрузку, либо каким-либо иным образом кэшировать экземпляры атрибутов. Обычно я делаю это один раз, используя статическое поле при инициализации приложения.
Если тип доступен статически, рассмотрите возможность использования чего-то вроде,
public class Data<T, V>
{
public static V Info;
}
который используется как
Data<int, string>.Info = "A string associated with int";
Data<string, string>.Info = "A string associated with string";
, а доступ к нему осуществляется как
Console.WriteLine(Data<int, string>.Info);
Console.WriteLine(Data<string, string>.Info);
. Это работает, потому что статические переменные универсального класса уникальны для отдельных универсальных параметров.
Если тип статически недоступен, вам следует использовать Dictionary , как указано в вашем вопросе и рекомендовано другими.
Объявите статические свойства или методы вашего типа.
class YourType
{
public static string GetMyInformation()
{
return "Some info on this type";
}
}
Затем вы можете получить доступ к данным в вашем коде следующим образом
var myInfo = YourType.GetMyInformation();
Или я упустил суть?
Хм, как насчет того, чтобы использовать словарь Dictionary:
Вы уже по определению знаете тип, который ищете, если используете метод typeof. Вместо этого вы можете объявить const string MY_CLASS_TYPE_NAME = "MyNamespace.MyClass"
Это не самый красивый вариант, но он молниеносно быстрый и не ограничивает вашу функциональность.
Как сказали другие люди, вы, вероятно, занимаетесь микрооптимизацией, но поскольку мы все прониклись духом этого, то и я тоже :)
Класс типа .NET может быть сведен к дескриптору типа во время выполнения, что может быть более эффективно, чем полный тип, если вам не нужно отражение...
Dictionary или то, что вы используете, примерно на 20% быстрее Dictionary в очень простом тесте, который я только что провел.
typeof(object).RuntimeTypeHandle;
// and
instance.GetType().RuntimeTypeHandle;
может использоваться вместо экземпляра полного типа
написать методы расширения для System.Type, которые будут выполнять все подобные операции за вас.