Diskuze: XmlSerializer při serializování nebo deserializování 200Mb vyskočí využití paměti na >3GB
Jirka Jr:2.10.2017 2:02
takže ... berouce inspiraci v následujícím odkazu a maje náladu se sám pocvičit jsem spatlal malé konzolové demo
https://stackoverflow.com/…rom-a-stream
v podstatě jde o to, že při serializaci do souboru i deserializaci ze souboru se mezi filestream a xmlserializer vloží šifrovací vrstva v podobě CryptoStream.
doufám, že bloky using{} v šifrovací i dešifrovací funkci by mohly zajistit uvolnění nepotřebných objektů z paměti na konci bloku, čímž by se vyřešil problém s pamětí ... jinak se to ještě bude muset potunit.
demoprogram funguje následovně
- pokud není v programu nastaven klíč a inicializační vektor pro šifrováíní, vygeneruje je a vypíše
- buď deserializuje kolekci ze souborů, pokud existují ... jinak kolekci vygeneruje
- poté kolekci vypíše
- kolekci zmodifikuje
- kolekci znovu vypíše
- vymaže stávající soubory se serializovanými daty
- kolekci serializuje do nových souborů
je tu problém, kam uložit klíč, pokud ne do programu, jako to mám já
... ale určitě je lepší klíč v programu, než base64 
jinak se dá použít asymetrická kryptografie a využít windowsí
úložiště certifikátů, je-li to extrémně nutné, ale do toho se mi už
nechtělo 
tak a tady je důkaz místo slibů:
using System;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Xml.Serialization;
using System.Security.Cryptography;
namespace HugeCollectionSerialize
{
public class MyClass
{
public int a, b;
public MyClass() { }
public MyClass(int _a, int _b)
{
this.a = _a;
this.b = _b;
}
public override string ToString()
{
return "[a: " + this.a + ", b: " + this.b + "]";
}
}
class Program
{
private static byte[] desIV = { 0x0, 0xb, 0xe1, 0xac, 0xfe, 0xe4, 0x44, 0x9f };
private static byte[] desKey = { 0xF4, 0x36, 0xAF, 0xC7, 0xC6, 0xAE, 0x24, 0x68 };
static void Main(string[] args)
{
if (desKey == null)
{
Console.Out.WriteLine("There is no key and initialization vector ... Generating ...");
generateIVAndKey();
Console.Out.WriteLine("\nPut the key into your code.");
Console.Out.WriteLine("Press <Enter> to quit ...");
Console.In.ReadLine();
Environment.Exit(0);
}
ObservableCollection<MyClass> col;
if (System.IO.File.Exists("c:\\Users\\doma\\hugecol0.dat"))
{
Console.Out.WriteLine("Deserializing collection items ...");
col = deserializeCollection("c:\\Users\\doma\\hugecol");
}
else
{
Console.Out.WriteLine("Creating collection ...");
col = createCollection();
}
Console.Out.WriteLine("Printing collection ...");
printCollection(col);
Console.Out.WriteLine("Modifying collection ...");
modifyCollection(col);
Console.Out.WriteLine("Printing collection ...");
printCollection(col);
Console.Out.WriteLine("Serializing collection ...");
serializeCollection("c:\\Users\\doma\\hugecol", col);
Console.Out.WriteLine("Press <Enter> to quit ...");
Console.In.ReadLine();
}
private static ObservableCollection<MyClass> deserializeCollection(string fileTemplate)
{
ObservableCollection<MyClass> col = new ObservableCollection<MyClass>();
DES des = new DESCryptoServiceProvider();
for (int i = 0; File.Exists(fileTemplate + i + ".dat"); i++)
{
MyClass item = DecryptAndDeserialize<MyClass>(fileTemplate + i + ".dat", des);
col.Add(item);
}
return col;
}
private static ObservableCollection<MyClass> createCollection()
{
ObservableCollection<MyClass> col = new ObservableCollection<MyClass>();
for(int i = 0; i < 5; i++)
{
MyClass mc = new MyClass(i, i + 1);
col.Add(mc);
}
return col;
}
private static void printCollection(ObservableCollection<MyClass> col)
{
foreach(MyClass item in col)
{
Console.Out.WriteLine(item.ToString());
}
}
private static void modifyCollection(ObservableCollection<MyClass> col)
{
foreach (MyClass item in col)
{
item.a += item.b;
}
}
private static void serializeCollection(string fileTemplate, ObservableCollection<MyClass> col)
{
string file = null;
int i = 0;
while(true)
{
file = fileTemplate + i + ".dat";
if(! File.Exists(file))
{
break;
}
File.Delete(file);
i++;
}
DES des = new DESCryptoServiceProvider();
for (i=0;i<col.Count();i++)
{
file = fileTemplate + i + ".dat";
EncryptAndSerialize<MyClass>(file, col[i], des);
}
}
private static void generateIVAndKey()
{
DES des = new DESCryptoServiceProvider();
bool first;
des.GenerateIV();
des.GenerateKey();
Console.Out.Write("IV: {");
first = true;
foreach (byte b in des.IV)
{
Console.Out.Write((first ? "" : ", ") + "0x" + b.ToString("x"));
first = false;
}
Console.Out.WriteLine("}");
Console.Out.Write("Key: {");
first = true;
foreach (byte b in des.Key)
{
Console.Out.Write((first ? "" : ", ") + "0x" + b.ToString("X"));
first = false;
}
Console.Out.WriteLine("}");
}
private static void EncryptAndSerialize<T>(string filename, T obj, SymmetricAlgorithm sa)
{
using (FileStream fs = File.Open(filename, FileMode.Create))
{
using (CryptoStream cs = new CryptoStream(fs, sa.CreateEncryptor(desKey, desIV), CryptoStreamMode.Write))
{
XmlSerializer xmlser = new XmlSerializer(typeof(T));
xmlser.Serialize(cs, obj);
}
}
}
private static T DecryptAndDeserialize<T>(string filename, SymmetricAlgorithm sa)
{
using (FileStream fs = File.Open(filename, FileMode.Open))
{
using (CryptoStream cs = new CryptoStream(fs, sa.CreateDecryptor(desKey, desIV), CryptoStreamMode.Read))
{
XmlSerializer xmlser = new XmlSerializer(typeof(T));
return (T)xmlser.Deserialize(cs);
}
}
}
}
}+20 Zkušeností
+2,50 Kč
Funguje to samozřejmě perfektně, ještě jsem to protáhl ještě deflate a výsledný soubor je 5x menší při o trošku zvýšeném nahrávacím času... Neznám pozadí těchto streamů a proto jsem netušil, že to udělá takový rozdíl v náročnosti. Nechal jsem tam tedy jen serialize a deserialize s tím, že tam jsou tři usingy ty dva + deflate
Díky moc za pomoci a vážím si toho
Jirka Jr:9.10.2017 10:37
S tím dispose vím, že uvolňuje prostředky a že bez toho se nedá uvolnit pamět po objektu
jinak tak hluboko do GC jsem jeste nepronikl, takže moje rady byly spíše intuitivní a výsledkem mého pozorování z velké výšky ...
takže každopádně velké díky za opravy a poučné upřesnění ...
teď už aspoň vím, proč musím GC volat dvakrát a že to není kvůli
debilitě Microsoftu, jak jsem si dlouho myslel
Marian Benčat:9.10.2017 11:30
Není to debilita microsoftu, je to tak vymyšlené kvůli efektivitě Proto jsou i různé generace a
proto je třeba něco jako large object heap;-) Obecně, pokud potřebuješ
volat GC ručně, tak je něco někde špatně. Ideální moment totiž je,
když paměť pravidelně nepřiděluješ a neuvolňuješ.. proto se dělají
věci jako object pooly a ta paměť se reusuje... -> pouze se nějakým
bitem dá vědět, jestli je objekt obsazený či ne.. Pokud tedy chceš mít
ještě více efektivní sw i v tom C#, tak si tam ten object pool taky
uděláš, protože kromě toho, že ušetříš za alokaci a dealokaci, tak
máš data co zpracováváš v jeden moment více v paměti u sebe, což má
taky extrémní vliv na performance.
I v C++, C jsi toto dělal naprosto běžně a v C++ jsi k tomu měl i syntactic sugar v podobě placement new.. Vždy se snažíš resourcy uvolňovat a alokovat co nejméně - to je důvod, proč se třeba i Connectiony pooli na základě connection stringu...
Dokonce i u jazyka, který nemá garbage collector, se používá výraz garbage collecting, .. procesu, kdy se v memory managementu (několik linked listu), spojují chunky paměti do větších atp. - mimochodem to je důvud existence large object poolu...
Takže to, že při každém GC nečistí všechny generace není debilita
microsoftu, naopak hodně velká inteligence Žádný rozumný GC neuvolňuje
všechnu nevyužitou paměť najednou.. Doporučuji se kouknout na rozumné
jazyky a zjistíš, že to tak dělají všude, protože ví, jak funguje memory
management.
Pak existují jazyky, které jsou tak debilní, že se tam debilní GC ztratí.. třeba PHP, které (pokud to nezměnili) generace v GC nepoužívá a taky to podle toho vypadá .
Zobrazeno 20 zpráv z 20.