public interface IAnimation
{
    //Should animations apply velocities to physics objects
    bool animatePhysics  { get; set;  }
    //How should animations mode updated based on renderer visibility
    AnimatorCullingMode cullingMode { get; set; }
    //Are we currently playing animations
    bool isPlaying { get;}
    //Should we start playing the default state
    bool playAutomatically { get; set; }
    //For clips where wrap mode is default, how should clips behave after they are done
    WrapMode wrapMode { get; set; }
    bool usesLegacy { get; }
    GameObject gameObject { get; }
    AnimationClip clip { get; set; }

    //Adds a new state named newName, which uses the AnimationClip clip
    void AddClip(AnimationClip clip, string newName);

    //Starts blending the state animation, towards weight targetWeight, fading over fadeLength seconds
    void Blend(string animation, float targetWeight, float fadeLength);
    
    //Over the next fadeLength seconds, start fading in state animation, fading out all other states
    void CrossFade(string animation, float fadeLength);
    
    //Queue a crossfade after the currently playing states are done playing.
    void CrossFadeQueued(string animation, float fadeLength, QueueMode queueMode);

    //Gets the number of AnimationClips attached to the component
    int GetClipCount();

    //Returns true if state stateName is playing
    bool IsPlaying(string stateName);
    
    //Stops all playing animations on this component
    void Stop();

    //Stops state named stateName
    void Stop(string stateName);

    //Evaluates the animations at the current time
    void Sample();
    
    //Plays the default clip. Returns false if there is no clip attached
    bool Play();

    //Plays the specified clip. Returns false if the state does not exist
    bool Play(string stateName);
    
    //Queue a Play after the current states are done playing
    void PlayQueued(string stateName, QueueMode queueMode);

    //Removes the specified clip, and any states using it
    void RemoveClip(AnimationClip clip);

    //Removes the specified state from the list of states,
    void RemoveClip(string stateName);

    //Rewinds all states
    void Rewind();

    //Rewinds state named stateName
    void Rewind(string stateName);

    //Returns a handle on a state. Returns null if the state doesn't exist
    IAnimationState GetState(string stateName);

    IAnimationState this[string name] { get; }

}

private class AnimationStateProxy: IAnimationState
    {
        public AnimationStateProxy(AnimationState state)
        {
            m_State = state;
        }

        private AnimationState m_State;

        public bool enabled
        {
            get { return m_State.enabled; }
            set { m_State.enabled = value; }
        }

        public bool isValid
        {
            get { return (bool)m_State; }
        }

        public float time
        {
            get { return m_State.time; }
            set { m_State.time = value; }
        }
        public float normalizedTime
        {
            get { return m_State.normalizedTime; }
            set { m_State.normalizedTime = value; }
        }
        public float speed
        {
            get { return m_State.speed; }
            set { m_State.speed = value; }
        }

        public string name
        {
            get { return m_State.name; }
            set { m_State.name = value; }
        }
        public float weight
        {
            get { return m_State.weight; }
            set { m_State.weight = value; }
        }
        public float length
        {
            get { return m_State.length; }
        }

        public AnimationClip clip
        {
            get { return m_State.clip; }
        }

        public WrapMode wrapMode
        {
            get { return m_State.wrapMode; }
            set { m_State.wrapMode = value; }
        }
    }

using UnityEngine;

[RequireComponent(typeof(Animation))]
public class AnimationProxy : MonoBehaviour, IAnimation
{
    private Animation m_Animation;

    new private Animation animation
    {
        get
        {
            if (m_Animation ==  null)
            {
                m_Animation = GetComponent<Animation>();
            }
            return m_Animation;
        }
    }

    public bool animatePhysics
    {
        get { return animation.animatePhysics; }
        set { animation.animatePhysics = value; }
    }

    public AnimatorCullingMode cullingMode
    {
        get
        {
            AnimatorCullingMode mode;
            switch (animation.cullingType)
            {
                case AnimationCullingType.AlwaysAnimate:
                    mode = AnimatorCullingMode.AlwaysAnimate;
                    break;
                case AnimationCullingType.BasedOnRenderers:
                    mode = AnimatorCullingMode.CullCompletely;
                    break;
                default:
                    mode = AnimatorCullingMode.CullUpdateTransforms;
                    break;
            }
            return mode;
        }

        set
        {
            AnimationCullingType type;
            switch(value)
            {
                case AnimatorCullingMode.AlwaysAnimate:
                    type = AnimationCullingType.AlwaysAnimate;
                    break;
                default:
                    type = AnimationCullingType.BasedOnRenderers;
                    break;

            }
            animation.cullingType = type;
        }
    }

