public interface IMapper
{
    TDestination Map<TSource, TDestination>(TSource source);
    void CreateMap<TSource, TDestination>();
}

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

public class Mapper : IMapper
{
    private readonly Dictionary<(Type Source, Type Destination), Delegate> _mappingFunctions = new();

    public TDestination Map<TSource, TDestination>(TSource source)
    {
        if (source == null)
        {
            throw new ArgumentNullException(nameof(source));
        }

        var key = (typeof(TSource), typeof(TDestination));

        if (!_mappingFunctions.TryGetValue(key, out var mapFunction))
        {
            throw new InvalidOperationException($"'{typeof(TSource).Name}' ve '{typeof(TDestination).Name}' arasında bir haritalama işlemi tanımlanmadı.");
        }

        return ((Func<TSource, TDestination>)mapFunction)(source);
    }

    public void CreateMap<TSource, TDestination>()
    {
        var sourceType = typeof(TSource);
        var destinationType = typeof(TDestination);
        var dynamicMethod = CreateMapDynamicMethod(sourceType, destinationType);

        var mapFunction = (Func<TSource, TDestination>)dynamicMethod.CreateDelegate(typeof(Func<TSource, TDestination>));
        var key = (sourceType, destinationType);
        _mappingFunctions[key] = mapFunction;
    }

    private DynamicMethod CreateMapDynamicMethod(Type sourceType, Type destinationType)
    {
        var dynamicMethod = new DynamicMethod(
            $"Map_{sourceType.Name}_To_{destinationType.Name}",
            destinationType,
            new[] { sourceType },
            typeof(Mapper),
            true);

        var ilGenerator = dynamicMethod.GetILGenerator();

        // Yeni hedef nesnesi örneği oluştur
        ilGenerator.Emit(OpCodes.Newobj, destinationType.GetConstructor(Type.EmptyTypes));

        // Kaynak ve hedef nesneler arasında eşleşen özelliklerin değerlerini kopyala
        foreach (var sourceProperty in sourceType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
        {
            var destinationProperty = destinationType.GetProperty(sourceProperty.Name, BindingFlags.Public | BindingFlags.Instance);

            if (
            	destinationProperty != null && destinationProperty.CanWrite && destinationProperty.PropertyType == sourceProperty.PropertyType)
            {
                // Hedef nesneyi yığın üstünde sakla
                ilGenerator.Emit(OpCodes.Dup);

                // Kaynak nesnenin özellik değerini yığın üstünde sakla
                ilGenerator.Emit(OpCodes.Ldarg_0);
                ilGenerator.Emit(OpCodes.Call, sourceProperty.GetMethod);

                // Hedef nesnenin özellik değerini ayarla
                ilGenerator.Emit(OpCodes.Call, destinationProperty.SetMethod);
            }
        }

        // Hedef nesneyi geri döndür
        ilGenerator.Emit(OpCodes.Ret);

        return dynamicMethod;
    }
}

public class Source
{
    public int Id { get; set; }
    public string FullName { get; set; }
}

public class Destination
{
    public int Id { get; set; }
    public string FullName { get; set; }
}

public static void Main()
{
    IMapper mapper = new Mapper();

    // CreateMap metodu ile kaynak ve hedef nesneler arasındaki dönüşümü tanımlayın
    mapper.CreateMap<Source, Destination>();

    // Kaynak nesneyi oluşturun
    var sourceObject = new Source
    {
        Id = 1,
        FullName = "Murat Genç"
    };

    // Haritalama işlemi gerçekleştirin
    var destinationObject = mapper.Map<Source, Destination>(sourceObject);

    // Çıktıyı göster
    Console.WriteLine($"ID: {destinationObject.Id}, FullName: {destinationObject.FullName}");
}