[.NET C#] Serialization in compact framework

[klaasopurk]

hoi,

google en MSDN geven geen oplossingen voor mijn probleem, of ik zoek verkeerd.
google --> alleen normale framework
MSDN --> bepaalde object in compact framework. maar voorbeelden werken met normale framework zodat de hele boel niet werkte

ik wil een aantal object Serialization op uitvoeren. echter ik loop tegen de beperking van compactf framework. ik ontdekte dat alleen nog de namespace system.xml.Serialization nog bestaat.
hierin kan nog een XmlSerializerNamespaces aangemaakt worden. echter hier kun je verder niks mee naar mijns inziens. het obejct XmlSerializer dat ik nodig heb is niet aan te maken odmat het niet bestaat.

mijn vraag is weet iemand een manier om alsnog een object binair (Serialization) weg te schrijven.

let dus wel op het gaat om het Compact Framework.

Modbreak:

Kicken van een topic staan we pas toe na 24 uur Ik heb je kick dan ook verwijderd

[ Voor 28% gewijzigd door gorgi_19 op 02-12-2004 12:29 ]

[dotcode]

Ik heb niet gezocht, maar ik kan me niet voor stellen dat er geen binaryserializer bestaat. Maar mocht dat zo zijn kan je toch altijd zelf een custom serializer schrijven. Dat is vaak toch handig als je wilt dat je object in een volgende versie van je prog blijft werken. Serializen met de std seriablizers is namelijk niet zo slim.

[klaasopurk]

dotcode schreef op donderdag 02 december 2004 @ 17:12:
Ik heb niet gezocht, maar ik kan me niet voor stellen dat er geen binaryserializer bestaat. Maar mocht dat zo zijn kan je toch altijd zelf een custom serializer schrijven. Dat is vaak toch handig als je wilt dat je object in een volgende versie van je prog blijft werken. Serializen met de std seriablizers is namelijk niet zo slim.

heeft iemand daarvoor een opzetje. ik heb wel aanzoiets gedacht, maar heb effe geen idee hoe aan te pakken. er komen namelijk veel verschillende objecten in hoofdobject voor. deze moeten allemaal weggeschreven worden.

[Brainstorm]

Voor zover ik weet, is binary serialization inderdaad op het CF weggelaten. Een aantal maanden geleden heb ik om deze reden ook een custom formatter geschreven, maar je kunt ook CompactFormatter gebruiken.

[edit]
De reden dat ik toen zelf een formatter moest schrijven, was omdat er performance problemen waren met de CompactFormatter library.

[ Voor 23% gewijzigd door Brainstorm op 02-12-2004 18:08 ]

[P_de_B]

Zelf schrijven, een minuutje googlen geeft mij bijvoorbeeld dit

Ook is er volgens mij op http://www.opennetcf.org een class die het ondersteunt, als onderdeel van het Smart Device Framework

[ Voor 16% gewijzigd door P_de_B op 02-12-2004 18:09 ]

[klaasopurk]

NoLife schreef op donderdag 02 december 2004 @ 18:06:
Voor zover ik weet, is binary serialization inderdaad op het CF weggelaten. Een aantal maanden geleden heb ik om deze reden ook een custom formatter geschreven, maar je kunt ook CompactFormatter gebruiken.

[edit]
De reden dat ik toen zelf een formatter moest schrijven, was omdat er performance problemen waren met de CompactFormatter library.

de performance ligt voor mijn prog erg hoog. er kunnen namelijk 20.000 objecten in staan. deze moeten razendsnel worden weggeschreven in weer in gelezen. liefst binnen 2 sec. dit zal wel niet kunnen, hoewel ik een programma ken die dat wel doet op de pocket PC, maar niet binnen .NET.

wil jij als je deze code met mij wil sharen even dit melden? Eigen prive dingen mogen er wel uit. Dat ik er dan nog even aan moet rommelen is niet zo erg. Dit is niet normaal de bedoeling van dit forum om complete code te sharen. maar dit scheelt mij dan veel werk en ik heb heel veel te doen in mijn afstuderen. alvast mijn dank.

[klaasopurk]

klaasopurk schreef op donderdag 02 december 2004 @ 19:00:
[...]


de performance ligt voor mijn prog erg hoog. er kunnen namelijk 20.000 objecten in staan. deze moeten razendsnel worden weggeschreven in weer in gelezen. liefst binnen 2 sec. dit zal wel niet kunnen, hoewel ik een programma ken die dat wel doet op de pocket PC, maar niet binnen .NET.

wil jij als je deze code met mij wil sharen even dit melden? Eigen prive dingen mogen er wel uit. Dat ik er dan nog even aan moet rommelen is niet zo erg. Dit is niet normaal de bedoeling van dit forum om complete code te sharen. maar dit scheelt mij dan veel werk en ik heb heel veel te doen in mijn afstuderen. alvast mijn dank.

wil je effe reageren AUB? dan weet ik wat ik moet doen.

overigs die compactformatter werkt totaal niet en niet aan het werk te krijgen. dan nog die van http://www.opennetcf.org werkt ook niet zoals het moet.

weet iemand er nog 1 werkende? ik moet de volgende types wegschrijven
-arrays
-eigen klassen met propertys
-eigenklassen arrays
-string
-int
-bool
-verdere standaard

[gorgi_19]

En dicht, ik gooi hem straks wel weer open..

Ik blijf niet herhalen over kicken. Daarnaast is niemand verplicht om te reageren op jou, als hij een reactie wil geven doet hij dat vanzelf wel Een opmerking als

wil je effe reageren AUB? dan weet ik wat ik moet doen.

is dan ook niet nodig

Sowieso begint het topic veel teveel te lijken op: "Wie weet het beste standaard component voor dit en dit probleem en begint het zelf programmeren van zaken eigenlijk steeds meer op de achtergrond te raken

edit:

En weer open

[ Voor 70% gewijzigd door gorgi_19 op 03-12-2004 13:43 ]

[Brainstorm]

Helaas kan ik de code niet met je delen, ik denk dat mijn baas dat niet erg leuk zou vinden Overigens is het idee erachter vrij simpel. In plaats van door middel van Reflection tijdens runtime te bepalen hoe objecten opgebouwd zijn is ervoor gekozen om tijdens design time in de code aan te geven welke objecten op welke manier geserialized kunnen worden. De BitConverter klasse kan gebruikt worden om de primitieven (string, bool, int, etc) naar bytes om te zetten (en omgekeerd). Op deze wijze kan een object in zijn geheel omgezet worden naar een array van bytes.

Voordeel van deze methode is dat het (de)serializen tijdens runtime sneller is, nadelen zijn dat de code niet dynamisch ook voor andere type objecten werkt en dat de onderhoudbaarheid van de code erop in moet boeten. In mijn geval wogen de voordelen op tegen de nadelen

[klaasopurk]

NoLife schreef op zaterdag 04 december 2004 @ 15:23:
Helaas kan ik de code niet met je delen, ik denk dat mijn baas dat niet erg leuk zou vinden Overigens is het idee erachter vrij simpel. In plaats van door middel van Reflection tijdens runtime te bepalen hoe objecten opgebouwd zijn is ervoor gekozen om tijdens design time in de code aan te geven welke objecten op welke manier geserialized kunnen worden. De BitConverter klasse kan gebruikt worden om de primitieven (string, bool, int, etc) naar bytes om te zetten (en omgekeerd). Op deze wijze kan een object in zijn geheel omgezet worden naar een array van bytes.

Voordeel van deze methode is dat het (de)serializen tijdens runtime sneller is, nadelen zijn dat de code niet dynamisch ook voor andere type objecten werkt en dat de onderhoudbaarheid van de code erop in moet boeten. In mijn geval wogen de voordelen op tegen de nadelen

Als ik het dus goed begrijp kun jij dus geen eigen klassen serializen. Dit dan wel jammer, want ik werk namelijk veel met eigen klassen die moeten worden gesesialized.

evengoed bedankt voor je reactie. ik zal nog wel effe kijken naar die bitconverter. misschien kan ik er toch wel mee werken.

[pjvandesande]

Je kan toch zelf een Seriazele class maken dmv XML of iets:

C#:

public class A
{
    private string m_value;

    public string Value
    {
        get
        {
            return m_value;
        }

        set
        {
            m_value = value;
        }
    }

    public A()
    {
    }

    // Private ctor voor het Deserializen
    private A(string value)
    {
        m_value = value;
    }

    public void Serialize(string path)
    {
        XmlTextWriter writer = new XmlTextWriter(path);
        writer.WriteStartElement("A");
        writer.WriteAttribute("m_value", m_value);
        writer.WriteEndElement();
        writer.Close();
    }

    public static A Deserialize(string path)
    {
        XmlTextReader reader = new XmlTextReader(path)
        string m_value = null;

        while(reader.Read())
        {
            if(reader.NodeType != XmlNodeType.StartElement)
                continuel;
            else
            {
                if(reader.Name == "A")
                {
                    m_value = reader.ReadElement("m_value");    
                }
            }
        }

        reader.Close();

        return (m_value != null ? new A(m_value) : null);
    }
}

Trouwens, heb het zo even in Notepad getypt, dus zou niet weten of de code ook echt werkt. Maar het is iig een idee dat jezelf zeker kan gebruiken.

[ Voor 8% gewijzigd door pjvandesande op 06-12-2004 10:25 ]

[klaasopurk]

hallo allemaal

Het serializen is werkend!

Ik heb het via XMLwriter gedaan op ongeveer de manier van opennetCF.org . dat lijkt op de vorige post.

mijn serializer kan nu ook arrays aan. dat kon die van opennetcf niet. overigs die van opencfnet werkt bij nog een aantal dingen niet.

echter arrays terug krijgen is moelijk. In de XML staat <klasse[]><var1>value</var1><var2>value</var2><var1>value</var1><var2>value</var2></klasse[]>

Het stukje <var1>value</var1><var2>value</var2> gebeurd net zolang totdat er een einde de klasse[] komt.

echter het terughalen is een probleem. dan gebeurd er namelijk de volgende aanroep om de instantie klasse[] weer te maken

object o = t.Assembly.CreateInstance(t.FullName,true);

maar daar loopt ie op vast omdat er geen constructor klasse[] bestaat.

heeft iemand een idee hoe je dat kan omzeilen. of had ik de xml <array>....</array> moet schrijven en dat aan het eind casten naar klasse[] ?

[pjvandesande]

Wat is je code, waar lees je het mee in? Je kan toch gewoon zo iets doen:

C#:

ArrayList tempArrayList = new ArrayList();

while(reader.Read)
{
   if(reader.NodeType == XmlNodeType.EndElement && reader.Name.ToLower() == "klasse[]")
   {
      break;
   }
   
   tempArrayList.Add(reader.ReadInnerXml());
}

return (MyArray[])tempArrayList.ToArray(typeoff(MyArray);

[klaasopurk]

Mijn code ziet er als volgt uit schrik niet:

ik heb gelijk alle code gepost wat betrekking heeft op deserialize.

public object DeserializeGraph(XmlTextReader r, Type t)
{
object o = t.Assembly.CreateInstance(t.FullName);
Bij deze regel kun je de code vinden die mis gaat.

Ik hoop dat je er wijs uit kunt worden.

C#:

        public object Deserialize(XmlTextReader xmlReader, Type type) 
        {
            object obj;
            xmlReader.MoveToContent();
            obj = DeserializeGraph(xmlReader, type);
            return obj;
        }

        public object DeserializeGraph(XmlTextReader r, Type t) 
        {
            object o = t.Assembly.CreateInstance(t.FullName);
            string InstanceName = r.Name;
            int i = 0;

            if(o.GetType().BaseType == typeof(System.Collections.CollectionBase) || o.GetType().BaseType == typeof(System.Array))
            {
                o = DeserializeCollection(r, t);
            }

            PropertyInfo[] properties = o.GetType().GetProperties(BindingFlags.Public|BindingFlags.Instance);
            
            #region Handle XmlRoot attributes
            if(r.HasAttributes) 
            {
                while(r.MoveToNextAttribute() && i < properties.Length) 
                {
                    object[] butes = properties[i].GetCustomAttributes(false);
                    object bute = null;
                    if(butes.Length > 0) 
                    { // 16/06/2004: RHM made this into a block because bute is not always nonnull
                        bute = butes[0];

                        PropertyInfo property = null;

                        if(r.Name == (bute as XmlAttributeAttribute).AttributeName) 
                        {
                            property = properties[i];
                        }
                        else 
                        {
                            property = t.GetProperty(r.Name);
                        }
                        if(property.PropertyType.Name == "String") 
                        {
                            // We have a string
                            r.ReadAttributeValue();
                            string s = r.Value;
                            if(property.CanWrite)
                                property.SetValue(o, s, null);
                        }
                        i++;
                    }
                }
            }
            #endregion

            while(r.Read() && i < properties.Length) 
            {
                if((r.Name == InstanceName) && (r.NodeType == XmlNodeType.EndElement)) 
                {
                    break;
                }

                object[] attribs = properties[i].GetCustomAttributes(false);
                object attrib = null;

                if(attribs.Length > 0)
                    attrib = attribs[0];        
    
                if(r.HasAttributes) 
                {
                    r.MoveToFirstAttribute();
                    while(r.HasAttributes) 
                    {
                        PropertyInfo property = null;

                        if(r.Name == (attrib as XmlAttributeAttribute).AttributeName) 
                        {
                            property = properties[i];
                        }
                        else 
                        {
                            property = t.GetProperty(r.Name);
                        }

                        if(property.PropertyType.Name == "String") 
                        {
                            // We have a string
                            r.ReadAttributeValue();
                            string s = r.Value;
                            if(property.CanWrite)
                                property.SetValue(o, s, null);
                        }
                        i++;
                    }
                }
                else if((r.NodeType == XmlNodeType.Element)) 
                {
                    
                    if(r.IsEmptyElement) 
                    {
                        i++;
                        continue;
                    }

                    PropertyInfo property = null;                   
                    if(attrib == null) 
                    {
                        property = t.GetProperty(r.Name);
                        if(property == null)
                            continue;
                    }
                    else 
                    {
                        if(attrib.GetType() == typeof(XmlElementAttribute))
                        {
                            if(r.Name == (attrib as XmlElementAttribute).ElementName)
                            {
                                property = properties[i];   i++;
                            }
                            else
                                continue;
                        }
                        else if(attrib.GetType() == typeof(XmlAttributeAttribute))
                        {
                            if(r.Name == (attrib as XmlAttributeAttribute).AttributeName)
                            {
                                property = properties[i];   i++;
                            }
                            else
                                continue;
                        }
                        else if(attrib.GetType() == typeof(XmlRootAttribute))
                        {
                            if(r.Name == (attrib as XmlRootAttribute).ElementName)
                            {
                                property = properties[i];   i++;
                            }
                            else
                                continue;
                        }
                    }
                                        
                    if(property.PropertyType.BaseType == typeof(System.Collections.CollectionBase)) 
                    {
                        // We have a collection
                        property.SetValue(o, DeserializeCollection(r, property.PropertyType),null);
                    }
                    else if(property.PropertyType.Name == "String") 
                    {
                        // We have a string
                        r.Read();
                        string s = r.Value;
                        if(property.CanWrite)
                            property.SetValue(o, s, null);
                    }
                    else if(property.PropertyType.IsValueType) 
                    {
                        // We have a value type
                        object oVal = null;
                        if ( typeof(IConvertible).IsAssignableFrom(property.PropertyType) )
                        {
                            r.Read();
                            string s = r.Value;
                            if ( property.PropertyType.IsEnum )
                            {
                                try 
                                { 
                                    oVal = Enum.ToObject(property.PropertyType, Convert.ToInt32(s));
                                } 
                                catch(InvalidCastException) 
                                {
                                }
                            }
                            else
                            {

                                try { oVal = Convert.ChangeType(s, property.PropertyType, null); } 
                                catch(InvalidCastException) 
                                {
                                    try { oVal = Convert.ChangeType(s, property.PropertyType.BaseType, null); }
                                    catch(InvalidCastException) { continue; }
                                }
                            }
                        }
                        else if ( !property.PropertyType.IsPrimitive )
                        {
                            oVal = DeserializeGraph(r, property.PropertyType);
                        }
                        if ( oVal != null )
                            property.SetValue(o, oVal, null);
                    }
                    else if(t.Assembly.GetType(property.PropertyType.FullName, false) != null) 
                    {
                        // We have a type in the current assembly. Recurse.
                        object val = DeserializeGraph(r, property.PropertyType);                        
                        property.SetValue(o,val, null);
                    }
                    else 
                    {
                        throw new NotSupportedException("Cannot deserialize to " + property.PropertyType.FullName + ".");
                    }
                }
                else if(r.NodeType == XmlNodeType.Text)
                {
                    PropertyInfo property = properties[i];
                    i++;

                    if(property.PropertyType.Name == "String") 
                    {
                        // We have a string
                        //r.Read();
                        string s = r.Value;
                        if(property.CanWrite)
                            property.SetValue(o, s, null);
                    }
                }
            }
            return o;
        }

        private MethodInfo GetMethod(string MethodName, Type t) 
        {
            MethodInfo[] methods = t.GetMethods();
            MethodInfo m = null;

            foreach(MethodInfo method in methods) 
            {
                if(method.Name == MethodName) 
                {
                    m = method;
                    break;
                }
            }

            if(m == null)
                throw new NotSupportedException("Type " + t.FullName + " does not have a " + MethodName + " method.");

            return m;
        }

        private object DeserializeCollection(XmlTextReader r, Type t) 
        {
            object o = t.Assembly.CreateInstance(t.FullName);

            string InstanceName = r.Name;

            MethodInfo addToColl = GetMethod("Add",t);
            //while(r.Read()) 
            {
                if((r.NodeType == XmlNodeType.EndElement) && (r.Name == InstanceName)) 
                {
                    //break;
                    return o;
                }

                if(r.NodeType == XmlNodeType.Element) 
                {
                    string typeName = r.Name;

                    //string namePrefix = t.FullName.Replace(t.FullName, "");
                    //Type childType = t.Assembly.GetType(t.FullName + "." + r.Name,true);
                    Type childType = addToColl.GetParameters()[0].ParameterType;

                    object child = DeserializeGraph(r,childType);
                    object[] args = { child };
                    addToColl.Invoke(o,args);
                }
            }
            return o;
        }
    }