ComponentArt 2009.3 破解

在EF 中使用mysql关联取数据时,如果当前实体中包含另一个实体的list成员,而这个成员为空的话,在json序列化的时候就会报错:

这里就使用了License, LicenseProvider, RegistryFileLicenseProvider。直接删除

'((System.Data.Entity.DynamicProxies.T_Module_FA775BC9946D7E533F86AFE9B59A3A33C411E1511C687B52EB12BAE7ACD1F195)(new System.Collections.Generic.Mscorlib_CollectionDebugView<T_Module>(resultList).Items[0])).RoleModuleList' threw an exception of type 'System.ObjectDisposedException'

类是一种数据结构,可以包括:数据成员(常量和字段),函数成员(方法、属性、事件、索引,操作符、实例构造函数、析构函数和静态构造函数),以及嵌套类。

public virtual bool IsLicensed()
{
    if (this.License != null)
    {
        return true;
    }
    try
    {
        this.License = LicenseManager.Validate(base.GetType(), this);
        return true;
    }
    catch
    {
        return false;
    }
}

每次都会报这个异常,网上参考资料:

抽象类:abstract修饰符可以用来指明一个类是不完整的,并且它只能被用作基础类。抽象类和非抽象类的区别,

 

 

   抽象类不能被直接实例化,直接在抽象类上使用new操作符会产生编译期错误。尽管编译期类型时抽象的类也可以拥有字段和值,不过这样的字段和值要么是null,要么包含了从抽象类型继承而来的非抽象类的实例的引用。

使他返回TRUE;

在继承实现DbContext的构造方法里面设置对应的属性,我只是使用了其中一种方案,大家如果按照我的方式得到的结果不满意的话可以点开这个链接使用适合自己的方案。

   抽象类可以包含抽象成员。

 

图片 1

   抽象类不可以是密封的。

---1506

this.Configuration.LazyLoadingEnabled = false;
this.Configuration.ProxyCreationEnabled = false;

非抽象类继承一个抽象类时,这个非抽象类必须包含所有继承抽象成员的实际实现。

.method public hidebysig newslot virtual
        instance bool  IsLicensed() cil managed
{
  // 代码大小       50 (0x32)
  .maxstack  3
  .locals init (bool V_0,
           bool V_1)
  IL_0000:  nop
  IL_0001:  ldarg.0
  IL_0002:  ldfld      class [System]System.ComponentModel.License

 

abstract class A

ComponentArt.Web.UI.WebControl::License
  IL_0007:  ldnull
  IL_0008:  ceq
  IL_000a:  stloc.1
  IL_000b:  ldloc.1
  IL_000c:  brtrue.s   IL_0012
  IL_000e:  ldc.i4.1
  IL_000f:  stloc.0
  IL_0010:  br.s       IL_002f
  .try
  {
    IL_0012:  nop
    IL_0013:  ldarg.0
    IL_0014:  ldarg.0
    IL_0015:  call       instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()
    IL_001a:  ldarg.0
    IL_001b:  call       class [System]System.ComponentModel.License

{

[System]System.ComponentModel.LicenseManager::Validate(class [mscorlib]System.Type,
                                                                                                                            object)
    IL_0020:  stfld      class [System]System.ComponentModel.License

      public abstract void F();

ComponentArt.Web.UI.WebControl::License
    IL_0025:  ldc.i4.1
    IL_0026:  stloc.0
    IL_0027:  leave.s    IL_002f
  }  // end .try
  catch [mscorlib]System.Object
  {
    IL_0029:  pop
    IL_002a:  nop
    IL_002b:  ldc.i4.0
    IL_002c:  stloc.0
    IL_002d:  leave.s    IL_002f
  }  // end handler
  IL_002f:  nop
  IL_0030:  ldloc.0
  IL_0031:  ret
} // end of method WebControl::IsLicensed

}

--1553

abstract class B:A

换成:

