// Finds the ResourceTypeCode for a type, or adds this type to the // types list. private ResourceTypeCode FindTypeCode(Object value, List <String> types) { if (value == null) { return(ResourceTypeCode.Null); } Type type = value.GetType(); if (type == typeof(String)) { return(ResourceTypeCode.String); } else if (type == typeof(Int32)) { return(ResourceTypeCode.Int32); } else if (type == typeof(Boolean)) { return(ResourceTypeCode.Boolean); } else if (type == typeof(Char)) { return(ResourceTypeCode.Char); } else if (type == typeof(Byte)) { return(ResourceTypeCode.Byte); } else if (type == typeof(SByte)) { return(ResourceTypeCode.SByte); } else if (type == typeof(Int16)) { return(ResourceTypeCode.Int16); } else if (type == typeof(Int64)) { return(ResourceTypeCode.Int64); } else if (type == typeof(UInt16)) { return(ResourceTypeCode.UInt16); } else if (type == typeof(UInt32)) { return(ResourceTypeCode.UInt32); } else if (type == typeof(UInt64)) { return(ResourceTypeCode.UInt64); } else if (type == typeof(Single)) { return(ResourceTypeCode.Single); } else if (type == typeof(Double)) { return(ResourceTypeCode.Double); } else if (type == typeof(Decimal)) { return(ResourceTypeCode.Decimal); } else if (type == typeof(DateTime)) { return(ResourceTypeCode.DateTime); } else if (type == typeof(TimeSpan)) { return(ResourceTypeCode.TimeSpan); } else if (type == typeof(byte[])) { return(ResourceTypeCode.ByteArray); } else if (type == typeof(StreamWrapper)) { return(ResourceTypeCode.Stream); } // This is a user type, or a precanned resource. Find type // table index. If not there, add new element. String typeName; if (type == typeof(PrecannedResource)) { typeName = ((PrecannedResource)value).TypeName; if (typeName.StartsWith("ResourceTypeCode.", StringComparison.Ordinal)) { typeName = typeName.Substring(17); // Remove through '.' ResourceTypeCode typeCode = (ResourceTypeCode)Enum.Parse(typeof(ResourceTypeCode), typeName); return(typeCode); } } else { typeName = MultitargetingHelpers.GetAssemblyQualifiedName(type, typeConverter); } int typeIndex = types.IndexOf(typeName); if (typeIndex == -1) { typeIndex = types.Count; types.Add(typeName); } return((ResourceTypeCode)(typeIndex + ResourceTypeCode.StartOfUserTypes)); }
[SecuritySafeCritical] // Asserts permission to create & delete a temp file. public void Generate() { if (_resourceList == null) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ResourceWriterSaved")); } BinaryWriter bw = new BinaryWriter(_output, Encoding.UTF8); List <String> typeNames = new List <String>(); // Write out the ResourceManager header // Write out magic number bw.Write(ResourceManager.MagicNumber); // Write out ResourceManager header version number bw.Write(ResourceManager.HeaderVersionNumber); MemoryStream resMgrHeaderBlob = new MemoryStream(240); BinaryWriter resMgrHeaderPart = new BinaryWriter(resMgrHeaderBlob); // Write out class name of IResourceReader capable of handling // this file. resMgrHeaderPart.Write(MultitargetingHelpers.GetAssemblyQualifiedName(typeof(ResourceReader), typeConverter)); // Write out class name of the ResourceSet class best suited to // handling this file. // This needs to be the same even with multi-targeting. It's the // full name -- not the ----sembly qualified name. resMgrHeaderPart.Write(ResourceManager.ResSetTypeName); resMgrHeaderPart.Flush(); // Write number of bytes to skip over to get past ResMgr header bw.Write((int)resMgrHeaderBlob.Length); // Write the rest of the ResMgr header bw.Write(resMgrHeaderBlob.GetBuffer(), 0, (int)resMgrHeaderBlob.Length); // End ResourceManager header // Write out the RuntimeResourceSet header // Version number bw.Write(RuntimeResourceSet.Version); #if RESOURCE_FILE_FORMAT_DEBUG // Write out a tag so we know whether to enable or disable // debugging support when reading the file. bw.Write("***DEBUG***"); #endif // number of resources int numResources = _resourceList.Count; if (_preserializedData != null) { numResources += _preserializedData.Count; } bw.Write(numResources); // Store values in temporary streams to write at end of file. int[] nameHashes = new int[numResources]; int[] namePositions = new int[numResources]; int curNameNumber = 0; MemoryStream nameSection = new MemoryStream(numResources * AverageNameSize); BinaryWriter names = new BinaryWriter(nameSection, Encoding.Unicode); // The data section can be very large, and worse yet, we can grow the byte[] used // for the data section repeatedly. When using large resources like ~100 images, // this can lead to both a fragmented large object heap as well as allocating about // 2-3x of our storage needs in extra overhead. Using a temp file can avoid this. // Assert permission to get a temp file name, which requires two permissions. // Additionally, we may be running under an account that doesn't have permission to // write to the temp directory (enforced via a Windows ACL). Fall back to a MemoryStream. Stream dataSection = null; // Either a FileStream or a MemoryStream String tempFile = null; #if MONO_FEATURE_CAS PermissionSet permSet = new PermissionSet(PermissionState.None); permSet.AddPermission(new EnvironmentPermission(PermissionState.Unrestricted)); permSet.AddPermission(new FileIOPermission(PermissionState.Unrestricted)); #endif try { #if MONO_FEATURE_CAS permSet.Assert(); #endif tempFile = Path.GetTempFileName(); File.SetAttributes(tempFile, FileAttributes.Temporary | FileAttributes.NotContentIndexed); // Explicitly opening with FileOptions.DeleteOnClose to avoid complicated File.Delete // (safe from ----s w/ antivirus software, etc) dataSection = new FileStream(tempFile, FileMode.Open, FileAccess.ReadWrite, FileShare.Read, 4096, FileOptions.DeleteOnClose | FileOptions.SequentialScan); } catch (UnauthorizedAccessException) { // In case we're running under an account that can't access a temp directory. dataSection = new MemoryStream(); } catch (IOException) { // In case Path.GetTempFileName fails because no unique file names are available dataSection = new MemoryStream(); } finally { #if MONO_FEATURE_CAS PermissionSet.RevertAssert(); #endif } using (dataSection) { BinaryWriter data = new BinaryWriter(dataSection, Encoding.UTF8); #if FEATURE_SERIALIZATION IFormatter objFormatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.File | StreamingContextStates.Persistence)); #endif // FEATURE_SERIALIZATION #if RESOURCE_FILE_FORMAT_DEBUG // Write NAMES right before the names section. names.Write(new byte[] { (byte)'N', (byte)'A', (byte)'M', (byte)'E', (byte)'S', (byte)'-', (byte)'-', (byte)'>' }); // Write DATA at the end of the name table section. data.Write(new byte[] { (byte)'D', (byte)'A', (byte)'T', (byte)'A', (byte)'-', (byte)'-', (byte)'-', (byte)'>' }); #endif // We've stored our resources internally in a Hashtable, which // makes no guarantees about the ordering while enumerating. // While we do our own sorting of the resource names based on their // hash values, that's only sorting the nameHashes and namePositions // arrays. That's all that is strictly required for correctness, // but for ease of generating a patch in the future that // modifies just .resources files, we should re-sort them. SortedList sortedResources = new SortedList(_resourceList, FastResourceComparer.Default); if (_preserializedData != null) { foreach (KeyValuePair <String, PrecannedResource> entry in _preserializedData) { sortedResources.Add(entry.Key, entry.Value); } } IDictionaryEnumerator items = sortedResources.GetEnumerator(); // Write resource name and position to the file, and the value // to our temporary buffer. Save Type as well. while (items.MoveNext()) { nameHashes[curNameNumber] = FastResourceComparer.HashFunction((String)items.Key); namePositions[curNameNumber++] = (int)names.Seek(0, SeekOrigin.Current); names.Write((String)items.Key); // key names.Write((int)data.Seek(0, SeekOrigin.Current)); // virtual offset of value. #if RESOURCE_FILE_FORMAT_DEBUG names.Write((byte)'*'); #endif Object value = items.Value; ResourceTypeCode typeCode = FindTypeCode(value, typeNames); // Write out type code Write7BitEncodedInt(data, (int)typeCode); // Write out value PrecannedResource userProvidedResource = value as PrecannedResource; if (userProvidedResource != null) { data.Write(userProvidedResource.Data); } else { #if FEATURE_SERIALIZATION WriteValue(typeCode, value, data, objFormatter); #else WriteValue(typeCode, value, data); #endif } #if RESOURCE_FILE_FORMAT_DEBUG data.Write(new byte[] { (byte)'S', (byte)'T', (byte)'O', (byte)'P' }); #endif } // At this point, the ResourceManager header has been written. // Finish RuntimeResourceSet header // Write size & contents of class table bw.Write(typeNames.Count); for (int i = 0; i < typeNames.Count; i++) { bw.Write(typeNames[i]); } // Write out the name-related items for lookup. // Note that the hash array and the namePositions array must // be sorted in parallel. Array.Sort(nameHashes, namePositions); // Prepare to write sorted name hashes (alignment fixup) // Note: For 64-bit machines, these MUST be aligned on 8 byte // boundaries! Pointers on IA64 must be aligned! And we'll // run faster on X86 machines too. bw.Flush(); int alignBytes = ((int)bw.BaseStream.Position) & 7; if (alignBytes > 0) { for (int i = 0; i < 8 - alignBytes; i++) { bw.Write("PAD"[i % 3]); } } // Write out sorted name hashes. // Align to 8 bytes. Contract.Assert((bw.BaseStream.Position & 7) == 0, "ResourceWriter: Name hashes array won't be 8 byte aligned! Ack!"); #if RESOURCE_FILE_FORMAT_DEBUG bw.Write(new byte[] { (byte)'H', (byte)'A', (byte)'S', (byte)'H', (byte)'E', (byte)'S', (byte)'-', (byte)'>' }); #endif foreach (int hash in nameHashes) { bw.Write(hash); } #if RESOURCE_FILE_FORMAT_DEBUG Console.Write("Name hashes: "); foreach (int hash in nameHashes) { Console.Write(hash.ToString("x") + " "); } Console.WriteLine(); #endif // Write relative positions of all the names in the file. // Note: this data is 4 byte aligned, occuring immediately // after the 8 byte aligned name hashes (whose length may // potentially be odd). Contract.Assert((bw.BaseStream.Position & 3) == 0, "ResourceWriter: Name positions array won't be 4 byte aligned! Ack!"); #if RESOURCE_FILE_FORMAT_DEBUG bw.Write(new byte[] { (byte)'P', (byte)'O', (byte)'S', (byte)'-', (byte)'-', (byte)'-', (byte)'-', (byte)'>' }); #endif foreach (int pos in namePositions) { bw.Write(pos); } #if RESOURCE_FILE_FORMAT_DEBUG Console.Write("Name positions: "); foreach (int pos in namePositions) { Console.Write(pos.ToString("x") + " "); } Console.WriteLine(); #endif // Flush all BinaryWriters to their underlying streams. bw.Flush(); names.Flush(); data.Flush(); // Write offset to data section int startOfDataSection = (int)(bw.Seek(0, SeekOrigin.Current) + nameSection.Length); startOfDataSection += 4; // We're writing an int to store this data, adding more bytes to the header BCLDebug.Log("RESMGRFILEFORMAT", "Generate: start of DataSection: 0x" + startOfDataSection.ToString("x", CultureInfo.InvariantCulture) + " nameSection length: " + nameSection.Length); bw.Write(startOfDataSection); // Write name section. bw.Write(nameSection.GetBuffer(), 0, (int)nameSection.Length); names.Close(); // Write data section. Contract.Assert(startOfDataSection == bw.Seek(0, SeekOrigin.Current), "ResourceWriter::Generate - start of data section is wrong!"); dataSection.Position = 0; dataSection.CopyTo(bw.BaseStream); data.Close(); } // using(dataSection) <--- Closes dataSection, which was opened w/ FileOptions.DeleteOnClose bw.Flush(); // Indicate we've called Generate _resourceList = null; }
public void Generate() { if (this._resourceList == null) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ResourceWriterSaved")); } BinaryWriter writer = new BinaryWriter(this._output, Encoding.UTF8); List <string> types = new List <string>(); writer.Write(ResourceManager.MagicNumber); writer.Write(ResourceManager.HeaderVersionNumber); MemoryStream output = new MemoryStream(240); BinaryWriter writer2 = new BinaryWriter(output); writer2.Write(MultitargetingHelpers.GetAssemblyQualifiedName(typeof(ResourceReader), this.typeConverter)); writer2.Write(ResourceManager.ResSetTypeName); writer2.Flush(); writer.Write((int)output.Length); writer.Write(output.GetBuffer(), 0, (int)output.Length); writer.Write(2); int count = this._resourceList.Count; if (this._preserializedData != null) { count += this._preserializedData.Count; } writer.Write(count); int[] keys = new int[count]; int[] items = new int[count]; int index = 0; MemoryStream stream2 = new MemoryStream(count * 40); BinaryWriter writer3 = new BinaryWriter(stream2, Encoding.Unicode); Stream stream3 = null; string path = null; PermissionSet set = new PermissionSet(PermissionState.None); set.AddPermission(new EnvironmentPermission(PermissionState.Unrestricted)); set.AddPermission(new FileIOPermission(PermissionState.Unrestricted)); try { set.Assert(); path = Path.GetTempFileName(); File.SetAttributes(path, FileAttributes.NotContentIndexed | FileAttributes.Temporary); stream3 = new FileStream(path, FileMode.Open, FileAccess.ReadWrite, FileShare.Read, 0x1000, FileOptions.SequentialScan | FileOptions.DeleteOnClose); } catch (UnauthorizedAccessException) { stream3 = new MemoryStream(); } catch (IOException) { stream3 = new MemoryStream(); } finally { PermissionSet.RevertAssert(); } using (stream3) { BinaryWriter store = new BinaryWriter(stream3, Encoding.UTF8); IFormatter objFormatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.Persistence | StreamingContextStates.File)); SortedList list2 = new SortedList(this._resourceList, FastResourceComparer.Default); if (this._preserializedData != null) { foreach (KeyValuePair <string, PrecannedResource> pair in this._preserializedData) { list2.Add(pair.Key, pair.Value); } } IDictionaryEnumerator enumerator = list2.GetEnumerator(); while (enumerator.MoveNext()) { keys[index] = FastResourceComparer.HashFunction((string)enumerator.Key); items[index++] = (int)writer3.Seek(0, SeekOrigin.Current); writer3.Write((string)enumerator.Key); writer3.Write((int)store.Seek(0, SeekOrigin.Current)); object obj2 = enumerator.Value; ResourceTypeCode typeCode = this.FindTypeCode(obj2, types); Write7BitEncodedInt(store, (int)typeCode); PrecannedResource resource = obj2 as PrecannedResource; if (resource != null) { store.Write(resource.Data); } else { this.WriteValue(typeCode, obj2, store, objFormatter); } } writer.Write(types.Count); for (int i = 0; i < types.Count; i++) { writer.Write(types[i]); } Array.Sort <int, int>(keys, items); writer.Flush(); int num4 = ((int)writer.BaseStream.Position) & 7; if (num4 > 0) { for (int j = 0; j < (8 - num4); j++) { writer.Write("PAD"[j % 3]); } } foreach (int num6 in keys) { writer.Write(num6); } foreach (int num7 in items) { writer.Write(num7); } writer.Flush(); writer3.Flush(); store.Flush(); int num8 = (int)(writer.Seek(0, SeekOrigin.Current) + stream2.Length); num8 += 4; writer.Write(num8); writer.Write(stream2.GetBuffer(), 0, (int)stream2.Length); writer3.Close(); stream3.Position = 0L; stream3.CopyTo(writer.BaseStream); store.Close(); } writer.Flush(); this._resourceList = null; }
private ResourceTypeCode FindTypeCode(object value, List <string> types) { string typeName; if (value == null) { return(ResourceTypeCode.Null); } Type type = value.GetType(); if (type == typeof(string)) { return(ResourceTypeCode.String); } if (type == typeof(int)) { return(ResourceTypeCode.Int32); } if (type == typeof(bool)) { return(ResourceTypeCode.Boolean); } if (type == typeof(char)) { return(ResourceTypeCode.Char); } if (type == typeof(byte)) { return(ResourceTypeCode.Byte); } if (type == typeof(sbyte)) { return(ResourceTypeCode.SByte); } if (type == typeof(short)) { return(ResourceTypeCode.Int16); } if (type == typeof(long)) { return(ResourceTypeCode.Int64); } if (type == typeof(ushort)) { return(ResourceTypeCode.UInt16); } if (type == typeof(uint)) { return(ResourceTypeCode.UInt32); } if (type == typeof(ulong)) { return(ResourceTypeCode.UInt64); } if (type == typeof(float)) { return(ResourceTypeCode.Single); } if (type == typeof(double)) { return(ResourceTypeCode.Double); } if (type == typeof(decimal)) { return(ResourceTypeCode.Decimal); } if (type == typeof(DateTime)) { return(ResourceTypeCode.DateTime); } if (type == typeof(TimeSpan)) { return(ResourceTypeCode.TimeSpan); } if (type == typeof(byte[])) { return(ResourceTypeCode.ByteArray); } if (type == typeof(StreamWrapper)) { return(ResourceTypeCode.Stream); } if (type == typeof(PrecannedResource)) { typeName = ((PrecannedResource)value).TypeName; if (typeName.StartsWith("ResourceTypeCode.", StringComparison.Ordinal)) { typeName = typeName.Substring(0x11); return((ResourceTypeCode)Enum.Parse(typeof(ResourceTypeCode), typeName)); } } else { typeName = MultitargetingHelpers.GetAssemblyQualifiedName(type, this.typeConverter); } int index = types.IndexOf(typeName); if (index == -1) { index = types.Count; types.Add(typeName); } return((ResourceTypeCode)(index + 0x40)); }
public void Generate() { if (this._resourceList == null) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ResourceWriterSaved")); } BinaryWriter binaryWriter1 = new BinaryWriter(this._output, Encoding.UTF8); List <string> types = new List <string>(); binaryWriter1.Write(ResourceManager.MagicNumber); binaryWriter1.Write(ResourceManager.HeaderVersionNumber); MemoryStream memoryStream1 = new MemoryStream(240); BinaryWriter binaryWriter2 = new BinaryWriter((Stream)memoryStream1); string assemblyQualifiedName = MultitargetingHelpers.GetAssemblyQualifiedName(typeof(ResourceReader), this.typeConverter); binaryWriter2.Write(assemblyQualifiedName); string str = ResourceManager.ResSetTypeName; binaryWriter2.Write(str); binaryWriter2.Flush(); binaryWriter1.Write((int)memoryStream1.Length); binaryWriter1.Write(memoryStream1.GetBuffer(), 0, (int)memoryStream1.Length); binaryWriter1.Write(2); int count = this._resourceList.Count; if (this._preserializedData != null) { count += this._preserializedData.Count; } binaryWriter1.Write(count); int[] keys = new int[count]; int[] items = new int[count]; int index1 = 0; MemoryStream memoryStream2 = new MemoryStream(count * 40); BinaryWriter binaryWriter3 = new BinaryWriter((Stream)memoryStream2, Encoding.Unicode); Stream output = (Stream)null; PermissionSet permissionSet = new PermissionSet(PermissionState.None); permissionSet.AddPermission((IPermission) new EnvironmentPermission(PermissionState.Unrestricted)); permissionSet.AddPermission((IPermission) new FileIOPermission(PermissionState.Unrestricted)); try { permissionSet.Assert(); string tempFileName = Path.GetTempFileName(); int num1 = 8448; File.SetAttributes(tempFileName, (FileAttributes)num1); int num2 = 3; int num3 = 3; int num4 = 1; int bufferSize = 4096; int num5 = 201326592; output = (Stream) new FileStream(tempFileName, (FileMode)num2, (FileAccess)num3, (FileShare)num4, bufferSize, (FileOptions)num5); } catch (UnauthorizedAccessException ex) { output = (Stream) new MemoryStream(); } catch (IOException ex) { output = (Stream) new MemoryStream(); } finally { PermissionSet.RevertAssert(); } using (output) { BinaryWriter binaryWriter4 = new BinaryWriter(output, Encoding.UTF8); IFormatter objFormatter = (IFormatter) new BinaryFormatter((ISurrogateSelector)null, new StreamingContext(StreamingContextStates.File | StreamingContextStates.Persistence)); SortedList sortedList = new SortedList((IDictionary)this._resourceList, (IComparer)FastResourceComparer.Default); if (this._preserializedData != null) { foreach (KeyValuePair <string, ResourceWriter.PrecannedResource> keyValuePair in this._preserializedData) { sortedList.Add((object)keyValuePair.Key, (object)keyValuePair.Value); } } IDictionaryEnumerator enumerator = sortedList.GetEnumerator(); while (enumerator.MoveNext()) { keys[index1] = FastResourceComparer.HashFunction((string)enumerator.Key); items[index1++] = (int)binaryWriter3.Seek(0, SeekOrigin.Current); binaryWriter3.Write((string)enumerator.Key); binaryWriter3.Write((int)binaryWriter4.Seek(0, SeekOrigin.Current)); object obj = enumerator.Value; ResourceTypeCode typeCode = this.FindTypeCode(obj, types); ResourceWriter.Write7BitEncodedInt(binaryWriter4, (int)typeCode); ResourceWriter.PrecannedResource precannedResource = obj as ResourceWriter.PrecannedResource; if (precannedResource != null) { binaryWriter4.Write(precannedResource.Data); } else { this.WriteValue(typeCode, obj, binaryWriter4, objFormatter); } } binaryWriter1.Write(types.Count); for (int index2 = 0; index2 < types.Count; ++index2) { binaryWriter1.Write(types[index2]); } Array.Sort <int, int>(keys, items); binaryWriter1.Flush(); int num1 = (int)binaryWriter1.BaseStream.Position & 7; if (num1 > 0) { for (int index2 = 0; index2 < 8 - num1; ++index2) { binaryWriter1.Write("PAD"[index2 % 3]); } } foreach (int num2 in keys) { binaryWriter1.Write(num2); } foreach (int num2 in items) { binaryWriter1.Write(num2); } binaryWriter1.Flush(); binaryWriter3.Flush(); binaryWriter4.Flush(); int num3 = (int)(binaryWriter1.Seek(0, SeekOrigin.Current) + memoryStream2.Length) + 4; binaryWriter1.Write(num3); binaryWriter1.Write(memoryStream2.GetBuffer(), 0, (int)memoryStream2.Length); binaryWriter3.Close(); output.Position = 0L; output.CopyTo(binaryWriter1.BaseStream); binaryWriter4.Close(); } binaryWriter1.Flush(); this._resourceList = (Dictionary <string, object>)null; }
public void Generate() { if (this._resourceList == null) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ResourceWriterSaved")); } BinaryWriter binaryWriter = new BinaryWriter(this._output, Encoding.UTF8); List <string> list = new List <string>(); binaryWriter.Write(ResourceManager.MagicNumber); binaryWriter.Write(ResourceManager.HeaderVersionNumber); MemoryStream memoryStream = new MemoryStream(240); BinaryWriter binaryWriter2 = new BinaryWriter(memoryStream); binaryWriter2.Write(MultitargetingHelpers.GetAssemblyQualifiedName(typeof(ResourceReader), this.typeConverter)); binaryWriter2.Write(ResourceManager.ResSetTypeName); binaryWriter2.Flush(); binaryWriter.Write((int)memoryStream.Length); binaryWriter.Write(memoryStream.GetBuffer(), 0, (int)memoryStream.Length); binaryWriter.Write(2); int num = this._resourceList.Count; if (this._preserializedData != null) { num += this._preserializedData.Count; } binaryWriter.Write(num); int[] array = new int[num]; int[] array2 = new int[num]; int num2 = 0; MemoryStream memoryStream2 = new MemoryStream(num * 40); BinaryWriter binaryWriter3 = new BinaryWriter(memoryStream2, Encoding.Unicode); Stream stream = null; PermissionSet permissionSet = new PermissionSet(PermissionState.None); permissionSet.AddPermission(new EnvironmentPermission(PermissionState.Unrestricted)); permissionSet.AddPermission(new FileIOPermission(PermissionState.Unrestricted)); try { permissionSet.Assert(); string tempFileName = Path.GetTempFileName(); File.SetAttributes(tempFileName, FileAttributes.Temporary | FileAttributes.NotContentIndexed); stream = new FileStream(tempFileName, FileMode.Open, FileAccess.ReadWrite, FileShare.Read, 4096, FileOptions.DeleteOnClose | FileOptions.SequentialScan); } catch (UnauthorizedAccessException) { stream = new MemoryStream(); } catch (IOException) { stream = new MemoryStream(); } finally { PermissionSet.RevertAssert(); } using (stream) { BinaryWriter binaryWriter4 = new BinaryWriter(stream, Encoding.UTF8); IFormatter objFormatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.File | StreamingContextStates.Persistence)); SortedList sortedList = new SortedList(this._resourceList, FastResourceComparer.Default); if (this._preserializedData != null) { foreach (KeyValuePair <string, ResourceWriter.PrecannedResource> keyValuePair in this._preserializedData) { sortedList.Add(keyValuePair.Key, keyValuePair.Value); } } IDictionaryEnumerator enumerator2 = sortedList.GetEnumerator(); while (enumerator2.MoveNext()) { array[num2] = FastResourceComparer.HashFunction((string)enumerator2.Key); array2[num2++] = (int)binaryWriter3.Seek(0, SeekOrigin.Current); binaryWriter3.Write((string)enumerator2.Key); binaryWriter3.Write((int)binaryWriter4.Seek(0, SeekOrigin.Current)); object value = enumerator2.Value; ResourceTypeCode resourceTypeCode = this.FindTypeCode(value, list); ResourceWriter.Write7BitEncodedInt(binaryWriter4, (int)resourceTypeCode); ResourceWriter.PrecannedResource precannedResource = value as ResourceWriter.PrecannedResource; if (precannedResource != null) { binaryWriter4.Write(precannedResource.Data); } else { this.WriteValue(resourceTypeCode, value, binaryWriter4, objFormatter); } } binaryWriter.Write(list.Count); for (int i = 0; i < list.Count; i++) { binaryWriter.Write(list[i]); } Array.Sort <int, int>(array, array2); binaryWriter.Flush(); int num3 = (int)binaryWriter.BaseStream.Position & 7; if (num3 > 0) { for (int j = 0; j < 8 - num3; j++) { binaryWriter.Write("PAD"[j % 3]); } } foreach (int value2 in array) { binaryWriter.Write(value2); } foreach (int value3 in array2) { binaryWriter.Write(value3); } binaryWriter.Flush(); binaryWriter3.Flush(); binaryWriter4.Flush(); int num4 = (int)(binaryWriter.Seek(0, SeekOrigin.Current) + memoryStream2.Length); num4 += 4; binaryWriter.Write(num4); binaryWriter.Write(memoryStream2.GetBuffer(), 0, (int)memoryStream2.Length); binaryWriter3.Close(); stream.Position = 0L; stream.CopyTo(binaryWriter.BaseStream); binaryWriter4.Close(); } binaryWriter.Flush(); this._resourceList = null; }