Usafe struct - 1.lekce – .NET – Fórum – Programujte.com

Ahoj, zkouším si použití "unsafe struct" pro ukládání strukturovaných dat.

Co mám v tomto kódu špatně:

using System;
using System.Text;
using System.IO;
using System.Runtime.InteropServices;

namespace StructTest1
{
    class Program
    {
        static void Main(string[] args)
        {
            unsafe
            {
               TestData buf;

                for (int i = 0; i < 6; i++) buf.head[i] = 0xFA;
                buf.dataA[0] = 'A';
                buf.dataA[1] = ':';
                buf.dataB[0] = 'B';
                buf.dataB[1] = ':';

                // výstupní soubor vypadá takto:
                // FA00 0000 0000 4100 0000 0000 4200 0000 0000

                // očekával bych tento formát:
                // FAFA FAFA FAFA 4100 3A00 0000 4200 3A00 0000

                FileStream fs;
                try
                {
                    fs = new FileStream("vystup", FileMode.Create);
                    BinaryWriter w;
                    try
                    {

                        w = new BinaryWriter(fs, Encoding.Unicode);
                        int cnt = 0;
                        byte[] out_buf = getBytes(buf, out cnt);
                        w.Write(out_buf, 0, cnt);
                        w.Close();
                    }
                    catch (Exception)
                    {
                        Console.WriteLine("Chyba pri zapisu!");
                    }
                    finally
                    {
                        fs.Close();
                    }
                }
                catch (Exception)
                {
                    Console.WriteLine("Do souboru nelze zapisovat!");
                }

                Console.WriteLine("stiskni enter pro ukonceni..\n");
                Console.ReadKey();
            }

        }

        private static byte[] getBytes(TestData str, out int count)
        {
            count = Marshal.SizeOf(str);
            byte[] arr = new byte[count];

            IntPtr ptr = Marshal.AllocHGlobal(count);
            Marshal.StructureToPtr(str, ptr, true);
            Marshal.Copy(ptr, arr, 0, count);
            Marshal.FreeHGlobal(ptr);
            return arr;
        }
    }
    //-----------------------------------------------------------
    internal unsafe struct TestData
    {
        public fixed byte  head[6];
        public fixed char dataA[3];
        public fixed char dataB[3];
    }
}

?

(Popis problému je v komentáři).

#1 BDS
Zajímavé. Mně to vypisuje ještě jinak: 

// fafa fafa fafa 0941 0000 0000 0042 0000 0018

Kompilátor mcs.

#1 BDS
Endianita, bitová konvence, ...

#3 Matěj Andrle
Proto je to také "unsafe". Vývojář si v tu chvíli musí uvědomit, že výstup může být závislý na platformě a může to zcela znehodnotit kvalitu jeho aplikace.

Když se na ten program koukám, tak to "unsafe" vidím jako zbytečné. Celé by se to dalo podstatně zkrátit.

#4 Kit
nedělám žádný kompletní software, tento program dělám je v rámci "výuky".

Jestli někdo víte jak, jak se dá vytvořit program na uložení "unsafe struct" do souboru, tak prosím poraďte.

V uvedené příkladu se mi jedná o funkci "byte[] getBytes" - ta nepracuje správně.

#5 BDS
Serializace...

#5 BDS
Poradím, ale potřebuji k tomu vědět, co jsou data a co jsou povinné položky cílového datového formátu. Je to v jedné hromadě a není to příliš přehledné.

Rada č. 1: Místo "try .. catch" zkus použít "using".

Rada č: 2: Místo getBytes by se spíš hodilo něco jako write(BinaryWriter, String), která ty vyrobené bajty rovnou zapíše do "w". Kromě toho to pole "arr" uvnitř getBytes máš moc malé. Proč ho vůbec vytváříš?

Rada č. 3: Uniká mi význam proměnné "ptr". Vývojáři přešli od C++ k C# právě proto, aby se těchto konstrukcí zbavili. Zkus to nahradit něčím elegantnějším.

Řekněme, že mám soubor který obsahuje 100 000 položek (v c++ uložených struktur o pevné velikosti) ve formátu:

{

char vlastnostA [32];

char vlastnostB [16];

char vlastnostC [16];

char vlastnostD [8];

char vlastnostE [8];

double hodnotaA;

long hodnotaB;

int hodnotaC;

short pole1[12];

byte pole2[256];

};

já budu muset zachovat tento formát (z důvodu kompatibility).

Jak data do souboru ukládat a připisovat bez toho, abych musel přepisovat celý soubor a nemusel data zapisovat po jedné položce. A samozřejmě pak data číst.

#7 Kit
Rada č. 3

ta funkce se uvádí na netu na několika diskuzích, jen jsem ji zkopíroval, její obsah zatím nechápu.

#3 Matěj Andrle
Endialita - to by snad bylo jen prohozené. Ne?

#8 BDS
A v jakém formátu je to uloženo - zdrojový kód? Serializace? Kompilace? ...

#11 Matěj Andrle

je to uloženo klasicky, binárně

kod mohl vypadat takto:

#include <stdio.h>