    public bool isPlaying
    {
        get { return animation.isPlaying; }
    }

    public bool playAutomatically
    {
        get { return animation.playAutomatically; }
        set { animation.playAutomatically = value; }
    }

    public WrapMode wrapMode
    {
        get { return animation.wrapMode; }
        set { animation.wrapMode = value; }
    }

    public AnimationClip clip
    {
        get { return animation.clip; }
        set { animation.clip = value; }
    }

    public bool usesLegacy
    {
        get { return true; }
    }
    new public GameObject gameObject
    {
        get { return animation.gameObject; }
    }

    public void AddClip(AnimationClip clip, string newName)
    {
        animation.AddClip(clip, newName);
    }

    public void Blend(string state, float targetWeight, float fadeLength)
    {
        animation.Blend(state, targetWeight, fadeLength);
    }

    public void CrossFade(string state, float fadeLength)
    {
        animation.CrossFade(state, fadeLength);
    }

    public void CrossFadeQueued(string state, float fadeLength, QueueMode queueMode)
    {
        animation.CrossFadeQueued(state, fadeLength, queueMode);
    }

    public int GetClipCount()
    {
        return animation.GetClipCount();
    }

    public bool IsPlaying(string stateName)
    {
        return animation.IsPlaying(stateName);
    }

    public void Stop()
    {
        animation.Stop();
    }

    public void Stop(string stateName)
    {
        animation.Stop(stateName);
    }

    public void Sample()
    {
        animation.Sample();
    }

    public bool Play()
    {
        return animation.Play();
    }

    public bool Play(string stateName)
    {
        return animation.Play(stateName);
    }

    public void PlayQueued(string stateName, QueueMode queueMode)
    {
        animation.PlayQueued(stateName, queueMode);
    }

    public void RemoveClip(AnimationClip clip)
    {
        animation.RemoveClip(clip);
    }

    public void RemoveClip(string stateName)
    {
        animation.RemoveClip(stateName);
    }

    public void Rewind()
    {
        animation.Rewind();
    }

    public void Rewind(string stateName)
    {
        animation.Rewind(stateName);
    }

    public IAnimationState GetState(string stateName)
    {
        AnimationState state = animation[stateName];
        if (state != null)
            return new AnimationStateProxy(state);

        return null;
    }

    public IAnimationState this[string name]
    {
        get { return GetState(name); }
    }
}

using System;
using System.Reflection;
using System.Reflection.Emit;

namespace EmitDemo
{
    public interface IConsole
    {
        void Say();
    }

    class Program
    {
        static void Main(string[] args)
        {
            //定义一个程序集名称
            AssemblyName aName = new AssemblyName("DynamicAssemblyExample");
            //创建一个程序集构建器
            AssemblyBuilder ab = AssemblyBuilder.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Run);
            //使用程序及构建创建一个模块构建器
            ModuleBuilder mb = ab.DefineDynamicModule(aName.Name + ".dll");
            //使用模块构建起创建一个类型构建器
            TypeBuilder tb = mb.DefineType("DynamicConsole");
            //使用类型实现IConsole接口
            tb.AddInterfaceImplementation(typeof(IConsole));
            var attrs = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.HideBySig | MethodAttributes.Final;
            // 使用类型构建器创建一个方法构建器
            MethodBuilder methodBuilder = tb.DefineMethod("Say", attrs, typeof(void), Type.EmptyTypes);
            //通过方法构建起获取一个MSIL生成器
            var IL = methodBuilder.GetILGenerator();
            //开始编写方法的执行逻辑
            //将一个字符串压入栈顶
            IL.Emit(OpCodes.Ldstr, "I'm here.");
            //调用Console.WriteLine函数
            IL.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }));
            //退出函数
            IL.Emit(OpCodes.Ret);
            //方法结束

            //从类型构建起中创建出类型
            var dymicType = tb.CreateType();

            //通过反射创建出动态类型的实例
            var console = Activator.CreateInstance(dymicType) as IConsole;
            console.Say();
            Console.Read();
        }
    }
}