SzoftverTechnikakTetelsor - Laptörténet

Kiskoza: halott link

2013-05-27T09:50:10Z

halott link

← Régebbi változat		A lap 2013. május 27., 11:50-kori változata
449. sor:		449. sor:
	}		}
	</pre>		</pre>
	~~Egyéb dolgok ebben a pdf-ben: http://web.conf.hu/2007/media/foliak/Sun-webconf2007-PersistenceEJB3.pdf~~

	~~-- [[DeVi\|DeVi]] - 2007.04.12.~~


	[[Category:Infoalap]]		[[Category:Infoalap]]

Ferrero: /* Linux */

2013-02-06T08:43:44Z

Linux

← Régebbi változat		A lap 2013. február 6., 10:43-kori változata
85. sor:		85. sor:
	Linux-on is kb ugyanezt csináljuk, csak másképp.		Linux-on is kb ugyanezt csináljuk, csak másképp.

	<pre>~~%BLACK%~~		<pre>
	~~%BLUE%~~#include~~%ENDCOLOR% %MAROON%~~<dlfcn.h>~~%ENDCOLOR%~~		#include <dlfcn.h>
	~~%BLUE%~~#include~~%ENDCOLOR% %MAROON%~~<stdio.h>~~%ENDCOLOR%~~		#include <stdio.h>

	~~%BLUE%~~typedef int~~%ENDCOLOR%~~(*MY_MAX_FUNC)(~~%BLUE%~~int~~%ENDCOLOR%~~, ~~%BLUE%~~int~~%ENDCOLOR%~~);		typedef int(*MY_MAX_FUNC)(int, int);

	int main(){		int main(){
95. sor:		95. sor:
	void *handle;		void *handle;

	~~%GREEN%~~/* Megnyitjuk a konyvtarat. */~~%ENDCOLOR%~~		/* Megnyitjuk a konyvtarat. */
	handle = dlopen(~~%MAROON%~~"./libcomplex.so"~~%ENDCOLOR%~~, RTLD_LAZY);		handle = dlopen("./libcomplex.so", RTLD_LAZY);
	if(!handle){		if(!handle){
	fputs(dlerror(), stderr);		fputs(dlerror(), stderr);
102. sor:		102. sor:
	}		}

	~~%GREEN%~~/* Hozzaferunk a szimbolumhoz. */~~%ENDCOLOR%~~		/* Hozzaferunk a szimbolumhoz. */
	fvMax = dlsym(handle, ~~%MAROON%~~"max"~~%ENDCOLOR%~~);		fvMax = dlsym(handle, "max");
	if(dlerror() != NULL){		if(dlerror() != NULL){
	fputs(dlerror(), stderr);		fputs(dlerror(), stderr);
109. sor:		109. sor:
	}		}

	~~%BLUE%~~int~~%ENDCOLOR%~~ max = (*fvMax)(a, b); ~~%RED%~~// int max = fvMax(a, b); is ugyanugy mukodik~~%ENDCOLOR%~~		int max = (*fvMax)(a, b); // int max = fvMax(a, b); is ugyanugy mukodik

	dlclose(handle);		dlclose(handle);
115. sor:		115. sor:
	return 0;		return 0;
	}		}
	~~%ENDCOLOR%~~</pre>		</pre>


	==Bináris komponensek evolúciója 2.==		==Bináris komponensek evolúciója 2.==

Ferrero: /* Windows */

2013-02-06T08:42:19Z

Windows