struct ITEMDATA
{
char vlastnostA [32];
char vlastnostB [16];
char vlastnostC [16];
char vlastnostD [8];
char vlastnostE [8];
double hodnotaA;
long hodnotaB;
int hodnotaC;
short pole1[12];
byte pole2[256];
};

ITEMDATA library[100000];

...
FILE *fi = fopen(".......
...
fwrite(library, sizeof(ITEMDATA), 100000, fi);

#8 BDS
To už by bylo lepší ta data zkonvertovat do databáze a pak už jen pracovat s databází. Úplně se tak vyhneš těmto strojovým závislostem, aplikace se tím významně zjednoduší. V případě potřeby můžeš zase udělat export.

Jako docela zásadní chybu vidím nicneříkající označení sloupců "head", "dataA" a "dataB". Chápu, že to chceš udělat univerzálně, ale používání bezvýznamných názvů proměnných vede do binárních pekel.

#14 Kit

To už by bylo lepší ta data zkonvertovat do databáze a pak už jen pracovat s databází. Úplně se tak vyhneš těmto strojovým závislostem, aplikace se tím významně zjednoduší. V případě potřeby můžeš zase udělat export.

V případě, že je nutnost zachovat formát souboru, aby byl čitelný pro jiné aplikace, tak přece nic jiného nezbude... A dělat import a export - co by se tím změnilo?

Jako docela zásadní chybu vidím nicneříkající označení sloupců "head", "dataA" a "dataB". Chápu, že to chceš udělat univerzálně, ale používání bezvýznamných názvů proměnných vede do binárních pekel.

Tato struktura je ukázková, pouze pro téma diskuze. Do kódu samozřejmě uvádím hodnoty tak, abych se i po čase ve zdrojáku vyznal...

#13 p3can
Díky moc, takto to funguje.

Ale přesto, budu rád, pokud mi kážete nějaká další řešení pro C# .NET - "jak ukládat struktury či třídy do souboru o pevně dané velikosti."

#15 BDS
Vkládání či mazání záznamů v obyčejném souboru je dost opruz, zejména pokud je na sdíleném úložišti - dřív nebo později o ta data přijdeš. Databáze bývají proti takovým chybám jištěny.

Takže sem dáváš takové názvy proměnných, abychom se v tom nevyznali...

#17 Kit
Takže sem dáváš takové názvy proměnných, abychom se v tom nevyznali...

omlouvám se, netušil jsem, že název proměnné je pro tento dotaz podstatný.

#18 BDS
Strukturované programování je založeno na správném používání syntaxe. Při objektovém programování je kladen mnohem větší důraz na sémantiku. Názvy proměnných jsou součástí sémantiky. Chybně nazvanou proměnnou často poznáš podle toho, že je okomentována.

Pochybuji, že proměnné fs, w, buf, arr a out_buf máš v ostré verzi pojmenované jinak. Neoficiální zkratky se v názvech proměnných nepoužívají.

#19 Kit
Jo máš pravdu, toto je pouze testovací kód, u takových to neřeším vůbec.

A jinak pokud funkce obsahuje pouze jeden interní FileStream dám mu vždy název fs, stejně tak BinaryWriter vždy pojmenuji w. (nikdy nic jiného nepojmenuji fs, nebo w, a nikdy např. fs nepoužiji do parametru funkce).

"Neoficiální zkratky se v názvech proměnných nepoužívají"

Jaké jsou ty oficiální?

#20 BDS
Chápu. fs, w, i, j, k, apod. jsou takové lokální názvy, které se používají všude, kde je to možné.

Na druhou stranu: Proč bys fs nepoužil do parametru funkce, kdyby ten parametr byl typu FileStream?

Oficiálních zkratek je hodně a běžně se s nimi setkáváme i v civilním životě. Asi těžko pojmenuješ proměnnou daňZPřidanéHodnoty. Místo toho použiješ běžnou zkratku dph. Ale i tady můžeš narazit, pokud tentýž program děláš i pro Angličany, kde používají "vat" nebo pro Němce s jejich "mwst".

Místo out_buf by to mělo skutečně být outputBuffer, ale můžeš se setkat se zažitou zkratkou "ob", která by se neměla používat v jimém významu, než je právě OutputBuffer. Takže si vyber mezi "outputBuffer" a "ob".

Obecně platí pravidlo, že čím je proměnná "lokálnější", tím může být její název kratší. Viz zmíněné i, j, k, které by se neměly používat v jiném významu, než jako řídicí proměnné cyklu.

Naopak čím je vzdálenější (typicky konstanty, které mají platit v celé aplikaci), tím by měl být jejich název delší, složený z více slov tak, aby vysvětloval, k čemu ta konstanta slouží.

Totéž platí pro veřejné/lokální proměnné či metody. A protože by veřejných proměnných a metod mělo být co nejméně (veřejné proměnné nejlépe žádné nebo skoro žádné) tak ty privátní názvy mohou být krátké.

Nikoli však zkracované. Místo buf použij b nebo buffer, tedy pokud to skutečně má význam bufferu - což v daném případě není splněno. V té proměnné se nenachází buffer, ale jeden datový záznam. Buffer je vyrovnávací paměť - z jedné strany do něj tečou data, z druhé strany vytékají ven ve stejném pořadí, ale jinou rychlostí.