Click here to Skip to main content
15,349,767 members
Articles / Programming Languages / C#
Posted 19 Jun 2012

Tagged as


3 bookmarked

A Simple PList Parser in C#

Rate me:
Please Sign up or sign in to vote.
5.00/5 (4 votes)
19 Jun 2012CPOL2 min read
A simple plist parser within 100 lines of C# code.


Recently I've been put in charge of making a texture packaging tool at work. We are using pure C# (4.0) for our tools. I need to read and parse plist files in my code. I searched the Internet, but unfortunately it seems it's lacking a plist parser in C#. I understood plist grammar very quick even by reading a few sample files, since it would be easy to analyze for a human as well easy to recognize for a parser. I decided to reinvent this wheel.

Show me the code

The implementation is quite simple, I did it in about an hour. Let's take a quick look at the whole code: 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace Data
    public class PList : Dictionary<string, dynamic>
        public PList()

        public PList(string file)

        public void Load(string file)

            XDocument doc = XDocument.Load(file);
            XElement plist = doc.Element("plist");
            XElement dict = plist.Element("dict");

            var dictElements = dict.Elements();
            Parse(this, dictElements);

        private void Parse(PList dict, IEnumerable<XElement> elements)
            for (int i = 0; i < elements.Count(); i += 2)
                XElement key = elements.ElementAt(i);
                XElement val = elements.ElementAt(i + 1);

                dict[key.Value] = ParseValue(val);

        private List<dynamic> ParseArray(IEnumerable<XElement> elements)
            List<dynamic> list = new List<dynamic>();
            foreach (XElement e in elements)
                dynamic one = ParseValue(e);

            return list;

        private dynamic ParseValue(XElement val)
            switch (val.Name.ToString())
                case "string":
                    return val.Value;
                case "integer":
                    return int.Parse(val.Value);
                case "real":
                    return float.Parse(val.Value);
                case "true":
                    return true;
                case "false":
                    return false;
                case "dict":
                    PList plist = new PList();
                    Parse(plist, val.Elements());
                    return plist;
                case "array":
                    List<dynamic> list = ParseArray(val.Elements());
                    return list;
                    throw new ArgumentException("Unsupported");

It's never more clear, isn't it?

The LINQ and dynamic type benefit this lightweight class. It would cost more lines without them. This class is a recursive data structure, although we can't see PList property defined in it; the base class is Dictionary<string, dynamic>, and values in it could be a value of string/int/float/bool/PList/List<dynamic>. The parsing methods are recursive, since the recursive structure. The Parse method enumerates all key-value pairs in a piece of XML data and fill the parsed string-dynamic pairs into the PList structure; each step it will call the ParseValue method to parse a value; the ParseValue method calls data conversion methods or ParseArray or Parse recursively according to the type indicated in the name of a XML node; the ParseArray method enumerates all sub XML nodes and parse them to dynamic type by calling ParseValue recursively. Of course we could use object instead of dynamic out there, but we had to add more type discrimination when we were retrieving a value from a PList, that is something I'd like to avoid. 

Using the code

To parse a plist file, just code it as:

PList plist = new PList();


PList plist = new PList("file_path.plist");

To retrieve the parsed data it's all the same as using a generic Dictionary, considering the PList is derived from Dictionary<string, dynamic>. The code might looks crude, because I'd like to only show the main idea here without disturbing noise. I think you could and should polish it before using it, for example adding some error/exception handling, or adding a serialization method, etc. Those could be very simple tasks.

Have fun 

Making a plist parser in C# is easier than I expected, and it works fine for me. I hope it would help you too. 


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

China China
Video game player & creator; Hardware geek & maker.

Comments and Discussions

PraiseThanks you! Pin
Member 129986855-May-17 3:37
MemberMember 129986855-May-17 3:37 
SuggestionMore enhancements are required Pin
Shadi_7723-Nov-12 5:28
MemberShadi_7723-Nov-12 5:28 
QuestionWhy "dynamic" vs "object"? Pin
Matt T Heffron19-Jun-12 7:56
professionalMatt T Heffron19-Jun-12 7:56 
AnswerRe: Why "dynamic" vs "object"? Pin
Andreas Gieriet19-Jun-12 8:38
professionalAndreas Gieriet19-Jun-12 8:38 
SuggestionWhich plist format? Pin
Andreas Gieriet19-Jun-12 4:50
professionalAndreas Gieriet19-Jun-12 4:50 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.