P2P Fálcserélő dokumentum (PDF) letöltése

P2P Fájlcserélő Prezentáció (PPTX) letöltése

P2P Fájlcserélő Szerver és Kliens (ZIP) letölése

A LINQ-ról általában

A LINQ query-k kísértetiesen hasonlítanak az SQL lekérdezésekre, különbség csupán annyi, hogy a select kulcsszó és maga a kiválasztandó objektum deklarációja hátra lett csapva.

var halmaz = from sor in Kollekcio
where sor.property  == "valami" && sor.propery2=="valami2"
select sor;

Az így kapott eredményhalmaz is szintén egy kollekció lesz függetlenül attól, hogy hány elemet tartalmaz, melyeken használhatóak a kollekcióknár már jól megszokott First(), Last(), Next(), OrderBy(), Sum(),  Average(), Contains() és még több száz generikus listaeljárás általunk definiált delegate-kkel de akár a jó öreg foreach -et is használhatjuk.

SajatObjektum o = halmaz.First<SajatOjektum>();

Él keresése GleeGraph-ban

Adott egy GleeGraph g gráfobjektum, melynek irányított éleit a g.Edges Edge típusú Generikus Lista tartalmazza és meg szeretném keresni az összes valamilyen A és valamilyen B tulajdonságú node között futó élet. Mivel minden egyes referenciaként hivatkozik azokhoz a csomópontokhoz (SourceNode és TargetNode) melyekhez kapcsolódik a megoldás LINQ-ban az alábbi C# kódot eredményezi, ha a Node-okat épp azonosítójuk alapján határozzuk meg:

var vk = from e in g.Edges
where e.SourceNode.Attr.Id =="A" &&
e.TargetNode.Attr.Id == "B"
select e;

vagy irányítatlan esetben:

var vk = from e in g.Edges
where (e.SourceNode.Attr.Id =="A" && e.TargetNode.Attr.Id == "B") ||
(e.SourceNode.Attr.Id =="B" && e.TargetNode.Attr.Id == "A")
select e;

Egyszerű, mint az egyszeregy. Ha többet szeretnél még tudni a LINQ-ról, klikk ide: LINQ az MSDN-en

Hosszas keresgélés után rábukkantam a Microsoft Research – VIBE csoport egyik kísérleti fejlesztésére a Microsoft Automatic Graph Layout (MSAGL) csomagra, korábbi nevén a Graph Layout Execution Engine (GLEE) -re, mely oktatási és kísérleti célokra szabadon használható.

A GLEE telepítőkészlete a .NET osztályokkal, dokumentációkkal és példa kódokkal összesen 2MB-ot foglal gépünkön. A csomag egyébként 3 komponensből, a gráf tárolásáért és alapműveleteiért felelős Microsoft.GLEE, a megjelenítésért, színezésért, él és node ábrázolásért felelős Microsoft.GLEE.Drawing és az interaktív működésért felelős Microsoft.GLEE.GraphViewerGDI -ből áll összesen. Használata rendkívül egyszerű és kényelmes.

GleeGraph

Gráf objektum létrehozásához a GleeGraph osztályt kell példányosítanunk. Ennek tagjai lehetnek Node -ok és Edge-ek, melyeket az AddNode() és a AddEdge() metódusokkal vehetünk fel.

GleeGraph graph = new GleeGraph();

Node

A GleeGraph Node-ok rendelkeznek saját string ID-val, amit pédányosításkor kell megadnunk és ezzel az azonosítóval kereshetjük vagy hivatkozhatunk rájuk később, továbbá képesek eltárolni grafikájukat és rendelhetőek hozzá tetszőleges Object-ek, ha tárolásra és használnánk ezeket a csomópontokat.

Node a = new Node("a", new Ellipse(w, h, new P()));
Node b = new Node("b", CurveFactory.CreateBox(w, h, new P()));
graph.AddNode(a);
graph.AddNode(b);

Edge

