c#中使用NetCDF存储二维数据的读写操作简单应用-阿里云开发者社区

  1 public static class NetCDF
  2     {
  3         [DllImport("netcdf4.dll")]
  4         public static extern int nc_put_att_uchar(int ncid, int varid, string name, NcType xtype, int len, byte[] op);
  5         [DllImport("netcdf4.dll")]
  6         public static extern int nc_get_att_uchar(int ncid, int varid, string name, byte[] op);
  7
  8         [DllImport("netcdf4.dll")]
  9         public static extern int nc_get_var_uchar(int ncid, int varid, byte[] ip);
10         [DllImport("netcdf4.dll")]
11         public static extern int nc_get_var_text(int ncid, int varid, StringBuilder ip);
12
13
14         [DllImport("netcdf4.dll")]
15         public static extern int nc_open(string path, CreateMode mode, out int ncidp);
16         [DllImport("netcdf4.dll")]
17         public static extern int nc_create(string path, CreateMode mode, out int ncidp);
18         [DllImport("netcdf4.dll")]
19         public static extern int nc_close(int ncidp);
20         [DllImport("netcdf4.dll")]
21         public static extern int nc_sync(int ncid);
22         [DllImport("netcdf4.dll")]
23         public static extern int nc_enddef(int ncid);
24         [DllImport("netcdf4.dll")]
25         public static extern int nc_redef(int ncid);
26         [DllImport("netcdf4.dll")]
27         public static extern string nc_strerror(int ncerror);
28
29         [DllImport("netcdf4.dll")]
30         public static extern int nc_inq(int ncid, out int ndims, out int nvars, out int ngatts, out int unlimdimid);
31
32         [DllImport("netcdf4.dll")]
33         public static extern int nc_def_var(int ncid, string name, NcType xtype, int ndims, int[] dimids, out int varidp);
34         [DllImport("netcdf4.dll")]
35         public static extern int nc_inq_var(int ncid, int varid, StringBuilder name, out NcType type, out int ndims, int[] dimids, out int natts);
36         [DllImport("netcdf4.dll")]
37         public static extern int nc_inq_varids(int ncid, out int nvars, int[] varids);
38         [DllImport("netcdf4.dll")]
39         public static extern int nc_inq_vartype(int ncid, int varid, out NcType xtypep);
40         [DllImport("netcdf4.dll")]
41         public static extern int nc_inq_varnatts(int ncid, int varid, out int nattsp);
42         [DllImport("netcdf4.dll")]
43         public static extern int nc_inq_varid(int ncid, string name, out int varidp);
44
45         [DllImport("netcdf4.dll")]
46         public static extern int nc_inq_ndims(int ncid, out int ndims);
47         [DllImport("netcdf4.dll")]
48         public static extern int nc_inq_nvars(int ncid, out int nvars);
49         [DllImport("netcdf4.dll")]
50         public static extern int nc_inq_varname(int ncid, int varid, StringBuilder name);
51         [DllImport("netcdf4.dll")]
52         public static extern int nc_inq_varndims(int ncid, int varid, out int ndims);
53         [DllImport("netcdf4.dll")]
54         public static extern int nc_inq_vardimid(int ncid, int varid, int[] dimids);
55         [DllImport("netcdf4.dll")]
56         public static extern int nc_inq_var_fill(int ncid, int varid, out int no_fill, out object fill_value);
57
58
59         [DllImport("netcdf4.dll")]
60         public static extern int nc_inq_natts(int ncid, out int ngatts);
61         [DllImport("netcdf4.dll")]
62         public static extern int nc_inq_unlimdim(int ncid, out int unlimdimid);
63         [DllImport("netcdf4.dll")]
64         public static extern int nc_inq_format(int ncid, out int format);
65
66         [DllImport("netcdf4.dll")]
67         public static extern int nc_inq_attname(int ncid, int varid, int attnum, StringBuilder name);
68         [DllImport("netcdf4.dll")]
69         public static extern int nc_inq_att(int ncid, int varid, string name, out NcType type, out int length);
70         [DllImport("netcdf4.dll")]
71         public static extern int nc_get_att_text(int ncid, int varid, string name, StringBuilder value);
72         [DllImport("netcdf4.dll")]
73         public static extern int nc_get_att_schar(int ncid, int varid, string name, sbyte[] data);
74         [DllImport("netcdf4.dll")]
75         public static extern int nc_get_att_short(int ncid, int varid, string name, short[] data);
76         [DllImport("netcdf4.dll")]
77         public static extern int nc_get_att_int(int ncid, int varid, string name, int[] data);
78         [DllImport("netcdf4.dll")]
79         public static extern int nc_get_att_float(int ncid, int varid, string name, float[] data);
80         [DllImport("netcdf4.dll")]
81         public static extern int nc_get_att_double(int ncid, int varid, string name, double[] data);
82         [DllImport("netcdf4.dll")]
83         public static extern int nc_get_att_long(int ncid, int varid, string name, long[] data);
84         [DllImport("netcdf4.dll")]
85         public static extern int nc_get_att_longlong(int ncid, int varid, string name, long[] data);
86
87         [DllImport("netcdf4.dll")]
88         public static extern int nc_put_att_text(int ncid, int varid, string name, int len, string tp);
89         [DllImport("netcdf4.dll")]
90         public static extern int nc_put_att_double(int ncid, int varid, string name, NcType type, int len, double[] tp);
91         [DllImport("netcdf4.dll")]
92         public static extern int nc_put_att_int(int ncid, int varid, string name, NcType type, int len, int[] tp);
93         [DllImport("netcdf4.dll")]
94         public static extern int nc_put_att_short(int ncid, int varid, string name, NcType type, int len, short[] tp);
95         [DllImport("netcdf4.dll")]
96         public static extern int nc_put_att_float(int ncid, int varid, string name, NcType type, int len, float[] tp);
97         [DllImport("netcdf4.dll")]
98         public static extern int nc_put_att_byte(int ncid, int varid, string name, NcType type, int len, sbyte[] tp);
99         [DllImport("netcdf4.dll")]
100         public static extern int nc_put_att_long(int ncid, int varid, string name, NcType type, int len, long[] tp);
101         [DllImport("netcdf4.dll")]
102         public static extern int nc_put_att_longlong(int ncid, int varid, string name, NcType type, int len, long[] tp);
103
104         [DllImport("netcdf4.dll")]
105         public static extern int nc_def_dim(int ncid, string name, int len, out int dimidp);
106         [DllImport("netcdf4.dll")]
107         public static extern int nc_inq_dim(int ncid, int dimid, StringBuilder name, out int length);
108         [DllImport("netcdf4.dll")]
109         public static extern int nc_inq_dimname(int ncid, int dimid, StringBuilder name);
110         [DllImport("netcdf4.dll")]
111         public static extern int nc_inq_dimid(int ncid, string name, out int dimid);
112         [DllImport("netcdf4.dll")]
113         public static extern int nc_inq_dimlen(int ncid, int dimid, out int length);
114
115
116         [DllImport("netcdf4.dll")]
117         public static extern int nc_get_var_text(int ncid, int varid, byte[] data);
118         [DllImport("netcdf4.dll")]
119         public static extern int nc_get_var_schar(int ncid, int varid, sbyte[] data);
120         [DllImport("netcdf4.dll")]
121         public static extern int nc_get_var_short(int ncid, int varid, short[] data);
122         [DllImport("netcdf4.dll")]
123         public static extern int nc_get_var_int(int ncid, int varid, int[] data);
124         [DllImport("netcdf4.dll")]
125         public static extern int nc_get_var_long(int ncid, int varid, long[] data);
126         [DllImport("netcdf4.dll")]
127         public static extern int nc_get_var_float(int ncid, int varid, float[,] data);
128         [DllImport("netcdf4.dll")]
129         public static extern int nc_get_var_double(int ncid, int varid, double[] data);
130
131         [DllImport("netcdf4.dll")]
132         public static extern int nc_put_var_ubyte(int ncid, int varid, byte[,] data);
133         [DllImport("netcdf4.dll")]
134         public static extern int nc_put_var_int(int ncid, int varid, int[,] data);
135         [DllImport("netcdf4.dll")]
136         public static extern int nc_put_var_text(int ncid, int varid, string op);
137         [DllImport("netcdf4.dll")]
138         public static extern int nc_put_var_uchar(int ncid, int varid, out byte[] op);
139         [DllImport("netcdf4.dll")]
140         public static extern int nc_put_var_float(int ncid, int varid, float[,] data);
141         [DllImport("netcdf4.dll")]
142         public static extern int nc_put_var_long(int ncid, int varid, long[] data);
143
144
145         [DllImport("netcdf4.dll")]
146         public static extern int nc_put_vara_double(int ncid, int varid, int[] start, int[] count, double[] dp);
147         [DllImport("netcdf4.dll")]
148         public static extern int nc_put_vara_float(int ncid, int varid, int[] start, int[] count, float[] fp);
149         [DllImport("netcdf4.dll")]
150         public static extern int nc_put_vara_short(int ncid, int varid, int[] start, int[] count, short[] sp);
151         [DllImport("netcdf4.dll")]
152         public static extern int nc_put_vara_int(int ncid, int varid, int[] start, int[] count, int[] ip);
153         [DllImport("netcdf4.dll")]
154         public static extern int nc_put_vara_long(int ncid, int varid, int[] start, int[] count, long[] lp);
155         [DllImport("netcdf4.dll")]
156         public static extern int nc_put_vara_ubyte(int ncid, int varid, int[] start, int[] count, byte[] bp);
157         [DllImport("netcdf4.dll")]
158         public static extern int nc_put_vara_schar(int ncid, int varid, int[] start, int[] count, sbyte[] cp);
159         [DllImport("netcdf4.dll")]
160         public static extern int nc_put_vara_string(int ncid, int varid, int[] start, int[] count, string[] sp);
161
162
163         [DllImport("netcdf4.dll")]
164         public static extern int nc_get_vara_text(int ncid, int varid, int[] start, int[] count, byte[] data);
165         [DllImport("netcdf4.dll")]
166         public static extern int nc_get_vara_schar(int ncid, int varid, int[] start, int[] count, sbyte[] data);
167         [DllImport("netcdf4.dll")]
168         public static extern int nc_get_vara_short(int ncid, int varid, int[] start, int[] count, short[] data);
169         [DllImport("netcdf4.dll")]
170         public static extern int nc_get_vara_ubyte(int ncid, int varid, int[] start, int[] count, byte[] data);
171         [DllImport("netcdf4.dll")]
172         public static extern int nc_get_vara_long(int ncid, int varid, int[] start, int[] count, long[] data);
173         [DllImport("netcdf4.dll")]
174         public static extern int nc_get_vara_int(int ncid, int varid, int[] start, int[] count, int[] data);
175         [DllImport("netcdf4.dll")]
176         public static extern int nc_get_vara_float(int ncid, int varid, int[] start, int[] count, float[] data);
177         [DllImport("netcdf4.dll")]
178         public static extern int nc_get_vara_double(int ncid, int varid, int[] start, int[] count, double[] data);
179         [DllImport("netcdf4.dll")]
180         public static extern int nc_get_vara_string(int ncid, int varid, int[] start, int[] count, string[] data);
181
182         ///<summary>
183         ///'size' argument to ncdimdef for an unlimited dimension
184         ///</summary>
185         public const int NC_UNLIMITED = 0;
186
187         ///<summary>
188         ///attribute id to put/get a global attribute
189         ///</summary>
190         public const int NC_GLOBAL = -1;
191
192         ///<summary>
193         ///The netcdf external data types
194         ///</summary>
195         public enum NcType : int
196         {
197             ///<summary>signed 1 byte intege</summary>
198             NC_BYTE = 1,
199             ///<summary>ISO/ASCII character</summary>
200             NC_CHAR = 2,
201             ///<summary>signed 2 byte integer</summary>
202             NC_SHORT = 3,
203             ///<summary>signed 4 byte integer</summary>
204             NC_INT = 4,
205             ///<summary>single precision floating point number</summary>
206             NC_FLOAT = 5,
207             ///<summary>double precision floating point number</summary>
208             NC_DOUBLE = 6,
209             ///<summary>signed 8-byte int</summary>
210             NC_INT64 = 10,
211             ///<summary>string</summary>
212             NC_STRING = 12
213         }
214
215         public static Type GetCLRType(NcType ncType)
216         {
217             switch (ncType)
218             {
219                 case NcType.NC_BYTE:
220                 return typeof(byte);
221                 case NcType.NC_CHAR:
222                 return typeof(sbyte);
223                 case NcType.NC_SHORT:
224                 return typeof(short);
225                 case NcType.NC_INT:
226                 return typeof(int);
227                 case NcType.NC_INT64:
228                 return typeof(long);
229                 case NcType.NC_FLOAT:
230                 return typeof(float);
231                 case NcType.NC_DOUBLE:
232                 return typeof(double);
233                 case NcType.NC_STRING:
234                 return typeof(string);
235                 default:
236                 throw new ApplicationException("Unknown nc type");
237             }
238         }
239
240         public static NcType GetNcType(Type type)
241         {
242             switch (Type.GetTypeCode(type))
243             {
244                 case TypeCode.Double:
245                 return NcType.NC_DOUBLE;
246
247                 case TypeCode.Single:
248                 return NcType.NC_FLOAT;
249
250                 case TypeCode.Int64:
251                 return NcType.NC_INT64;
252
253                 case TypeCode.Int32:
254                 return NcType.NC_INT;
255
256                 case TypeCode.Int16:
257                 return NcType.NC_SHORT;
258
259                 case TypeCode.Byte:
260                 return NcType.NC_BYTE;
261
262                 case TypeCode.SByte:
263                 return NcType.NC_CHAR;
264
265                 case TypeCode.String:
266                 return NcType.NC_STRING;
267
268                 case TypeCode.DateTime:
269                 return NcType.NC_INT64;
270
271
272                 default:
273                 throw new NotSupportedException("Not supported type of data.");
274             }
275         }
276
277         public enum CreateMode : int
278         {
279             NC_NOWRITE = 0,
280             ///<summary>read & write</summary>
281             NC_WRITE = 0x0001,
282             NC_CLOBBER = 0,
283             ///<summary>Don't destroy existing file on create</summary>
284             NC_NOCLOBBER = 0x0004,
285             ///<summary>argument to ncsetfill to clear NC_NOFILL</summary>
286             NC_FILL = 0,
287             ///<summary>Don't fill data section an records</summary>
288             NC_NOFILL = 0x0100,
289             ///<summary>Use locking if available</summary>
290             NC_LOCK = 0x0400,
291             ///<summary>Share updates, limit cacheing</summary>
292             NC_SHARE = 0x0800,
293             NC_64BIT_OFFSET = 0x0200,
294             ///<summary>Enforce strict netcdf-3 rules</summary>
295             NC_CLASSIC = 0x0100,
296             ///<summary>causes netCDF to create a HDF5/NetCDF-4 file</summary>
297             NC_NETCDF4 = 0x1000
298         }
299
300         public enum ResultCode : int
301         {
302             ///<summary>No Error</summary>
303             NC_NOERR = 0,
304             ///<summary>Invalid dimension id or name</summary>
305             NC_EBADDIM = -46,
306             ///<summary>Attribute not found</summary>
307             NC_ENOTATT = -43,
308         }
309
310         ///<summary>
311         ///    Default fill values, used unless _FillValue attribute is set.
312         ///These values are stuffed into newly allocated space as appropriate.
313         ///The hope is that one might use these to notice that a particular datum
314         ///has not been set.
315         ///</summary>
316         public static class FillValues
317         {
318             public const byte NC_FILL_BYTE = 255;
319             public const char NC_FILL_CHAR = (char)0;
320             public const short NC_FILL_SHORT = -32767;
321             public const int NC_FILL_INT = -2147483647;
322             public const float NC_FILL_FLOAT = 9.96921E+36f;    /* near 15 * 2^119 */
323             public const double NC_FILL_DOUBLE = 9.969209968386869E+36;
324         }
325
326
327         ///<summary>These maximums are enforced by the interface, to facilitate writing
328         ///applications and utilities.  However, nothing is statically allocated to
329         ///these sizes internally.</summary>
330         public enum Limits
331         {
332             ///<summary>max dimensions per file </summary>
333             NC_MAX_DIMS = 10,
334             ///<summary>max global or per variable attributes </summary>
335             NC_MAX_ATTRS = 2000,
336             ///<summary>max variables per file</summary>
337             NC_MAX_VARS = 2000,
338             ///<summary>max length of a name </summary>
339             NC_MAX_NAME = 128,
340             ///<summary>max per variable dimensions </summary>
341             NC_MAX_VAR_DIMS = 10
342         }
343     }

  1 /// <summary>
  2     /// 二维网格数据文件创建、读、写
  3     /// </summary>
  4     class TwoDimDB : IDataBase
  5     {
  6         public TwoDimDB(string filename)
  7         {
  8             dbfile = filename;
  9         }
 10 
 11         public override bool Create(string[] varname, string xdimname, string ydimname, long[] xdim, long[] ydim)
 12         {
 13             try
 14             {
 15                 int ndims = 2;
 16                 int ncid, res, varid;
 17                 int x_dimid, y_dimid;
 18                 int[] dimids = new int[ndims];
 19 
 20                 //创建文件
 21                 res = NetCDF.nc_create(dbfile, NetCDF.CreateMode.NC_NETCDF4, out ncid);
 22                 if (res != 0) return false;
 23 
 24                 int NX = xdim.Length;
 25                 int NY = ydim.Length;
 26                 int[,] datas = new int[NX, NY];
 27 
 28                 //定义维度
 29                 res = NetCDF.nc_def_dim(ncid, xdimname, NX, out x_dimid);
 30                 if (res != 0) return false;
 31                 res = NetCDF.nc_def_dim(ncid, ydimname, NY, out y_dimid);
 32                 if (res != 0) return false;
 33 
 34                 res = NetCDF.nc_put_att_longlong(ncid, NetCDF.NC_GLOBAL, xdimname, NetCDF.NcType.NC_INT64, xdim.Length, xdim);
 35                 if (res != 0) return false;
 36                 res = NetCDF.nc_put_att_longlong(ncid, NetCDF.NC_GLOBAL, ydimname, NetCDF.NcType.NC_INT64, ydim.Length, ydim);
 37                 if (res != 0) return false;
 38 
 39                 dimids[0] = x_dimid;
 40                 dimids[1] = y_dimid;
 41 
 42                 //定义变量
 43                 if (varname != null)
 44                 {
 45                     foreach (var vn in varname)
 46                     {
 47                         res = NetCDF.nc_def_var(ncid, vn, NetCDF.NcType.NC_FLOAT, 2, dimids, out varid);
 48                         if (res != 0) continue;
 49 
 50                         res = NetCDF.nc_enddef(ncid);
 51                         if (res != 0) continue;
 52 
 53                         NetCDF.nc_put_var_int(ncid, varid, datas);
 54                         if (res != 0) continue;
 55                     }
 56                 }
 57 
 58                 //关闭文件
 59                 res = NetCDF.nc_close(ncid);
 60                 if (res == 0) return true;
 61             }
 62             catch (Exception ex)
 63             {
 64 
 65             }
 66             return false;
 67         }
 68 
 69         public override bool Write(string[] varName, string dimName, long dimValue, int[][] value, bool isXdim = false)
 70         {
 71             try
 72             {
 73                 int ncid, res, varid;
 74 
 75                 //创建文件
 76                 res = NetCDF.nc_open(dbfile, NetCDF.CreateMode.NC_WRITE, out ncid);
 77                 if (res != 0) return false;
 78 
 79                 #region GetDimIndex
 80 
 81                 int dimIdx = 0;
 82                 NetCDF.NcType dimXTtype;
 83                 int dimAttLen = 0;
 84 
 85                 res = NetCDF.nc_inq_att(ncid, NetCDF.NC_GLOBAL, dimName, out dimXTtype, out dimAttLen);
 86                 if (res != 0) return false;
 87                 long[] xdimValue = new long[dimAttLen];
 88                 res = NetCDF.nc_get_att_longlong(ncid, NetCDF.NC_GLOBAL, dimName, xdimValue);
 89                 dimIdx = Array.IndexOf(xdimValue, dimValue);
 90                 if (dimIdx == -1) dimIdx = 0;
 91 
 92                 #endregion
 93 
 94                 int xdimBeginIndex = isXdim ? dimIdx : 0;
 95                 int ydimBeginIndex = !isXdim ? dimIdx : 0;
 96 
 97                 int xdimNumber = !isXdim ? value.Length : 1;
 98                 int ydimNumber = isXdim ? value.Length : 1;
 99 
100                 //定义变量    
101                 if (varName != null)
102                 {
103                     for (int i = 0; i < varName.Length; i++)
104                     {
105                         res = NetCDF.nc_inq_varid(ncid, varName[i], out varid);
106                         if (res != 0) continue;
107 
108                         var origin = new int[] { xdimBeginIndex, ydimBeginIndex };//第一维的1开始,第二维从0开始
109                         var size = new int[] { xdimNumber, ydimNumber };//数量分别为1,2
110 
111                         NetCDF.nc_put_vara_int(ncid, varid, origin, size, value[i]);
112                         if (res != 0) return false;
113                     }
114                 }
115 
116                 //关闭文件
117                 res = NetCDF.nc_close(ncid);
118                 if (res == 0) return true;
119             }
120             catch (Exception ex)
121             {
122 
123             }
124             return false;
125         }
126 
127         public override int[][] Read(string[] varname, string xdimname, string ydimname, long? xdimValue = null, long? ydimValue = null)
128         {
129             long[] xDimValue;
130             long[] yDimValue;
131             Dictionary<long, int[][]> dic = new Dictionary<long, int[][]>();
132             try
133             {
134                 int ndims = 2;
135                 int ncid, res, varid;
136                 int[] dimids = new int[ndims];
137 
138                 //打开文件
139                 res = NetCDF.nc_open(dbfile, NetCDF.CreateMode.NC_NOWRITE, out ncid);
140                 if (res != 0) return null;
141 
142                 #region XDimIndex
143 
144                 int xDimIdx = 0;
145                 NetCDF.NcType xDimxtype;
146                 int xDimAttlen = 0;
147 
148                 res = NetCDF.nc_inq_att(ncid, NetCDF.NC_GLOBAL, xdimname, out xDimxtype, out xDimAttlen);
149                 if (res != 0) return null;
150                 xDimValue = new long[xDimAttlen];
151 
152                 res = NetCDF.nc_get_att_longlong(ncid, NetCDF.NC_GLOBAL, xdimname, xDimValue);
153                 if (xdimValue != null)
154                 {
155                     xDimIdx = Array.IndexOf(xDimValue, xdimValue);
156                     if (xDimIdx == -1) xDimIdx = 0;
157                 }
158                 #endregion
159 
160                 #region YDimIndex
161 
162                 int yDimIdx = 0;
163                 NetCDF.NcType yDimxtype;
164                 int yDimAttlen = 0;
165 
166                 res = NetCDF.nc_inq_att(ncid, NetCDF.NC_GLOBAL, ydimname, out yDimxtype, out yDimAttlen);
167                 if (res != 0) return null;
168                 yDimValue = new long[yDimAttlen];
169                 res = NetCDF.nc_get_att_longlong(ncid, NetCDF.NC_GLOBAL, ydimname, yDimValue);
170                 if (ydimValue != null)
171                 {
172                     yDimIdx = Array.IndexOf(yDimValue, ydimValue);
173                     if (yDimIdx == -1) yDimIdx = 0;
174                 }
175 
176                 #endregion
177 
178                 int NX = xDimValue.Length;
179                 int NY = yDimValue.Length;
180 
181                 int xdimCount = NX - xDimIdx;
182                 int ydimCount = NY - yDimIdx;
183                 int resCount = xdimCount * ydimCount;
184                 if (xdimValue == null)
185                 {
186                     resCount = xdimCount;
187                     xdimCount = NX;
188                     ydimCount = 1;
189                 }
190                 if (ydimValue == null)
191                 {
192                     resCount = ydimCount;
193                     xdimCount = 1;
194                     ydimCount = NY - yDimIdx;
195                 }
196 
197                 int[] origin = new int[] { xDimIdx, yDimIdx };//第一维的1开始,第二维从0开始
198                 int[] size = new int[] { xdimCount, ydimCount };//数量分别为1,2
199 
200                 int[][] result = new int[varname.Length + 1][];
201                
202                 for (int i = 0; i < varname.Length; i++)
203                 {
204                     res = NetCDF.nc_inq_varid(ncid, varname[i], out varid);
205                     if (res != 0) continue;
206 
207                     result[i+1] = new int[resCount];
208                     NetCDF.nc_get_vara_int(ncid, varid, origin, size, result[i + 1]);
209                     if (res != 0) continue;
210                 }
211                 
212 
213                 res = NetCDF.nc_close(ncid);
214                 if (res == 0) return result;
215             }
216             catch (Exception ex)
217             {
218 
219             }
220             finally
221             {
222                 xDimValue = null;
223                 yDimValue = null;
224                 GC.Collect();
225             }
226             return null;
227         }
228     }


本文转自94cool博客园博客，原文链接：http://www.cnblogs.com/94cool/p/3171101.html，如需转载请自行联系原作者