← Régebbi változat		A lap 2013. február 6., 10:42-kori változata
34. sor:		34. sor:
	====Windows====		====Windows====
	windows.h-ban vannak a szükséges függvények, ezért:		windows.h-ban vannak a szükséges függvények, ezért:
	<pre>~~%BLUE%~~#include~~%ENDCOLOR% %MAROON%~~"windows.h"~~%ENDCOLOR%~~</pre>		<pre>#include "windows.h"</pre>

	Betöltetjük az OS-el a dll-elünket, amire egy HMODULE típusú változóval tudunk a későbbiekben hivatkozni		Betöltetjük az OS-el a dll-elünket, amire egy HMODULE típusú változóval tudunk a későbbiekben hivatkozni
	<pre>~~%BLACK%~~HMODULE hDLL = !LoadLibrary(~~%MAROON%~~"myDll.dll"~~%ENDCOLOR%~~);~~%ENDCOLOR%~~</pre>		<pre>HMODULE hDLL = !LoadLibrary("myDll.dll");</pre>

	Persze lehet, hogy nincs is dll, ekkor null-t kapunk vissza.		Persze lehet, hogy nincs is dll, ekkor null-t kapunk vissza.
	<pre>~~%BLACK%%BLUE%~~if~~%ENDCOLOR%~~ (hDLL == NULL)		<pre>if (hDLL == NULL)
	{		{
	fprintf(stderr, ~~%MAROON%~~"Cannot find DLL\n"~~%ENDCOLOR%~~); ~~%GREEN%~~//kiírjuk az stderr-re, hogy baj van~~%ENDCOLOR%~~		fprintf(stderr, "Cannot find DLL\n"); //kiírjuk az stderr-re, hogy baj van
	return -1; ~~%GREEN%~~//végül kilépünk~~%ENDCOLOR%~~		return -1; //végül kilépünk
	}~~%ENDCOLOR%~~</pre>		}</pre>

	Van már DLL-elünk, valahogy kellene használni a benne lévő függvényeket is. Megkérjük a Windows-t, hogy a DLL-ből keresse ki a megadott nevű függvényt, és ha szerencsénk van, vissza kapunk egy rá mutató függvény pointert.		Van már DLL-elünk, valahogy kellene használni a benne lévő függvényeket is. Megkérjük a Windows-t, hogy a DLL-ből keresse ki a megadott nevű függvényt, és ha szerencsénk van, vissza kapunk egy rá mutató függvény pointert.
	Az élet nem ennyire egyszerű, mert elképzelhető, hogy van a függvényünknek visszatérési értéke, akár még paramétere is lehet. A fordítónknak sem ártana tudnia, hogy hány darab és milyen méretű paramétert kell le push-nia a stack-be. Legyen pl. egy olyan függvény, ami 2 szám közül visszaadja a nagyobbat. Rakjuk el egy változóba, de már meg kell adni a visszatérési érték és a paraméterek típusát is.		Az élet nem ennyire egyszerű, mert elképzelhető, hogy van a függvényünknek visszatérési értéke, akár még paramétere is lehet. A fordítónknak sem ártana tudnia, hogy hány darab és milyen méretű paramétert kell le push-nia a stack-be. Legyen pl. egy olyan függvény, ami 2 szám közül visszaadja a nagyobbat. Rakjuk el egy változóba, de már meg kell adni a visszatérési érték és a paraméterek típusát is.

	<pre>~~%BLACK%%BLUE%~~int~~%ENDCOLOR%~~ (*fvMax)(~~%BLUE%~~int~~%ENDCOLOR%~~, ~~%BLUE%~~int~~%ENDCOLOR%~~);~~%ENDCOLOR%~~</pre>		<pre>int (*fvMax)(int, int);</pre>

	Ezt a csúnya és hosszú sort még minimum 2x le kellene írni, ezért typedefelünk:		Ezt a csúnya és hosszú sort még minimum 2x le kellene írni, ezért typedefelünk:

	<pre>~~%BLACK%%BLUE%~~typedef int~~%ENDCOLOR%~~(*MY_MAX_FUNC)(~~%BLUE%~~int~~%ENDCOLOR%~~, ~~%BLUE%~~int~~%ENDCOLOR%~~);		<pre>typedef int(*MY_MAX_FUNC)(int, int);
	...		...
	MY_MAX_FUNC fvMax;~~%ENDCOLOR%~~</pre>		MY_MAX_FUNC fvMax;</pre>

	Van egy függvény pointer típusunk, amely int-et ad vissza, és 2 db int a paramétere. Nem adtuk meg, hogy mik a paraméterek nevei. Erre a fordító magasról sz*rik, őt csak a típusok érdeklik.		Van egy függvény pointer típusunk, amely int-et ad vissza, és 2 db int a paramétere. Nem adtuk meg, hogy mik a paraméterek nevei. Erre a fordító magasról sz*rik, őt csak a típusok érdeklik.
	Töltsük be.		Töltsük be.

	<pre>~~%BLACK%~~fvMax = (MY_MAX_FUNC)GetProcAddress(hDLL, ~~%MAROON%~~"add"~~%ENDCOLOR%~~);~~%ENDCOLOR%~~</pre>		<pre>fvMax = (MY_MAX_FUNC)GetProcAddress(hDLL, "add");</pre>

	A GetProcAddress egy void*-ot ad vissza, azaz egy általános pointert, ami a függvényre mutat a memóriában. Csakhogy nekünk spéci függvényünk van, ezért cast-olunk. Itt már kezdünk örülni a typedef-nek, hogy nem kell mindenféle csúnya zárójeles csillagos dolgokat leírni.		A GetProcAddress egy void*-ot ad vissza, azaz egy általános pointert, ami a függvényre mutat a memóriában. Csakhogy nekünk spéci függvényünk van, ezért cast-olunk. Itt már kezdünk örülni a typedef-nek, hogy nem kell mindenféle csúnya zárójeles csillagos dolgokat leírni.

	<pre>~~%BLACK%%BLUE%~~if~~%ENDCOLOR%~~ (fvMax == NULL)		<pre>if (fvMax == NULL)
	{		{
	fprintf(stderr, %MAROON%"Cannot find function\n"~~%ENDCOLOR%~~);		fprintf(stderr, %MAROON%"Cannot find function\n");
	~~%BLUE%~~return~~%ENDCOLOR%~~ -1;		return -1;
	}~~%ENDCOLOR%~~</pre>		}</pre>

	Ha nincs szerencsénk, NULL-t kapunk vissza.		Ha nincs szerencsénk, NULL-t kapunk vissza.

	Ennyi küzdelem után jó lenne használni is:		Ennyi küzdelem után jó lenne használni is:
	<pre>~~%BLACK%%BLUE%~~int~~%ENDCOLOR%~~ max = (MY_MAX_FUNC)(a, b); ~~%RED%~~// Valoszinuleg inkabb int max = (fvMax)(a, b);~~%ENDCOLOR%~~</pre>		<pre>int max = (MY_MAX_FUNC)(a, b); // Valoszinuleg inkabb int max = (fvMax)(a, b);</pre>

	A MY_MAX_FUNC egy függvény pointer, de mi nem a címet szeretnénk, hanem megakarjuk hívni. A * pont ezért kell, hogy a pointerre rámutassunk. C-ben zárójelekkel () jelezzük, hogy a változónk egy függvény, és hogy hívni szeretnénk, ezért olyan a typedef. Tehát elmutatunk a memóriában valahova, amiről tudjuk, hogy egy függvény, és meghívjuk a, b int-ekkel, és a visszatérési értéket elrakjuk max-ba.		A MY_MAX_FUNC egy függvény pointer, de mi nem a címet szeretnénk, hanem megakarjuk hívni. A * pont ezért kell, hogy a pointerre rámutassunk. C-ben zárójelekkel () jelezzük, hogy a változónk egy függvény, és hogy hívni szeretnénk, ezért olyan a typedef. Tehát elmutatunk a memóriában valahova, amiről tudjuk, hogy egy függvény, és meghívjuk a, b int-ekkel, és a visszatérési értéket elrakjuk max-ba.