Az élek tárolására megvalósított osztály, amely két node között húzódik. Ezek az élek minden esetben irányított éleknek, melyek konstruktoruk első Node-jából a másodikba mutatnak. Természetes ábrázolás szempontjából az irányítottság kérdése egyszerűen megoldható ha nyilak helyett csak szakaszokat használunk. Az Edge objektumok azonban a Node-okkal ellentétben nem rendelkeznek saját ID-val és a GleeGraph sem tartalmaz élkeresési eljárást, így ha ilyenre lenne szükségünk magunknak kell ezt megoldani.

Edge e = new Edge(a, b);
e.ArrowHeadAtSource = true; //Nyíl irányjelzője
graph.AddEdge(e);
graph.AddEdge(new Edge(a,b));

A GleeGraph -ok ábrázolására használhatjuk saját metódusainkat, de rá is bízhatjuk  a GraphViewerGDI vezérlőre, melynek Graph Propery-jének átadva gráfunkat az automatikusan le is rendereli. Ezen kívül a GLEE képes hagyományos Graphics objektumot is adni kimenetként, így gráfjainak akár egy ASP oldalon is generálhatjuk.

További infirmációk az MS AGL-ről és GLEE-ről:
http://research.microsoft.com/en-us/projects/msagl/

Amennyiben kereskdelmi szándékkal fejlesztünk az MS AGL 2007 csomag 280 USD -ért megrendelhető a Windows MarketPlace-en:

http://store.microsoft.com/microsoft/Automatic-Graph-Layout-2007/product/4DD40C40

ODP driverrel lekérdezéseink eredményét, ahogy azt már előző bejegyzésemben is láthattuk, az OracleDataReader objektummal olvashatjuk végig. Ennek az olvasás utáni aktuális példánya tartalmazza az eredménymutató alatti éppen olvasott rekord mezőit. Látható, hogy egy eredménysor mezőinek átadásának legegyszerűbb módja, ha a példányosítani kívánt osztály konstruktorának  átadjuk az OracleDataReader aktuális példányát.

Tegyük fel, hogy lekérdezésünk Lokáció adatokat fog eredményül adni, melynek első oszlopa egy number típusú ID, a többi pedig valamilyen szöveges érték lesz, amely tartalmazza az érintett rekord címét (STREET_ADDRESS), irányítószámát (POSTAL_CODE), stb..

Ennek szellemében készítsük el  osztályunkat, amely prezentálni fogja eredményhalmazunk egy ilyen rekordját, melynek konstruktorra, épp a OracleDataReader típusú objektumot vesz át, amely kitölti az osztály megfelelő változóit az aktuális rekord oszlopai alapján. Fontos, hogy az egyes oszlopok értékeinek tárolásához használjunk publikus Property-ket, akár csak olvasható módon is. Ezek alkalmazása azért lényeges, mert e változók fogják jelölni a DataGridView táblázatunk egyes oszlopait. A rekord reprezentán osztály ezek után valahogy így nézhet ki:

using System;
using Oracle.DataAccess.Client;

namespace odp_test_12
{
 class MyLocation
 {
 //Publikus property-k a DataGrid oszlopok megadásához
 public int ID { get; set; }
 public String Street { get; set; }
 public String PostalCode { get; set; }
 public String City { get; set; }
 public String State { get; set; }

 /* Téynleges LOCATIONS tábla Oszlopok:

 LOCATION_ID,
 STREET_ADDRESS,
 POSTAL_CODE,
 CITY,
 STATE_PROVINCE,
 COUNTRY_ID
 */

 //Konstruktor az adatok átvételére
 public MyLocation(OracleDataReader r)
 {
 //Indexelés a C-ben megszokottakhoz híven 0-tól kezdődik
 ID = r.GetInt32(0);
 Street = r["STREET_ADDRESS"].ToString();
 PostalCode = r["POSTAL_CODE"].ToString();
 City = r[3].ToString();
 State = r["STATE_PROVINCE"].ToString();
 }
 }
}

