MonoGame在iOS上缺少数据存储IsolatedStorageSettings类的解决办法

1. using System;
2. using System.Collections;
3. using System.Collections.Generic;
4. using System.IO;
5. using System.Runtime.Serialization;
6. using System.Text;
8. namespace System.IO.IsolatedStorage {
10. public sealed class IsolatedStorageSettings : IDictionary<string, object>, IDictionary,
11. ICollection<KeyValuePair<string, object>>, ICollection,
12. IEnumerable<KeyValuePair<string, object>>, IEnumerable {
14. static private IsolatedStorageSettings application_settings;
15. static private IsolatedStorageSettings site_settings;
17. private IsolatedStorageFile container;
18. private Dictionary<string, object> settings;
20. // SL2 use a "well known" name and it's readable (and delete-able) directly by isolated storage
21. private const string LocalSettings = "__LocalSettings";
23. internal IsolatedStorageSettings (IsolatedStorageFile isf)
24. {
25. container = isf;
27. if (!isf.FileExists (LocalSettings)) {
28. settings = new Dictionary<string, object> ();
29. return;
30. }
32. using (IsolatedStorageFileStream fs = isf.OpenFile (LocalSettings, FileMode.Open)) {
33. using (StreamReader sr = new StreamReader (fs)) {
34. DataContractSerializer reader = new DataContractSerializer (typeof (Dictionary<string, object>));
35. try {
36. settings = (Dictionary<string, object>) reader.ReadObject (fs);
37. } catch (Xml.XmlException) {
38. settings = new Dictionary<string, object> ();
39. }
40. }
41. }
42. }
44. ~IsolatedStorageSettings ()
45. {
46. // settings are automatically saved if the application close normally
47. Save ();
48. }
50. // static properties
52. // per application, per-computer, per-user
53. public static IsolatedStorageSettings ApplicationSettings {
54. get {
55. if (application_settings == null) {
56. application_settings = new IsolatedStorageSettings (
57. IsolatedStorageFile.GetUserStoreForApplication ());
58. }
59. return application_settings;
60. }
61. }
63. // per domain, per-computer, per-user
64. public static IsolatedStorageSettings SiteSettings {
65. get {
66. if (site_settings == null) {
67. site_settings = new IsolatedStorageSettings (
68. IsolatedStorageFile.GetUserStoreForSite ());
69. }
70. return site_settings;
71. }
72. }
74. // properties
76. public int Count {
77. get { return settings.Count; }
78. }
80. public ICollection Keys {
81. get { return settings.Keys; }
82. }
84. public ICollection Values {
85. get { return settings.Values; }
86. }
88. public object this [string key] {
89. get {
90. return settings [key];
91. }
92. set {
93. settings [key] = value;
94. }
95. }
97. // methods
99. public void Add (string key, object value)
100. {
101. settings.Add (key, value);
102. }
104. // This method is emitted as virtual due to: https://bugzilla.novell.com/show_bug.cgi?id=446507
105. public void Clear ()
106. {
107. settings.Clear ();
108. }
110. public bool Contains (string key)
111. {
112. if (key == null)
113. throw new ArgumentNullException ("key");
114. return settings.ContainsKey (key);
115. }
117. public bool Remove (string key)
118. {
119. return settings.Remove (key);
120. }
122. public void Save ()
123. {
124. using (IsolatedStorageFileStream fs = container.CreateFile (LocalSettings)) {
125. DataContractSerializer ser = new DataContractSerializer (settings.GetType ());
126. ser.WriteObject (fs, settings);
127. }
128. }
130. public bool TryGetValue<T> (string key, out T value)
131. {
132. object v;
133. if (!settings.TryGetValue (key, out v)) {
134. value = default (T);
135. return false;
136. }
137. value = (T) v;
138. return true;
139. }
141. // explicit interface implementations
143. int ICollection<KeyValuePair<string, object>>.Count {
144. get { return settings.Count; }
145. }
147. bool ICollection<KeyValuePair<string, object>>.IsReadOnly {
148. get { return false; }
149. }
151. void ICollection<KeyValuePair<string, object>>.Add (KeyValuePair<string, object> item)
152. {
153. settings.Add (item.Key, item.Value);
154. }
156. void ICollection<KeyValuePair<string, object>>.Clear ()
157. {
158. settings.Clear ();
159. }
161. bool ICollection<KeyValuePair<string, object>>.Contains (KeyValuePair<string, object> item)
162. {
163. return settings.ContainsKey (item.Key);
164. }
166. void ICollection<KeyValuePair<string, object>>.CopyTo (KeyValuePair<string, object> [] array, int arrayIndex)
167. {
168. (settings as ICollection<KeyValuePair<string, object>>).CopyTo (array, arrayIndex);
169. }
171. bool ICollection<KeyValuePair<string, object>>.Remove (KeyValuePair<string, object> item)
172. {
173. return settings.Remove (item.Key);
174. }
177. ICollection<string> IDictionary<string, object>.Keys {
178. get { return settings.Keys; }
179. }
181. ICollection<object> IDictionary<string, object>.Values {
182. get { return settings.Values; }
183. }
185. bool IDictionary<string, object>.ContainsKey (string key)
186. {
187. return settings.ContainsKey (key);
188. }
190. bool IDictionary<string, object>.TryGetValue (string key, out object value)
191. {
192. return settings.TryGetValue (key, out value);
193. }
196. private string ExtractKey (object key)
197. {
198. if (key == null)
199. throw new ArgumentNullException ("key");
200. return (key as string);
201. }
203. void IDictionary.Add (object key, object value)
204. {
205. string s = ExtractKey (key);
206. if (s == null)
207. throw new ArgumentException ("key");
209. settings.Add (s, value);
210. }
212. void IDictionary.Clear ()
213. {
214. settings.Clear ();
215. }
217. bool IDictionary.Contains (object key)
218. {
219. string skey = ExtractKey (key);
220. if (skey == null)
221. return false;
222. return settings.ContainsKey (skey);
223. }
225. object IDictionary.this [object key] {
226. get {
227. string s = ExtractKey (key);
228. return (s == null) ? null : settings [s];
229. }
230. set {
231. string s = ExtractKey (key);
232. if (s == null)
233. throw new ArgumentException ("key");
234. settings [s] = value;
235. }
236. }
238. bool IDictionary.IsFixedSize {
239. get { return false; }
240. }
242. bool IDictionary.IsReadOnly {
243. get { return false; }
244. }
246. void IDictionary.Remove (object key)
247. {
248. string s = ExtractKey (key);
249. if (s != null)
250. settings.Remove (s);
251. }
254. void ICollection.CopyTo (Array array, int index)
255. {
256. (settings as ICollection).CopyTo (array, index);
257. }
259. bool ICollection.IsSynchronized {
260. get { return (settings as ICollection).IsSynchronized; }
261. }
263. object ICollection.SyncRoot {
264. get { return (settings as ICollection).SyncRoot; }
265. }
268. IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator ()
269. {
270. return settings.GetEnumerator ();
271. }
273. IEnumerator IEnumerable.GetEnumerator ()
274. {
275. return settings.GetEnumerator ();
276. }
279. IDictionaryEnumerator IDictionary.GetEnumerator ()
280. {
281. return settings.GetEnumerator ();
282. }
283. }
284. }

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Text;