79. sor:		79. sor:
	Végül illene közölni a Windows-al, hogy már nem szeretnénk használni a dll-t, akár ki is szedheti a memóriából.		Végül illene közölni a Windows-al, hogy már nem szeretnénk használni a dll-t, akár ki is szedheti a memóriából.

	<pre>~~%BLACK%~~FreeLibrary(hDLL);~~%ENDCOLOR%~~</pre>		<pre>FreeLibrary(hDLL);</pre>

	====Linux====		====Linux====

Ferrero, 2013. február 6., 08:38-n

2013-02-06T08:38:44Z

← Régebbi változat		A lap 2013. február 6., 10:38-kori változata
1. sor:		1. sor:
	~~{{GlobalTemplate\|Infoalap\|SzoftverTechnikakTetelsor}}~~

	==Bináris komponensek evolúciója 1.==		==Bináris komponensek evolúciója 1.==

Unknown user: Új oldal, tartalma: „{{GlobalTemplate|Infoalap|SzoftverTechnikakTetelsor}} ==Bináris komponensek evolúciója 1.== ===Soroljon fel három C++ tulajdonságot, amelyek alkalmatlanná teszi…”

2012-10-21T20:22:55Z

Új oldal, tartalma: „{{GlobalTemplate|Infoalap|SzoftverTechnikakTetelsor}} ==Bináris komponensek evolúciója 1.== ===Soroljon fel három C++ tulajdonságot, amelyek alkalmatlanná teszi…”

