C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;
using System.Linq;
					
public class Program
{
	public static void Main()
	{
		Console.WriteLine("Hello World");
	}
	
	public enum PrecisionType
    {
        Titre = 0,
        TextItem = 1
    }

    #region Precision
    public class PrecisionChoice
    {
        public PrecisionChoice()
        {
           
        }

        public PrecisionChoice(string value)
        {
            _value = value;
        }

        private string _value;

	    public string Value
	    {
		    get { return _value;}
		    set 
            {
                if (_value != value)
                {
                    _value = value;
                    NotifyPropertyChanged("Value");
                }
            }
	    }

        public override string ToString()
        {
            return _value;
        }
    }

    public class PrecisionChoices : List<PrecisionChoice>
    {
        public PrecisionChoices()
        {
        }

        internal PrecisionChoices(string src)
        {
            if (string.IsNullOrEmpty(src))
                return;

            char[] separators = { ';' };
            string[] lines = src.Split(separators);
            foreach (string line in lines)
            {
                if (!string.IsNullOrEmpty(line))
                    base.Add(new PrecisionChoice(line));
            }
        }

        public override string ToString()
        {
            string ret = "";

            foreach (PrecisionChoice item in Items)
            {
                if (!string.IsNullOrEmpty(item.Value))
                {
                    if (string.IsNullOrEmpty(ret))
                        ret = item.Value;
                    else
                        ret = ret + ";" + item.Value;
                }
            }

            return ret;
        }
    }


    public class PrecisionGroup
    {
        public PrecisionGroup()
        {

        }

        public override string ToString()
        {
            if (!string.IsNullOrEmpty(_nom))
                return _nom;

            return base.ToString();
        }

        private string _nom;

        public string Nom
        {
            get
            {
                if (_nom == null)
                    return string.Empty;

                return _nom;
            }
            set
            {
                if (_nom != value)
                {
                    _nom = value;
                    NotifyPropertyChanged("Nom");
                }
            }
        }


        private bool _isPrintable = true;

        public bool IsPrintable
        {
            get
            {
                return _isPrintable;
            }
            set
            {
                if (_isPrintable != value)
                {
                    _isPrintable = value;
                    NotifyPropertyChanged("IsPrintable");
                }
            }
        }

        private PrecisionItems _precisions;

        public PrecisionItems Items
        {
            get 
            {
                if (_precisions == null)
                {
                    _precisions = new PrecisionItems();
                }

                return _precisions; 
            }
        }
    }

    public class PrecisionItems : List<Precision>
    {
        public PrecisionItems()
        {

        }

        public Precision Find(string name)
        {
            if (string.IsNullOrEmpty(name))
                return null;

            foreach (Precision item in Items)
                if (!string.IsNullOrEmpty(item.Nom) && item.Nom.ToLower() == name.ToLower())
                    return item;

            return null;
        }

        public void AddOrUpdateNotEmpty(string name, string value)
        {
            if (string.IsNullOrEmpty(value))
                return;

            AddOrUpdate(name, value);
        }

        public Precision this[string name]
        {
            get
            {
                foreach (Precision item in Items)
                {
                    if (item.Nom.ToLower() == name.ToLower())
                        return item;
                }
                
                Precision newItem = new Precision();

                newItem.Nom = name;
                newItem.Value = string.Empty;
                newItem.Type = PrecisionType.TextItem;

                base.Add(newItem);

                return newItem;
            }
        }

        public void AddOrUpdate(string name, string value)
        {
            Precision newItem = null;
            foreach (Precision item in Items)
            {
                if (item.Nom.ToLower() == name.ToLower())
                {
                    newItem = item;
                    break;
                }
            }

            if (newItem == null)
            {
                newItem = new Precision();
                base.Add(newItem);
            }

            newItem.Nom = name;
            newItem.Value = value;
            newItem.Type = PrecisionType.TextItem;

        }

        public void Add(string name, string value)
        {
            Precision newItem = new Precision();
            base.Add(newItem);

            newItem.Nom = name;
            newItem.Value = value;
            newItem.Type = PrecisionType.TextItem;
        }
    }