namespace System.IO.IsolatedStorage {

public sealed class IsolatedStorageSettings : IDictionary<string, object>, IDictionary,
ICollection<KeyValuePair<string, object>>, ICollection,
IEnumerable<KeyValuePair<string, object>>, IEnumerable {

static private IsolatedStorageSettings application_settings;
static private IsolatedStorageSettings site_settings;

private IsolatedStorageFile container;
private Dictionary<string, object> settings;

// SL2 use a "well known" name and it's readable (and delete-able) directly by isolated storage
private const string LocalSettings = "__LocalSettings";

internal IsolatedStorageSettings (IsolatedStorageFile isf)
{
container = isf;

if (!isf.FileExists (LocalSettings)) {
settings = new Dictionary<string, object> ();
return;
}

using (IsolatedStorageFileStream fs = isf.OpenFile (LocalSettings, FileMode.Open)) {
using (StreamReader sr = new StreamReader (fs)) {
DataContractSerializer reader = new DataContractSerializer (typeof (Dictionary<string, object>));
try {
settings = (Dictionary<string, object>) reader.ReadObject (fs);
} catch (Xml.XmlException) {
settings = new Dictionary<string, object> ();
}
}
}
}

~IsolatedStorageSettings ()
{
// settings are automatically saved if the application close normally
Save ();
}

// static properties

// per application, per-computer, per-user
public static IsolatedStorageSettings ApplicationSettings {
get {
if (application_settings == null) {
application_settings = new IsolatedStorageSettings (
IsolatedStorageFile.GetUserStoreForApplication ());
}
return application_settings;
}
}

// per domain, per-computer, per-user
public static IsolatedStorageSettings SiteSettings {
get {
if (site_settings == null) {
site_settings = new IsolatedStorageSettings (
IsolatedStorageFile.GetUserStoreForSite ());
}
return site_settings;
}
}

// properties

public int Count {
get { return settings.Count; }
}

public ICollection Keys {
get { return settings.Keys; }
}

public ICollection Values {
get { return settings.Values; }
}

public object this [string key] {
get {
return settings [key];
}
set {
settings [key] = value;
}
}

// methods

public void Add (string key, object value)
{
settings.Add (key, value);
}

// This method is emitted as virtual due to: https://bugzilla.novell.com/show_bug.cgi?id=446507
public void Clear ()
{
settings.Clear ();
}

public bool Contains (string key)
{
if (key == null)
throw new ArgumentNullException ("key");
return settings.ContainsKey (key);
}

public bool Remove (string key)
{
return settings.Remove (key);
}

public void Save ()
{
using (IsolatedStorageFileStream fs = container.CreateFile (LocalSettings)) {
DataContractSerializer ser = new DataContractSerializer (settings.GetType ());
ser.WriteObject (fs, settings);
}
}

public bool TryGetValue<T> (string key, out T value)
{
object v;
if (!settings.TryGetValue (key, out v)) {
value = default (T);
return false;
}
value = (T) v;
return true;
}

// explicit interface implementations

int ICollection<KeyValuePair<string, object>>.Count {
get { return settings.Count; }
}

bool ICollection<KeyValuePair<string, object>>.IsReadOnly {
get { return false; }
}

void ICollection<KeyValuePair<string, object>>.Add (KeyValuePair<string, object> item)
{
settings.Add (item.Key, item.Value);
}

void ICollection<KeyValuePair<string, object>>.Clear ()
{
settings.Clear ();
}

bool ICollection<KeyValuePair<string, object>>.Contains (KeyValuePair<string, object> item)
{
return settings.ContainsKey (item.Key);
}

void ICollection<KeyValuePair<string, object>>.CopyTo (KeyValuePair<string, object> [] array, int arrayIndex)
{
(settings as ICollection<KeyValuePair<string, object>>).CopyTo (array, arrayIndex);
}

bool ICollection<KeyValuePair<string, object>>.Remove (KeyValuePair<string, object> item)
{
return settings.Remove (item.Key);
}


ICollection<string> IDictionary<string, object>.Keys {
get { return settings.Keys; }
}

ICollection<object> IDictionary<string, object>.Values {
get { return settings.Values; }
}

bool IDictionary<string, object>.ContainsKey (string key)
{
return settings.ContainsKey (key);
}

bool IDictionary<string, object>.TryGetValue (string key, out object value)
{
return settings.TryGetValue (key, out value);
}


private string ExtractKey (object key)
{
if (key == null)
throw new ArgumentNullException ("key");
return (key as string);
}

void IDictionary.Add (object key, object value)
{
string s = ExtractKey (key);
if (s == null)
throw new ArgumentException ("key");

settings.Add (s, value);
}

void IDictionary.Clear ()
{
settings.Clear ();
}

bool IDictionary.Contains (object key)
{
string skey = ExtractKey (key);
if (skey == null)
return false;
return settings.ContainsKey (skey);
}

object IDictionary.this [object key] {
get {
string s = ExtractKey (key);
return (s == null) ? null : settings [s];
}
set {
string s = ExtractKey (key);
if (s == null)
throw new ArgumentException ("key");
settings [s] = value;
}
}

bool IDictionary.IsFixedSize {
get { return false; }
}

bool IDictionary.IsReadOnly {
get { return false; }
}

void IDictionary.Remove (object key)
{
string s = ExtractKey (key);
if (s != null)
settings.Remove (s);
}


void ICollection.CopyTo (Array array, int index)
{
(settings as ICollection).CopyTo (array, index);
}

bool ICollection.IsSynchronized {
get { return (settings as ICollection).IsSynchronized; }
}

object ICollection.SyncRoot {
get { return (settings as ICollection).SyncRoot; }
}


IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator ()
{
return settings.GetEnumerator ();
}

IEnumerator IEnumerable.GetEnumerator ()
{
return settings.GetEnumerator ();
}


IDictionaryEnumerator IDictionary.GetEnumerator ()
{
return settings.GetEnumerator ();
}
}
}