Beispiel #1
0
        internal ILPropertyBuilder(ILTypeBuilder typeBuilder, PropertyInfo baseProperty)
        {
            this.ILTypeBuilder   = typeBuilder;
            this.PropertyType    = baseProperty.PropertyType;
            this.PropertyBuilder = this.ILTypeBuilder.TypeBuilder.DefineProperty(baseProperty.Name, baseProperty.Attributes, baseProperty.PropertyType, Type.EmptyTypes);
            this.Name            = baseProperty.Name;

            if (baseProperty.GetGetMethod() != null)
            {
                this._getMethodBuilder = typeBuilder.DefineOverrideMethod(baseProperty.GetGetMethod());
            }
            if (baseProperty.GetSetMethod() != null)
            {
                this._setMethodBuilder = typeBuilder.DefineOverrideMethod(baseProperty.GetSetMethod());
            }
            if (this._setMethodBuilder == null && this._getMethodBuilder == null)
            {
                throw new BuildException("Property does not contain any method.");
            }
            if (this._setMethodBuilder == null ? false : this._setMethodBuilder.IsStatic || this._getMethodBuilder == null ? false : this._getMethodBuilder.IsStatic)
            {
                throw new BuildException("Static property cannot override.");
            }

            this.BaseProperty = baseProperty;
            this.IsOverride   = true;
        }
        internal ILProperty(ILCoder coding, ILVariable instance, ILPropertyBuilder propertyBuilder)
        {
            this.Coding            = coding;
            this._instance         = instance;
            this._getMethodBuilder = propertyBuilder.GetMethod;
            this._setMethodBuilder = propertyBuilder.SetMethod;
            this.PropertyType      = propertyBuilder.PropertyType;

            this.GetModifier = propertyBuilder.GetMethod == null ? AccessModifiers.Private : propertyBuilder.GetModifier;
            this.SetModifier = propertyBuilder.SetMethod == null ? AccessModifiers.Private : propertyBuilder.SetModifier;
        }
        public ILMethodBuilder DefineOverrideMethod(MethodInfo baseMethod)
        {
            if (this._isBuild)
            {
                throw new DefinitionException("Tip daha önce derlenmiş. Derlenmiş tipler üzerinde yeni üye eklemesi yapılamaz.");
            }
            if (baseMethod == null)
            {
                throw new ArgumentNullException("baseMethod");
            }

            Type tempBase           = baseMethod.DeclaringType;
            bool isMethodOnAnyBases = tempBase == typeof(object);

            while (!tempBase.IsInterface && tempBase != typeof(object) && !isMethodOnAnyBases)
            {
                isMethodOnAnyBases = this.BaseType == tempBase;
                tempBase           = tempBase.BaseType;
            }

            if (!isMethodOnAnyBases && Array.IndexOf(this._interfaces, baseMethod.DeclaringType) == -1)
            {
                throw new BuildException("Temel metot, temel sınıf ya da uygulanan arabirimlerin en az bir tanesinde tanımlanmış olmalıdır.");
            }
            if (baseMethod.IsStatic)
            {
                throw new BuildException("Static metotlar geçersiz kılınamaz.");
            }
            if (baseMethod.IsFinal)
            {
                throw new BuildException("Mühürlenmiş metotlar geçersiz kılınamaz.");
            }
            if (!baseMethod.IsVirtual)
            {
                throw new BuildException("Metodun hükümsüz kılınabilmesi için sanal veya soyut olması gerekiyor.");
            }

            ILMethodBuilder builder = new ILMethodBuilder(this, baseMethod);

            if (this._definedMethods.ContainsKey(baseMethod.Name))
            {
                this._definedMethods[baseMethod.Name].Add(builder);
            }
            else
            {
                List <ILMethodBuilder> list = new List <ILMethodBuilder>();
                list.Add(builder);
                this._definedMethods.Add(baseMethod.Name, list);
            }
            return(builder);
        }