Ezután készítsük el Windows Formunkat. Vegyük fel a DataGridView objektumot ablakunkra, amit nevezzünk el dg_results-nak és tegyünk fel 3 gombot is a formra, melyek kötül az egyik a kapcsolat felépítéséért, a másik annak lezárásáért a harmadik pedig lekérdezésünk futtatásáért és az eredményhalmaz megjelenítéséért felel a dg_results vezérlőnkben.

Kódolásnál az OracleConnection conn változónkat deklarájuk Formunk osztályában globális objektumnak, hogy azt minden vezérlőből és eseményből elérhessük:

public partial class Form1 : Form
{
OracleConnection conn;

Ezután nincs más, mint elkészíteni ODP parancsainkat  az egyes  gomb oklenyomására. Dupla klikk a formon lévő gombra és írjuk meg a szokásos kapcslat-parancs-eredményolvasás kódrészleteket.

Kapcsolódás gomb

private void bt_connect_Click(object sender, EventArgs e)
 {
 try
 {
 //Kapcsolat példányosítása a ConnectionString alapján:
 conn = new OracleConnection();
 conn.ConnectionString = tx_connstr.Text;

 //Kapcsolat megnyitása
 conn.Open();
 MessageBox.Show("Kapcsolat sikeresen felépítve:" + conn.ServiceName);

 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 }

Lekapcsolódás gomb

private void button2_Click(object sender, EventArgs e)
 {
 try
 {
 //Kapcsolat lezárása
 conn.Dispose();
 MessageBox.Show("Kapcsolat sikeresen lezárva:");
 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 }

Lekérdezés futtatása

Ebben az esetben a már jól megszokott lekérdezés futtatáson kívül példányosítanunk kell az eredményhalmazt tároló listánkat is. Erre a célra használható a .NET ArrayList osztálya, mely a System.Collections névtérben található. Gombnyomásunk eseményének első sorába írjuk is be: ArrayList results = new ArrayList();

Az eredményhalmaz végigolvasásakor szükségünk van az aktuális rekordok .NET példányaira, amiket ott helyben pédányosítunk az OracleDataReader instanciánkkal, majd beteszük azt az előbb kreált eredményhalmazba:

MyLocation l = new MyLocation(dr);
results.Add(l);

Ezek után, ha minden jól ment az eredményhalmazunk a results ArrayListben található, melyek sorai az általun létrehozott MyLocation osztály egy-egy példánya. Innentől nincs más dolgunk, minthogy átadjuk ezt a változót a DataGridView-nak megjelenítésre az alábbi egyszerű utasítással:
dg_results.DataSource = results;

Ennyi. A lekérdezés gomb futtatása ezek alapján valahogy így nézhet ki:

private void bt_execute_Click(object sender, EventArgs e)
 {
 try
 {
 //Eredményhalmaz eltárolása
 ArrayList results = new ArrayList();

 //Kapcsolat, ha minden jól ment, már fel van építve
 //Új SQL utasítás kreálása
 OracleCommand cmd = new OracleCommand();
 cmd.Connection = conn;
 cmd.CommandText = tx_sqlquery.Text;

 //Szabad szöveges
 cmd.CommandType = CommandType.Text;

 //Eredményhalmaz kiolvasása DataReader-rel elöltesztelős ciklussal
 OracleDataReader dr = cmd.ExecuteReader();
 while (dr.Read())
 {
 MyLocation l = new MyLocation(dr);
 results.Add(l);
 }

 //Eredményhalmaz lezárása
 dr.Dispose();

 //Utasításpéldány felszabadítása
 cmd.Dispose();

 dg_results.DataSource = results;
 MessageBox.Show("Query lefutott: " + results.Count);

 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 }

Ezek után, ha mindent jól csináltunk Connect-álás után és Execute gombok nyomogatására látnunk kell lekérdezésünk eredményét dg_result táblázatunkban valahogy így:

A teljes Visual Studio 2008 projekt letöltéséhez kattins ide:ODP Datagrid Project – Saját osztállyal

Az ODP sem bonyolultabb, mint bármilyen más .NET driver, előnye viszont abban rejlik, hogy nemcsak gyorsabb és hangolható elérést biztosít Oracle adatbázisainkhoz, de teljesen lefedi az abban elérhető adattípusok széles skáláját, melyek így különösebb trükközések nélkül elérhetőek közvetlenül .NET alkalmazásunkból.

Referenciák

Hozzuk létre új ConsoleApplication projektünket a Visual Studio File/New/Project/Windows/ConsoleApplication menü választásával. Ahhoz, hogy használni tudjuk az ODP .NET csomag nyújtotta lehetőségeket hozzá kell adnunk projektünk referenciához, melyet a Solution Explorer-ben található References mappára jobb egérgombbal kattintva érhetünk el az Add Reference menün keresztül. Ezután a megjelenő .NET listából válasszuk az Oracle.DataAccess 2.0-s .NET runtime komponensét. Ezután pedig adjuk meg ezt a library-t a Program.cs fejlécébe: using Oracle.DataAccess.Client;

OracleConnection

Itt is, mint mindenhol szükségünk van egy kapcsolat objektumra, mely megnyitja és lezárja az adatbázissal a kommunikációs csatornánkat. Ennek megfelelője esetünkben az OracleConnection, melynek konstruktorának adhatjuk át a a megszokott connectionstringet.

string connStr= "Data Source=(DESCRIPTION=(ADDRESS_LIST="
                + "(ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=1521)))"
                + "(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=XE)));"
                + "User Id=HR;Password=teszt;";

OracleConnection conn = new OracleConnection(connStr);

Kapcsolatunkat nyithatjuk és zárhatjuk a conn.Open() illetve conn.Dispose() metódusokkal, de használhatjuk a .NET alatt jól megszokott using() {} kulcsszót is.

OracleCommand

Felépített kapcsolatban vagy using eljárásban futtathatjuk SQL utasításainkat, melyeket az OracleCommand osztályból példányosíthatunk. Ezek lehetnek általunk szerkesztett SQL query-k vagy tárolt eljárás hívások, melyet a CommandType property-vel állíthatunk be.

conn.Open();
OracleCommand cmd = new OracleCommand();
cmd.Connection = conn;
cmd.CommandText = "select deptno, dname, loc from dept";
cmd.CommandType = CommandType.Text;

OracleDataReader

Majd utasításunkat az ExecuteReader() metódussal futtatva, kiolvassunk annak eredményét az OracleDataReader osztály egy példányával, majd a példány Read() függvénnyel sorról sorra kiolvassuk amíg lehet és végül lezárjuk az egyes instanciákat a Dispose() metódussal

OracleDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
Console.WriteLine(dr.GetInt16(0).ToString() + " - "
 + dr["STREET_ADDRESS"].ToString());
}
dr.Dispose();
cmd.Dispose();
conn.Dispose();

A Teljes mintakódunk így az alábbiak szerint néz ki:

using System;
using System.Data;
using Oracle.DataAccess.Client;

namespace ConsoleApplication1
{
 class Program
 {
 static void Main(string[] args)
 {
 string connStr = "Data Source=(DESCRIPTION=(ADDRESS_LIST="
 + "(ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=1521)))"
 + "(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=XE)));"
 + "User Id=HR;Password=teszt;";

 OracleConnection conn = new OracleConnection(connStr);
 conn.Open();

 OracleCommand cmd = new OracleCommand();
 cmd.Connection = conn;
 cmd.CommandText = "SELECT * FROM LOCATIONS";
 cmd.CommandType = CommandType.Text;

 OracleDataReader dr = cmd.ExecuteReader();
 while (dr.Read())
 {
Console.WriteLine(dr.GetInt16(0).ToString() + " - "
 + dr["STREET_ADDRESS"].ToString());
 }

 dr.Dispose();
 cmd.Dispose();
 conn.Dispose();

 Console.ReadLine();
 }
 }
}

A forráskód letöltéséhez kattint ide: ODP .NET Első Console Demo Projekt

Tanulmányaimat segítik (abc rendben):

• Fekete Zoltán (Oracle)
• Kardkovács Zsolt Tivadar (BME – TMIT)
• Marton József (BME TMIT)
• Sárecz Lajos (Oracle)

2008/2009 – I. félév

Első Önálló labor feladatom az Oracle Business Intelligence megoldásának részletes feltárása, megismerése és másokkal való megismertetése volt. A félév során a cég megoldásaik közül az Oracle BI Enterprise Edition-jét vettem górcső alá.

2008/2009 – II. félév

Szakirányos tanulmányaim második féléves sok-kredites önálló laborom céljául e-mailek tárolásának és kezelésének problémakörét boncolgatom Oracle technológiák segítségével, de a feladatról teljes egészében most csak ennyit szeretnék nyilatkozni.

2009/2010 – I. félév

Szakirányom harmadik önálló labor céljának az előző félévben elkezdett e-mailek és elemzéséhez kapcsolódó feladatot fogom folytatni.

Az emailek logikailag két részre oszthatók: A fejre és a tartalomra, azaz a header-re és a content-re, amik még a levelezés hőskorából átörökölték a 7bites – ANSI karakterkészletes ábrázolás átkát, amikre később furfangos bővítéseket és kódolásokat találtak ki az általános használhatóság érdekében.

A fej az, ami megmondja kiszolgálóinknak, hogy kitől, ki(k)nek, merre és hogyan menjenek az üzenet, ez a rész gyakorlatilag minden mail-szerveren (MTA)  áthaladva módosul, bővülnek egy kicsit, de a lényegi információk (remélhetőleg) megmaradnak. Ugyanakkor a fej rengeteg meta adatot is tartalmaz rólunk, levelezőnkről (MUA), levelünk útjáról és kézbesítésének körülményeiről.

Habár az e-mail üzeneteknek is megvannak a maga szabványai, de az élet természetesen ezekhez is megtalálta egyéb megoldásait, így féléves feladatom megtervezéséhez először ezeket a széles körben alkalmazott, nem feltétlenül szükséges, szabványos vagy ajánlott MIME headereket gyűjtöttem össze:

Általánosan elterjedt MIME headerek dokumentuma (word 2007 docx)

Szabályozástechnika HF letöltése

Telepítés és futtatás után egy kör alakú windows ablakot kapunk, amelyben egy analóg óra informál minket a gépen beállított időről. Az ablak mindig legfelül helyezkedik el, mozgatni a fogd és vidd módszerrel lehet, kilépni, pedig az ESC billentyű leütésével lehet. Átméretezni a Start Menü-ben, az Analóg Óra mappáján belül az átméretezés parancsikonnal tudjuk.

Szerzők:
Konfár András
Muráti Ákos

A skandáló korábbi DOS-os verziója tisztán karakteres felületű, csak szövegfájlokat képes olvasni, ám megbírkózik ezekben Windows-os ékezetek értelmezésével is.

Funkciói:

• Assembly kódok importálhatósága más assembly kódokból
• Hibakereső és statisztikai adatok vezetése
• Fejlett hiba- és kivételkezelés, hatékony debugger a kódok nyomonkövetésére
• Futtatás sebességének beállítása, lépésenkénti végrehajtás
• Bőví­tett rendszerfelület, a gyors kódfejlesztéshez, Funkcióbillentyűk
• Több oszlopos kódmegjelení­tés
• Memóriací­mek sorszámozása 1-től
• Oda-vissza kompatibilis Rozgonyi-Borus Ferenc Assembly Emulátorával készí­tett programokkal is.
• Sorszám nélküli metés, ezáltal kisebb a fájlok mérete
• Utasí­tás súgók és ToolTip gyorssúgók
• Optimalizált forrásód a hatékonyabb működéshez
• Idegennyelvi modulokkal támogatható a program többnyelvűsége