Új lap

{{GlobalTemplate|Infoalap|SzoftverTechnikakTetelsor}}

==Bináris komponensek evolúciója 1.==

===Soroljon fel három C++ tulajdonságot, amelyek alkalmatlanná teszik a nyelvet lazán csatolt komponensek fejlesztésére!===

Elveszik a kompatibilitás ha az új lib verzióban:

* újraimplementálsz virtuális függvényeket
* hozzáadsz vagy elveszel virtuális tagfüggvényeket (asszem a virual fv. táblák méreteinek megváltozása átrendezi a kész lib szerkezetét)
* megváltoztatod az osztályhierarchiát (kivéve ha csak új leveleket adsz hozzá)
* elveszel/hozzáadsz privát adattagokat
* eltávolítasz public vagy protected nem inline metódust
* inlineként valósítasz meg régi (nem inline) public/protected metódusokat
* megváltoztatod egy inline metódus működését úgy, hogy a régi verzió így már nem működik megfelelően

szóval a dolog lényege szerintem az, hogy ha c++ shared libet próbálsz meg tovább fejleszteni,
és nem tartod be ezeket a korlátozásokat, akkor az új libben máshová kerülnek azok a fv-ek is,
amelyek a régi verzióban kerültek megvalósításra, így viszont az új verzióban nem fogják őket
megtalálni a programok, magyarul nem leszel '''binárisan kompatibilis'''.

===Hasonlítsa össze a statikus és a dinamikus programkönyvtárakat!===
A dinamikus libek nem linkelési (fordítási) időben, vagy a program indulásakor töltődnek be,
hanem egy API segítségével futásidőben.
http://www.dwheeler.com/program-library/Program-Library-HOWTO/x170.html
===Ismertesse a dinamikus könyvtárak elnevezésikonvenció-hierarchiáját!===
->libakarmi.so: "linker name", szimlink a soname-re, ez alapján keresgél a linker

->libakarmi.so.3: "soname", általában szimlink a valódi névre, a vége a verzió szám
(ami az interface változásakor nő)

->libakarmi.so.3.2.1: valódi név - soname + minor number + release number, ez már konkrétan a lib

===Mutasson egy Linux VAGY Windows alatt futó példát dinamikus programkönyvtárak betöltésére, felszabadítására és egy könyvtári függvény meghívására! Hol jelenik meg a fordító szintjén lévő kapcsolódás?===

====Windows====
windows.h-ban vannak a szükséges függvények, ezért:
<pre>%BLUE%#include%ENDCOLOR% %MAROON%"windows.h"%ENDCOLOR%</pre>

Betöltetjük az OS-el a dll-elünket, amire egy HMODULE típusú változóval tudunk a későbbiekben hivatkozni
<pre>%BLACK%HMODULE hDLL = !LoadLibrary(%MAROON%"myDll.dll"%ENDCOLOR%);%ENDCOLOR%</pre>