    public class Precision
    {
        public Precision()
        {

        }
        /*
        public static implicit operator Precision(string f)
        {
            return new Precision();
        }
        */
        public override string ToString()
        {
            return _nom;
        }

        private PrecisionType _type;

        public PrecisionType Type
        {
            get
            {
                return _type;
            }
            set
            {
                if (_type != value)
                {
                    _type = value;
                    NotifyPropertyChanged("Type");
                }
            }
        }

        private string _nom;

        public string Nom
        {
            get
            {
                if (_nom == null)
                    return string.Empty;

                return _nom;
            }
            set
            {
                if (_nom != value)
                {
                    _nom = value;
                    NotifyPropertyChanged("Nom");
                }
            }
        }

        private string _value;

        public string Value
        {
            get { return _value; }
            set
            {
                if (_value != value)
                {
                    _value = value;
                    NotifyPropertyChanged("Value");
                }
            }
        }

//        private string _choices;
        private PrecisionChoices _choices;

        internal string ChoicesForSerialisation
        {
            get 
            {
                if (_choices == null)
                    return "";

                return _choices.ToString(); 
            }
            set
            {
                if (_choices == null || _choices.ToString() != value)
                {
                    _choices = new PrecisionChoices(value);

                    NotifyPropertyChanged("Choices");
                }
            }
        }
        public PrecisionChoices Choices
        {
            get 
            {
                if (_choices == null)
                {
                    _choices = new PrecisionChoices("");
                }

                return _choices; 
            }

        }
    }
    #endregion

    #region PrecisionGroups
    public class PrecisionGroups : List<PrecisionGroup>
    {
        public PrecisionGroups()
        {
        }

        public void AddOrUpdateNotEmptyItem(string groupName, string itemName, string value)
        {
            if (string.IsNullOrEmpty(value))
                return;

            this[groupName].Items.AddOrUpdateNotEmpty(itemName, value);
        }

        public void DeleteSubItem(string name)
        {
            for (int i = Items.Count-1 ; i >= 0 ; i--)            
            {
                PrecisionGroup group = Items[i];
                Precision ret = group.Items.Find(name);
                if (ret != null)
                {
                    group.Items.Remove(ret);
                    if (group.Items.Count == 0)
                        Items.Remove(group);
                }
            }            
        }

        public void MoveGroupToEnd(string groupName)
        {
            PrecisionGroup gp = Find(groupName);
            if (gp != null)
            {
                base.Remove(gp);
                base.Add(gp);
            }
        }

        public void MoveToEnd(PrecisionGroup gp)
        {
            base.Remove(gp);
            base.Add(gp);
        }

        public PrecisionGroup Add(string name)
        {
            PrecisionGroup newGroup = new PrecisionGroup();
            base.Add(newGroup);
            newGroup.Nom = name;
            return newGroup;
        }

        public Precision FindItem(string name)
        {
            foreach (PrecisionGroup group in Items)
            {
                Precision ret = group.Items.Find(name);
                if (ret != null)
                    return ret;
            }

            return null;
        }

        public PrecisionGroup Find(string name)
        {
            foreach (PrecisionGroup group in Items)
                if (group.Nom == name)
                    return group;

            return null;
        }

        public PrecisionGroup this[string name]
        {
            get
            {
                return AddOrUpdate(name);
            }
        }

        public PrecisionGroup AddOrUpdate(string name)
        {
            foreach (PrecisionGroup group in Items)
                if (group.Nom == name)
                    return group;

            PrecisionGroup newGroup = new PrecisionGroup();
            base.Add(newGroup);
            newGroup.Nom = name;
            return newGroup;
        }

