程式師世界 >> 編程語言 >> .NET網頁編程 >> C# >> C#入門知識 >> 從C#法式中挪用非受管DLLs的辦法

從C#法式中挪用非受管DLLs的辦法

編輯：C#入門知識

從C#法式中挪用非受管DLLs的辦法。本站提示廣大學習愛好者：（從C#法式中挪用非受管DLLs的辦法）文章只能為提供參考，不一定能成為您想要的結果。以下是從C#法式中挪用非受管DLLs的辦法正文

在Java中聲明屬性、辦法和類時，可以使用症結字final來潤飾。final變量即為常量，只能賦值一次；final辦法不克不及被子類重寫；final類不克不及被繼續。
1．final成員
聲明 final 字段有助於優化器作出更好的優化決議，由於假如編譯器曉得字段的值不會更改，那末它能平安地在存放器中高速緩存該值。final 字段還經由過程讓編譯器強迫該字段為只讀來供給額定的平安級別。

1.1關於final成員賦值
1）在java中，通俗變量可默許初始化。然則final類型的變量必需顯式地初始化。

2）final 成員能且只能被初始化一次。

3）final成員必需在聲明時（在final變量界說時直接給其賦值）或許在結構函數中被初始化，而不克不及在其它的處所被初始化。
示例1 Bat.java

public class Bat {
  final double PI = 3.14; // 在界說時賦值
  final int i; // 由於要在結構函數中停止初始化，所以此處便弗成再賦值
  final List<Bat> list; // 由於要在結構函數中停止初始化，所以此處便弗成再賦值
 
  Bat() {
    i = 100;
    list = new LinkedList<Bat>();
  }
 
  Bat(int ii, List<Bat> l) {
    i = ii;
    list = l;
  }
 
  public static void main(String[] args) {
    Bat b = new Bat();
    b.list.add(new Bat());
    // b.i=25;
    // b.list=new ArrayList<Bat>();
    System.out.println("I=" + b.i + " List Type:" + b.list.getClass());
    b = new Bat(23, new ArrayList<Bat>());
    b.list.add(new Bat());
    System.out.println("I=" + b.i + " List Type:" + b.list.getClass());
  }
}

成果：

I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList

在main辦法中有兩行語句正文失落了，假如你去失落正文，法式便沒法經由過程編譯，這就是說，豈論是i的值或是list的類型，一旦初始化，確切沒法再更改。但是b可以經由過程從新初始化來指定i的值或list的類型。

1.2 final援用字段的有效初始化
要准確應用final字段有點費事，關於其結構子能拋出異常的對象援用來講特別如斯。由於 final 字段在每一個結構器中必需只初始化一次，假如 final 對象援用的結構器能夠拋出異常，編譯器能夠會報錯，說該字段沒有被初始化。編譯器普通比擬智能化，足以發明在兩個互斥代碼分支（好比，if...else 塊）的每一個分支中的初始化正好只停止了一次，然則它對 try...catch 塊平日不會如斯“寬容”。
上面這段代碼平日會湧現成績。

class Thingie {
  public static Thingie getDefaultThingie() {
    return new Thingie();
  }
}
 
public class Foo {
  private final Thingie thingie;
 
  public Foo() {
    try {
      thingie = new Thingie();
    } catch (Exception e) {
      thingie = Thingie.getDefaultThingie();//Error:The final field thingie may already have been assigned
    }
  }
}

你可以如許修正。

public class Foo {
  private final Thingie thingie;
 
  public Foo() {
    Thingie tempThingie;
    try {
      tempThingie = new Thingie();
    } catch (Exception e) {
      tempThingie = Thingie.getDefaultThingie();
    }
    thingie = tempThingie;
  }
}

1.3關於final成員應用
當你在類中界說變量時，在其後面加上final症結字，那就是說，這個變量一旦被初始化便弗成轉變，這裡弗成轉變的意思對根本類型來講是其值弗成變，而關於對象變量來講其援用弗成再變。但是，對象其自己倒是可以被修正的，Java並未供給使任何對象恆定不變的門路。這一限制異樣合適數組，它也是對象。
示例2

private final int VAL_ONE=9;
private static final int VAL_TWO=99;
public static final int VAL_THREE=999;

因為VAL_ONE 和VAL_TOW 是帶有編譯期數值的final 原始類型，所以它們兩者都可以用作編譯期常量，而且沒有嚴重差別。VAL_THREE是一種加倍典范的對常量停止界說的方法：界說為 public，則可以被用於包以外；界說為 static 來強調只要一份；界說為 final 來講明它是一個常量。
final標志的變量即成為常量，但這個“常量”也只能在這個類的外部應用，不克不及在類的內部直接應用。然則當我們用public static final 配合標志常量時，這個常量就成為全局的常量（一個既是static又是final的字段只占領一段不克不及轉變的存儲空間）。並且如許界說的常量只能在界說時賦值，其他處所都不可。
示例3

class Value {
  int i;
 
  public Value(int i) {
    this.i = i;
  }
}
 
public class FinalData {
  private static Random rand = new Random();
 
  private String id;
 
  public FinalData(String id) {
    this.id = id;
  }
 
  private final int i4 = rand.nextInt(20);
 
  static final int i5 = rand.nextInt(20);
 
  public String toString() {
    return id + ":" + "i4:" + i4 + ", i5=" + i5;
  }
 
  public static void main(String[] args) {
    FinalData fd1 = new FinalData("fd1");
    System.out.println(fd1);
    System.out.println("Creating new FinalData");
    FinalData fd2 = new FinalData("fd2");
    System.out.println(fd1);
    System.out.println(fd2);
  }
}

成果

fd1:i4:6, i5=3
Creating new FinalData
fd1:i4:6, i5=3
fd2:i4:17, i5=3