Persze lehet, hogy nincs is dll, ekkor null-t kapunk vissza.
<pre>%BLACK%%BLUE%if%ENDCOLOR% (hDLL == NULL)
{
fprintf(stderr, %MAROON%"Cannot find DLL\n"%ENDCOLOR%); %GREEN%//kiírjuk az stderr-re, hogy baj van%ENDCOLOR%
return -1; %GREEN%//végül kilépünk%ENDCOLOR%
}%ENDCOLOR%</pre>

Van már DLL-elünk, valahogy kellene használni a benne lévő függvényeket is. Megkérjük a Windows-t, hogy a DLL-ből keresse ki a megadott nevű függvényt, és ha szerencsénk van, vissza kapunk egy rá mutató függvény pointert.
Az élet nem ennyire egyszerű, mert elképzelhető, hogy van a függvényünknek visszatérési értéke, akár még paramétere is lehet. A fordítónknak sem ártana tudnia, hogy hány darab és milyen méretű paramétert kell le push-nia a stack-be. Legyen pl. egy olyan függvény, ami 2 szám közül visszaadja a nagyobbat. Rakjuk el egy változóba, de már meg kell adni a visszatérési érték és a paraméterek típusát is.

<pre>%BLACK%%BLUE%int%ENDCOLOR% (*fvMax)(%BLUE%int%ENDCOLOR%, %BLUE%int%ENDCOLOR%);%ENDCOLOR%</pre>

Ezt a csúnya és hosszú sort még minimum 2x le kellene írni, ezért typedefelünk:

<pre>%BLACK%%BLUE%typedef int%ENDCOLOR%(*MY_MAX_FUNC)(%BLUE%int%ENDCOLOR%, %BLUE%int%ENDCOLOR%);
...
MY_MAX_FUNC fvMax;%ENDCOLOR%</pre>

Van egy függvény pointer típusunk, amely int-et ad vissza, és 2 db int a paramétere. Nem adtuk meg, hogy mik a paraméterek nevei. Erre a fordító magasról sz*rik, őt csak a típusok érdeklik.
Töltsük be.

<pre>%BLACK%fvMax = (MY_MAX_FUNC)GetProcAddress(hDLL, %MAROON%"add"%ENDCOLOR%);%ENDCOLOR%</pre>

A GetProcAddress egy void*-ot ad vissza, azaz egy általános pointert, ami a függvényre mutat a memóriában. Csakhogy nekünk spéci függvényünk van, ezért cast-olunk. Itt már kezdünk örülni a typedef-nek, hogy nem kell mindenféle csúnya zárójeles csillagos dolgokat leírni.

<pre>%BLACK%%BLUE%if%ENDCOLOR% (fvMax == NULL)
{
fprintf(stderr, %MAROON%"Cannot find function\n"%ENDCOLOR%);
%BLUE%return%ENDCOLOR% -1;
}%ENDCOLOR%</pre>

Ha nincs szerencsénk, NULL-t kapunk vissza.

Ennyi küzdelem után jó lenne használni is:
<pre>%BLACK%%BLUE%int%ENDCOLOR% max = (*MY_MAX_FUNC)(a, b); %RED%// Valoszinuleg inkabb int max = (*fvMax)(a, b);%ENDCOLOR%</pre>

A MY_MAX_FUNC egy függvény pointer, de mi nem a címet szeretnénk, hanem megakarjuk hívni. A * pont ezért kell, hogy a pointerre rámutassunk. C-ben zárójelekkel () jelezzük, hogy a változónk egy függvény, és hogy hívni szeretnénk, ezért olyan a typedef. Tehát elmutatunk a memóriában valahova, amiről tudjuk, hogy egy függvény, és meghívjuk a, b int-ekkel, és a visszatérési értéket elrakjuk max-ba.

Végül illene közölni a Windows-al, hogy már nem szeretnénk használni a dll-t, akár ki is szedheti a memóriából.

<pre>%BLACK%FreeLibrary(hDLL);%ENDCOLOR%</pre>

====Linux====

Linux-on is kb ugyanezt csináljuk, csak másképp.

<pre>%BLACK%
%BLUE%#include%ENDCOLOR% %MAROON%<dlfcn.h>%ENDCOLOR%
%BLUE%#include%ENDCOLOR% %MAROON%<stdio.h>%ENDCOLOR%

