Dynamic Language Runtime (DLR) в C#

// До DLR - работа с COM объектами через рефлексию
object excelApp = Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));
Type excelType = excelApp.GetType();
excelType.InvokeMember("Visible", BindingFlags.SetProperty, null, excelApp, new object[] { true });

// После DLR - тот же код с COM объектами, но намного проще
dynamic excelApp = Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));
excelApp.Visible = true;

// Без DLR - тяжеловесный и трудночитаемый код
JObject jsonData = JObject.Parse(jsonString);
string name = null;
if (jsonData["user"] != null && jsonData["user"]["profile"] != null && jsonData["user"]["profile"]["name"] != null)
{
    name = jsonData["user"]["profile"]["name"].Value<string>();
}
 
// С DLR - изящно и понятно
dynamic data = JsonConvert.DeserializeObject(jsonString);
string name = data?.user?.profile?.name;

// Пример использования Expression Trees в DLR
Expression<Func<int, int, int>> expr = (a, b) => a + b;
// Это не простой лямбда, а целое дерево, которое можно анализировать
BinaryExpression binExpr = (BinaryExpression)expr.Body;
Console.WriteLine(binExpr.NodeType);  // Выводит: Add

dynamic obj = GetSomeObject();
// Первый вызов метода - DLR запоминает, как он был разрешен
obj.SomeMethod();
// Последующие вызовы происходят быстрее благодаря кэшированию
obj.SomeMethod();

// На первый взгляд - обычная переменная
dynamic x = 10;
x = "Hello";  // Но мы можем менять её тип на лету
 
// Динамический вызов методов
dynamic obj = new MyClass();
obj.Method(1, "text");  // Метод будет искаться в рантайме

// Рефлексия - медленный способ
object obj = new MyClass();
MethodInfo method = obj.GetType().GetMethod("Method");
method.Invoke(obj, new object[] { 1, "text" });
 
// DLR - может быть значительно быстрее
dynamic dObj = new MyClass();
dObj.Method(1, "text");

// ExpandoObject - крайне гибкий динамический объект
dynamic person = new ExpandoObject();
person.Name = "John";
person.Age = 30;
person.SayHello = new Action(() => Console.WriteLine($"Hello, my name is {person.Name}"));
person.SayHello();

// Пример использования DLR в Moq
var mock = new Mock<IMyInterface>();
mock.Setup(m => m.SomeMethod()).Returns(42);
IMyInterface instance = mock.Object;
int result = instance.SomeMethod();  // Вернёт 42

a + b * c

   +
  / \
 a   *
    / \
   b   c

// Создание дерева выражения для лямбда-функции
Expression<Func<int, int, bool>> expr = (x, y) => x > y;
 
// Анализ его структуры
BinaryExpression binary = (BinaryExpression)expr.Body;
Console.WriteLine(binary.Left.NodeType);  // Parameter
Console.WriteLine(binary.Right.NodeType); // Parameter
Console.WriteLine(binary.NodeType);       // GreaterThan

// Упрощенный пример построения динамического LINQ-запроса
public static IQueryable<T> Where<T>(this IQueryable<T> source, string propertyName, string operation, object value)
{
    var parameter = Expression.Parameter(typeof(T), "x");
    var property = Expression.Property(parameter, propertyName);
    var constant = Expression.Constant(value);
    
    Expression body;
    switch (operation)
    {
        case "==": body = Expression.Equal(property, constant); break;
        case ">": body = Expression.GreaterThan(property, constant); break;
        // другие операции...
        default: throw new NotSupportedException($"Operation {operation} not supported");
    }
    
    var lambda = Expression.Lambda<Func<T, bool>>(body, parameter);
    return source.Where(lambda);
}

dynamic obj = GetObject();
obj.Method(); // Здесь Binder решает, какой метод вызывать

class DuckTypingBinder : CallSiteBinder
{
    public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel)
    {
        // Реализация "утиной типизации"
        // ...
    }
}

// Пример реализации собственного динамического объекта
public class DynamicDictionary : DynamicObject
{
    private Dictionary<string, object> _dictionary = new Dictionary<string, object>();
 
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        return _dictionary.TryGetValue(binder.Name, out result);
    }
 
    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        _dictionary[binder.Name] = value;
        return true;
    }
}

dynamic dict = new DynamicDictionary();
dict.Name = "John";
Console.WriteLine(dict.Name);  // Выведет: John

