示例#1
0
 internal NestedStaticClassWithMonoCecil(ITypeWithMonoCecil declaringType, TypeDefinition type)
 {
     this.declaringType    = declaringType;
     hiddenMembersAnalyzer = new HiddenMembersAnalyzer(Assembly, type);
     this.type             = type;
     typeWithMonoCecil     = new StaticTypeWithMonoCecil(this);
     methods = new NestedStaticClassMethodCollectionWithMonoCecil(typeWithMonoCecil);
 }
 internal StaticClassWithMonoCecil(AssemblyWithMonoCecil assembly, NamespaceWithMonoCecil @namespace, TypeDefinition type)
 {
     this.assembly         = assembly;
     this.@namespace       = @namespace;
     this.type             = type;
     typeWithMonoCecil     = new StaticTypeWithMonoCecil(this);
     hiddenMembersAnalyzer = new HiddenMembersAnalyzer(assembly, type);
 }
 internal StaticClassWithReflection(AssemblyWithReflection assembly, NamespaceWithReflection @namespace, Type type)
 {
     this.assembly         = assembly;
     this.@namespace       = @namespace;
     this.type             = type;
     typeWithReflection    = new StaticTypeWithReflection(this);
     hiddenMembersAnalyzer = new HiddenMembersAnalyzer(type);
 }
示例#4
0
 internal NestedStaticClassWithReflection(ITypeWithReflection declaringType, Type type)
 {
     this.declaringType    = declaringType;
     hiddenMembersAnalyzer = new HiddenMembersAnalyzer(type);
     this.type             = type;
     typeWithReflection    = new StaticTypeWithReflection(this);
     methods = new NestedStaticClassMethodCollectionWithReflection(typeWithReflection);
 }
示例#5
0
        internal SealedClassWithMonoCecil(AssemblyWithMonoCecil assembly, NamespaceWithMonoCecil @namespace, TypeDefinition type)
        {
            this.assembly   = assembly;
            this.@namespace = @namespace;
            this.type       = type;
            if (type.BaseType != null && type.BaseType.FullName != "System.Object")
            {
                baseClass = new ClassReferenceWithMonoCecil(assembly, type.BaseType);
            }

            hiddenMembersAnalyzer = new HiddenMembersAnalyzer(assembly, type);
            typeWithMonoCecil     = new SealedTypeWithMonoCecil(this);
            destructor            = new Lazy <DestructorWithMonoCecil>(InitializeDestructor);
        }
        internal SealedClassWithReflection(AssemblyWithReflection assembly, NamespaceWithReflection @namespace, Type type)
        {
            this.assembly   = assembly;
            this.@namespace = @namespace;
            this.type       = type;
            if (type.BaseType != null && type.BaseType != typeof(object))
            {
                baseClass = new ClassReferenceWithReflection(type.BaseType);
            }

            hiddenMembersAnalyzer = new HiddenMembersAnalyzer(type);
            typeWithReflection    = new SealedTypeWithReflection(this);
            destructor            = new Lazy <DestructorWithReflection>(InitializeDestructor);
        }
        internal NestedClassWithMonoCecil(ITypeWithMonoCecil declaringType, TypeDefinition type)
        {
            this.declaringType    = declaringType;
            hiddenMembersAnalyzer = new HiddenMembersAnalyzer(declaringType.Assembly, type);
            this.type             = type;
            if (type.BaseType != null && type.BaseType.FullName != "System.Object")
            {
                baseClass = new ClassReferenceWithMonoCecil(declaringType.Assembly, type.BaseType);
            }

            typeWithMonoCecil = new ClassTypeWithMonoCecil(this);
            destructor        = new Lazy <DestructorWithMonoCecil>(
                () => typeWithMonoCecil.Destructor == null ? null : new DestructorWithMonoCecil(null, this, typeWithMonoCecil.Destructor));
        }
        internal NestedClassWithReflection(ITypeWithReflection declaringType, Type type)
        {
            this.declaringType    = declaringType;
            hiddenMembersAnalyzer = new HiddenMembersAnalyzer(type);
            this.type             = type;
            if (type.BaseType != null && type.BaseType != typeof(object))
            {
                baseClass = new ClassReferenceWithReflection(type.BaseType);
            }

            typeWithReflection = new ClassTypeWithReflection(this);
            destructor         = new Lazy <DestructorWithReflection>(() =>
            {
                MethodInfo destructorMethod = typeWithReflection.Destructor;
                return(destructorMethod == null ? null : new DestructorWithReflection(this, destructorMethod));
            });
        }