%BLUE%typedef int%ENDCOLOR%(*MY_MAX_FUNC)(%BLUE%int%ENDCOLOR%, %BLUE%int%ENDCOLOR%);

int main(){
MY_MAX_FUNC fvMax;
void *handle;

%GREEN%/* Megnyitjuk a konyvtarat. */%ENDCOLOR%
handle = dlopen(%MAROON%"./libcomplex.so"%ENDCOLOR%, RTLD_LAZY);
if(!handle){
fputs(dlerror(), stderr);
return 1;
}

%GREEN%/* Hozzaferunk a szimbolumhoz. */%ENDCOLOR%
fvMax = dlsym(handle, %MAROON%"max"%ENDCOLOR%);
if(dlerror() != NULL){
fputs(dlerror(), stderr);
return 1;
}

%BLUE%int%ENDCOLOR% max = (*fvMax)(a, b); %RED%// int max = fvMax(a, b); is ugyanugy mukodik%ENDCOLOR%

dlclose(handle);

return 0;
}
%ENDCOLOR%</pre>

==Bináris komponensek evolúciója 2.==

===Hogyan lehet egy osztály metódusait/tagváltozóit lekérdezni? Mutasson egy C# VAGY egy Java példát!===
Java:
<pre>
import java.lang.reflect.*;
import java.awt.*;

class SampleField {

public static void main(String[] args) {
GridBagConstraints g = new GridBagConstraints();
printFieldNames(g);
}

static void printFieldNamesAndMethods(Object o) {
Class c = o.getClass();
Field[] publicFields = c.getFields();
Method[] theMethods = c.getMethods();
// Tagvaltozok lekerdezese
for (int i = 0; i < publicFields.length; i++) {
String fieldName = publicFields[i].getName();
Class typeClass = publicFields[i].getType();
String fieldType = typeClass.getName();
System.out.println("Name: " + fieldName +
", Type: " + fieldType);
}
}
// Metodusok lekerdezese
for (int i = 0; i < theMethods.length; i++) {
String methodString = theMethods[i].getName();
System.out.println("Name: " + methodString);
String returnString =
theMethods[i].getReturnType().getName();
System.out.println(" Return Type: " + returnString);
Class[] parameterTypes = theMethods[i].getParameterTypes();
System.out.print(" Parameter Types:");
for (int k = 0; k < parameterTypes.length; k ++) {
String parameterString = parameterTypes[k].getName();
System.out.print(" " + parameterString);
}
System.out.println();
}
}
}
</pre>
Ahogy ezt megszokhattuk, a fuggvenynevek eleg beszedesek...

===Hasonlítsa össze a C/C++ nyelv; bináris komponenseket a modern futtatókörnyezetek megoldásaival! Miért van szükség reflexióra?===
sun.com szerint azert van szukseg reflexiora, mert igy lehet pl. debuggereket,
class browsereket es GUI buildereket irni.
<pre>
Viewing metadata
This might be used by tools and utilities that wish to display metadata.
Performing type discovery
This allows you to examine the types in an assembly and interact with or instantiate those types. This can
be useful in creating custom scripts. For example, you might want to allow your users to interact with your
program using a script language, such as JavaScript, or a scripting language you create yourself.
Late binding to methods and properties
This allows the programmer to invoke properties and methods on objects dynamically instantiated based on type
discovery. This is also known as dynamic invocation.
Creating types at runtime (Reflection Emit)
The ultimate use of reflection is to create new types at runtime and then to use those types to perform tasks.
You might do this when a custom class, created at runtime, will run significantly faster than more generic code
created at compile time.
</pre>
[http://www.ondotnet.com/pub/a/dotnet/excerpt/prog_csharp_ch18/index.html?page=4#reflection --forrás]
===Mutasson példát attribútumokra C# nyelven VAGY annotációkra Java nyelven (saját létrehozása, használat, lekérdezés)!===
Létrehozás, ez ugye innentől .NET és attribútum:
<pre>

[AttributeUsage(AttributeTargets.Class,
AllowMultiple=false)]
public class TableAttribute : System.Attribute
{
private string _name;
public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}

public TableAttribute(string name)
{
_name = name;
}
}

</pre>
Használat:
<pre>
[Table("Customer")]
public class Customer
{
// Anything...
}
// Lekerdezes:
private string GetTable(Type type)
{
object[] tables = type.
GetCustomAttributes(typeof(TableAttribute), true);

if (tables.Length == 1)
return (tables[0] as TableAttribute).Name;
else
return null;
}
</pre>
A lenyeg (szerintem): az attributumok a System.Attribute-ból származnak, a nevük végén ott az
"Attribute" (??), szögletes zárójelben lehet használni őket (az Attribute végződés nélkül),
lekérdezés mega a Type.GetCustomAttributes()-szal megy.

==Adatkezelés 1.==

===Mutasson egy példát a három anomáliatípusra! Küszöbölje ki a példa anomáliáit BCNF dekompozícióval!===
* törlési anomália

Egy szükségtelen adat törlése magával ránt hasznos információt is.

* beszúrási anomália

Inkonzisztens adatok szúrhatók be a táblába, pl.:

{| border="1"
| '''Név''' || '''Osztály száma''' || '''Osztály neve'''
|-
| Ede || 42 || Takarítók
|-
| Gizi|| 42 || IT
|}

Akkor Gizi most takarít, vagy bitet heggeszt?

* módosítási anomália

Redundánsan tárolt adat megváltoztatásához az összes tárolási ponton változtatni kell
===Mutassa be az objektum-relációs leképezést! Adjon meg példaként osztálydiagramot, amely tartalmaz 1-1, 1-több, több-több kapcsolatot! Képezze le ezeket adatbázistáblákba!===

==Adatkezelés 2.==

===Ismertesse egy rövid C# nyelv; példán keresztül az ADO.NET kapcsolatalapú adathozzáférését!===
<pre>
SqlConnection conn = null;
try
{
// Kapcsolódás azadatbázishoz
conn = new SqlConnection(@"Data Source=LAPTOP\SQLEXPRESS;Initial Catalog=Northwind;Integrated Security=True");

// A kapcsolat megnyitása
conn.Open();

// Az adatbázis parancs létrehozása
SqlCommand command = new SqlCommand("SELECT ShipperID, CompanyName, Phone FROM Shippers");

// Adatbázis kapcsolat megadása
command.Connection = conn;
Console.WriteLine("{0,0}{1,15}{2,15}", "ShipperID", "CompanyName", "Phone");
Console.WriteLine("-----------------------------------------------------------------");
// Az adatok lekérdezése és kiiratása
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
Console.WriteLine("{0,4}{1,20}{2,20}", reader["ShipperID"].ToString(), reader["CompanyName"].ToString(), reader["Phone"].ToString());
}
}
catch (Exception ex)
{
// Kivétel szövegének kiiratása
Console.WriteLine(ex.Message);
}
finally
{
// Az adatbázis kapcsolat lezárása, ha meg lett nyitva
if((conn!=null)&&(conn.State==System.Data.ConnectionState.Open)) conn.Close();
}
</pre>
===Ismertesse egy rövid C# nyelv; példán keresztül az ADO.NET kapcsolat nélküli adathozzáférését!===

<pre>
using System;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.Windows.forms;