        public PrecisionGroups(string src)
        {
            if (string.IsNullOrEmpty(src))
                return;

            PrecisionGroup curGroup = null;

            char[] separators = { 'ÿ' };
            string[] lines = src.Split(separators);
            foreach (string line in lines)
            {
                char[] colseparators = { '\t' };
                string[] columns = line.Split(colseparators);

                Precision prec = new Precision();

                int type = 0;
                for (int col = 0; col < columns.Length; col++)
                {                    
                    switch (col)
                    {
                        case 0:                            
                            int.TryParse(columns[col], out type);
                            prec.Type = (PrecisionType) type;
                            break;
                        case 1:
                            prec.Nom = columns[col].Trim();
                            break;
                        case 2:
                            prec.Value = columns[col];
                            break;
                        case 3:
                            prec.ChoicesForSerialisation = columns[col];
                            break;
                    }
                }

                if (type == 0)
                {
                    curGroup = new PrecisionGroup();
                    curGroup.Nom = prec.Nom;
                    if (prec.Value == "1")
                        curGroup.IsPrintable = false;

                    base.Add(curGroup);
                }
                else
                    if (curGroup != null)
                        curGroup.Items.Add(prec);
                    else
                    {
                        curGroup = new PrecisionGroup();
                        curGroup.Nom = "Divers";
                        curGroup.Items.Add(prec);
                        base.Add(curGroup);
                    }
            }
        }

        public override string ToString()
        {
            string ret = "";

            foreach (PrecisionGroup grp in Items)
            {
                if (string.IsNullOrEmpty(ret))
                    ret = "0\t" + grp.Nom+"\t"+(grp.IsPrintable?"":"1")+"\t";
                else
                    ret = ret + "ÿ0\t" + grp.Nom + "\t" + (grp.IsPrintable ? "" : "1") + "\t";

                foreach (Precision item in grp.Items)
                    ret = ret + "ÿ" + ((int)item.Type).ToString() + "\t" + item.Nom + "\t" + item.Value + "\t" + item.ChoicesForSerialisation;
            }

            return ret;
        }
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
                    
public class Program
{
    public static void Main()
    {
        Console.WriteLine("Hello World");
    }
    
    public enum PrecisionType
    {
        Titre = 0,
        TextItem = 1
    }
​
    #region Precision
    public class PrecisionChoice
    {
        public PrecisionChoice()
        {
           
        }
​
        public PrecisionChoice(string value)
        {
            _value = value;
        }
​
        private string _value;
​
        public string Value
        {
            get { return _value;}
            set 
            {
                if (_value != value)
                {
                    _value = value;
                    NotifyPropertyChanged("Value");
                }
            }
        }
​
        public override string ToString()
        {
            return _value;
        }
    }
​
    public class PrecisionChoices : List<PrecisionChoice>
    {
        public PrecisionChoices()
        {
        }
​
        internal PrecisionChoices(string src)
        {
            if (string.IsNullOrEmpty(src))
                return;
​
            char[] separators = { ';' };
            string[] lines = src.Split(separators);
            foreach (string line in lines)
            {
                if (!string.IsNullOrEmpty(line))
                    base.Add(new PrecisionChoice(line));
            }
        }
​
        public override string ToString()
        {
            string ret = "";
​
            foreach (PrecisionChoice item in Items)
            {
                if (!string.IsNullOrEmpty(item.Value))
                {
                    if (string.IsNullOrEmpty(ret))
                        ret = item.Value;
                    else
                        ret = ret + ";" + item.Value;
                }
            }
​
            return ret;
        }
    }
​
​
    public class PrecisionGroup
    {
        public PrecisionGroup()
        {
​
        }
​
        public override string ToString()
        {
            if (!string.IsNullOrEmpty(_nom))
                return _nom;
​
            return base.ToString();
        }
​
        private string _nom;
​
        public string Nom
        {
            get
            {
                if (_nom == null)
                    return string.Empty;
​
                return _nom;
            }
            set
            {
                if (_nom != value)
                {
                    _nom = value;
                    NotifyPropertyChanged("Nom");
                }
            }
        }
​
​
        private bool _isPrintable = true;
​
        public bool IsPrintable
        {
            get
            {
                return _isPrintable;
            }
            set
            {
                if (_isPrintable != value)
                {
                    _isPrintable = value;
                    NotifyPropertyChanged("IsPrintable");
                }
            }
        }
​
        private PrecisionItems _precisions;
​
        public PrecisionItems Items
        {
            get 
            {
                if (_precisions == null)
                {
                    _precisions = new PrecisionItems();
                }
​
                return _precisions; 
            }
        }
    }
​
    public class PrecisionItems : List<Precision>
    {
        public PrecisionItems()
        {
​
        }
​
        public Precision Find(string name)
        {
            if (string.IsNullOrEmpty(name))
                return null;
​
            foreach (Precision item in Items)
                if (!string.IsNullOrEmpty(item.Nom) && item.Nom.ToLower() == name.ToLower())
                    return item;
​
            return null;
        }
​
        public void AddOrUpdateNotEmpty(string name, string value)
        {
            if (string.IsNullOrEmpty(value))
                return;
​
            AddOrUpdate(name, value);
        }
​
        public Precision this[string name]
        {
            get
            {
                foreach (Precision item in Items)
                {
                    if (item.Nom.ToLower() == name.ToLower())
                        return item;
                }
                
                Precision newItem = new Precision();
​
                newItem.Nom = name;
                newItem.Value = string.Empty;
                newItem.Type = PrecisionType.TextItem;
​
                base.Add(newItem);
​
                return newItem;
            }
        }
​
        public void AddOrUpdate(string name, string value)
        {
            Precision newItem = null;
            foreach (Precision item in Items)
            {
                if (item.Nom.ToLower() == name.ToLower())
                {
                    newItem = item;
                    break;
                }
            }
​
            if (newItem == null)
            {
                newItem = new Precision();
                base.Add(newItem);
            }
​
            newItem.Nom = name;
            newItem.Value = value;
            newItem.Type = PrecisionType.TextItem;
​
        }
​
        public void Add(string name, string value)
        {
            Precision newItem = new Precision();
            base.Add(newItem);
​
            newItem.Nom = name;
            newItem.Value = value;
            newItem.Type = PrecisionType.TextItem;
        }
    }
​
    public class Precision
    {
        public Precision()
        {
​
        }
        /*
        public static implicit operator Precision(string f)
        {
            return new Precision();
        }
        */
        public override string ToString()
        {
            return _nom;
        }
​
        private PrecisionType _type;
​
        public PrecisionType Type
        {
            get
            {
                return _type;
            }
            set
            {
                if (_type != value)
                {
                    _type = value;
                    NotifyPropertyChanged("Type");
                }
            }
        }
​
        private string _nom;
​
        public string Nom
        {
            get
            {
                if (_nom == null)
                    return string.Empty;
​
                return _nom;
            }
            set
            {
                if (_nom != value)
                {
                    _nom = value;
                    NotifyPropertyChanged("Nom");
                }
            }
        }
​
        private string _value;
​
        public string Value
        {
            get { return _value; }
            set
            {
                if (_value != value)
                {
                    _value = value;
                    NotifyPropertyChanged("Value");
                }
            }
        }
​
//        private string _choices;
        private PrecisionChoices _choices;
​
        internal string ChoicesForSerialisation
        {
            get 
            {
                if (_choices == null)
                    return "";
​
                return _choices.ToString(); 
            }
            set
            {
                if (_choices == null || _choices.ToString() != value)
                {
                    _choices = new PrecisionChoices(value);
​
                    NotifyPropertyChanged("Choices");
                }
            }
        }
        public PrecisionChoices Choices
        {
            get 
            {
                if (_choices == null)
                {
                    _choices = new PrecisionChoices("");
                }
​
                return _choices; 
            }
​
        }
    }
    #endregion
​
    #region PrecisionGroups
    public class PrecisionGroups : List<PrecisionGroup>
    {
        public PrecisionGroups()
        {
        }
​
        public void AddOrUpdateNotEmptyItem(string groupName, string itemName, string value)
        {
            if (string.IsNullOrEmpty(value))
                return;
​
            this[groupName].Items.AddOrUpdateNotEmpty(itemName, value);
        }
​
        public void DeleteSubItem(string name)
        {
            for (int i = Items.Count-1 ; i >= 0 ; i--)            
            {
                PrecisionGroup group = Items[i];
                Precision ret = group.Items.Find(name);
                if (ret != null)
                {
                    group.Items.Remove(ret);
                    if (group.Items.Count == 0)
                        Items.Remove(group);
                }
            }            
        }
​
        public void MoveGroupToEnd(string groupName)
        {
            PrecisionGroup gp = Find(groupName);
            if (gp != null)
            {
                base.Remove(gp);
                base.Add(gp);
            }
        }
​
        public void MoveToEnd(PrecisionGroup gp)
        {
            base.Remove(gp);
            base.Add(gp);
        }
​
        public PrecisionGroup Add(string name)
        {
            PrecisionGroup newGroup = new PrecisionGroup();
            base.Add(newGroup);
            newGroup.Nom = name;
            return newGroup;
        }
​
        public Precision FindItem(string name)
        {
            foreach (PrecisionGroup group in Items)
            {
                Precision ret = group.Items.Find(name);
                if (ret != null)
                    return ret;
            }
​
            return null;
        }
​
        public PrecisionGroup Find(string name)
        {
            foreach (PrecisionGroup group in Items)
                if (group.Nom == name)
                    return group;
​
            return null;
        }
​
        public PrecisionGroup this[string name]
        {
            get
            {
                return AddOrUpdate(name);
            }
        }
​
        public PrecisionGroup AddOrUpdate(string name)
        {
            foreach (PrecisionGroup group in Items)
                if (group.Nom == name)
                    return group;
​
            PrecisionGroup newGroup = new PrecisionGroup();
            base.Add(newGroup);
            newGroup.Nom = name;
            return newGroup;
        }
​
        public PrecisionGroups(string src)
        {
            if (string.IsNullOrEmpty(src))
                return;
​
            PrecisionGroup curGroup = null;
​
            char[] separators = { 'ÿ' };
            string[] lines = src.Split(separators);
            foreach (string line in lines)
            {
                char[] colseparators = { '\t' };
                string[] columns = line.Split(colseparators);
​
                Precision prec = new Precision();
​
                int type = 0;
                for (int col = 0; col < columns.Length; col++)
                {                    
                    switch (col)
                    {
                        case 0:                            
                            int.TryParse(columns[col], out type);
                            prec.Type = (PrecisionType) type;
                            break;
                        case 1:
                            prec.Nom = columns[col].Trim();
                            break;
                        case 2:
                            prec.Value = columns[col];
                            break;
                        case 3:
                            prec.ChoicesForSerialisation = columns[col];
                            break;
                    }
                }
​
                if (type == 0)
                {
                    curGroup = new PrecisionGroup();
                    curGroup.Nom = prec.Nom;
                    if (prec.Value == "1")
                        curGroup.IsPrintable = false;
​
                    base.Add(curGroup);
                }
                else
                    if (curGroup != null)
                        curGroup.Items.Add(prec);
                    else
                    {
                        curGroup = new PrecisionGroup();
                        curGroup.Nom = "Divers";
                        curGroup.Items.Add(prec);
                        base.Add(curGroup);
                    }
            }
        }
​
        public override string ToString()
        {
            string ret = "";
​
            foreach (PrecisionGroup grp in Items)
            {
                if (string.IsNullOrEmpty(ret))
                    ret = "0\t" + grp.Nom+"\t"+(grp.IsPrintable?"":"1")+"\t";
                else
                    ret = ret + "ÿ0\t" + grp.Nom + "\t" + (grp.IsPrintable ? "" : "1") + "\t";
​
                foreach (Precision item in grp.Items)
                    ret = ret + "ÿ" + ((int)item.Type).ToString() + "\t" + item.Nom + "\t" + item.Value + "\t" + item.ChoicesForSerialisation;
            }
​
            return ret;
        }
    }
}

View IL Code