{

.method public hidebysig newslot virtual instance bool IsLicensed() cil managed
{
    .maxstack 1
    .locals init (
        [0] bool CS$1$0000)
    L_0000: nop
    L_0001: ldc.i4.1
    L_0002: stloc.0
    L_0003: br.s L_0005
    L_0005: ldloc.0
    L_0006: ret
}

      public void G() {}

 

}

 

class C:B

 

{

删掉:

      public override void F(){ ... }

 299637  ---   299739

}

.class public auto ansi beforefieldinit ComponentArt.Licensing.Providers.License
       extends [System]System.ComponentModel.License

 

298904 -----299456
.class public auto ansi beforefieldinit ComponentArt.Licensing.Providers.LicenseProvider
       extends [mscorlib]System.Object

密封类

298824 ---- 298902
.class public auto ansi beforefieldinit ComponentArt.Licensing.Providers.RegistryFileLicenseProvider
       extends [System]System.ComponentModel.LicenseProvider

sealed修饰符可以用来禁止一个类被继承。密封类不可以是抽象类。

299148 ---  299366
.class private auto ansi beforefieldinit ComponentArt.Licensing.Providers.'ᜀ'
       extends ComponentArt.Licensing.Providers.'ᜃ'

 

 

静态类

299150  ---

static修饰符用来将一个类声明为静态类。静态类不可以被实例化,不可以被当做类型来使用,并且只能包含静态成员。只有静态类才可以包含展开函数。

.class private auto ansi beforefieldinit ComponentArt.Licensing.Providers.'ᜁ'
       extends ComponentArt.Licensing.Providers.'ᜃ'

常量和嵌套类型都会被归纳为静态成员。

 

 

 

partial修饰符

.class private auto ansi beforefieldinit ComponentArt.Licensing.Providers.'ᜂ'
       extends [mscorlib]System.Collections.ArrayList

partial修饰符可以用来指明这个类声明是一个局部的类型声明。

 

 

.class private abstract auto ansi beforefieldinit ComponentArt.Licensing.Providers.'ᜃ'
       extends [mscorlib]System.Object

类型参数

 

类型参数是一个简单的标识符,它作为被提供的类型实参的占位符来创建构造类型。

 

 

 

类型参数限制

 IL_0001:  ldarg.1
    IL_0002:  newobj     instance void ComponentArt.Licensing.Providers.RegistryFileLicenseProvider::.ctor()
    IL_0007:  ldstr      ""
    IL_000c:  newobj     instance void ComponentArt.Licensing.Providers.License::.ctor(class

泛型类型和方法声明可以选择通过包含类型形参限制子句来制定类类型形参的限制。

ComponentArt.Licensing.Providers.RegistryFileLicenseProvider,
                                                                                       string)
    IL_0011:  stfld      class [System]System.ComponentModel.License

每个类型形参限制子句由标记where,加上类型形参的名字,加上一个冒号和那个类型形参限制的列表所组成。

ComponentArt.Web.UI.WebControl::License
    IL_0016:  ldarg.1

 

 

局部方法

 

局部方法可以在类型声明的一个部分里定义,并且在另一个部分里实现。这个实现是可选的,如果没有实现这个局部方法,那么局部方法的声明和合所有对它的调用都会在组合时被移除。

 

局部方法只能在局部类或局部结构里声明。它不能声明在非局部类型或接口里。

 

局部方法不能定义访问修饰符,它们都是隐式私有的。它们的返回类型必须为void,并且它们的形参不可以带有out修饰符。

删掉:

partial class Customer

504  --514

