private bool GetElementInfo(IntermediateSerializer serializer, MemberInfo member, out ElementInfo info) { info = new ElementInfo(); // Are we ignoring this property? if (ReflectionHelpers.GetCustomAttribute(member, typeof(ContentSerializerIgnoreAttribute)) != null) return false; var prop = member as PropertyInfo; var field = member as FieldInfo; // If we can write or read from it we can skip it. if (prop != null && (!prop.CanWrite || !prop.CanRead)) return false; // Default the to member name as the element name. info.Name = member.Name; var attrib = ReflectionHelpers.GetCustomAttribute(member, typeof(ContentSerializerAttribute)) as ContentSerializerAttribute; if (attrib != null) { if (!string.IsNullOrEmpty(attrib.ElementName)) info.Name = attrib.ElementName; } else if (prop != null) { if (!ReflectionHelpers.PropertyIsPublic(prop)) return false; } else if (field != null) { if (!field.IsPublic) return false; } if (prop != null) { info.Serializer = serializer.GetTypeSerializer(prop.PropertyType); info.Setter = (o, v) => prop.SetValue(o, v, null); info.Getter = (o) => prop.GetValue(o, null); } else if (field != null) { info.Serializer = serializer.GetTypeSerializer(field.FieldType); info.Setter = field.SetValue; info.Getter = field.GetValue; } return true; }
protected override void Initialize() { XMLDataPLine.MapData myMap = new XMLDataPLine.MapData(); myMap.mapName = "Battle In The Middle"; myMap.numberOfCastles = 8; myMap.allies.Add("Humans"); myMap.allies.Add("Elves"); myMap.allies.Add("Dwarves"); string fileName = "data.xml"; XmlWriter writer = XmlWriter.Create(fileName); IntermediateSerializer.Serialize <XMLDataPLine.MapData>(writer, myMap, fileName); writer.Close(); base.Initialize(); }
public void OptionalElements() { object result; var filePath = Paths.Xml("07_OptionalElements.xml"); using (var reader = XmlReader.Create(filePath)) result = IntermediateSerializer.Deserialize <object>(reader, filePath); Assert.NotNull(result); Assert.IsAssignableFrom <OptionalElements>(result); var optional = (OptionalElements)result; Assert.AreEqual(null, optional.a); Assert.AreEqual(null, optional.b); Assert.AreEqual(string.Empty, optional.c); }
public static T Deserialize <T>(string filename) { T data; if (!filename.EndsWith(".xml")) { filename += ".xml"; } using (FileStream stream = new FileStream(filename, FileMode.Open)) { using (XmlReader reader = XmlReader.Create(stream)) { data = IntermediateSerializer.Deserialize <T>(reader, null); } } return(data); }
public void CollectionItemName() { object result; var filePath = Paths.Xml("10_CollectionItemName.xml"); using (var reader = XmlReader.Create(filePath)) result = IntermediateSerializer.Deserialize <object>(reader, filePath); Assert.NotNull(result); Assert.IsAssignableFrom <CollectionItemName>(result); var collections = (CollectionItemName)result; Assert.NotNull(collections.StringArray); Assert.AreEqual(2, collections.StringArray.Length); Assert.AreEqual("Hello", collections.StringArray[0]); Assert.AreEqual("World", collections.StringArray[1]); }
public void Dictionaries() { object result; var filePath = Paths.Xml("11_Dictionaries.xml"); using (var reader = XmlReader.Create(filePath)) result = IntermediateSerializer.Deserialize <object>(reader, filePath); Assert.NotNull(result); Assert.IsAssignableFrom <Dictionaries>(result); var dictionaries = (Dictionaries)result; Assert.NotNull(dictionaries.TestDictionary); Assert.AreEqual(2, dictionaries.TestDictionary.Count); Assert.AreEqual(true, dictionaries.TestDictionary[23]); Assert.AreEqual(false, dictionaries.TestDictionary[42]); }
public void ExternalReferences() { object result; var filePath = Paths.Xml("17_ExternalReferences.xml"); using (var reader = XmlReader.Create(filePath)) result = IntermediateSerializer.Deserialize <object>(reader, filePath); Assert.NotNull(result); Assert.IsAssignableFrom <ExternalReferences>(result); var externalReferences = (ExternalReferences)result; Assert.NotNull(externalReferences.Texture); Assert.IsTrue(externalReferences.Texture.Filename.EndsWith(@"\Xml\grass.tga")); Assert.NotNull(externalReferences.Shader); Assert.IsTrue(externalReferences.Shader.Filename.EndsWith(@"\Xml\foliage.fx")); }
public virtual void saveGame(GameData data) { SaveData saveData; XmlWriter writer; XmlWriterSettings settings; saveData = new SaveData(); saveData.playerLevel = data.player.level; saveData.playerXP = data.player.XP; saveData.weaponMods = data.player.myWeapon.mods; saveData.mods = data.mods._content; saveData.firstModValue = data.mods.firstMod.value; saveData.missionLevels = new byte[4]; saveData.missionTKinds = new byte[4]; saveData.missionTCounts = new byte[4]; saveData.missionZones = new byte[4]; saveData.missionAreas = new byte[4]; saveData.missionStates = new bool[4]; saveData.missionKinds = new byte[4][]; for (int i = 0; i < 4; i++) { saveData.missionLevels[i] = data.missions[i].level; saveData.missionTKinds[i] = data.missions[i].target; saveData.missionTCounts[i] = data.missions[i].tarCount; //saveData.missionKinds[i] = data.missions[i].Kinds; saveData.missionZones[i] = data.missions[i].Zone; saveData.missionAreas[i] = data.missions[i].Area; saveData.missionStates[i] = data.missions[i].active; saveData.missionKinds[i] = data.missions[i].Kinds; } string filename = "doNotTouchThis.Never"; settings = new XmlWriterSettings(); settings.Indent = true; writer = XmlWriter.Create(filename, settings); using (writer) { IntermediateSerializer.Serialize(writer, saveData, null); } }
public override object Process(string inputClass, ContentProcessorContext context) { var inputType = findTypeForClass(inputClass, context); var xmlSettings = new XmlWriterSettings(); xmlSettings.Indent = true; var obj = Activator.CreateInstance(inputType); var outputString = new StringBuilder(); using (var xmlWriter = XmlWriter.Create(outputString, xmlSettings)) IntermediateSerializer.Serialize(xmlWriter, obj, null); context.Logger.LogMessage("\n------- BEGIN XML TEMPLATE -------\n{0}\n------- END XML TEMPLATE -------\n", outputString); throw new Exception("------ DISREGARD THIS EXCEPTION. IT IS THROWN ONLY SO THE XNB DOESNT GET WRITTEN TO THE PROJECT FILE"); }
protected internal override void Initialize(IntermediateSerializer serializer) { var properties = TargetType.GetAllProperties(); foreach (var prop in properties) { ElementInfo info; if (GetElementInfo(serializer, prop, out info)) _elements.Add(info.Name, info); } var fields = TargetType.GetAllFields(); foreach (var field in fields) { ElementInfo info; if (GetElementInfo(serializer, field, out info)) _elements.Add(info.Name, info); } }
/* The Load<T>() function loads an object from a certain file path. */ public static T Load <T>(string path) { /* A generically typed variable is declared, which will be returned at the end. * Using a new FileStream with Open as the FileMode, and an XmlReader that uses the stream, * the object is deserialized from the XML file in the path. */ T data; using (FileStream stream = new FileStream(path, FileMode.Open)) { using (XmlReader reader = XmlReader.Create(stream)) { data = IntermediateSerializer.Deserialize <T>(reader, null); } } /* The object is then returned. */ return(data); }
internal CollectionHelper(IntermediateSerializer serializer, Type type) { this.targetType = type; Type type2 = CollectionUtils.CollectionElementType(type, false); if (type2 == null) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.NotACollectionType, new object[] { type })); } this.contentSerializer = serializer.GetTypeSerializer(type2); Type type3 = typeof(ICollection<>).MakeGenericType(new Type[] { type2 }); this.countPropertyGetter = ReflectionEmitUtils.GenerateGetter(type3.GetProperty("Count")); this.addToCollection = ReflectionEmitUtils.GenerateAddToCollection(type3, type2); }
public static void SerializeMap <T>(string filename, T data) { XmlWriterSettings settings = new XmlWriterSettings { Indent = true }; if (!filename.EndsWith(".xml")) { filename += ".xml"; } //filename = "/TestGame/Content/maps/" + filename; filename = "Content/maps/" + filename; //filename = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName + filename; using (XmlWriter writer = XmlWriter.Create(filename, settings)) { IntermediateSerializer.Serialize <T>(writer, data, null); } }
public static T LoadXML <T>(String filename) { Object data = null; if (!filename.EndsWith(".xml", true, System.Globalization.CultureInfo.CurrentCulture)) { filename = filename + ".xml"; } XmlReaderSettings xmlSettings = new XmlReaderSettings(); xmlSettings.IgnoreComments = true; using (XmlReader xmlReader = XmlReader.Create(filename, xmlSettings)) { data = IntermediateSerializer.Deserialize <T>(xmlReader, filename); } return((T)data); }
public void Namespaces() { object result; var filePath = Paths.Xml("14_Namespaces.xml"); using (var reader = XmlReader.Create(filePath)) result = IntermediateSerializer.Deserialize <object>(reader, filePath); Assert.NotNull(result); Assert.IsAssignableFrom <NamespaceClass>(result); var namespaceClass = (NamespaceClass)result; Assert.IsAssignableFrom <NamespaceHelper>(namespaceClass.A); Assert.AreEqual(true, ((NamespaceHelper)namespaceClass.A).Value); Assert.IsAssignableFrom <Vector2>(namespaceClass.B); Assert.AreEqual(Vector2.Zero, namespaceClass.B); Assert.IsAssignableFrom <SpriteSortMode>(namespaceClass.C); Assert.AreEqual(SpriteSortMode.Immediate, namespaceClass.C); }
private void SaveCurve_Click(object sender, RoutedEventArgs e) { CurveTreeLeaf leaf = ((FrameworkElement)sender).DataContext as CurveTreeLeaf; if (leaf == null) { return; } // Get the actual curve to save. Curve curve = leaf.Curve.Curve; if (curve == null) { return; } // Configure save file dialog box Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog(); dlg.FileName = leaf.Curve.Name; // Default file name dlg.DefaultExt = ".xml"; // Default file extension dlg.Filter = "Xml files (.xml)|*.xml"; // Filter files by extension // Show save file dialog box Nullable <bool> result = dlg.ShowDialog(); // Process save file dialog box results if (result != true) { return; } // Write! using (var streamOut = new FileStream(dlg.FileName, FileMode.Create)) { XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.IndentChars = " "; XmlWriter writer = XmlWriter.Create(streamOut, settings); IntermediateSerializer.Serialize <Curve>(writer, curve, dlg.FileName); writer.Close(); } }
/// <summary> /// Loads all factories found at the specified path. /// </summary> /// <param name="path">The path.</param> public static void Load(string path) { SavePath = path; SavePath += '/'; SavePath = SavePath.Replace('\\', '/'); SavePath = SavePath.Substring(0, SavePath.LastIndexOf('/') + 1); Clear(); foreach (var file in Directory.GetFiles(path, "*.xml", SearchOption.AllDirectories)) { using (var reader = new XmlTextReader(file)) { try { var attributePools = IntermediateSerializer.Deserialize <object>(reader, null) as AttributePool[]; if (attributePools != null) { foreach (var attributePool in attributePools) { // Adjust paths. foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(attributePool, new Attribute[] { new EditorAttribute(typeof(TextureAssetEditor), typeof(UITypeEditor)) })) { var value = property.GetValue(attributePool) as string; if (!string.IsNullOrWhiteSpace(value)) { property.SetValue(attributePool, value.Replace('\\', '/')); } } Add(attributePool); AttributePoolFilenames.Add(attributePool, file); } } } catch (InvalidContentException ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); } } } }
private void loadAnimationToolStripMenuItem_Click(object sender, EventArgs e) { if (loadAnimationDialog.ShowDialog() == DialogResult.OK) { Animation loadedAnimation; using (XmlReader xmlRead = XmlReader.Create(loadAnimationDialog.FileName)) { loadedAnimation = IntermediateSerializer.Deserialize <Animation>(xmlRead, null); } if (animationBox.Enabled == false) { EnableAnimationEditingControls(); InitiateAnimationList(); } AddAnimation(loadedAnimation); currentAnimation = animations[animationBox.SelectedIndex]; ReadAnimationInfo(); UpdateAnimation(); } }
public override List <byte[]> Import(string filename, ContentImporterContext context) { List <byte[]> imageData = new List <byte[]>(); List <string> imageFilenames; context.AddDependency(Path.Combine(Environment.CurrentDirectory, filename)); using (XmlReader reader = XmlReader.Create(filename)) { imageFilenames = IntermediateSerializer.Deserialize <List <string> >(reader, null); } foreach (string imageFilename in imageFilenames) { byte[] imageBytes = File.ReadAllBytes(imageFilename); imageData.Add(imageBytes); context.AddDependency(Path.Combine(Environment.CurrentDirectory, imageFilename)); } return(imageData); }
public void TheBasics() { object result; var filePath = Paths.Xml("01_TheBasics.xml"); using (var reader = XmlReader.Create(filePath)) result = IntermediateSerializer.Deserialize <object>(reader, filePath); Assert.NotNull(result); Assert.IsAssignableFrom <TheBasics>(result); var theBasics = (TheBasics)result; Assert.AreEqual(1, theBasics.PublicField); Assert.AreEqual(0, theBasics.InternalField); Assert.AreEqual("Hello World", theBasics.GetSetProperty); Assert.NotNull(theBasics.Nested); Assert.AreEqual("Shawn", theBasics.Nested.Name); Assert.AreEqual(true, theBasics.Nested.IsEnglish); }
public virtual void loadGame(GameData data) { string filename = "doNotTouchThis.Never"; XmlReaderSettings settings = new XmlReaderSettings(); SaveData saveData; XmlReader reader; reader = XmlReader.Create(filename, settings); using (reader) { saveData = IntermediateSerializer.Deserialize <SaveData>(reader, null); } byte[][] kinds = saveData.missionKinds; data.loadData(saveData.playerLevel, saveData.playerXP, saveData.weaponMods, saveData.mods, saveData.missionLevels, saveData.missionTKinds, saveData.missionTCounts, saveData.missionZones, saveData.missionAreas, saveData.missionStates, saveData.missionKinds, saveData.firstModValue); }
public void SharedResources() { object result; var filePath = Paths.Xml("16_SharedResources.xml"); using (var reader = XmlReader.Create(filePath)) result = IntermediateSerializer.Deserialize <object>(reader, filePath); Assert.NotNull(result); Assert.IsAssignableFrom <SharedResources>(result); var sharedResources = (SharedResources)result; Assert.NotNull(sharedResources.Head); Assert.AreEqual(1, sharedResources.Head.Value); Assert.NotNull(sharedResources.Head.Next); Assert.AreEqual(2, sharedResources.Head.Next.Value); Assert.NotNull(sharedResources.Head.Next.Next); Assert.AreEqual(3, sharedResources.Head.Next.Next.Value); Assert.AreSame(sharedResources.Head, sharedResources.Head.Next.Next.Next); }
static void Main(string[] args) { Console.Write("Type in the number of which level to build (none for test level): "); int input; LevelData ExampleData; string exportPath = "../../../NDE/NDEContent/levels/"; try { input = Convert.ToInt32(Console.ReadLine()); } catch (OverflowException) { input = 0; } catch (FormatException) { input = 0; } if (input > 0) { exportPath += "level" + input + ".xml"; LevelCreator newLevel = new LevelCreator(); ExampleData = newLevel.buildLevel(Convert.ToInt32(input)); } else { exportPath += "dummyLevel.xml"; ExampleData = dummyLevel(); } // Set up XML writer XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; // Export directly to NDEContent directory for immediate deserialization using (XmlWriter writer = XmlWriter.Create(exportPath, settings)) IntermediateSerializer.Serialize(writer, ExampleData, null); }
private void LoadSpriteMap() { if (loadMapDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK) { CurrentSpriteMapFileLocation = loadMapDialog.FileName; Dictionary <string, Sprite> loadedSpriteMap; using (XmlReader xmlRead = XmlReader.Create(CurrentSpriteMapFileLocation)) { loadedSpriteMap = IntermediateSerializer.Deserialize <Dictionary <string, Sprite> >(xmlRead, null); } sprites = new BindingList <Sprite>(); foreach (KeyValuePair <string, Sprite> sprite in loadedSpriteMap) { sprites.Add(sprite.Value); } spriteList.DataSource = sprites; } }
public void FlattenContent() { object result; var filePath = Paths.Xml("15_FlattenContent.xml"); using (var reader = XmlReader.Create(filePath)) result = IntermediateSerializer.Deserialize <object>(reader, filePath); Assert.NotNull(result); Assert.IsAssignableFrom <FlattenContent>(result); var flattenContent = (FlattenContent)result; Assert.IsAssignableFrom <NestedClass>(flattenContent.Nested); Assert.NotNull(flattenContent.Nested); Assert.AreEqual("Shawn", flattenContent.Nested.Name); Assert.AreEqual(true, flattenContent.Nested.IsEnglish); Assert.NotNull(flattenContent.Collection); Assert.AreEqual(2, flattenContent.Collection.Length); Assert.AreEqual("Hello", flattenContent.Collection[0]); Assert.AreEqual("World", flattenContent.Collection[1]); }
public string GetContentAsXml() { if (xmlContent == null) { if (base.Count == 0) { xmlContent = string.Empty; } else { StringBuilder output = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(output)) { IntermediateSerializer.Serialize <OpaqueDataDictionary>(writer, this, null); } this.xmlContent = output.ToString(); } } return(this.xmlContent); }
public void UnitEditorMapMenuSave() { XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; string path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); //string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); path += @"\SavedUnitData\"; if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } using (XmlWriter writer = XmlWriter.Create( path + Save_Name + ".xml", settings)) { IntermediateSerializer.Serialize(writer, _unitData, null); } LastSavedUnitData = new Map_Unit_Data(_unitData); }
public static T DeserializeMap <T>(string filename) { T data; if (!filename.EndsWith(".xml")) { filename += ".xml"; } //filename = "/TestGame/Content/maps/" + filename; filename = "Content/maps/" + filename; //filename = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName + filename; Debug.WriteLine(filename); using (FileStream stream = new FileStream(filename, FileMode.Open)) { using (XmlReader reader = XmlReader.Create(stream)) { data = IntermediateSerializer.Deserialize <T>(reader, null); } } return(data); }
private static string Serialize <T>(string filePath, T value) { string referenceRelocationPath = filePath; // Note: Can't use StringBuilder here because it is always UTF-16, // while our test XML files use a UTF-8 encoding. var memoryStream = new MemoryStream(); var xmlWriterSettings = new XmlWriterSettings { Encoding = Encoding.UTF8, Indent = true }; using (var writer = XmlWriter.Create(memoryStream, xmlWriterSettings)) IntermediateSerializer.Serialize(writer, value, referenceRelocationPath); memoryStream.Position = 0; var actualXml = new StreamReader(memoryStream).ReadToEnd(); return(actualXml); }
/* When the Export World button is pressed start a routine to serialize the world */ private void ExportWorld_Click(object sender, EventArgs e) { ObjectList.TopNode.Tag = game.root; /* If the world have a name */ if (this.textBox1.Text != "") { /* Start a dialog to choose where to save the exported file */ SaveFileDialog saveFile = new SaveFileDialog(); saveFile.Title = "Save World"; saveFile.DefaultExt = ".xml"; saveFile.Filter = "XML Files (*.xml)|*.xml|" + "All Files (*.*)|*.*"; saveFile.AddExtension = true; saveFile.OverwritePrompt = true; saveFile.FileName = this.textBox1.Text; if (saveFile.ShowDialog() == System.Windows.Forms.DialogResult.OK) { /* Transfrom the services of the created World Objects to Factories */ this.game.root = (WorldObject)this.ObjectList.TopNode.Tag; Cursor = Cursors.WaitCursor; ServicesToFactories(this.game.root); /* Start the serialization */ XmlWriterSettings xmlSettings = new XmlWriterSettings(); xmlSettings.Indent = true; using (XmlWriter xmlWriter = XmlWriter.Create(saveFile.FileName, xmlSettings)) { IntermediateSerializer.Serialize(xmlWriter, this.game.root, null); } } Cursor = Cursors.Arrow; this.game.Exit(); this.Close(); } /* In case that the world name is not yet defined ask for one */ else { //InsertName insertName = new InsertName(); //insertName.ShowDialog(); } }
/// <summary> /// Save the current state of this GameLevel as an XML file. /// </summary> /// <param name="path">File path to save this GameLevel.</param> public void saveLevel(String path) { // XML writer settings for serialization XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; // GameLevelData to hold state data GameLevelData data = new GameLevelData(); // Save GameTiles data.NumRows = _tileRows; data.NumCols = _tileCols; data.Tiles = new GameTileData[_tileRows * _tileCols]; for (int row = 0; row < _tileRows; row++) { for (int col = 0; col < _tileCols; col++) { data.Tiles[row * _tileCols + col] = _tiles[row, col].save(); } } // Save GameObjects data.GameObjs = new GameObjectData[_gameObjs.Count]; int i = 0; foreach (KeyValuePair <String, GameObject> entry in _gameObjs) { data.GameObjs[i] = entry.Value.save(); i++; } // Write XML file using (XmlWriter writer = XmlWriter.Create(path + ".xml", settings)) IntermediateSerializer.Serialize(writer, data, null); // Print success message to console Console.WriteLine("Current level saved to: " + path); }
private Dictionary <string, Sprite> LoadSpriteMapFromFile() { if (loadSpriteMapDialog.ShowDialog() == DialogResult.OK) { Dictionary <string, Sprite> loadedSpriteMap; using (XmlReader xmlRead = XmlReader.Create(loadSpriteMapDialog.FileName)) { loadedSpriteMap = IntermediateSerializer.Deserialize <Dictionary <string, Sprite> >(xmlRead, null); } spriteMap = new BindingList <Sprite>(); foreach (KeyValuePair <string, Sprite> sprite in loadedSpriteMap) { spriteMap.Add(sprite.Value); } spriteMapListBox.DataSource = spriteMap; spriteMapListBox.DisplayMember = "Name"; spriteMapListBox.ValueMember = "Bounds"; //enable spriteMap-required controls addSpriteToFrameListButton.Enabled = true; addSpriteToFrameSpritesButton.Enabled = true; replaceSpriteButton.Enabled = true; if (currentAnimation == null) { frames = new BindingList <Frame>(); frameListBox.DataSource = frames; frameListBox.DisplayMember = "Name"; InitiateAnimationList(); } EnableAnimationEditingControls(); return(loadedSpriteMap); } return(null); }
/// <summary> /// Loads all factories found at the specified path. /// </summary> /// <param name="path">The path.</param> public static void Load(string path) { Clear(); foreach (var file in Directory.GetFiles(path, "*.xml", SearchOption.AllDirectories)) { using (var reader = new XmlTextReader(file)) { try { var factories = IntermediateSerializer.Deserialize <object>(reader, null) as IFactory[]; if (factories != null) { foreach (var factory in factories) { // Adjust paths. foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(factory, new Attribute[] { new EditorAttribute(typeof(TextureAssetEditor), typeof(UITypeEditor)) })) { var value = property.GetValue(factory) as string; if (!string.IsNullOrWhiteSpace(value)) { property.SetValue(factory, value.Replace('\\', '/')); } } Add(factory); FactoryFilenames.Add(factory, file); } } } catch (InvalidContentException ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); } } } }
/// <summary>Retrieves and caches any nested type serializers and allows reflection over the target data type.</summary> /// <param name="serializer">The content serializer.</param> protected internal virtual void Initialize(IntermediateSerializer serializer) { }
protected internal override void ScanChildren(IntermediateSerializer serializer, ChildCallback callback, object value) { throw new NotImplementedException(); }
protected internal override void Initialize(IntermediateSerializer serializer) { // If we have a base type then we need to deserialize it first. if (TargetType.BaseType != null) _baseSerializer = serializer.GetTypeSerializer(TargetType.BaseType); // Cache all our serializable properties. var properties = TargetType.GetProperties(_bindingFlags); foreach (var prop in properties) { ElementInfo info; if (GetElementInfo(serializer, prop, out info)) _elements.Add(info); } // Cache all our serializable fields. var fields = TargetType.GetFields(_bindingFlags); foreach (var field in fields) { ElementInfo info; if (GetElementInfo(serializer, field, out info)) _elements.Add(info); } }
private bool GetElementInfo(IntermediateSerializer serializer, MemberInfo member, out ElementInfo info) { info = new ElementInfo(); // Are we ignoring this property? if (ReflectionHelpers.GetCustomAttribute<ContentSerializerIgnoreAttribute>(member) != null) return false; var prop = member as PropertyInfo; var field = member as FieldInfo; var attrib = ReflectionHelpers.GetCustomAttribute<ContentSerializerAttribute>(member); if (attrib != null) { // Store the attribute for later use. info.Attribute = attrib.Clone(); // Default the to member name as the element name. if (string.IsNullOrEmpty(attrib.ElementName)) info.Attribute.ElementName = member.Name; } else { // We don't have a serializer attribute, so we can // only access this member thru a public field/property. if (prop != null) { // If we don't have at least a public getter then this // property can't be serialized or deserialized in any way. if (prop.GetGetMethod() == null) return false; // If there is a setter, but it's private, then don't include this element // (although technically we could, as long as we have a serializer with // CanDeserializeIntoExistingObject=true for this property type) var setter = prop.GetSetMethod(true); if (setter != null && !setter.IsPublic) return false; // If there is no setter, and we don't have a type serializer // that can deserialize into an existing object, then we have no way // for it to be deserialized. if (setter == null && !serializer.GetTypeSerializer(prop.PropertyType).CanDeserializeIntoExistingObject) return false; // Don't serialize or deserialize indexers. if (prop.GetIndexParameters().Any()) return false; } else if (field != null) { if (!field.IsPublic) return false; } info.Attribute = new ContentSerializerAttribute(); info.Attribute.ElementName = member.Name; } if (prop != null) { info.Serializer = serializer.GetTypeSerializer(prop.PropertyType); if (prop.CanWrite) info.Setter = (o, v) => prop.SetValue(o, v, null); info.Getter = o => prop.GetValue(o, null); } else if (field != null) { info.Serializer = serializer.GetTypeSerializer(field.FieldType); info.Setter = field.SetValue; info.Getter = field.GetValue; } return true; }
protected internal override void ScanChildren (IntermediateSerializer serializer, ChildCallback callback, object value) { base.ScanChildren (serializer, callback, value); }
protected internal override void ScanChildren(IntermediateSerializer serializer, ChildCallback callback, object value) { if (serializer.AlreadyScanned(value)) return; // First scan the base type. if (_baseSerializer != null) _baseSerializer.ScanChildren(serializer, callback, value); // Now scan our own elements. foreach (var info in _elements) { var elementValue = info.Getter(value); callback(info.Serializer, elementValue); var elementSerializer = info.Serializer; if (elementValue != null) elementSerializer = serializer.GetTypeSerializer(elementValue.GetType()); elementSerializer.ScanChildren(serializer, callback, elementValue); } }
/// <summary>Examines the children of the specified object, passing each to a callback delegate.</summary> /// <param name="serializer">The content serializer.</param> /// <param name="callback">The method to be called for each examined child.</param> /// <param name="value">The object whose children are being scanned.</param> protected internal virtual void ScanChildren(IntermediateSerializer serializer, ContentTypeSerializer.ChildCallback callback, object value) { }