Smulovics Peter Rovid Bevezetes A Cba

Forrás: http://www.doksi.
hu
C# Rövid bevezetés a C# -ba

példákon keresztül
Smulovics Péter © 2001
Eredetit készítette és fordította:
Originally written and translated by
Smulovics Péter © 2001
Forrás: http://www.doksi.hu
Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

alkalmazásához használja a Kezdőlap lapot.
1. TARTALOMJEGYZÉK
1. Tartalomjegyzék ............................................................................................................. 2
2. A C# bemutatása ............................................................................................................. 4
2.1. A C# .......................................................................................................................................... 4
2.2. JITting ....................................................................................................................................... 4
2.3. CLS ........................................................................................................................................... 4
2.4. A “Hello World” Kód ............................................................................................................... 5
2.5. Típusok ..................................................................................................................................... 6
2.5.1. Megszámlálható Típusok ............................................................................................................ 6
Sbyte ............................................................................................................................................................................. 6
Byte ............................................................................................................................................................................... 6
Short.............................................................................................................................................................................. 6
Ushort............................................................................................................................................................................ 6
Int .................................................................................................................................................................................. 6
Uint ............................................................................................................................................................................... 6
Long .............................................................................................................................................................................. 6
Ulong ............................................................................................................................................................................ 6
2.5.2. Bool Típus .................................................................................................................................. 6
2.5.3. Char Típus .................................................................................................................................. 6
2.5.4. Lebegőpontos Típus .................................................................................................................... 6
Float .............................................................................................................................................................................. 6
Double........................................................................................................................................................................... 6
2.5.5. Decimal Típus............................................................................................................................. 6
Decimal ......................................................................................................................................................................... 6
2.5.6. Struct Típus................................................................................................................................. 6
2.5.7. Enum Típus ................................................................................................................................. 7
2.5.8. Object Típus ............................................................................................................................... 7
2.5.9. Class Típus ................................................................................................................................. 7
2.5.10. Interface ..................................................................................................................................... 7
2.5.11. Delegates .................................................................................................................................... 8
2.5.12. String Típus ................................................................................................................................ 8
2.5.13. Tömbök ....................................................................................................................................... 8
2.5.14. Boxing és Unboxing.................................................................................................................... 8
2.6. Class .......................................................................................................................................... 8
2.6.1. Constructor és destructor ........................................................................................................... 8
2.6.2. Metódusok .................................................................................................................................. 9
In Paraméterek .............................................................................................................................................................. 9
Ref Paraméterek ............................................................................................................................................................ 9
Out Paraméterek ............................................................................................................................................................ 9
Override ........................................................................................................................................................................ 9
Hide............................................................................................................................................................................... 9
2.6.3. Példa Class ............................................................................................................................... 10
2.6.4. Class Property-k és Indexer-k .................................................................................................. 10
2.6.5. Attribútumok ............................................................................................................................. 11
2.6.6. Event ......................................................................................................................................... 11
2.6.7. Modifikátorok alkalmazása ...................................................................................................... 12
Class Modifikátorok .................................................................................................................................................... 12
Member Modifikátorok ............................................................................................................................................... 12
Access Modifikátorok ................................................................................................................................................. 12
2.7. Vezérlő Kulcsszavak............................................................................................................... 13
2.7.1. Szelekciós Kulcsszavak ............................................................................................................. 13
If Kulcsszó .................................................................................................................................................................. 13
Switch Kulcsszó .......................................................................................................................................................... 13
2.7.2. Iterációs Kulcsszavak ............................................................................................................... 14
For Kulcsszó ............................................................................................................................................................... 14
Foreach Kulcsszó ....................................................................................................................................................... 14
While Kulcsszó............................................................................................................................................................ 14
Do Kulcsszó ................................................................................................................................................................ 14