{

.publickey = (00 24 00 00 04 80 00 00 94 00 00 00 06 02 00 00   // .$..............
                00 24 00 00 52 53 41 31 00 04 00 00 01 00 01 00   // .$..RSA1........
                8F B8 4C 20 4D AD 24 D4 AC FF 94 0C 9C 74 AB F4   // ..L M.$......t..
                E1 F7 7D 41 81 9F BB 3B 43 5C 4A 16 B6 9C C1 04   // ..}A...;CJ.....
                AE 54 6C C0 7A FA A8 65 F0 D4 7B 89 AE 63 70 48   // .Tl.z..e..{..cpH
                23 C7 67 35 BC 1C 00 A9 BC C1 B6 F0 CC F6 D9 90   // #.g5............
                55 8E 30 3C 00 E1 6A AF E2 C4 2F A2 2E D4 0B BC   // U.0<..j.../.....
                A3 9A 71 40 FA 9F 95 D9 E6 F9 96 6F 01 9C 0B E3   // ..q@.......o....
                4A 79 D9 00 57 85 A3 AA 70 5B 0F A1 48 B4 B1 07   // Jy..W...p[..H...
                C9 3C 1C 11 10 7E 7F BB BF C5 50 09 E3 9E A6 B4 ) // .<...~....P.....
  .hash algorithm 0x00008004

string name;

 

public string Name{

  1. 删除VS2005对项目的权限检查。
    一般就是依赖了LicenseProviderAttribute,打开IL,找到类似的代码,直接删除。20 多个!

      get { return name; }

 .custom instance void [System]System.ComponentModel.LicenseProviderAttribute::.ctor(class

      set {

[mscorlib]System.Type) = ( 01 00 3C 43 6F 6D 70 6F 6E 65 6E 74 41 72 74 2E   // ..<ComponentArt.
                                                                                                                       4C 69 63 65 6E 73

               OnNameChanging(value);

69 6E 67 2E 50 72 6F 76 69 64   // Licensing.Provid
                                                                                                                       65 72 73 2E 52 65

               name = value;

67 69 73 74 72 79 46 69 6C 65   // ers.RegistryFile
                                                                                                                       4C 69 63 65 6E 73

               OnNameChanged();

65 50 72 6F 76 69 64 65 72 00   // LicenseProvider.
                                                                                                                       00 )

      }

 

}

命令:

partial void OnNameChanging(string newName);

c:

partial void OnNameChanged();

cd C:Documents and Settingsitd0300166.PLSH166桌面123

}

ilasm /dll /resource=123.res /output:123.dll  123.il     

partial class Customer

 

{

 

      partial void OnNameChanging(string newName)

 

      {

 

            Console.WriteLine("changing" name "to" newName);

 

      }

 

      partial void OnNameChanged()

      {

            Console.WriteLine("Changed to" name);

      }

}

 

类成员

常量,代表了和类相关联的常数值。

字段,也就是类的变量。

方法,实现了类可以进行的计算和操作。

属性,定义了命名特性以及读写这些特性的操作。

事件,定义了类可以生成的通知。

索引,让类的实例可以像数组一样被索引。

操作符,定义了可以作用于类实例之上的表达式操作符。

实例构造函数,实现了初始化类所需的操作。

析构函数,实现了再彻底丢弃类实例之前要进行的操作。

静态构造函数,实例了初始化类本身所需的操作。

类型,代表了类的本地类型。

 

构造类型的成员

构造类型的非继承成员可以通过将成员声明里的每一个类型形参替换成构造类型里相应的类型实参来获得。替换过程是基于类型声明的羽翼含义,而非简单的文本替换。

class Gen<T,U>

{

      public T[,]  a;

      public void G(int i,T t,Gen<U,T> gt) {...}

      public U Prop{ get {...} set{...} }

      public int H(double d){...}

}

构造类型Gen<int[],IComparable<string>>具有以下成员:

public int[,][] a;

public void G(int i,int[] t,Gen<IComparable<string>,int[]> gt) {...}

public IComparable<string> Prop{ get{...} set{...} }

public int H(double d) {...}

本文由糖果派对电玩城发布于用户反馈,转载请注明出处:ComponentArt 2009.3 破解

您可能还会对下面的文章感兴趣: