zoukankan      html  css  js  c++  java

  • iOS应用本地缓存

    转自http://mobile.51cto.com/iphone-314382.htm

    在手机应用程序开发中，为了减少与服务端的交互次数，加快用户的响应速度，一般都会在iOS设备中加一个缓存的机制.

    功能需求

    这个缓存机制满足下面这些功能。

    1、可以将数据缓存到本地磁盘。

    2、可以判断一个资源是否已经被缓存。如果已经被缓存，在请求相同的资源，先到本地磁盘搜索。

    3、可以判断文件缓存什么时候过期。这里为了简单起见这里，我们在请求url资源的时候，给每次请求的文件设定一个过期的时间。

    4、可以实现：如果文件已经被缓存，而且没有过期，这将本地的数据返回，否则重新请求url。

    5、可以实现：如果文件下载不成功或者下载没有完成，下次打开程序的时候，移除这些没有成功或者没有下载完成的文件。

    6、可以实现：同时请求或者下载多个资源。

    设计实现：

    1、设计一个CacheItem类，用来请求一个web连接，它的一个实例表示一个缓存项。这个CacheItem类，需要一个url创建一个NSURLConnection，去请求web资源。使用CacheItem类主要用来请求web资源。

    1. /* ---------缓存项-------------- */   
    2.  
    3. @interface CacheItem : NSObject {   
    4. @public   
    5.   id<CacheItemDelegate> delegate;   
    6.     //web地址   
    7.   NSString              *remoteURL;   
    8. @private   
    9.     //是否正在下载   
    10.   BOOL                  isDownloading;   
    11.        //NSMutableData对象   
    12.   NSMutableData         *connectionData;   
    13.    //NSURLConnection对象   
    14.   NSURLConnection       *connection;   
    15. }   
    16.  
    17. /* -------------------------- */   
    18.  
    19. @property (nonatomic, retain) id<CacheItemDelegate> delegate;   
    20. @property (nonatomic, retain) NSString  *remoteURL;   
    21. @property (nonatomic, assign) BOOL      isDownloading;   
    22. @property (nonatomic, retain) NSMutableData *connectionData;   
    23. @property (nonatomic, retain) NSURLConnection *connection;   
    24.  
    25. /* ----------开始下载方法----------- */   
    26.  
    27. - (BOOL) startDownloadingURL:(NSString *)paramRemoteURL;   
    28.  
    29. @end   

    2、在NSURLConnection开始请求之前，调用CachedDownloadManager类，来搜索和管理本地的缓存文件。将缓存文件的情况保存到一个字典类中。这个字典设计如下：

    1. {   
    2.  
    3.   "http://www.cnn.com" =     {   
    4.  
    5.     DownloadEndDate = "2011-08-02 07:51:57 +0100";   
    6.  
    7.     DownloadStartDate = "2011-08-02 07:51:55 +0100";   
    8.  
    9.     ExpiresInSeconds = 20;   
    10.  
    11.     ExpiryDate = "2011-08-02 07:52:17 +0100";   
    12.  
    13.     LocalURL = "/var/mobile/Applications/ApplicationID/Documents/   
    14.  
    15.                 httpwww.cnn.com.cache";   
    16.  
    17.   };   
    18.  
    19.   "http://www.baidu.com" =     {   
    20.  
    21.     DownloadEndDate = "2011-08-02 07:51:49 +0100";   
    22.  
    23.     DownloadStartDate = "2011-08-02 07:51:44 +0100";   
    24.  
    25.     ExpiresInSeconds = 20;   
    26.  
    27.     ExpiryDate = "2011-08-02 07:52:09 +0100";   
    28.  
    29.     LocalURL = "/var/mobile/Applications/ApplicationID/Documents/   
    30.  
    31.                 httpwww.oreilly.com.cache";   
    32.  
    33.   };   
    34.  
    35. }   

    上面这个字典里面嵌套了字典。里面那层字典表示一个缓存项的缓存信息：下载结束时间、下载开始时间、缓存有效时间、缓存过期时间、缓存到本地的路径。

    下面看下CachedDownloadManager类。用它来实现和封装我们的缓存策略。

    1. /* -----------CachedDownloadManager-------------- */ 
    2.  
    3. @interface CachedDownloadManager : NSObject 
    4.  
    5. { 
    6.  
    7. @public 
    8.  
    9. id delegate; 
    10.  
    11. @private 
    12.  
    13. //记录缓存数据的字典 
    14.  
    15. NSMutableDictionary *cacheDictionary; 
    16.  
    17. //缓存的路径 
    18.  
    19. NSString *cacheDictionaryPath; 
    20.  
    21. } 
    22.  
    23. @property (nonatomic, assign) 
    24.  
    25. id delegate; 
    26.  
    27. @property (nonatomic, copy) 
    28.  
    29. NSMutableDictionary *cacheDictionary; 
    30.  
    31. @property (nonatomic, retain) 
    32.  
    33. NSString *cacheDictionaryPath; 
    34.  
    35. /* 保持缓存字典 */ 
    36.  
    37. - (BOOL) saveCacheDictionary; 
    38.  
    39. /* 公有方法：下载 */ 
    40.  
    41. - (BOOL) download:(NSString *)paramURLAsString 
    42.  
    43. urlMustExpireInSeconds:(NSTimeInterval)paramURLMustExpireInSeconds 
    44.  
    45. updateExpiryDateIfInCache:(BOOL)paramUpdateExpiryDateIfInCache; 
    46.  
    47. /* -------------------------- */ 
    48.  
    49. @end 
    50.  

    从上面代码可以看出，这个管理缓存的类中，有一个缓存字典：cacheDictionary，用来表示所有资源的缓存情况;cacheDictionaryPath用来表示缓存的路径;saveCacheDictionary用来将缓存字典归档到本地文件中。download：urlMustExpireInSeconds：updateExpiryDateIfInCache是一个公共接口，通过传递url、缓存过期时间、是否更新缓存过期时间三个参数来方便的使用，实现我们的缓存策略。

    3、如果这个文件已经被下载，而且没有过期，则从本地获取文件的数据。如果文件已经过期，则重新下载。我们通过download：urlMustExpireInSeconds：updateExpiryDateIfInCache方法来实现，主要看这个方法的代码：

    1. /* ---------下载-------------- */ 
    2.  
    3. - (BOOL) download:(NSString *)paramURLAsString 
    4.  
    5. urlMustExpireInSeconds:(NSTimeInterval)paramURLMustExpireInSeconds 
    6.  
    7. updateExpiryDateIfInCache:(BOOL)paramUpdateExpiryDateIfInCache{ 
    8.  
    9. BOOL result = NO; 
    10.  
    11. if (self.cacheDictionary == nil || 
    12.  
    13. [paramURLAsString length] == 0){ 
    14.  
    15. return(NO); 
    16.  
    17. } 
    18.  
    19. paramURLAsString = [paramURLAsString lowercaseString]; 
    20.  
    21. //根据url，从字典中获取缓存项的相关数据 
    22.  
    23. NSMutableDictionary *itemDictionary = 
    24.  
    25. [self.cacheDictionary objectForKey:paramURLAsString]; 
    26.  
    27. /* 使用下面这些变量帮助我们理解缓存逻辑 */ 
    28.  
    29. //文件是否已经被缓存 
    30.  
    31. BOOL fileHasBeenCached = NO; 
    32.  
    33. //缓存是否过期 
    34.  
    35. BOOL cachedFileHasExpired = NO; 
    36.  
    37. //缓存文件是否存在 
    38.  
    39. BOOL cachedFileExists = NO; 
    40.  
    41. //缓存文件能否被加载 
    42.  
    43. BOOL cachedFileDataCanBeLoaded = NO; 
    44.  
    45. //缓存文件数据 
    46.  
    47. NSData *cachedFileData = nil; 
    48.  
    49. //缓存文件是否完全下载 
    50.  
    51. BOOL cachedFileIsFullyDownloaded = NO; 
    52.  
    53. //缓存文件是否已经下载 
    54.  
    55. BOOL cachedFileIsBeingDownloaded = NO; 
    56.  
    57. //过期时间 
    58.  
    59. NSDate *expiryDate = nil; 
    60.  
    61. //下载结束时间 
    62.  
    63. NSDate *downloadEndDate = nil; 
    64.  
    65. //下载开始时间 
    66.  
    67. NSDate *downloadStartDate = nil; 
    68.  
    69. //本地缓存路径 
    70.  
    71. NSString *localURL = nil; 
    72.  
    73. //有效时间 
    74.  
    75. NSNumber *expiresInSeconds = nil; 
    76.  
    77. NSDate *now = [NSDate date]; 
    78.  
    79. if (itemDictionary != nil){ 
    80.  
    81. fileHasBeenCached = YES; 
    82.  
    83. } 
    84.  
    85. //如果文件已经被缓存，则从缓存项相关数据中获取相关的值 
    86.  
    87. if (fileHasBeenCached == YES){ 
    88.  
    89. expiryDate = [itemDictionary 
    90.  
    91. objectForKey:CachedKeyExpiryDate]; 
    92.  
    93. downloadEndDate = [itemDictionary 
    94.  
    95. objectForKey:CachedKeyDownloadEndDate]; 
    96.  
    97. downloadStartDate = [itemDictionary 
    98.  
    99. objectForKey:CachedKeyDownloadStartDate]; 
    100.  
    101. localURL = [itemDictionary 
    102.  
    103. objectForKey:CachedKeyLocalURL]; 
    104.  
    105. expiresInSeconds = [itemDictionary 
    106.  
    107. objectForKey:CachedKeyExpiresInSeconds]; 
    108.  
    109. //如果下载开始和结束时间不为空，表示文件全部被下载 
    110.  
    111. if (downloadEndDate != nil && 
    112.  
    113. downloadStartDate != nil){ 
    114.  
    115. cachedFileIsFullyDownloaded = YES; 
    116.  
    117. } 
    118.  
    119. /* 如果expiresInSeconds不为空，downloadEndDate为空，表示文件已经正在下载 */ 
    120.  
    121. if (expiresInSeconds != nil && 
    122.  
    123. downloadEndDate == nil){ 
    124.  
    125. cachedFileIsBeingDownloaded = YES; 
    126.  
    127. } 
    128.  
    129. /* 判断缓存是否过期 */ 
    130.  
    131. if (expiryDate != nil && 
    132.  
    133. [now timeIntervalSinceDate:expiryDate] > 0.0){ 
    134.  
    135. cachedFileHasExpired = YES; 
    136.  
    137. } 
    138.  
    139. if (cachedFileHasExpired == NO){ 
    140.  
    141. /* 如果缓存文件没有过期，加载缓存文件，并且更新过期时间 */ 
    142.  
    143. NSFileManager *fileManager = [[NSFileManager alloc] init]; 
    144.  
    145. if ([fileManager fileExistsAtPath:localURL] == YES){ 
    146.  
    147. cachedFileExists = YES; 
    148.  
    149. cachedFileData = [NSData dataWithContentsOfFile:localURL]; 
    150.  
    151. if (cachedFileData != nil){ 
    152.  
    153. cachedFileDataCanBeLoaded = YES; 
    154.  
    155. } /* if (cachedFileData != nil){ */ 
    156.  
    157. } /* if ([fileManager fileExistsAtPath:localURL] == YES){ */ 
    158.  
    159. [fileManager release]; 
    160.  
    161. /* 更新缓存时间 */ 
    162.  
    163. if (paramUpdateExpiryDateIfInCache == YES){ 
    164.  
    165. NSDate *newExpiryDate = 
    166.  
    167. [NSDate dateWithTimeIntervalSinceNow: 
    168.  
    169. paramURLMustExpireInSeconds]; 
    170.  
    171. NSLog(@"Updating the expiry date from %@ to %@.", 
    172.  
    173. expiryDate, 
    174.  
    175. newExpiryDate); 
    176.  
    177. [itemDictionary setObject:newExpiryDate 
    178.  
    179. forKey:CachedKeyExpiryDate]; 
    180.  
    181. NSNumber *expires = 
    182.  
    183. [NSNumber numberWithFloat:paramURLMustExpireInSeconds]; 
    184.  
    185. [itemDictionary setObject:expires 
    186.  
    187. forKey:CachedKeyExpiresInSeconds]; 
    188.  
    189. } 
    190.  
    191. } /* if (cachedFileHasExpired == NO){ */ 
    192.  
    193. } 
    194.  
    195. if (cachedFileIsBeingDownloaded == YES){ 
    196.  
    197. NSLog(@"这个文件已经正在下载..."); 
    198.  
    199. return(YES); 
    200.  
    201. } 
    202.  
    203. if (fileHasBeenCached == YES){ 
    204.  
    205. if (cachedFileHasExpired == NO && 
    206.  
    207. cachedFileExists == YES && 
    208.  
    209. cachedFileDataCanBeLoaded == YES && 
    210.  
    211. [cachedFileData length] > 0 && 
    212.  
    213. cachedFileIsFullyDownloaded == YES){ 
    214.  
    215. /* 如果文件有缓存而且没有过期 */ 
    216.  
    217. NSLog(@"文件有缓存而且没有过期."); 
    218.  
    219. [self.delegate 
    220.  
    221. cachedDownloadManagerSucceeded:self 
    222.  
    223. remoteURL:[NSURL URLWithString:paramURLAsString] 
    224.  
    225. localURL:[NSURL URLWithString:localURL] 
    226.  
    227. aboutToBeReleasedData:cachedFileData 
    228.  
    229. isCachedData:YES]; 
    230.  
    231. return(YES); 
    232.  
    233. } else { 
    234.  
    235. /* 如果文件没有被缓存，获取缓存失败 */ 
    236.  
    237. NSLog(@"文件没有缓存."); 
    238.  
    239. [self.cacheDictionary removeObjectForKey:paramURLAsString]; 
    240.  
    241. [self saveCacheDictionary]; 
    242.  
    243. } /* if (cachedFileHasExpired == NO && */ 
    244.  
    245. } /* if (fileHasBeenCached == YES){ */ 
    246.  
    247. /* 去下载文件 */ 
    248.  
    249. NSNumber *expires = 
    250.  
    251. [NSNumber numberWithFloat:paramURLMustExpireInSeconds]; 
    252.  
    253. NSMutableDictionary *newDictionary = 
    254.  
    255. [[[NSMutableDictionary alloc] init] autorelease]; 
    256.  
    257. [newDictionary setObject:expires 
    258.  
    259. forKey:CachedKeyExpiresInSeconds]; 
    260.  
    261. localURL = [paramURLAsString 
    262.  
    263. stringByAddingPercentEscapesUsingEncoding: 
    264.  
    265. NSUTF8StringEncoding]; 
    266.  
    267. localURL = [localURL stringByReplacingOccurrencesOfString:@"://" 
    268.  
    269. withString:@""]; 
    270.  
    271. localURL = [localURL stringByReplacingOccurrencesOfString:@"/" 
    272.  
    273. withString:@"{1}quot;]; 
    274.  
    275. localURL = [localURL stringByAppendingPathExtension:@"cache"]; 
    276.  
    277. NSString *documentsDirectory = 
    278.  
    279. [self documentsDirectoryWithTrailingSlash:NO]; 
    280.  
    281. localURL = [documentsDirectory 
    282.  
    283. stringByAppendingPathComponent:localURL]; 
    284.  
    285. [newDictionary setObject:localURL 
    286.  
    287. forKey:CachedKeyLocalURL]; 
    288.  
    289. [newDictionary setObject:now 
    290.  
    291. forKey:CachedKeyDownloadStartDate]; 
    292.  
    293. [self.cacheDictionary setObject:newDictionary 
    294.  
    295. forKey:paramURLAsString]; 
    296.  
    297. [self saveCacheDictionary]; 
    298.  
    299. CacheItem *item = [[[CacheItem alloc] init] autorelease]; 
    300.  
    301. [item setDelegate:self]; 
    302.  
    303. [item startDownloadingURL:paramURLAsString]; 
    304.  
    305. return(result); 
    306.  
    307. } 
    308.  

    4、下面我们设计缓存项下载成功和失败的两个委托方法：

    1. @protocol CacheItemDelegate <NSObject>   
    2.  
    3. //下载成功执行该方法   
    4.  
    5. - (void) cacheItemDelegateSucceeded   
    6.  
    7.   :(CacheItem *)paramSender   
    8.  
    9.   withRemoteURL:(NSURL *)paramRemoteURL   
    10.  
    11.   withAboutToBeReleasedData:(NSData *)paramAboutToBeReleasedData;   
    12.  
    13. //下载失败执行该方法   
    14.  
    15. - (void) cacheItemDelegateFailed   
    16.  
    17.   :(CacheItem *)paramSender   
    18.  
    19.   remoteURL:(NSURL *)paramRemoteURL   
    20.  
    21.   withError:(NSError *)paramError;  
    22.  
    23. @end   

    当我们下载成功的时候，修改缓存字典中的下载时间，表示已经下载完成，而且需要将请求的资源数据缓存到本地：

    1. //缓存项的委托方法 
    2.  
    3. - (void) cacheItemDelegateSucceeded:(CacheItem *)paramSender 
    4.  
    5. withRemoteURL:(NSURL *)paramRemoteURL 
    6.  
    7. withAboutToBeReleasedData:(NSData *)paramAboutToBeReleasedData{ 
    8.  
    9. //从缓存字典中获取该缓存项的相关数据 
    10.  
    11. NSMutableDictionary *dictionary = 
    12.  
    13. [self.cacheDictionary objectForKey:[paramRemoteURL absoluteString]]; 
    14.  
    15. //取当前时间 
    16.  
    17. NSDate *now = [NSDate date]; 
    18.  
    19. //获取有效时间 
    20.  
    21. NSNumber *expiresInSeconds = [dictionary 
    22.  
    23. objectForKey:CachedKeyExpiresInSeconds]; 
    24.  
    25. //转换成NSTimeInterval 
    26.  
    27. NSTimeInterval expirySeconds = [expiresInSeconds floatValue]; 
    28.  
    29. //修改字典中缓存项的下载结束时间 
    30.  
    31. [dictionary setObject:[NSDate date] 
    32.  
    33. forKey:CachedKeyDownloadEndDate]; 
    34.  
    35. //修改字典中缓存项的缓存过期时间 
    36.  
    37. [dictionary setObject:[now dateByAddingTimeInterval:expirySeconds] 
    38.  
    39. forKey:CachedKeyExpiryDate]; 
    40.  
    41. //保存缓存字典 
    42.  
    43. [self saveCacheDictionary]; 
    44.  
    45. NSString *localURL = [dictionary objectForKey:CachedKeyLocalURL]; 
    46.  
    47. /* 将下载的数据保持到磁盘 */ 
    48.  
    49. if ([paramAboutToBeReleasedData writeToFile:localURL 
    50.  
    51. atomically:YES] == YES){ 
    52.  
    53. NSLog(@"缓存文件到磁盘成功."); 
    54.  
    55. } else{ 
    56.  
    57. NSLog(@"缓存文件到磁盘失败."); 
    58.  
    59. } 
    60.  
    61. //执行缓存管理的委托方法 
    62.  
    63. [self.delegate 
    64.  
    65. cachedDownloadManagerSucceeded:self 
    66.  
    67. remoteURL:paramRemoteURL 
    68.  
    69. localURL:[NSURL URLWithString:localURL] 
    70.  
    71. aboutToBeReleasedData:paramAboutToBeReleasedData 
    72.  
    73. isCachedData:NO]; 
    74.  
    75. } 
    76.  

    如果下载失败我们需要从缓存字典中移除改缓存项：

    1. //缓存项失败失败的委托方法 
    2.  
    3. - (void) cacheItemDelegateFailed:(CacheItem *)paramSender 
    4.  
    5. remoteURL:(NSURL *)paramRemoteURL 
    6.  
    7. withError:(NSError *)paramError{ 
    8.  
    9. /* 从缓存字典中移除缓存项，并发送一个委托 */ 
    10.  
    11. if (self.delegate != nil){ 
    12.  
    13. NSMutableDictionary *dictionary = 
    14.  
    15. [self.cacheDictionary 
    16.  
    17. objectForKey:[paramRemoteURL absoluteString]]; 
    18.  
    19. NSString *localURL = [dictionary 
    20.  
    21. objectForKey:CachedKeyLocalURL]; 
    22.  
    23. [self.delegate 
    24.  
    25. cachedDownloadManagerFailed:self 
    26.  
    27. remoteURL:paramRemoteURL 
    28.  
    29. localURL:[NSURL URLWithString:localURL] 
    30.  
    31. withError:paramError]; 
    32.  
    33. } 
    34.  
    35. [self.cacheDictionary 
    36.  
    37. removeObjectForKey:[paramRemoteURL absoluteString]]; 
    38.  
    39. } 
    40.  

    5、加载缓存字典的时候，我们可以将没有下载完成的文件移除：

    1. //初始化缓存字典 
    2.  
    3. NSString *documentsDirectory = 
    4.  
    5. [self documentsDirectoryWithTrailingSlash:YES]; 
    6.  
    7. //生产缓存字典的路径 
    8.  
    9. cacheDictionaryPath = 
    10.  
    11. [[documentsDirectory 
    12.  
    13. stringByAppendingString:@"CachedDownloads.dic"] retain]; 
    14.  
    15. //创建一个NSFileManager实例 
    16.  
    17. NSFileManager *fileManager = [[NSFileManager alloc] init]; 
    18.  
    19. //判断是否存在缓存字典的数据 
    20.  
    21. if ([fileManager 
    22.  
    23. fileExistsAtPath:self.cacheDictionaryPath] == YES){ 
    24.  
    25. NSLog(self.cacheDictionaryPath); 
    26.  
    27. //加载缓存字典中的数据 
    28.  
    29. NSMutableDictionary *dictionary = 
    30.  
    31. [[NSMutableDictionary alloc] 
    32.  
    33. initWithContentsOfFile:self.cacheDictionaryPath]; 
    34.  
    35. cacheDictionary = [dictionary mutableCopy]; 
    36.  
    37. [dictionary release]; 
    38.  
    39. //移除没有下载完成的缓存数据 
    40.  
    41. [self removeCorruptedCachedItems]; 
    42.  
    43. } else { 
    44.  
    45. //创建一个新的缓存字典 
    46.  
    47. NSMutableDictionary *dictionary = 
    48.  
    49. [[NSMutableDictionary alloc] init]; 
    50.  
    51. cacheDictionary = [dictionary mutableCopy]; 
    52.  
    53. [dictionary release]; 
    54.  
    55. } 
    56.  

    这样就基本上完成了我们需要的功能，下面看看我们如何使用我们设计的缓存功能。

    例子场景：

    我们用一个UIWebView来显示stackoverflow这个网站，我们在这个网站的内容缓存到本地20秒，如果在20秒内用户去请求该网站，则从本地文件中获取内容，否则过了20秒，则重新获取数据，并缓存到本地。

    在界面上拖放一个button和一个webview控件，如下图。

    这样我们可以很方便使用前面定义好的类。我们在viewDidLoad 中实例化一个CachedDownloadManager，并设置它的委托为self。当下载完成的时候，执行CachedDownloadManager的下载成功的委托方法。

    - (void)viewDidLoad { [super viewDidLoad]; [self setTitle:@"本地缓存测试"];

    CachedDownloadManager *newManager =[[CachedDownloadManager alloc] init];

    self.downloadManager = newManager; [newManager release]; [self.downloadManager setDelegate:self]; }

    在button的点击事件中加入下面代码，请求stackoverflow ：

    static NSString *url = @http://stackoverflow.com;

    [self.downloadManager download:url urlMustExpireInSeconds:20.0fupdateExpiryDateIfInCache:YES];

    上面的代码表示将这个stackoverflow的缓存事件设置为20s，并且如果在20s内有相同的请求，则从本地获取stackoverflow的内容数据。updateExpiryDateIfInCache设置为yes表示：在此请求的时候，缓存时间又更新为20s，类似我们的session。如果设置成no，则第一次请求20s之后，该缓存就过期。

    请求完成之后会执行CachedDownloadManager的委托方法。我们将数据展示在uiwebview中，代码如下：

    - (void) cachedDownloadManagerSucceeded:(CachedDownloadManager *)paramSender remoteURL:(NSURL *)paramRemoteURL localURL:(NSURL*)paramLocalURL aboutToBeReleasedData:(NSData *)paramAboutToBeReleasedData isCachedData:(BOOL)paramIsCachedData

    { [webview loadData:paramAboutToBeReleasedData MIMEType:@"text/html" textEncodingName:@"UTF-8" baseURL:[NSURL URLWithString:@"http://stackoverflow.com"]]; }

    这样我们就实现了20s的缓存。

    效果：

    第一次点击测试按钮：

    20s内点击按钮，程序就从本地获取数据，比较快速的就显示出该网页了。

    总结：

    本文通过代码和实例设计了一个iPhone应用程序本地缓存的方案。
  • 相关阅读:
    跟layout_weight说88,轻松搞定百分比布局
    跟闪退、程序崩溃说88
    程序的需求层次
    开博
    第十章 数组与集合 发牌程序 实例代码
    C#面向对象基础01
    winform form
    html
    C#语言基础02
    C#语言基础01
  • 原文地址：https://www.cnblogs.com/jiangshiyong/p/2845346.html
Copyright © 2011-2022 走看看