2.7.3. Egyéb kulcsszavak .................................................................................................................... 14
Lock Kulcsszó ............................................................................................................................................................. 14
2.8. Exception Kezelés................................................................................................................... 15
2.8.1. Checked és Unchecked ............................................................................................................. 15
2.8.2. Exception Kezelő Kulcsszavak.................................................................................................. 15
Catching : try-catch ..................................................................................................................................................... 15
Catching : try-finally ................................................................................................................................................... 15
Catching : try-catch-finally ......................................................................................................................................... 15
2.8.3. Kivétel Throwing és Re-Throwing ............................................................................................ 16
Standard Kivételek ...................................................................................................................................................... 16
Throwing ..................................................................................................................................................................... 16
Re-Throwing ............................................................................................................................................................... 16
2.8.4. Saját Exception Class ............................................................................................................... 16
2.8.5. Mit szabad és mit nem — Kivétel Kezelés ................................................................................ 17
3. Komponensek Készítése C# -ban ................................................................................ 18
3.1. Az első komponens ................................................................................................................. 18
3.1.1. Komponens építése ................................................................................................................... 18
3.1.2. Megfelelő kliens elkészítése ...................................................................................................... 18
3.2. Namespace .............................................................................................................................. 19
3.2.1. Komponens építése ................................................................................................................... 19
3.2.2. Megfelelő kliens elkészítése ...................................................................................................... 20
3.3. Configuration és Deployment ................................................................................................. 20
3.3.1. Kondícionális fordítás .............................................................................................................. 20
Prepocessor használat.................................................................................................................................................. 20
Kondícionális fordítás ................................................................................................................................................. 21
3.3.2. Dokumentáció........................................................................................................................... 21
3.4. Unmanaged Kód felhasználása ............................................................................................... 21
3.4.1. COM Objektumok felhasználása az NGWS Runtime-ban ........................................................ 21
Early-bound object hívása ........................................................................................................................................... 21
Late-bound object hívása ............................................................................................................................................ 22
3.4.2. Platform Invocation Services (PIS) .......................................................................................... 22
3.4.3. Unsafe és Fixed kód.................................................................................................................. 23
4. NGWS általi biztonság ................................................................................................. 24
4.1. Kód Alapú Biztonság .............................................................................................................. 24
4.1.1. Funkciói .................................................................................................................................... 24
4.1.2. Jogok ........................................................................................................................................ 24
4.1.3. Standard Jogok ......................................................................................................................... 24
4.1.4. Identity Jogok ........................................................................................................................... 24
4.2. Szerep Alapú Biztonság .......................................................................................................... 25