示例部門展現了將final 數值界說為static（i5）和非static（i4）的差別。此差別只要在數值在運轉期內被初始化時才會浮現，這是由於編譯器對編譯期數值厚此薄彼。（而且它們能夠因優化而消逝。）當你運轉法式時，就會看到這個差別。請留意，在fd1 和fd2 中， i5 的值是弗成以經由過程創立第二個FinalData 對象而加以轉變的。這是由於它是 static，在裝載時已被初始化，而不是每次創立新對象時都初始化。
示例4

class Value {
  int i;
 
  public Value(int i) {
    this.i = i;
  }
}
 
public class … {
  private Value v1=new Value(11);
  private final Value v2=new Value(22);
  private static final Value v3=new Value(33);
  …
}
 
public static void main(String[] args) {
  …
  fd1.v2.i++;// OK--Object isn't constant!
  fd1.v1=new Value(9);//OK--not final
  fd1.v2=new Value(0);//Error:Can't change reference
  fd1.v3=new Value(1);//Error:Can't change reference
  …
}

從v1 到v3 的變量解釋了final 援用的意義。正如你在main( )中所看到的，不克不及由於v2 是final 的，就以為你沒法轉變它的值。因為它是一個援用，final 意味著你沒法將v2 再次指向另外一個新的對象。
示例5

public class … {
  private final int[] a={1,2,3,4,5,6};
  …
}
 
public static void main(String[] args) {
  …
  for(int i=0;i<fd1.a.length;i++)
 fd1.a[i]++;// OK--Object isn't constant!
  fd1.a=new int[3];//Error:Can't change reference  …
}

對數組具有異樣的意義（可以轉變它的值，但不克不及指向一個新的對象），數組是另外一種援用。

1.4處理final數組的局限性
雖然數組援用能被聲明成 final，然則該數組的元素卻不克不及。這意味著裸露 public final 數組字段的或許經由過程它們的辦法將援用前往給這些字段的類都不是弗成轉變的。

// Not immutable -- the states array could be modified by a malicious
// callerpublic
class DangerousStates {
  private final String[] states = new String[] { "Alabama", "Alaska", "ect" };
 
  public String[] getStates() {
    return states;
  }
}

異樣，雖然對象援用可以被聲明成 final 字段，而它所援用的對象仍能夠是可變的。假如想要應用 final 字段創立不變的對象，必需避免對數組或可變對象的援用“逃離”你的類。要不消反復克隆該數組做到這一點，一個簡略的辦法是將數組改變成 List。

// Immutable -- returns an unmodifiable List insteadpublic
class SafeStates {
  private final String[] states = new String[] { "Alabama", "Alaska", "ect" };
 
  private final List statesAsList = new AbstractList() {
    public Object get(int n) {
      return states[n];
    }
 
    public int size() {
      return states.length;
    }
  };
 
  public List getStates() {
    return statesAsList;
  }
}

1.5關於final參數應用
還有一種用法是界說辦法中的參數為final，關於根本類型的變量，如許做並沒有甚麼現實意義，由於根本類型的變量在挪用辦法時是傳值的，也就是說你可以在辦法中更改這個參數變量而不會影響到挪用語句，但是關於對象變量，卻顯得很適用，由於對象變量在傳遞時是傳遞其援用，如許你在辦法中對對象變量的修正也會影響到挪用語句中的對象變量，當你在辦法中不須要轉變作為參數的對象變量時，明白應用final停止聲明，會避免你有意的修正而影響到挪用辦法。

1.6關於外部類中的參數變量
別的辦法中的外部類在用到辦法中的參變量時，此參數變量必需聲明為final才可以使用。
示例6 INClass.java

public class INClass {
  void innerClass(final String str) {
    class IClass {
      IClass() {
       System.out.println(str);
      }
    }
    IClass ic = new IClass();
  }
 
  public static void main(String[] args) {
    INClass inc = new INClass();
    inc.innerClass("Hello");
  }
}

2．final辦法
2.1final辦法用處
1）為了確保某個函數的行動在繼續進程中堅持不變，而且不克不及被籠罩（overridding），可使用final辦法。

2）class中一切的private和static辦法天然就是final。

2.2 final與private症結字
類中一切的private辦法都隱式地指定是final的。因為沒法取用private辦法，所以也就沒法籠罩它。
“籠罩”只要在某辦法是基類的接口的一部門時才會湧現。即，必需能將一個對象向上轉型為它的根本類型並挪用雷同的辦法。假如某辦法為private，它就不是基類的接口的一部門。它僅是一些隱蔽於類中的代碼，只不外是具有雷同的稱號罷了。但假如在導出類以雷同的辦法生成一個public、protected或包拜訪權限辦法的話，該辦法就不會發生在基類中湧現的“僅具有雷同稱號”的情形。此時，你並沒有籠罩該辦法，僅是生成了一個新的辦法。因為private辦法沒法觸及並且能有用隱蔽，所以除把它算作是由於它所歸屬的類的組織構造的緣由而存在外，其他任何事物都不須要斟酌它。
3．final類
將某個類的全體界說為final 時，該類沒法被繼續。並且因為final類制止繼續，所以final類中一切的辦法都隱式指定為final的，由於沒法籠罩它們。
final 用於類或辦法是為了避免辦法間的鏈接被損壞。例如，假定類 X 的某個辦法的完成假定了辦法 M 將以某種方法任務。將 X 或 M 聲明成 final 將避免派生類以這類方法從新界說 M，從而招致 X 的任務不正常。雖然不消這些外部相干性來完成 X 能夠會更好，但這不老是可行的，並且應用 final 可以避免往後這類不兼容的更改。

PS：final,finally和finallize的差別