// Пример простой системы плагинов с использованием DLR
public class PluginHost
{
    public void ExecuteMethod(dynamic plugin, string methodName, params object[] args)
    {
        // Вызываем метод динамически, без необходимости знать его сигнатуру заранее
        var method = plugin.GetType().GetMethod(methodName);
        if (method != null)
        {
            method.Invoke(plugin, args);
        }
    }
}

using IronPython.Hosting;
using Microsoft.Scripting.Hosting;
 
// Создаём движок Python
ScriptEngine engine = Python.CreateEngine();
ScriptScope scope = engine.CreateScope();
 
// Передаём переменные из C# в Python
scope.SetVariable("x", 42);
scope.SetVariable("y", "Hello");
 
// Выполняем Python-код
engine.Execute("result = x * 2", scope);
engine.Execute("message = y + ', World!'", scope);
 
// Получаем результаты обратно в C#
int result = scope.GetVariable<int>("result");
string message = scope.GetVariable<string>("message");
 
Console.WriteLine($"Result: {result}");  // Выведет: Result: 84
Console.WriteLine($"Message: {message}");  // Выведет: Message: Hello, World!

// Blazor компонент, вызывающий JavaScript
@inject IJSRuntime JSRuntime
 
<button @onclick="CallJavaScript">Вызвать JavaScript</button>
 
@code {
    private async Task CallJavaScript()
    {
        // Динамический вызов JavaScript функции
        await JSRuntime.InvokeVoidAsync("myJsFunction", "Hello from Blazor!");
    }
}

// Упрощенный пример создания собственного языка на базе DLR
public class MyLanguageBinder : BinaryOperationBinder
{
    public MyLanguageBinder(ExpressionType operation) : base(operation) { }
 
    public override DynamicMetaObject FallbackBinaryOperation(DynamicMetaObject target, DynamicMetaObject arg, DynamicMetaObject errorSuggestion)
    {
        // Определяем правила для операций в нашем языке
        // Например, можно реализовать сложение между числами и строками особым образом
        // ...
    }
}

// Определяем класс на C#
public class Calculator
{
    public int Add(int a, int b) => a + b;
    public int Subtract(int a, int b) => a - b;
}
 
// Используем его из IronPython
// (Python-скрипт, выполняемый через IronPython)
calculator = Calculator()
result = calculator.Add(10, 20)
print(result)  # Выведет: 30

// Прямой вызов (baseline)
public void DirectCall()
{
    var obj = new TestClass();
    for (int i = 0; i < 1000000; i++)
    {
        obj.TestMethod();
    }
}
 
// Вызов через рефлексию
public void ReflectionCall()
{
    var obj = new TestClass();
    var method = typeof(TestClass).GetMethod("TestMethod");
    for (int i = 0; i < 1000000; i++)
    {
        method.Invoke(obj, null);
    }
}
 
// Вызов через DLR
public void DynamicCall()
{
    dynamic obj = new TestClass();
    for (int i = 0; i < 1000000; i++)
    {
        obj.TestMethod();
    }
}

// Создание и использование COM-объекта Excel через DLR
dynamic excel = Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));
excel.Visible = true;
dynamic workbook = excel.Workbooks.Add();
dynamic sheet = workbook.ActiveSheet;
sheet.Cells[1, 1].Value = "Hello, Excel!";

// Пример метапрограммирования с использованием DLR
public class DynamicProxy : DynamicObject
{
    private object _target;
    private Action<string, object[]> _beforeMethod;
    private Action<string, object[], object> _afterMethod;
 
    public DynamicProxy(object target, Action<string, object[]> beforeMethod, Action<string, object[], object> afterMethod)
    {
        _target = target;
        _beforeMethod = beforeMethod;
        _afterMethod = afterMethod;
    }
 
    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        _beforeMethod?.Invoke(binder.Name, args);
        
        var method = _target.GetType().GetMethod(binder.Name);
        result = method.Invoke(_target, args);
        
        _afterMethod?.Invoke(binder.Name, args, result);
        
        return true;
    }
}

// Пример простого DSL для описания бизнес-правил валидации
public class ValidationLanguage : DynamicObject
{
    private object _target;
    
    public ValidationLanguage(object target)
    {
        _target = target;
    }
    
    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        if (binder.Name == "RequireNotNull")
        {
            var prop = (string)args[0];
            var value = _target.GetType().GetProperty(prop).GetValue(_target);
            result = value != null;
            if (value == null)
                Console.WriteLine($"Ошибка: свойство {prop} не может быть null");
            return true;
        }
        // Другие валидационные правила...
        
        result = null;
        return false;
    }
}

dynamic validator = new ValidationLanguage(user);
validator.RequireNotNull("Name");
validator.RequireNotNull("Email");

dynamic article = new ExpandoObject();
article.Title = "Магия DLR в C#";
article.PublishedDate = DateTime.Now;
article.WordCount = 3500;
 
// Можно даже добавлять методы!
article.GetReadingTimeMinutes = new Func<int>(() => article.WordCount / 200);
 
Console.WriteLine($"Чтение займет примерно {article.GetReadingTimeMinutes()} минут");

var articleDict = (IDictionary<string, object>)article;
articleDict["Author"] = "Джон Скит";
Console.WriteLine(article.Author);  // Выведет: Джон Скит

// Десериализация JSON в динамический объект
dynamic userData = JsonConvert.DeserializeObject<ExpandoObject>(jsonString);
Console.WriteLine(userData.Name);
Console.WriteLine(userData.Address.City);

// Динамическое создание и использование обобщённых типов
public static T CreateGeneric<T>(string typeName, params object[] args)
{
    Type genericTypeDefinition = Type.GetType(typeName);
    Type genericType = genericTypeDefinition.MakeGenericType(typeof(T));
    dynamic instance = Activator.CreateInstance(genericType, args);
    return (T)instance;
}
 
// Использование
var list = CreateGeneric<string>("System.Collections.Generic.List`1");
list.Add("Item 1");
list.Add("Item 2");

// Контроллер
public ActionResult Index()
{
    dynamic model = new ExpandoObject();
    model.Users = _userService.GetUsers();
    model.Stats = _statisticsService.GetStatistics();
    model.Settings = _settingsService.GetApplicationSettings();
    
    return View(model);
}
 
// Представление
@model dynamic
<h1>Пользователей в системе: @Model.Stats.UserCount</h1>
<ul>
    @foreach (var user in Model.Users)
    {
        <li>@user.Name</li>
    }
</ul>

// Пример динамического создания класса для сериализации
public static dynamic CreateDynamicClass(IDictionary<string, Type> properties)
{
    var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
        new AssemblyName("DynamicAssembly"), AssemblyBuilderAccess.Run);
    var module = assembly.DefineDynamicModule("DynamicModule");
    var typeBuilder = module.DefineType("DynamicType", 
        TypeAttributes.Public | TypeAttributes.Class);
    
    // Добавление свойств
    foreach (var prop in properties)
    {
        var field = typeBuilder.DefineField("_" + prop.Key, prop.Value, FieldAttributes.Private);
        var property = typeBuilder.DefineProperty(prop.Key, PropertyAttributes.None, prop.Value, null);
        
        // Геттер
        var getter = typeBuilder.DefineMethod("get_" + prop.Key,
            MethodAttributes.Public | MethodAttributes.SpecialName, prop.Value, Type.EmptyTypes);
        var getterIL = getter.GetILGenerator();
        getterIL.Emit(OpCodes.Ldarg_0);
        getterIL.Emit(OpCodes.Ldfld, field);
        getterIL.Emit(OpCodes.Ret);
        
        // Сеттер
        var setter = typeBuilder.DefineMethod("set_" + prop.Key,
            MethodAttributes.Public | MethodAttributes.SpecialName, null, new[] { prop.Value });
        var setterIL = setter.GetILGenerator();
        setterIL.Emit(OpCodes.Ldarg_0);
        setterIL.Emit(OpCodes.Ldarg_1);
        setterIL.Emit(OpCodes.Stfld, field);
        setterIL.Emit(OpCodes.Ret);
        
        property.SetGetMethod(getter);
        property.SetSetMethod(setter);
    }
    
    Type type = typeBuilder.CreateType();
    return Activator.CreateInstance(type);
}

dynamic chameleon = "Строка";
Console.WriteLine(chameleon.ToUpper());  // СТРОКА
 
chameleon = 42;
Console.WriteLine(chameleon + 8);  // 50
 
chameleon = DateTime.Now;
Console.WriteLine(chameleon.Year);  // 2023

public class DynamicMessageProcessor
{
    public void Process(dynamic message)
    {
        // Вызываем метод, который может даже не существовать в compile-time
        ProcessInternal(message);
    }
 
    private void ProcessInternal(TextMessage message)
    {
        Console.WriteLine($"Обработка текстового сообщения: {message.Text}");
    }
 
    private void ProcessInternal(ImageMessage message)
    {
        Console.WriteLine($"Обработка изображения: {message.Url}, размер {message.Width}x{message.Height}");
    }
 
    // Можно добавлять обработчики новых типов сообщений без изменения интерфейсов
}

// Старый подход - многословно и не очень интуитивно
JObject jsonObj = JObject.Parse(jsonString);
string name = null;
int? age = null;
if (jsonObj["person"] != null && jsonObj["person"]["name"] != null)
    name = jsonObj["person"]["name"].Value<string>();
if (jsonObj["person"] != null && jsonObj["person"]["age"] != null)
    age = jsonObj["person"]["age"].Value<int>();

// Новый подход с Dynamic
dynamic jsonData = JsonConvert.DeserializeObject(jsonString);
string name = jsonData?.person?.name;
int? age = jsonData?.person?.age;

var xml = @"<person>
                <name>Иван</name>
                <age>30</age>
                <contacts>
                    <email>ivan@example.com</email>
                    <phone>+123456789</phone>
                </contacts>
            </person>";
 
dynamic data = new DynamicXml(xml);
Console.WriteLine(data.name);  // Иван
Console.WriteLine(data.contacts.email);  // ivan@example.com

// Создание мока с использованием динамической типизации
var mock = new Mock<IUserRepository>();
mock.Setup(repo => repo.GetUserById(42)).Returns(new User { Name = "Иван", Role = "Admin" });
 
IUserRepository repository = mock.Object;
var user = repository.GetUserById(42);
Assert.Equal("Иван", user.Name);

class DynamicMock : DynamicObject
{
    private Dictionary<string, Func<object[], object>> _methodCallbacks = 
        new Dictionary<string, Func<object[], object>>();
 
    public void SetupMethod(string methodName, Func<object[], object> callback)
    {
        _methodCallbacks[methodName] = callback;
    }
 
    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        if (_methodCallbacks.TryGetValue(binder.Name, out var callback))
        {
            result = callback(args);
            return true;
        }
        
        result = null;
        return false;
    }
}
 
// Использование
dynamic mock = new DynamicMock();
mock.SetupMethod("GetUserById", args => new { Name = "Иван", Role = "Admin" });
var user = mock.GetUserById(42);
Console.WriteLine(user.Name);  // Иван

public class DynamicPluginHost
{
    private List<dynamic> _plugins = new List<dynamic>();
 
    public void RegisterPlugin(dynamic plugin)
    {
        _plugins.Add(plugin);
    }
 
    public void ProcessData(dynamic data)
    {
        foreach (var plugin in _plugins)
        {
            // Мы даже не знаем, имеет ли плагин метод Process!
            // DLR разрешит это в рантайме
            if (CanProcess(plugin, data))
            {
                plugin.Process(data);
            }
        }
    }
 
    private bool CanProcess(dynamic plugin, dynamic data)
    {
        try
        {
            return plugin.CanProcess(data);
        }
        catch (RuntimeBinderException)
        {
            // Плагин не поддерживает этот тип данных
            return false;
        }
    }
}

// Класс, который реализует методы Walk() и Quack(),
// но не реализует интерфейс IDuck
class SomeBird
{
    public void Walk() => Console.WriteLine("Ходит как утка");
    public void Quack() => Console.WriteLine("Крякает как утка");
}
 
public void MakeItQuack(dynamic duck)
{
    // Мы не проверяем, реализует ли duck интерфейс IDuck
    // Нам важно только то, что у него есть метод Quack()
    duck.Quack();
}

// До C# 9.0 - использование dynamic для работы с гетерогенными данными
dynamic data = GetData();
if (data.Type == "User")
{
    ProcessUser(data);
}
 
// C# 9.0+ - использование pattern matching
var data = GetData();
if (data is User user)
{
    ProcessUser(user);
}

dynamic config = GetConfigFromExternalSource();
// Опечатка в имени свойства, но компилятор не сможет её обнаружить
int timeout = config.TimeOut; // Должно быть Timeout