Beispiel #4
0
        public void DefineSetMethod(AccessModifiers modifier)
        {
            if (this.IsDefaultProperty)
            {
                throw new DefinitionException("Özellik zaten varsayılan olarak atanmış. Yeni bir ekleme yapılamaz.");
            }
            if (this._setMethodBuilder != null)
            {
                throw new DefinitionException("Set metodu daha önce tanımlanmış. Geçersiz kılınmış bir özellik olabilir.");
            }

            MethodAttributes attributes = MethodAttributes.ReuseSlot | ILPropertyBuilder._propMethodAttributes;

            switch (modifier)
            {
            case AccessModifiers.Public:
                attributes |= MethodAttributes.Public;
                break;

            case AccessModifiers.Protected:
                attributes |= MethodAttributes.Family;
                break;

            case AccessModifiers.ProtectedInternal:
                attributes |= MethodAttributes.FamORAssem;
                break;

            case AccessModifiers.Internal:
                attributes |= MethodAttributes.Assembly;
                break;

            case AccessModifiers.Private:
                attributes |= MethodAttributes.Private;
                break;
            }
            if (this.IsStatic)
            {
                attributes |= MethodAttributes.Static;
            }

            ILMethodBuilder setBuilder = this.ILTypeBuilder.DefineMethod("set_" + this.Name, attributes);

            setBuilder.AddParameter(this.PropertyType, "value", ParameterAttributes.None);
            setBuilder.SetReturnType(typeof(void));
            this.PropertyBuilder.SetGetMethod(setBuilder.MethodBuilder);
            this._setMethodBuilder = setBuilder;
        }
        public override ILLazy Call(string methodName, Type[] genericArgs, ILData[] invokeParams)
        {
            if (((IBuilder)this.Coding).IsBuild)
            {
                throw new CodingException("Metodun tanımlandığı tip derlenmiş. Derlenmiş metotların gövdesi yeniden yazılamaz.");
            }
            if (methodName == null)
            {
                throw new ArgumentNullException("methodName");
            }

            ILLazy push = null;

            Type[]          parameterTypes = ILExtentionUtils.ParametersToTypeList(invokeParams);
            ILMethodBuilder builder        = this.Coding.CurrentMethod.ILTypeBuilder.FindMethod(methodName, parameterTypes);

            if (builder == null)
            {
                return(this.Coding.Base.Call(methodName, genericArgs, invokeParams));
            }
            if (builder.IsStatic)
            {
                throw new MethodNotFoundException("Hedef obje, çağrılan metodu içermiyor veya metot statik.");
            }
            else
            if (builder.IsGeneric && (genericArgs == null || genericArgs.Length == 0))
            {
                throw new ArgumentNullException("genericArgs", "Çağrılan yöntem bir generic tanımlama içeriyor.");
            }
            else
            {
                push = new ILLazyInvoke(this.Coding, this, builder, genericArgs, invokeParams);
            }

            if (push.ILType == typeof(void))
            {
                ((IILPusher)push).Push();
                return(null);
            }
            else
            {
                return(push);
            }
        }
        public ILLazy Invoke(ILMethodBuilder methodBuilder, Type[] genericArgs, ILData[] invokeParams)
        {
            if (((IBuilder)this.Coding).IsBuild)
            {
                throw new CodingException("Metodun tanımlandığı tip derlenmiş. Derlenmiş metotların gövdesi yeniden yazılamaz.");
            }
            if (this.PinnedState == ILEmitter.PinnedState.Base)
            {
                throw new NotSupportedException("Bu metot base işaretçisi tarafından desteklenmiyor. This işaretçisi kullanılmalı.");
            }
            if (methodBuilder == null)
            {
                throw new ArgumentNullException("methodBuilder");
            }

            if (methodBuilder.MethodBuilder.IsGenericMethod && (genericArgs == null || genericArgs.Length == 0))
            {
                throw new ArgumentNullException("genericArgs", "Çağrılan yöntem bir generic tanımlama içeriyor.");
            }

            ILLazy push = null;

            if (methodBuilder.IsStatic)
            {
                throw new CodingException("Çağrılan metot statik olmamalı.");
            }
            else
            {
                push = new ILLazyInvoke(this.Coding, this, methodBuilder, genericArgs, invokeParams);
            }

            if (push.ILType == typeof(void))
            {
                ((IILPusher)push).Push();
                return(null);
            }
            else
            {
                return(push);
            }
        }
        public ILMethodBuilder DefineMethod(string methodName, MethodAttributes attributes, CallingConventions conventions)
        {
            if (this._isBuild)
            {
                throw new DefinitionException("Tip daha önce derlenmiş. Derlenmiş tipler üzerinde yeni üye eklemesi yapılamaz.");
            }

            ILMethodBuilder builder = new ILMethodBuilder(this, methodName, attributes, conventions);

            if (this._definedMethods.ContainsKey(methodName))
            {
                this._definedMethods[methodName].Add(builder);
            }
            else
            {
                List <ILMethodBuilder> list = new List <ILMethodBuilder>();
                list.Add(builder);
                this._definedMethods.Add(methodName, list);
            }
            return(builder);
        }
        public ILMethodBuilder FindMethod(string name, Type[] parameters)
        {
            if (this._isBuild)
            {
                throw new InvalidOperationException("Tip daha önce derlenmiş. Üye aramak, getirmek ve yönetmek için System.Reflection kullanılmalıdır.");
            }

            if (this._definedMethods.ContainsKey(name))
            {
                List <ILMethodBuilder> methodsByName = this._definedMethods[name];
                List <ILMethodBuilder> competibles   = new List <ILMethodBuilder>();
                for (int i = 0; i < methodsByName.Count; i++)
                {
                    ILMethodBuilder builder             = methodsByName[i];
                    Type[]          containedParameters = builder.GetParameterTypes();
                    if (containedParameters.Length == parameters.Length)
                    {
                        bool parameterCompetible = containedParameters.Length == 0; //ArgCount 0 ise, methotlar uyumludur.
                        for (int j = 0; j < containedParameters.Length; j++)
                        {
                            Type contain   = containedParameters[j];
                            Type parameter = parameters[j];
                            if (!(parameterCompetible = (contain.IsGenericParameter || contain.IsAssignableFrom(parameter))))
                            {
                                break;
                            }
                        }
                        if (parameterCompetible)
                        {
                            competibles.Add(builder);
                        }
                        else
                        {
                            continue;
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
                if (competibles.Count == 0)
                {
                    return(null);
                }
                else
                {
                    for (int i = 0; i < competibles.Count; i++)
                    {
                        ILMethodBuilder builder             = competibles[i];
                        Type[]          containedParameters = builder.GetParameterTypes();
                        if (containedParameters.Length == parameters.Length)
                        {
                            bool parameterCompetible = containedParameters.Length == 0; //ArgCount 0 ise, methotlar uyumludur.
                            for (int j = 0; j < containedParameters.Length; j++)
                            {
                                Type contain   = containedParameters[j];
                                Type parameter = parameters[j];
                                if (!(parameterCompetible = (contain.IsGenericParameter || contain.IsAssignableFrom(parameter))))
                                {
                                    break;
                                }
                            }
                            if (parameterCompetible)
                            {
                                return(builder);
                            }
                            else
                            {
                                continue;
                            }
                        }
                        else
                        {
                            continue;
                        }
                    }
                    return(competibles[0]);
                }
            }
            else
            {
                return(null);
            }
        }