2. A C# BEMUTATÁSA
2.1. A C#
• Egyszerű Nincs pointer
Nincs ::, ., ->
Egységes típus rendszer
Boxing/Unboxing támogatás
If csak Boolean lehet
Ismétlődések kizárása (const <-> #define, stb.)
• Modern Decimal típus

Garbage Collector (szemétgyűjtés)
Exception (kivétel)
Biztonság
• Objektum Nincs többé global

orientált Alapban minden nonvirtual
‘Internal’ elérési típus
Egyszeri öröklődés
Delegálás (funkció pointerek)
• Típus biztos Inicializálás

Biztonságos cast-olás
Túlcímzés ellenőrzés
Túlcsordulás ellenőrzés
• Verziók Komponensek
Verzió számozás
• Kompatibilis NGWS Common Language Specifiaction

COM, COM+
OLE Automation
Platform Invocation Services
• Rugalmas Unsafe metódusok

Unsafe memória
2.2. JITting
• JIT Erősen optimalizált IL kód, lassú fordítás
• EconoJIT Gyors konverzió, kód cache
• PreJIT Ellenőrzött natív kód
2.3. CLS
• Primitív Típusok Bool, char, byte, short, int, long, float, double, string, object
• Tömbök Ismert dimenzió, lehet többszörös is

Alsó határ: 0
• Típusok Abstract vagy sealed

Nulla vagy több interface
Egyszeres öröklődés
Overriding és hiding létezik
Fields, methods, events, types
Constructors
Belső láthatóság

Öröklődés: System.ValueType / System.Enum
• Típus members Hide vagy override

Argument és return type CLS
Constructor, metódus, property felülírható
Abstract members
• Metódusok Static, virtual, instance

Final vagy nem Final
• Mezők Static vagy nonstatic
• Property-k Get és Set metódusok

Indexelhető
• Enumerations Byte, short, int, long

Nincs interface
• Kivételek Throw és catch, finalize

COM Exceptions
• Interface-k Öröklődés
• Events Add és Remove metódusok

Öröklődik: System.Delegate
• Delegates Created és Invoked
• Identifiers Nincs case sensitivity!
2.4. A “Hello World” Kód

Using System;
Class HelloWorld
{
public static int Main(string[] args)
{
Console.WriteLine(“Hello Világ!”);
}
}
Using System;
Class InputOutput
{
public static void Main()
{
Console.Write(“Név ?”);
String strName = Console.ReadLine();
Console.Write(“Hello ” + strName);
Console.Write(“Hello {0}”, strName);
}
}
Részletes, futó kódok a Komponensek építése részben találhatóak (3.1 és 3.2)

2.5. Típusok
2.5.1. Megszámlálható Típusok

Sbyte 8 bit signed -128 127
Byte 8 bit unsigned 0 255
Short 16 bit signed -32768 32767
Ushort 16 bit unsigned 0 65535
Int 32 bit signed -2147483648 2147483647
Uint 32 bit unsigned 0 4294967295
Long 64 bit signed -9223372036854775808 9223372036854775807
Ulong 64 bit unsigned 0 18446744073709551615
2.5.2. Bool Típus

Nincs többé nemnulla igaz
2.5.3. Char Típus

char chSomeChar = ’A’;
chSomeChar = ’\x0065’;
chSomeChar = ’\u0065’;
chSomeChar = (char)65;
nSomeInt = (int)'A';
\’ ’
\” ”
\\ \
\0 Null
\a Alert
\b Backspace
\f Form feed
\n New line
\r Carriage return
\t Horizontal tab
\v Vertical tab
2.5.4. Lebegőpontos Típus

Float 7 1.5x10-45 3.4x1038
Double 15 5x10-324 1.7x10308
• Pozitív és negatív nulla

• Pozitív és negatív végtelen
• NaN
• Nem nulla értékek
2.5.5. Decimal Típus

Decimal 28 1.0x10-28 7.9x1028
2.5.6. Struct Típus

struct IP
{
public byte b1,b2,b3,b4;
}
class Test
{

{
IP myIP;
MyIP.b1 = 192;
MyIP.b2 = 168;
MyIP.b3 = 0;
MyIP.b4 = 1;
Console.Write("{0}.{1}.{2}.{3}", myIP.b1, myIP.b2,
myIP.b3, myIP.b4);
}
}
struct Point
{
double X;
double Y;
void MoveBy(double dX, double dY)
{ X+=dX; Y+=dY; }
}
2.5.7. Enum Típus

enum MonthNames { January, February, March, April };
enum MonthNames { January=1, February, March, April };
enum MonthNames { January=31, February=28, March=31, April=30 };
enum MonthNames : byte { January, February, March, April };

0-val indul, típusa int. Lehetséges típusok: long, int, short, byte
2.5.8. Object Típus

Alapclass az összes típushoz.
Object theObj = 123;
2.5.9. Class Típus

Lásd Class Modifikátorok (2.6.7)
2.5.10. Interface
Interface Iface
{
void ShowMyFace();
int a {get;set}
}
class Cface:Iface
{
public void ShowMyFace()
{
// Implementation
}
int a
{
// Implementation
}
}
class Test

{
{
Cface myFace = new CFace();
Iface myIFace = (IFace)CFace;
}
}
2.5.11. Delegates
Lásd Events (2.6.6)
2.5.12. String Típus

String myString = "text";
MyString = "text" + " more text";
char chFirst = myString[0];
if (myString == yourString) { ... }
2.5.13. Tömbök
String[] arrArray = { "C", "C++", "C#" };
int[,] arr = {{0,1}, {2,3}, {4,5}};

int[,] myArr = new int[5,3];
int[][] my2Arr = new int[5];
my2Arr[0] = new int[4];
int[] SingleDim;
int[,] TwoDim;
int [][] Jagged;
SingleDim = new int[20];

TwoDim = new int[,]{{1,2,3},{4,5,6}};
Jagged = new int[1][];
Jagged[0] = new int[]{1,2,3}
2.5.14. Boxing és Unboxing

double Value;
// Boxing
object BoxedValue = Value;
// Unboxing
Value = (double)BoxedValue;
2.6. Class
2.6.1. Constructor és destructor

// default constructor
class TestClass
{
public TestClass(): base {} // default
}

// parameterized constructor
class TestClass
{
public TestClass(string strName, int nAge) { ... }
public ~TestClass() { Release(); } // destructor, called by GC !
public Release() { ... } // call it by hand
}
2.6.2. Metódusok
In Paraméterek
public int Square(int n) { ... }
Console.WriteLine(Square(25));
// object always pass a reference by value
Ref Paraméterek
void Square(ref int n) { ... }
int n = 20; // init
Square(ref n);
Console.WriteLine(n);
Out Paraméterek
void Square(int n, out int nn) { ... }
int n; // noninit
Square(20, out n);
Console.WriteLine(n);
Override
class Triangle
{
public virtual double Area(int a, int b, int c)
{
}
}
class RightTriangle:Triangle
{
public override double Area(int a, int b, int c)
{
return(base.Area(a, b, c));
}
}
class Test
{
{
RightTriangle Instance = new RightTriangle();
Console.WriteLine(((Triangle)Instance).Area(3,4,7));
}
}
Hide
class Triangle
{
public double Area(int a, int b, int c)
{
}
}
class RightTriangle:Triangle
{
new public double Area(int a, int b, int c)

{
return(base.Area(a, b, c));
}
}
class Test
{
{
RightTriangle Instance = new RightTriangle();
Console.WriteLine(((Triangle)Instance).Area(3,4,7));
}
}
2.6.3. Példa Class

Public class Person :
IPersonAge
{
private int YOB;
public Person()
{
}
public int YearOfBirth

{
get { return YOB; };
set { YOB = value; };
}
public int GetAgeToday()

{
return Today()-
YearOfBirth
};
}
2.6.4. Class Property-k és Indexer-k

Public class House
{
private int m_myInt;
private int[] m_myIntArray;
public int myInt

{
get { return m_myInt; }
set { m_myInt = value; }
}
public int this[int nIndex]

{
get { return m_myIntArray[nIndex]; }
}
}
class Test
{
{

House myHouse = new House();
myHouse.myInt = 100;
Console.WriteLine(myHouse.myInt);
Console.WriteLine(myHouse[0]);
}
}
2.6.5. Attribútumok
// Transaction logic
[Transaction(TransactionOption.Required)]
class MyBusinessComponent { ... }
[PersonFirstName] String Vorname;

[PersonFirstName] String PrimarioNome;
// custom attributes
// Typeof(<object-expr>).GetCustomAttributes();
class PersonFirstNameAttribute : Attribute

{
public PersonFirstName()
{
}
}
2.6.6. Event
// forward declaration with delegation
public delegate void EventHandler(string strText);
class EventSource
{
public event EventHandler TextOut;
public void TriggerEvent()

{
if (TextOut != null) TextOut("Triggered");
}
}
class TestApp
{
{
EventSource evsrc = new EventSource();
evsrc.TextOut += new EventHandler(CatchEvent);

evsrc.TriggerEvent();
evsrc.TextOut -= new EventHandler(CatchEvent);

TestApp theApp = new TestApp();

evsrc.TextOut += new EventHandler(theApp.InstanceCatch);
}
public static void CacthEvent(string strText)

{

Console.WriteLine(strText);
}
public void InstanceCatch(string strText)

{
Console.WriteLine("Instance " + strText);
}
}
2.6.7. Modifikátorok alkalmazása

Class Modifikátorok
• Abstract Nem lehet instace-t csinálni, implementálni kell az abstract metódusokat
• Sealed Nem lehet örökölni
abstract class AbstractClass

{
abstract public void MyMethod();
}
sealed class DerivedClass : AbstractClass

{
public override void MyMethod()
{
Console.Writeline("sealed");
}
}
public class TestApp

{
{
DerivedClass dc = new DerivedClass();
dc.MyMethod();
}
}
Member Modifikátorok
• Abstract Method és accessor Nem tartalmaz implementációt. Implikálisan virtual, és öröklődéskor
meg kell adni az override Kulcsszót.
• Const Field és local Nem tartalmazhat referenciát, fordítási időben kiértékelődik
variable
• Event Field és property Class eseményeihez kliens kód hozzákötése
• Extern Method Külső implementáció
• Override Method és accessor Módósítani egy abstract definiálású elemet
• Readonly Field Csak deklaráció és contstructor változtathatja meg
• Static Field, method, A Class-hoz és nem az instance-hez tartozik

property, operator és
constructor
• Virtual Method és accessor Öröklődéssel felülírható
Access Modifikátorok
• Public Mindenhonnan elérhető

• Protected A Classból és minden származottból
• Private Csak a Classból, leszármazottból sem
• Internal Ugyanabból az applikációból
2.7. Vezérlő Kulcsszavak
2.7.1. Szelekciós Kulcsszavak

If Kulcsszó
class NestedIfApp
{
public static int Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage: one argument");
return 1;
}
char chLetter = args[0][0];
if (chLetter >= 'A')

if (chLetter <= 'Z')
{
Console.WriteLine("{0} is uppercase",chLetter);
Return 0;
}
chLetter = Char.FromString(args[0]);
if (chLetter >= 'a' && chLetter <= 'z')

Console.WriteLine('{0} is lowercase",chLetter);
if (Char.IsDigit((chLetter = args[0][0])))
Console.WriteLine('{0} is digit",chLetter);
return 0;
}
}
Switch Kulcsszó
switch (nInt)
{
case 6:
// something
// won't drop to case 1, coz there is code at case 6
case 1:
break;
default:
// code
case 7:
case 2:
// here 7 will drop to 2, coz there is no code at case 7
goto case 3;
// this line is unreachable
case 4:
goto default;
}
String is használható !

2.7.2. Iterációs Kulcsszavak
For Kulcsszó
for (initializer; condition; iterator)
{
if (condition1)
{
continue;
// next iteration
}
// code
if (condition2)
{
break;
// terminate loop
}
// code
}
Foreach Kulcsszó
// foreach (Type identifier in expression) { ... }
class EnviromentDumpApp
{
{
Idictionary envvars = Environment.GetEnvironmentVariables();
Console.WriteLine("Count: {0}", envvars.Keys.Count);
Foreach (String strKey in envvars.Keys)

{
Console.WriteLine("{0} = {1}", strKey,
envvars[strKey].ToString());
}
}
}
// Implements IEnumerable with GetEnumerator()

Point[] Points = GetPoints();
foreach( Point p in Points )
{
MyPen.MoveTo(Point.x,Point.y);
}
While Kulcsszó
while (conditional) { ... }
Do Kulcsszó
do
{
embedded statements
}
while (condition);
2.7.3. Egyéb kulcsszavak

Lock Kulcsszó
lock(<object>){ ... };

2.8. Exception Kezelés
2.8.1. Checked és Unchecked

// Programatic Exception Checking
checked { ... }
unchecked { ... }
2.8.2. Exception Kezelő Kulcsszavak

Catching : try-catch
Try
{
checked
{
for (;nCurDig <= nComputeTo; nCurDig++)
nFactorial *= nCurDig;
}
}
catch (OverflowException oe)

{
Console.WriteLine("Computing {0} caused overflow", nComputeTo);
Return
}
Console.WriteLine("{0}! is {1}", nComputeTo, nFactorial);

Catching : try-finally
bool bAllFine = false;
try
{
checked
{
}
bAllFine = true;
}
finally
{
if (!bAllFine)
Console.WriteLine("{0} caused", nComputeTo, nFactorial);
Else
Console.WriteLine("{0}! is {1}", nComputeTo, nFactorial);
}
Catching : try-catch-finally
class CatchIT
{
{
try
{
int x = 10/0;
}
catch(DivideByZeroException divEx)
{
}

catch(Exception Ex)
{
}
finally
{
}
}
}
Megcserélve a kettő catch sorrendjét, a második sosem hajtódna végre
2.8.3. Kivétel Throwing és Re-Throwing

Standard Kivételek
• Exception Base class minden exception object-hez
• SystemException Base class minden exception object-hez, ami runtime
• IndexOutOfRangeException Kiindexelve egy tömbből
• NullReferenceException NULL objektum referenciálva
• InvalidOperationException Ha a hívás, figyelembe véve a class aktuális helyzetét, érvénytelen
• ArgumentException Base class minden argumens alapú exception object-hez
• ArgumentNullException Ha az argument NULL ahol nem megengedett
• ArgumentOutOfRangeException Ha az argument kívűl van a megengedett határokon
• InteropException NGWS-n kívüli exceptionok
• ComException A COM klasszikus HRESULT információt tartalmazó exception-ja
• SEHException Exception enkapszulálva a Win32 Structured Exception Handling

információt
Throwing
throw new ArgumentException("Argument can\'t be 5");
Re-Throwing
Try
{
checked
{
}
}
catch (OverflowException oe)
{
Console.WriteLine("Computing {0} caused overflow", nComputeTo);
throw; // rethrowing
}
2.8.4. Saját Exception Class

public class MyImportantException:Exception
{
public MyImportantException():base() {}
public MyImportantException(string message):base(message) {}


public MyImportantException(string message,
Exception inner):base(message, inner) {}
}
public class ExceptionTestApp

{
public static void TestThrow()
{
throw new MyImportantException("Baaaad !");
}

{
try
{
ExceptionTestApp.TestThrow();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
2.8.5. Mit szabad és mit nem — Kivétel Kezelés

• Adjunk jól érthető leírást, amikor eldobjuk a kivételt
• Csak akkor dobjunk kivételt, ha az eset kivételes; vagyis, amikor a normális visszatérési érték nem
elégséges
• Normális vagy várható hibák jelzésére ne használjunk kivételt
• Dobjunk ARGUMENTEXCEPTION -t, ha nem jó paramétert kapunk
• Dobjunk INVALIDOPERATIONEXCEPTION -t, ha nem megfelelő státuszban van az objektumunk
• Dobjuk mindig a legmegfelelőbb kivételt
• Használjunk láncba fűzött kivételeket. Segítenek követni a kivétel-fát
• Ne dobjunk NULLREFERENCEEXCEPTION vagy INDEXOUTOFRANGEEXCEPTION kivételt

3. KOMPONENSEK KÉSZÍTÉSE C# -BAN

3.1. Az első komponens
3.1.1. Komponens építése

Using System;
using System.Net;
using System.IO;
using System.Text;
public class RequestWebPage

{
private const int BUFFER_SIZE=128;
private string m_strURL;
public RequestWebPage() { }
public RequestWebPage(string strURL) { m_strURL = strURL; }
public string URL

{
get { return m_strURL; }
set { m_strURL = value; }
}
public void GetContent( out string strContent)

{
if (m_strURL == "")
throw new ArgumentException("URL must be provided");
WebRequest theRequest =
(WebRequest) WebRequestFactory.Create(m_strURL);
WebResponse theResponse = theRequest.GetResponse();
int BytesRead = 0;
Byte[] Buffer = new Byte[BUFFER_SIZE];
Stream ResponseStream = theResponse.GetResponseStream();

BytesRead = ResponseStream.Read(Buffer, 0, BUFFER_SIZE);
StringBuilder strResponse = new StringBuilder("");

while (BytesRead != 0)
{
strResponse.Append(Encoding.ASCII.GetString
(Buffer, 0, BytesRead));
BytesRead = ResponseStream.Read(Buffer, 0, BUFFER_SIZE);
}
strContent = strResponse.ToString();
}
}
3.1.2. Megfelelő kliens elkészítése

Using System;

Class TestWebReq
{
{
RequestWebPage wrq = new RequestWebPage();
wrq.URL = "http://www.microsoft.com";
string strResult;
try
{
wrq.GetContent(out strResult);
}
catch (Exception e)
{
return;
}
Console.WriteLine(strResult);
}
}
3.2. Namespace
3.2.1. Komponens építése

Using System;
using System.Net.Sockets;
using System.IO;
using System.Text;
namespace CSharp
{
public class WhoisLookup
{
public static bool Query(string strDomain, out string
strWhoisInfo)
{
const int BUFFER_SIZE = 128;
if (strDomain == "")
throw new ArgumentException(
"Domain must be provided");
TCPClient tcpc = new TCPClient();

StrWhoisInfo = "N/A";
if (tcpc.Connect("whois.networksolutions.com", 43) != 0)
return false;
Stream s = tcpc.GetStream();
strDomain += "\r\n"
Byte[] bDomArr =
Encoding.ASCII.GetBytes(strDomain.ToCharArray());
s.Write(bDomArr, 0, strDomain.Length);
Byte[] Buffer = new Byte[BUFFER_SIZE];

StringBuilder strWhoisResponse = new StringBuilder("");

int BytesRead = s.Read(Buffer, 0, BUFFER_SIZE);
while(BytesRead != 0)
{
strWhoisResponse.Append(
Encoding.ASCII.GetString(Buffer, 0, BytesRead));
BytesRead = s.Read(Buffer, 0, BUFFER_SIZE);
}
tcpc.Close();
strWhoisInfo = strWhoisResponse.ToString();
return true;
}
}
}
3.2.2. Megfelelő kliens elkészítése

using System;
using CSharp;
class TestWhois
{
public static void Main(string[] args)
{
string strResult;
bool bReturnValue;
try
{
bReturnValue = WhoisLookup.Query(args[0], out strResult);
}
catch (Exception e)
{
return;
}
if (bReturnValue)
Console.WriteLine(strResult);
else
Console.WriteLine("No Info");
}
}
3.3. Configuration és Deployment
3.3.1. Kondícionális fordítás

Prepocessor használat
#define RELEASE
#undef DEBUG
#if RELEASE
// code1
#warning Warning
#elif DEBUG && !DEMO


// code2
#error Error
#else
// code3
#endif
Kondícionális fordítás
#define DEBUG
using System;
class Info
{
[conditional("DEBUG")]
public static void Trace(string strMessage)
{
Console.WriteLine(strMessage);
}
[conditional("DEBUG")]
public static void TraceX(string strFormat, params object[] list)
{
Console.WriteLine(strFormat, list);
}
}
class TestConditional
{
{
Info.Trace("Coool!");
Info.TraceX("{0} {1} {2}", "C", "U", 2001);
}
}
3.3.2. Dokumentáció
• <summary> Egyszerű leírás
• <para> Paragrafus
• <see cref/> Referencia másik elemre
• <seealso cref/> Lásd még
• <list> Lista
• <item> Elem
• <remarks> Megjegyzés
• <paramref> Referencia paraméterre
• <example> Leírás és példa
• <code> Példa kód
• <param> Paraméter
• <returns> Visszatérési paraméter
• <value> Property leírása
3.4. Unmanaged Kód felhasználása
3.4.1. COM Objektumok felhasználása az NGWS Runtime-ban

Early-bound object hívása
// tlbimp asptouch.dll /out:asptouchlib.dll

using System;
using ASPTOUCHLib;
class TouchFile
{
{
TouchIt ti = new TouchIt();
Try
{
bResult = ti.SetToCurrentTime("asptouch.cs");
}
catch(Exception e)
{
}
}
}
Late-bound object hívása
using System;
using System.Reflection;
class TestLateBound
{
{
Type tTouch;
tTouch = Type.GetTypeFromProgID("AspTouch.TouchIt");
Object objTouch;
objTouch = Activator.CreateInstance(tTouch);
Object[] parameters = new Object[1];

parameters[0] = "text.txt";
bool bResult = false;
try
{
bResult = (bool)tTouch.InvokeMember("SetToCurrentTime",
BindingFlags.InvokeMethod, null, objTouch, parameters);
}
catch(Exception e)
{
}
if (bResult)
Console.WriteLine("Success !");
}
}
3.4.2. Platform Invocation Services (PIS)

using System;
class TestPInvoke
{
[sysimport(dll="user32.dll", name="MessageBoxA"]
public static extern int PopupBox(int h, string m,
string c, int type);

{
int nMsgBoxResult;
nMsgBoxResult = PopupBox(0, "Hello C#", "PInvoke", 0);

}
}
3.4.3. Unsafe és Fixed kód

• Unsafe Lehetőséget ad, hogy memóriablokkokkal dolgozzunk (pointers, COM Interoperability és PIS)
• Fixed Megvédi a GC általi relokációtól
public class SquareSampleUnsafe

{
unsafe public void CalcSquare(int nSideLength, int *pResult)
{
*pResult = nSideLength * nSideLength;
}
}
class TestUnsafe
{
{
int nResult = 0;
unsafe
{
fixed (int * pResult = &nResult)
{
SquareSampleUnsafe sqsu = new SquareSampleUnsafe();
sqsu.CalcSquare(15, pResult);
Console.WriteLine(nResult);
}
}
}
}

4. NGWS ÁLTALI BIZTONSÁG

4.1. Kód Alapú Biztonság
4.1.1. Funkciói
• Adminisztrátorok létrehozhatnak biztonsági beállításokat, amik bizonyos jogokat adhatnak bizonyos kód-
csoportoknak
• A kód megkövetelheti, hogy a hívó bizonyos jogokkal rendelkezzen
• Kód végrehajtás a futtató rendszer által korlátozható. Ellenőrzések történnek, hogy a hívó rendelkezik-e a
szükséges jogokkal a végrehajtáshoz
• Kód megadhatja, mik azok a jogok, amik szükségesek a futásához, mik azok, amik jók lennének, és mik
azok a jogok, amikkel soha nem szabad rendelkeznie
• A kód alapú biztonság a jogokat a komponens betöltésekor adja. Ez a folyamat a kód követelésein alapszik,
figyelembe véve a biztonsági beállításokat
4.1.2. Jogok
• Required Jogok, melyek szükségesek a kód futásához
• Optional Jogok, melyek nem alapvetően szükségesek a helyes futáshoz, de jó lenne, ha

rendelkezhetnénk velük
• Refused Jogok, melyekről biztosítani szeretnénk, hogy a kód soha ne juthasson hozzájuk — még akkor
is, ha a biztonsági beállítások engedélyeznék. Lehetséges biztonsági lyukak kiküszöböléséhez
használatos
4.1.3. Standard Jogok

• EnvironmentPermission Hozzáférhetőség környezeti változókhoz, csak olvasható és/vagy
írható/olvasható (módósítás, létrehozás és törlés)
• FileDialogPermission Hozzáférhetőség a fileokhoz a SystemFileDialog használatával, a

felhasználónak jóvá kell hagynia
• FileIOPermission Hozzáférhetőség file I/O-hoz, lehetőségek: olvasás, írás (felülírás és törlés)
és append
• IsolatedStoragePermission Hozzáférhetőség az isolated storage-hoz, lehetőségek: allowed usage, quota
size, expiration of data, data retaining
• ReflectionPermission Hozzáférhetőség a típusok nempublikus mezőihez, Reflection.Emit
• RegistryPermission Hozzáférhetőség a registry kulcsaihoz, olvasás, létrehozás, írás céljából,

megadott kulcslistákkal
• SecurityPermission Hozzáférhetőség a biztonsági rendszer kapcsolóihoz, lehetőségek (többek
között): control execution of code, override security checks, invocation of
unmanaged code, verification skipping, serialization, etc.
• UIPermission Hozzáférhetőség az UI-hoz, lehetőségek (többek között): ablakok használata,

hozzáférés az event queues-hoz, clipboard
4.1.4. Identity Jogok

• PublisherIdentityPermission Egy NGWS komponensen lévő aláírás bizonyítja a software publisher
kilétét
• StrongNameIdentityPermission Definiálja a kriptografikusan erős nevét a komponensnek. Az erős név

kulcs és az egyszerű név együtt számít bele az identitásba

• ZoneIdentityPermission Definiálja a zonát ahonnan a kód származik. Egy URL csak egy zónához
tartozhat
• SiteIdentityPermission Jogok, melyek alapjául az a web oldal szolgál, ahonnan a futatott kód
származik
• URLIdentityPermission Jogok, melyek alapjául az az URL szolgál, ahonnan a futatott kód

származik
4.2. Szerep Alapú Biztonság

• Generic principals Nem hitelesített felhasználók
• Windows principals Windows felhasználók és csoportjaik. A megszemélyesítés támogatott
• Custom principals Az applikáció által definiált. A felhasználó alapfogalmát, személyiségét és szerepét

bővíti ki. Az egyetlen megszorítás az, hogy az applikációnak rendelkeznie kell egy
authentikációs modullal, és egy a felhasználót jelképező típussal

Smulovics Peter Rovid Bevezetes A Cba

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Smulovics Peter Rovid Bevezetes A Cba

Uploaded by

Copyright:

Available Formats

Forrás: http://www.doksi.

C# Rövid bevezetés a C# -ba

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

• Modern Decimal típus

• Objektum Nincs többé global

• Típus biztos Inicializálás

• Kompatibilis NGWS Common Language Specifiaction

• Rugalmas Unsafe metódusok

• Tömbök Ismert dimenzió, lehet többszörös is

• Típusok Abstract vagy sealed

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

• Típus members Hide vagy override

• Metódusok Static, virtual, instance

• Mezők Static vagy nonstatic

• Property-k Get és Set metódusok

• Enumerations Byte, short, int, long

• Kivételek Throw és catch, finalize

• Events Add és Remove metódusok

• Delegates Created és Invoked

• Identifiers Nincs case sensitivity!

2.4. A “Hello World” Kód

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

2.5.1. Megszámlálható Típusok

2.5.2. Bool Típus

2.5.3. Char Típus

2.5.4. Lebegőpontos Típus

• Pozitív és negatív nulla

2.5.5. Decimal Típus

2.5.6. Struct Típus

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

2.5.7. Enum Típus

enum MonthNames { January=1, February, March, April };

enum MonthNames { January=31, February=28, March=31, April=30 };

enum MonthNames : byte { January, February, March, April };

2.5.8. Object Típus

2.5.9. Class Típus

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

2.5.12. String Típus

MyString = "text" + " more text";

char chFirst = myString[0];

if (myString == yourString) { ... }

int[,] arr = {{0,1}, {2,3}, {4,5}};

SingleDim = new int[20];

2.5.14. Boxing és Unboxing

2.6.1. Constructor és destructor

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

2.6.3. Példa Class

public int YearOfBirth

public int GetAgeToday()

2.6.4. Class Property-k és Indexer-k

public int myInt

public int this[int nIndex]

Hiba! A(z) Heading 1 itt megjelenítendő szövegre történő

[PersonFirstName] String Vorname;

class PersonFirstNameAttribute : Attribute

public void TriggerEvent()

evsrc.TextOut += new EventHandler(CatchEvent);

evsrc.TextOut -= new EventHandler(CatchEvent);

TestApp theApp = new TestApp();

public static void CacthEvent(string strText)