class DisconnectedDataform : form
{
private SqlConnection conn;
private SqlDataAdapter daCustomers;

private DataSet dsCustomers;
private DataGrid dgCustomers;

private const string tableName = "Customers";

// initialize form with DataGrid and Button
public DisconnectedDataform()
{
// fill dataset
Initdata();

// set up datagrid
dgCustomers = new DataGrid();
dgCustomers.Location = new Point(5, 5);
dgCustomers.Size = new Size(
this.Clientrectangle.Size.Width - 10,
this.Clientrectangle.Height - 50);
dgCustomers.DataSource = dsCustomers;
dgCustomers.DataMember = tableName;

// create update button
Button btnUpdate = new Button();
btnUpdate.Text = "Update";
btnUpdate.Location = new Point(
this.Clientrectangle.Width/2 - btnUpdate.Width/2,
this.Clientrectangle.Height - (btnUpdate.Height + 10));
btnUpdate.Click += new EventHandler(btnUpdateClicked);

// make sure controls appear on form
Controls.AddRange(new Control[] { dgCustomers, btnUpdate });
}

// set up ADO.NET objects
public void Initdata()
{
// instantiate the connection
conn = new SqlConnection(
"Server=(local);DataBase=Northwind;Integrated Security=SSPI");

// 1. instantiate a new DataSet
dsCustomers = new DataSet();

// 2. init SqlDataAdapter with select command and connection
daCustomers = new SqlDataAdapter(
"select CustomerID, CompanyName from Customers", conn);

// 3. fill in insert, update, and delete commands
SqlCommandBuilder cmdBldr = new SqlCommandBuilder(daCustomers);

// 4. fill the dataset
daCustomers.Fill(dsCustomers, tableName);
}

// Update button was clicked
public void btnUpdateClicked(object sender, EventArgs e)
{
// write changes back to DataBase
daCustomers.Update(dsCustomers, tableName);
}

// start the Windows form
static void Main()
{
Application.Run(new DisconnectedDataform());
}
}
</pre>
[http://www.csharp-station.com/Tutorials/AdoDotNet/Lesson05.aspx --forrás]
<pre>
using System;
using System.Data;
using System.Data.SqlClient;

class SelectIntoDataSet{
public static void Main(){
string connectionString = "server=(local)\\SQLEXPRESS;database=MyDatabase;Integrated Security=SSPI";

SqlConnection mySqlConnection = new SqlConnection(connectionString);

string selectString = "SELECT TOP 10 ID, FirstName, LastName FROM Employee ORDER BY ID";

SqlCommand mySqlCommand = mySqlConnection.CreateCommand();

mySqlCommand.CommandText = selectString;

SqlDataAdapter mySqlDataAdapter = new SqlDataAdapter();

mySqlDataAdapter.SelectCommand = mySqlCommand;
DataSet myDataSet = new DataSet();

mySqlConnection.Open();

Console.WriteLine("Retrieving rows from the Employee table");
mySqlDataAdapter.Fill(myDataSet, "Employee");

mySqlConnection.Close();

DataTable myDataTable = myDataSet.Tables["Employee"];

foreach (DataRow myDataRow in myDataTable.Rows){
Console.WriteLine("ID = "+ myDataRow["ID"]);
Console.WriteLine("FirstName = "+ myDataRow["FirstName"]);
Console.WriteLine("LastName = "+ myDataRow["LastName"]);
}
}
}
</pre>
[http://www.java2s.com/Code/CSharp/Database-ADO.net/HowtoperformaSELECTstatementandstorethereturnedrowsinaDataSetobject.htm --forrás]

===Ismertesse az adatkötés fogalmát!===

<pre>

Def1: Az adatkötés az adatforrásokból származó adatok összerendelése az adatmegjelenítő
vezérlőkkel.
Def2: Adatkötés alatt azt a folyamatot értjük, mely segítségével kiolvassuk a szükséges
adatokat az adatforrásból és dinamikusan egy vizuális elem egyik tulajdonságához "kötjük",
azaz a vizuális elem szóban forgó tulajdonságának értékét az adatforrás bizonyos adataitól
tesszük (kölcsönösen) függővé.

</pre>

===Mutasson egy példát egy osztály perzisztenssé tételére a Java Persistence API segítségével! Ismertesse a szükséges annotációk jelentését! Mire használjuk a @Transient annotációt?===
<pre>
@Entity
public class Foo { // perzisztens osztály
@Id
protected int id; // elsődleges kulcs
protected int x;
protected int y;
@Transient
protected int z; // nem lesz elmentve az adatbázisba
}
</pre>
Egyéb dolgok ebben a pdf-ben: http://web.conf.hu/2007/media/foliak/Sun-webconf2007-PersistenceEJB3.pdf

-- [[DeVi|DeVi]] - 2007.04.12.

[[Category:Infoalap]]