Apuntes sobre C# - chsos20112906536.files.wordpress.com · APUNTES SOBRE C# y comparación otros...

APUNTES SOBRE C# y comparación otros lenguajes

Carlos Hernán Gómez G.

1

Tabla de contenido

1. Apuntes sobre C# ............................................................................................................................................................ 2

1.1. Compilación y ejecución ........................................................................................................................................ 2

1.2. Estructura general de un programa en C# ............................................................................................................... 3

1.3. Utilizar nombres completos .................................................................................................................................... 4

1.4. Crear y utilizar archivos DLL de C# ...................................................................................................................... 5

Archivos de código fuente .............................................................................................................................................. 5

Compilación .................................................................................................................................................................... 7

Ejecución ........................................................................................................................................................................ 8

Resultados ....................................................................................................................................................................... 8

1.5. Comparación entre C++ y C# ................................................................................................................................. 8

2. Comparativo entre lenguajes ........................................................................................................................................ 17

Instrucciones de selección ............................................................................................................................................ 18

Pasar parámetros por referencia .................................................................................................................................... 20

Control estructurado de excepciones ............................................................................................................................ 20

Establecer una referencia de objeto a Nothing ............................................................................................................. 21

3. Palabras clave comparadas en diferentes lenguajes ...................................................................................................... 22

4. Programación orientada a objetos ................................................................................................................................. 25

5. Control de excepciones ................................................................................................................................................. 28

6. Estructuras de decisión ................................................................................................................................................. 29

7. Matrices ........................................................................................................................................................................ 29

8. Ámbito de clase ............................................................................................................................................................ 30

9. Ámbito de miembro ...................................................................................................................................................... 30

10. Varios Período de duración....................................................................................................................................... 31

11. Varios ........................................................................................................................................................................ 31

12. Operadores comparados en diferentes lenguajes ...................................................................................................... 34

13. Tipos de datos comparados en diferentes lenguajes ................................................................................................. 37

14. Comparación de los controles y objetos programables de distintos lenguajes y bibliotecas .................................... 39



2

1. Apuntes sobre C#

C# es un lenguaje de programación simple pero potente diseñado para escribir aplicaciones empresariales.

El lenguaje C# es una evolución de los lenguajes C y C++. Utiliza muchas de las características de C++ en las áreas de

instrucciones, expresiones y operadores.

C# presenta considerables mejoras e innovaciones en áreas como seguridad de tipos, control de versiones, eventos y

recolección de elementos no utilizados (liberación de memoria).

El siguiente programa de consola es la versión de C# del tradicional programa "Hola mundo!", el cual muestra en pantalla

la cadena Hola mundo!.

// Hola mundo en C#

class Hello

{

static void Main()

{

System.Console.WriteLine("Hola mundo!");

}

}

1.1. Compilación y ejecución

El programa "Hola a todos" se puede compilar creando un proyecto en el Entorno de desarrollo integrado (IDE) de Visual

Studio, o bien mediante la línea de comandos.

Para compilar el programa desde la línea de comandos:

Cree el archivo de código fuente mediante cualquier editor de texto y guárdelo con un nombre como Hello.cs.

Los archivos de código fuente de C# utilizan la extensión .cs.

Para invocar el compilador, ejecute el comando:



3

csc Hello.cs

Si el programa no contiene errores de compilación, se creará un archivo Hello.exe.

Para ejecutar el programa, escriba el comando:

Hello

1.2. Estructura general de un programa en C#

Los programas en C# pueden constar de uno o varios archivos. Cada archivo puede contener uno o varios espacios de

nombres. Un espacio de nombres puede contener tipos como clases, estructuras, interfaces, enumeraciones y delegados,

además de otros espacios de nombres. A continuación, se muestra el esqueleto de un programa en C# que contiene todos

estos elementos.

// Esqueleto de un programa en C#

using System;

namespace MyNamespace1

{

class MyClass1

{

}

struct MyStruct

{

}

interface IMyInterface

{

}

delegate int MyDelegate();

enum MyEnum

{

}

namespace MyNamespace2

{

}

class MyClass2

{

public static void Main(string[] args)

{



4

}

}

}

1.3. Utilizar nombres completos

Los espacios de nombres y los tipos tienen nombres únicos, que se describen mediante nombres completos que indican

una jerarquía lógica. Por ejemplo, A.B es el nombre del espacio de nombres o tipo B anidado en el espacio de nombres o

tipo A.

En el siguiente segmento de código, existen clases y espacios de nombres anidados. El nombre completo se indica como

un comentario que sigue a cada entidad.

namespace N1 // N1

{

class C1 // N1.C1

{

class C2 // N1.C1.C2

{

}

}

namespace N2 // N1.N2

{

class C2 // N1.N2.C2

{

}

}

}

En el segmento de código anterior:

El espacio de nombres N1 es un miembro del espacio de nombres global. Su nombre completo es N1.

El espacio de nombres N2 es un miembro del espacio de nombres N1. Su nombre completo es N1.N2.

La clase C1 es un miembro del espacio de nombres N1. Su nombre completo es N1.C1.



5

El nombre de clase C2 se utiliza dos veces en el código. Sin embargo, los nombres completos son únicos. El

primero se declara dentro de C1; así, su nombre completo es: N1.C1.C2. El segundo se declara dentro de un

espacio de nombres N2; así, su nombre completo es N1.N2.C2.

En el segmento de código anterior se puede agregar un nuevo miembro de clase C3 al espacio de nombres N1.N2 de la

siguiente forma:

namespace N1.N2

{

class C3 // N1.N2.C3

{

}

}

1.4. Crear y utilizar archivos DLL de C#

Las bibliotecas de vínculos dinámicos (DLL) se vinculan al programa en tiempo de ejecución. Para ilustrar la creación y

el uso de una DLL, considere el siguiente escenario:

MyLibrary.DLL: archivo de biblioteca que contiene los métodos que se utilizarán durante la ejecución. En este

ejemplo, la DLL contiene dos métodos, Add y Multiply.

Add.cs: archivo de código fuente que contiene el método Add(long i, long j). Devuelve la suma de sus

parámetros. La clase AddClass, que contiene el método Add, es un miembro del espacio de nombres MyMethods.

Mult.cs: archivo de código fuente que contiene el método Multiply(long x, long y). Devuelve el producto

de sus parámetros. La clase MultiplyClass, que contiene el método Multiply, es también un miembro del

espacio de nombres MyMethods.

MyClient.cs: archivo que contiene el método Main. Utiliza los métodos del archivo DLL para calcular la suma y

el producto de los argumentos especificados en tiempo de ejecución.

Archivos de código fuente

Archivo: Add.cs

// Add two numbers

using System;



6

namespace MyMethods

{

public class AddClass

{

public static long Add(long i, long j)

{

return(i+j);

}

}

}

Archivo: Mult.cs

// Multiply two numbers

using System;

namespace MyMethods

{

public class MultiplyClass

{

public static long Multiply(long x, long y)

{

return (x*y);

}

}

}

Archivo: MyClient.cs

// Calling methods from a DLL file

using System;

using MyMethods;

class MyClient

{

public static void Main(string[] args)

{

Console.WriteLine("Calling methods from MyLibrary.DLL:");

if (args.Length != 2)

{

Console.WriteLine("Usage: MyClient <num1> <num2>");

return;

}

long num1 = long.Parse(args[0]);

long num2 = long.Parse(args[1]);



7

long sum = AddClass.Add(num1, num2);

long product = MultiplyClass.Multiply(num1, num2);

Console.WriteLine("The sum of {0} and {1} is {2}",

num1, num2, sum);

Console.WriteLine("The product of {0} and {1} is {2}",

num1, num2, product);

}

}

Este archivo contiene el algoritmo que utiliza los métodos de la DLL, Add y Multiply. Empieza analizando los

argumentos especificados en la línea de comandos, num1 y num2. A continuación, calcula la suma mediante el método Add

de la clase AddClass, y el producto mediante el método Multiply de la clase MultiplyClass.

Observe que la directiva using situada al principio del archivo permite utilizar los nombres de las clases sin calificar para

hacer referencia a los métodos de la DLL en tiempo de compilación, por ejemplo:

MultiplyClass.Multiply(num1, num2);

De lo contrario, sería necesario usar nombres completos, por ejemplo:

MyMethods.MultiplyClass.Multiply(num1, num2);

Compilación

Para generar el archivo MyLibrary.DLL, compile los dos archivos Add.cs y Mult.cs mediante la siguiente línea de

comandos:

csc /target:library /out:MyLibrary.DLL Add.cs Mult.cs

La opción /target:library indica al compilador que genere un archivo DLL en vez de un archivo EXE. La opción /out del

compilador seguida de un nombre de archivo se utiliza para especificar el nombre de archivo de la DLL. Si no se utiliza,

el compilador usa el primer archivo (Add.cs) como nombre de la DLL.

Para generar el archivo ejecutable, MyClient.exe, utilice la siguiente línea de comandos:

csc /out:MyClient.exe /reference:MyLibrary.DLL MyClient.cs



8

La opción /out indica al compilador que genere un archivo EXE y especifica el nombre del archivo (MyClient.exe).

Esta opción del compilador no es de uso obligatorio. La opción /reference del compilador especifica el archivo o archivos

DLL que utiliza el programa.

Ejecución

Para ejecutar el programa, especifique el nombre del archivo EXE seguido de dos números, por ejemplo:

MyClient 1234 5678

Resultados

Calling methods from MyLibrary.DLL:

The sum of 1234 and 5678 is 6912

The product of 1234 and 5678 is 7006652

1.5. Comparación entre C++ y C#

La siguiente tabla contiene comparaciones importantes entre características de C++ y C#. Los programadores de C++

encontrarán rápidamente en esta tabla las diferencias más importantes entre ambos lenguajes. Para obtener más

información, utilice el vínculo para examinar el tema correspondiente.

Nota Los proyectos de C++ y C# provienen de diferentes modelos de proyecto. Para obtener más información acerca de

las diferencias entre los proyectos de C++ y C#.

Característica

Herencia: una clase puede heredar la implementación de una sola clase base. Además, una clase o una interfaz

pueden implementar varias interfaces.

Matrices: la sintaxis para declarar matrices de C# es diferente de la sintaxis de C++. Los símbolos "[]" aparecen a

continuación del tipo de matriz en C#.

El tipo bool: no existe una conversión entre el tipo bool y otros tipos (concretamente, int).

El tipo long: en C#, el tipo de datos long tiene 64 bits, mientras que en C++ tiene 32 bits.

El tipo struct: en C#, las clases y las estructuras son semánticamente diferentes. Una estructura (struct) es un tipo

de valor mientras que una clase (class) es un tipo de referencia.



9

La instrucción switch: a diferencia de la instrucción switch de C++, C# no admite el paso explícito de una

etiqueta de caso a otra.

El tipo delegate: los delegados son prácticamente similares a los punteros a función de C++, pero más seguros.

Llamadas a los miembros reemplazados de una clase base desde clases derivadas.

Uso del modificador new para ocultar explícitamente un miembro heredado.

La declaración de métodos que reemplazan a otros requiere la palabra clave override.

Las directivas de preprocesador se utilizan para la compilación condicional. En C# no se utilizan archivos de

encabezado.

Control de excepciones: uso de la instrucción finally.

Operadores de C#: en C# no se incluyen operadores adicionales como is y typeof. También presenta una

funcionalidad diferente en algunos operadores lógicos.

Uso de la palabra clave extern.

Uso de la palabra clave static.

Método alternativo a la lista de inicialización de C++ para construir una clase base.

Estructura general de un programa en C#: espacios de nombres, clases, estructuras, delegados y enumeraciones.

El método Main se declara de forma diferente a la función main de C++. Además, se compara el uso de los

argumentos de línea de comandos de cada lenguaje.

Parámetros de métodos: C# admite parámetros ref y out, que se utilizan en lugar de punteros para pasar

parámetros por referencia.

C# admite punteros, pero sólo en modo no seguro (unsafe).

La sobrecarga de operadores se realiza de forma diferente en C#.

Cadenas: las cadenas (tipo string) de C# son diferentes de las cadenas de C++.

La palabra clave foreach permite realizar iteraciones en matrices y colecciones.

No existen métodos o variables globales en C#: los métodos y las variables deben residir dentro de una

declaración de tipo (class o struct).

No existen archivos de encabezado ni directivas #include en C#: la directiva using se utiliza para hacer referencia

a tipos en otros espacios de nombres sin necesidad de usar los nombres de tipo completos.

Las variables locales de C# no se pueden utilizar antes de su inicialización.

Destructores: en C#, no se tiene control sobre cuándo se llama a los destructores, ya que es el recolector de

elementos no utilizados el que se encarga de llamarlos automáticamente.

Constructores: a diferencia de C++, si no se proporciona un constructor de clase en C#, se genera automáticamente

un constructor predeterminado. El constructor predeterminado inicializa todos los campos de la estructura con sus

valores predeterminados.



10

C# no admite campos de bits.

Los servicios de entrada y salida de C# y el formato los proporciona la biblioteca de tiempo de ejecución de .NET

Framework.

En C#, los parámetros de los métodos no pueden tener valores predeterminados. Utilice sobrecargas de métodos

para obtener ese efecto.

class sola

{ static void Main(string[] par)

{

string dato;

long l1;

dato =1523.ToString();

System.Console.WriteLine ("Muestra el dato {0}",dato);

try

{l1 = long.Parse(par[0]);}

catch(System.FormatException)

{ l1 = 0;}

int e1 = int.Parse(par[1]);

dato =l1.ToString();

System.Console.WriteLine ("Muestra el dato entrado {0}",dato);

System.Console.WriteLine ("Muestra entradas desde {0} a {1}",par[0],par[par.Length-1]);

System.Console.WriteLine ("Largo de {0} es {1}",par[0],l1);

System.Console.WriteLine ("entero de {0} es {1}",par[1],e1);

for (int i=0;i<par.Length;i++)

{ System.Console.WriteLine ("Argumento {0} = {1}",i,par[i]); }

foreach (string elemento in par)

{

System.Console.Write("{0} parametros entrados>", elemento);

switch (elemento)

{



11

case "pedro":

System.Console.WriteLine ("Hola Pedro");

break;

case "juan":

System.Console.WriteLine ("Hola juan");

break;

default:

System.Console.WriteLine ("Hola como esta");

break;

}

int i=0;

do

{ System.Console.WriteLine ("Argumento {0} = {1}",i,par[i++]); }

while (i < par.Length);

int[] x = new int[5] {4,5,8,9,7};

i=0;

while (i<5)

System.Console.WriteLine("{0}",x[i++]);

int[][] y = {new int[3],new int[4]};

for(int j=0;j<2;j++)

for(int k=0;k<3;k++)

y[j][k]=k+j;

for(int j=0;j<2;j++) {

for(int k=0;k<3;k++)

System.Console.Write("{0}\t",y[j][k]);

System.Console.WriteLine();

} } } }



12

C# obtiene la mayoría de sus instrucciones directamente de C y C++, aunque tiene algunas adiciones y modificaciones dignas de comentar. En

la tabla siguiente se proporciona una lista de las clases de instrucciones que pueden utilizarse, junto con ejemplos.

Instrucción Ejemplo

Listas de instrucciones e instrucciones de bloque

static void Main() {

F();

G();

{

H();

I();

}

}

Instrucciones con etiqueta e

instrucciones goto

static void Main(string[] args) {

if (args.Length == 0)

goto done;

Console.WriteLine(args.Length);

done:

Console.WriteLine("Done");

}

Declaraciones de constantes locales static void Main() {

const float pi = 3.14f;

const int r = 123;

Console.WriteLine(pi * r * r);

}

Declaraciones de variables locales static void Main() {

int a;

int b = 2, c = 3;

a = 1;

Console.WriteLine(a + b + c);

}



13

Instrucciones de expresiones static int F(int a, int b) {

return a + b;

}


F(1, 2); // Expression statement

}

Instrucciones if static void Main(string[] args) {

if (args.Length == 0)

Console.WriteLine("No args");

else

Console.WriteLine("Args");

}

Instrucciones switch static void Main(string[] args) {

switch (args.Length) {

case 0:

Console.WriteLine("No args");

break;

case 1:

Console.WriteLine("One arg ");

break;

default:

int n = args.Length;

Console.WriteLine("{0} args", n);

break;

}

}

Instrucciones while static void Main(string[] args) {

int i = 0;

while (i < args.Length) {

Console.WriteLine(args[i]);

i++;

}

}



14

Instrucciones do static void Main() {

string s;

do { s = Console.ReadLine(); }

while (s != "Exit");

}

Instrucciones for static void Main(string[] args) {

for (int i = 0; i < args.Length; i++)

Console.WriteLine(args[i]);

}

Instrucciones foreach static void Main(string[] args) {

foreach (string s in args)

Console.WriteLine(s);

}

Instrucciones break static void Main(string[] args) {

int i = 0;

while (true) {

if (i == args.Length)

break;

Console.WriteLine(args[i++]);

}

}

Instrucciones continue static void Main(string[] args) {

int i = 0;

while (true) {

Console.WriteLine(args[i++]);

if (i < args.Length)

continue;

break;

}

}



15

Instrucciones return static int F(int a, int b) {

return a + b;

}


Console.WriteLine(F(1, 2));

return;

}

Instrucciones throw e instrucciones try static int F(int a, int b) { if (b == 0)

throw new Exception("Divide by zero");

return a / b;

}


try {

Console.WriteLine(F(5, 0));

}

catch(Exception e) {

Console.WriteLine("Error");

}

}

Instrucciones checked y unchecked static void Main() {

int x = Int32.MaxValue;

Console.WriteLine(x + 1); // Overflow

checked {

Console.WriteLine(x + 1); // Exception

}

unchecked {

Console.WriteLine(x + 1); // Overflow

}

}



16

Instrucciones lock static void Main() {

A a = ...;

lock(a) {

a.P = a.P + 1;

}

}

using statements static void Main() {

using (Resource r = new Resource()) {

r.F();

}

}



17

2. Comparativo entre lenguajes

Concepto Visual Basic C# Java C++ JScript VisualFoxPro

Declarar

variables

Dim x As Integer

Public x As Integer = 10

int x;

int x = 10;

int x;

int x =

10;

int x;

int x = 10;

var x : int;

var x : int =

10;

var x = 10;

LOCAL x

X = 10

Comentarios ' comment

x = 1 ' comment

Rem comment

// comment

/* multiline

comment */

//

/*

multilin

e

comment

*/

/**

Class

Document

ation

*/

// comment

/* multiline

comment */

// comment

/* multiline

comment */

* full line

USE && end

of line

NOTE

multiline ;

comment

Instrucciones

de asignación

nVal = 7

nVal = 7; nVal = 7; nVal = 7; nVal = 7;

nVal = 7

O

STORE 7 to

nVal

Instrucciones

condicionales

If nCnt <= nMax Then

nTotal += nCnt '

Same as nTotal =

nTotal + nCnt.

nCnt += 1 '

Same as nCnt = nCnt +

1.

Else

nTotal += nCnt

nCnt -= 1

End If

if (nCnt <= nMax)

{

nTotal += nCnt;

nCnt++;

}

else

{

nTotal +=nCnt;

nCnt--;

}

if (nCnt

<=

nMax){

nTotal

+= nCnt;

nCnt++;

}

if(nCnt <

nMax) {

nTotal +=

nCnt;

nCnt++;

}

else {

nTotal +=

nCnt;

nCnt --;

};

if(nCnt <

nMax) {

nTotal +=

nCnt;

nCnt ++;

}

else {

nTotal +=

nCnt;

nCnt --;

};

IF nCnt <

nMax

nTot =

nTot * nCnt

nCnt =

nCnt + 1

ENDIF



18

Instrucciones de selección

Select Case n

Case 0

MsgBox ("Zero")

' Visual Basic

.NET exits the Select

at the end of a Case.

Case 1

MsgBox ("One")

Case 2

MsgBox ("Two")

Case Else

MsgBox

("Default")

End Select

switch(n)

{

case 0:

Console.WriteLine("Zero");

break;

case 1:

Console.WriteLine("One");

break;

case 2:

Console.WriteLine("Two");

break;

default:

Console.WriteLine("?");

}

switch(n

) {

case

0:

System.o

ut.print

ln("Zero

\n");

break;

case

1:

System.o

ut.print

ln("One\

n");

break;

default:

System.o

ut.print

ln("?\n"

);

}

switch(n) {

case 0:

printf("Zero

\n");

break;

case 1:

printf("One\

n");

break;

case 2:

printf("Two\

n");

break;

default:

printf("?\n"

);}

switch(int(n))

{

case 0 :

print("Zero")

break

case 1 :

print("One")

break

case 2 :

print("Two")

default :

print("Default

")

}

DO CASE

CASE n = 0

? 'Zero'

CASE n > 0

? 'Pos'

OTHERWISE

? 'Neg'

ENDCASE

Bucles FOR For n = 1 To 10

MsgBox("The number

is " & n)

Next

For Each prop In obj

prop = 42

Next prop

for (int i = 1; i <= 10; i++)

Console.WriteLine("The

number is {0}", i);

foreach(prop current in obj)

{

current=42;

}

for(n=1;

n<11;n++

)

System.o

ut.print

ln("The

number

is " +

n);

for(int n=1;

n<11; n++)

printf("%d\n

",n);

for (var n =

0; n < 10;

n++) {

print("The

number is " +

n)

}

for (var prop

in obj)

obj[prop] = 42

FOR n = 1 TO

10

? n

ENDFOR

Bucles

WHILE

While n < 100 ' Test

at start of loop.

while (n < 100)

n++;

while (n

< 100)

while(int n

< 100)

while (n <

100)

DO WHILE n <

100



19

n += 1 ' Same

as n = n + 1.

End While '

n++;

n++;

n++;

n = n + n

ENDDO

Pasar

parámetros

por valor

Public Sub ABC(ByVal y

As Long) ' The

argument Y is passed

by value.

' If ABC changes y,

the changes do not

affect x.

End Sub

ABC(x) ' Call the

procedure.

' You can force

parameters to be

passed by value,

regardless of how

' they are declared,

by enclosing the

parameters in extra

parentheses.

ABC((x))

/* Note that there is no way to

pass reference types (objects)

strictly by value. You can

choose to either pass the

reference (essentially a

pointer), or a reference to the

reference (a pointer to a

pointer).*/

// The method:

void ABC(int x)

{

...

}

// Calling the method:

ABC(i);

Objects are

always

passed by

reference,

and

primitive

data types

are always

passed by

value.

MyMethod(i,j

);

ABC(i) =ABC(X)



20

Pasar parámetros por referencia

Public Sub ABC(ByRef y

As Long)

' The parameter y is

declared by by

referece:

' If ABC changes y,

the changes are made

to the value of x.

End Sub

ABC(x) ' Call the

procedure.

/* Note that there is no way to

pass reference types (objects)

strictly by value. You can

choose to either pass the

reference (essentially a

pointer), or a reference to the

reference (a pointer to a

pointer).*/

// Note also that unsafe C#

methods can take pointers just

like C++ methods. For details,

see unsafe.

// The method:

void ABC(ref int x)

{

...

}

// Calling the method:

ABC(ref i);

Objects are

always

passed by

reference,

and

primitive

data types

are always

passed by

value.

// Prototype

of ABC that

takes a

pointer to

integer.

int ABC(long

*py);

ABC(&VAR);

// Prototype

of ABC that

takes a

reference to

integer.

int ABC(long

&y);

ABC(VAR);

/* Reference

parameters are

supported for

external

objects, but

not internal

JScript

functions. Use

'&' to call by

reference */

myObject.ByRef

Method(&x);

=ABC(@X)

O bien

DO ABC WITH X

Control estructurado de excepciones

Try

If x = 0 Then

Throw New

Exception("x equals

zero")

Else

Throw New

Exception("x does not

equal zero")

End If

Catch err As

System.Exception

MsgBox("Error: " &

Err.Description)

Finally

MsgBox("Executing

finally block.")

End Try

// try-catch-finally

try

{

if (x == 0)

throw new

System.Exception ("x equals

zero");

else

throw new

System.Exception ("x does not

equal zero");

}

catch (System.Exception err)

{

System.Console.WriteLine(err.Me

ssage);

}

finally

{

System.Console.WriteLine("execu

ting finally block");

try{

if (x

== 0)

throw

new

Exceptio

n ("x

equals

zero");

else

throw

new

Exceptio

n ("x

does not

equal

zero");

}

catch

(Excepti

on err){

__try{

if (x

== 0)

throw new

Exception

("x equals

zero");

else

throw new

Exception

("x does not

equal

zero");

}

__catch(Exce

ption e)

{

Console.Writ

eLine("Caugh

try {

if (x == 0)

throw "x

equals zero"

else

throw "x

does not equal

zero"

}

catch(e) {

print("Error

description: "

+ e)

}

finally {

print("Executi

ng finally

block.")

}



21

}

if

(err.get

Message(

) == "x

equals

zero")

System.o

ut.print

ln(err.g

etMessag

e());

//Handle

Error

Here

}

t

Exception");

}

__finally

{

Console.Writ

eLine("Execu

ting finally

block");

}

Establecer una referencia de objeto a Nothing

o = Nothing o = null; stringVar =

null; o = undefined;

MyObj = null O

bien

Obj.RELEASE



22

3. Palabras clave comparadas en diferentes lenguajes Propósito Palabra clave en

Visual Basic

Palabra clave en C#

NUEVO

Palabra clave en

Java

Palabra clave en

C++

Palabra clave en

JScript

Palabra clave

en Visual

FoxPro

Declarar una

variable

Private, Public,

Friend,

Protected,

Static1, Shared,

Dim

declaradores (las

palabras clave

incluyen tipos

definidos por el

usuario y tipos

integrados)

public, private,

protected (si es

una variable

miembro)

const, volatile

(Nota: no son

necesarias para una

declaración).

declaradores

(concepto, no

palabra clave)

var [declaración

implícita];

también PUBLIC,

LOCAL, PRIVATE

Declarar una

constante

con nombre

Const const

readonly

final (se aplica a

una declaración de

campo)

const const NUEVA #DEFINE

Crear un

nuevo objeto

New New New new new no disponible

CreateObject() no disponible CoCreateInstance

()

new

ActiveXObject()

CREATEOBJECT;

NEWOBJECT

Asignar un

objeto a una

variable

objeto

= = = = = =; también

STORE

La

función/méto

do no

devuelve un

valor

Sub2 Void void void void Void (sólo

servidores COM)

Sobrecargar

una función

o un método

(Visual

Basic:

sobrecargar

un

procedimient

Overloads NUEVA No se requiere

ninguna palabra clave

para esta finalidad

No se requiere

ninguna palabra

clave para esta

finalidad

No se requiere

ninguna palabra

clave para esta

finalidad

No se requiere

ninguna palabra

clave para esta

finalidad

No se requiere

ninguna palabra

clave para esta

finalidad



23

o o un

método)

Hacer

referencia

al objeto

actual

Me3 this this This this This;

Thisform

Realizar una

llamada no

virtual a un

método

virtual del

objeto

actual

MyClass no disponible MyClass:Func1(),

donde MyClass es

una clase de C+

con una función

miembro Func1.

no disponible no disponible

Recuperar

caracteres

de una

cadena

GetChar

Function NUEVA

[] getChar *(p + 10) o

p[10] donde p es

un char*

str[10], donde

str es una

cadena, charAt,

substring,

substr4

SUBSTR( )

Declarar un

tipo de

datos

compuesto

(Visual

Basic:

Structure)

Structure

<miembros> End

Structure

struct, class,

interface

no disponible class, struct,

union

__interface

class,

interface NUEVA

no disponible

Inicializar

un objeto

(constructor

es)

Sub New()5 Constructores, o

constructores de

tipos predeterminados

del sistema

Constructores

(concepto, no

palabra clave)

constructores

(concepto, no

palabra clave)

constructor

(concepto, no

palabra clave) 6

evento Init

Finalizar un

objeto de

forma

directa

no disponible no disponible no disponible ~ClassName no disponible no disponible

Llamada del

método por

el sistema

antes de que

el

recolector

de elementos

Finalize NUEVA (En

Visual Basic 6.0,

Class_Terminate)

destructor finalize destructor no disponible evento Destroy



24

no

utilizados

reclame un

objeto7

Inicializar

una variable

donde se

declara

Dim x As Long = 5

Dim c As New

Car(FuelTypeEnum.

Gas)

// inicializar con un

valor:

int x = 123;

// o utilizar el

constructor

predeterminado:

int x = new int();

int x = 5;

//or initialized by

constructor

C c(10);

int x=5; var x = 5

var y : car =

new car()

no disponible

Tomar la

dirección de

una función

AddressOf (para

los miembros de

clase, este

operador devuelve

una referencia a

una función en el

formulario de una

instancia de

delegado)

delegate no disponible __delegate Utilice el

nombre de la

función sin

paréntesis

no disponible

Devolución

de llamada

no disponible no disponible Pase la dirección

de una función a

otra que devuelve

la llamada al

llamador. Para

obtener un ejemplo,

vea Utilizar

funciones de

devolución de

llamada.

CALLBACK (tipo

estándar);

callback

(atributo IDL)


Declarar que

un objeto se

puede

modificar de

forma

asincrónica

no disponible volatile volatile volatile no disponible no disponible

Forzar la Option Explicit no disponible. Es no disponible. Es no disponible. modo rápido _VFP.LanguageOp



25

declaración

explícita de

variables

preciso declarar

todas las variables

antes de utilizarlas.

preciso declarar

todas las variables

antes de

utilizarlas.

Es preciso

declarar todas

las variables

antes de

utilizarlas.

(activada de

manera

predeterminada)

tions NUEVA

Probar una

variable

objeto que

no hace

referencia a

un objeto

obj = Nothing obj == null pObj == 0 pobj == NULL obj == undefined

obj == null

EMPTY();

ISNULL()

Valor de una

variable

objeto que

no hace

referencia a

un objeto

Nothing Null null no disponible null

undefined

no disponible

Probar una

expresión de

tipo null de

una base de

datos

IsDbNull no disponible Compatible con

diversos tipos de

datos del espacio

de nombres

System.Data.SqlType

s

no disponible x == null ISNULL( )

Probar si

una variable

Variant se

ha

inicializado

no disponible no disponible no disponible no disponible x == undefined EMPTY( )

Definir una

propiedad

predetermina

da

Default NUEVA utilizar indizadores [System::Reflection

::DefaultMember("Na

me")]

no disponible no disponible no disponible

4. Programación orientada a objetos

Propósito Palabra clave en Visual

Basic

Palabra clave

en C# NUEVO

Palabra clave en

Java

Palabra clave

en C++

Palabra clave en

JScript

Palabra clave en Visual

FoxPro

Hacer referencia a

una clase base

MyBase NUEVA

base super __super super NUEVA

BaseClass property;

ParentClass property;



26

DODEFAULT()

Declarar una

interfaz

Interface NUEVA

interface interface __interface Interface NUEVA

DEFINE CLASS

Especificar una

interfaz para que se

implemente

Implements (instrucción) class C1 : I1 implements (cláusula en una

declaración de

clase)

Sólo hay que

derivar de la

interfaz.

class C1 :

public I1

implements NUEVA

IMPLEMENTS NUEVA

Declarar una clase Class NUEVA

<implementación>

class class class class NUEVA

DEFINE CLASS MyClass

AS <BaseClass>

Especificar que una

clase sólo se puede

heredar. No se

puede crear una

instancia de la

clase.

MustInherit NUEVA

abstract abstract __abstract8 (sólo

en extensiones

administradas

de C++)

abstract NUEVA

no disponible

Especificar que una

clase no se puede

heredar

NotInheritable NUEVA

sealed final __sealed (sólo

en extensiones

administradas

de C++)

final NUEVA

no disponible

Declarar un tipo

enumerado

Enum <miembros> End

Enum

enum no disponible enum enum NUEVA

no disponible

Declarar una

constante de clase

Const const (se aplica a

una declaración

de campo)

static final (se

aplica a una

declaración de

campo)

const const NUEVA

#DEFINE

Derivar una clase

de una clase base

Inherits C2 NUEVA

clase C1 : C2 class C1 extends

C2

Clase C1 : base

pública (No se

requiere

ninguna palabra

clave para esta

finalidad)

class c1 extends

c2 NUEVA

DEFINE CLASS MyClass

AS ParentClass



27

Reemplazar un

método

Overrides NUEVA

override No se requiere

ninguna palabra

clave para esta

finalidad

No se requiere

ninguna palabra

clave para esta

finalidad

No se requiere

ninguna palabra clave

para esta finalidad

No se requiere ninguna

palabra clave para esta

finalidad

Declarar un método

que se debe

implementar en una

clase que se deriva

MustOverride NUEVA

abstract abstract Poner = 0 al

final de la

declaración

(método virtual

puro)

abstract NUEVA

No se requiere ninguna

palabra clave para esta

finalidad

Declarar un método

que no se puede

reemplazar

NotOverridable NUEVA

(Los

métodos no se reemplazan

de forma predeterminada.)

sealed final __sealed (sólo

en extensiones

administradas

de C++)

final NUEVA

no disponible

Declarar un

método, una

propiedad (Visual

Basic) o un

descriptor de acceso

a propiedad (C#,

C++) virtual

Overridable virtual Los métodos son

virtuales de forma

predeterminada

virtual Los métodos son

virtuales de forma

predeterminada

no disponible

Declarar una

referencia con

seguridad de tipos a

un método de una

clase

Delegate NUEVA

delegate no disponible __delegate (sólo

en extensiones

administradas

de C++)

Utilice el nombre de

la función sin

paréntesis

no disponible

Especificar que una

variable puede

contener un objeto

cuyos eventos se

desea controlar

WithEvents Escribir código.

No hay una

palabra clave

específica

no disponible no disponible Escribir código. No

hay una palabra clave

específica

EVENTHANDLER( )

NUEVA

Especificar los

eventos para los

que se llamará a un

Handles NUEVA

(Los

procedimientos de evento

se pueden seguir asociando

no disponible no disponible no disponible no disponible no disponible



28

procedimiento de

evento.

a una variable WithEvents

mediante el modelo de

nomenclatura)

Evaluar una

expresión de objeto

una vez para tener

acceso a varios

miembros

With objExpr <.miembro>

<.miembro> End With

no disponible no disponible no disponible with9 WITH…ENDWITH

5. Control de excepciones

Propósito Palabra clave en

Visual Basic

Palabra clave en

C# NUEVO

Palabra clave en

Java

Palabra clave en

C++

Palabra clave en

JScript

Palabra clave en Visual

FoxPro

Control estructurado

de excepciones

Try NUEVA

<attempt>

Catch

<handle errors>

Finally

<always execute>

End Try

try, catch, finally,

throw Try, catch,

finally, throw

__try, __except,

__finally

try, catch, finally,

throw

ONERROR( ),

COMRETURNERROR( ),

ERROR(); MESSAGE(),

AERROR()

Control de

excepciones de C++

no disponible no disponible no disponible try, catch, throw No disponible no disponible



29

6. Estructuras de decisión


Visual Basic

Palabra clave en

C# NUEVO

Palabra clave en

Java

Palabra clave en

C++

Palabra clave en

JScript

Palabra clave en

Visual FoxPro

Estructura de decisión

(selección)

Select Case …, Case,

Case Else, End Select

switch, case,

default, goto,

break

switch, case,

break; default;

switch, case,

default, goto,

break;

switch, case, break CASE

Estructura de decisión

(if ... then)

If … Then, ElseIf …

Then, Else, End If

if, else if, else if, else if, else IF ... ENDIF

Estructura de bucle

(condicional)

While, Do [While,

Until] …, Loop [While,

Until]

do, while, continue do, while,

continue

do, while, continue do, while, break,

continue DO, WHILE (cláusulas)

Estructura de bucle

(iteración)

For …, [Exit For,] Next

For Each …, [Exit

For,] Next

for, foreach for, break for for

(x=0;x<10;x++){…}

for (prop in obj) {

print (obj[prop]);}

FOR (cláusulas),

FOR … ENDFOR,

Continue, Next

7. Matrices


Visual Basic

Palabra clave en

C# NUEVO

Palabra clave en

Java

Palabra clave en

C++

Palabra clave en

JScript

Palabra clave en

Visual FoxPro

Declarar una matriz Dim a() As Long int[] x = new

int[5];

int[] x = new

int[5];

int x[5]; var x : int[], var arr =

Array() DIMENSION,

DECLARE

Inicializar una matriz Dim a() As Long = {3,

4, 5}

int[] x = new

int[5] {1, 2, 3, 4,

5};

int[] x = new int[]

{1,2,3,4,5};

int x[5]=

{1,2,3,4,5};

var x : int[] = [1, 2, 3, 4,

5], var arr = new

Array(1, 2, 3, 4, 5)]

DIMENSION,

DECLARE

Reasignar matriz ReDim no disponible no disponible no disponible arr.length=newSize(sólo

para matrices de

JScript)10

DIMENSION,

DECLARE



30

8. Ámbito de clase


Visual Basic

Palabra clave en

C# NUEVO

Palabra clave en

Java

Palabra clave en

C++

Palabra clave en

JScript

Palabra clave en

Visual FoxPro

Visible fuera del

proyecto o del

ensamblado

Public public public public public NUEVA

PUBLIC

Invisible outside the

assembly (C#/Visual

Basic) or within the

package (Java,

JScript)

Friend internal Al omitir la

palabra clave del

ámbito se

especifica "ámbito

del paquete"

private internal NUEVA

no disponible

Sólo visible dentro

del proyecto (para

clases anidadas,

dentro de la clase

envolvente)

Private private private private private NUEVA

HIDDEN

9. Ámbito de miembro


Visual Basic

Palabra clave en

C# NUEVO

Palabra clave en

Java

Palabra clave en

C++

Palabra clave en

JScript

Palabra clave en

Visual FoxPro

Accesible desde fuera de

la clase y del proyecto

(Java/JScript/C++/Visual

Basic) o del módulo

(Visual Basic)

Public public public public public NUEVA

PUBLIC

Accesible desde fuera de

la clase, pero desde

dentro del proyecto (C#,

Visual Basic, C++) o del

paquete (Java, JScript)

Friend internal Al omitir la

palabra clave del

ámbito se

especifica "ámbito

del paquete"

public private: internal NUEVA

no disponible

Accesible sólo desde

dentro de la clase

Private private private private private NUEVA

HIDDEN



31

(Java/JScript/C++/Visual

Basic) o del módulo

(Visual Basic)

Accesible sólo para

clases actuales y

derivadas

Protected NUEVA

protected protected protected protected NUEVA

PROTECTED

Especificar que una

función u otra clase tiene

acceso a miembros

privados de la clase que

se declara

no disponible no disponible no disponible friend (no se

permite en las

extensiones

administradas de

C++)


Protegido dentro del

ensamblado y privado

para los demás

ensamblados

no disponible no disponible no disponible protected

private:

(Sólo en las

extensiones

administradas de

C++)


10. Varios Período de duración


Visual Basic

Palabra clave en

C# NUEVO

Palabra clave en

Java

Palabra clave en

C++

Palabra clave en

JScript

Palabra clave en

Visual FoxPro

Conservar las

variables locales de

un procedimiento

Static11

no disponible static static no disponible PRIVATE

Compartido por todas

las instancias de una

clase.

Shared NUEVA

static static static static NUEVA

no disponible

11. Varios


Visual Basic

Palabra clave en

C# NUEVO

Palabra clave en

Java

Palabra clave en

C++

Palabra clave en

JScript

Palabra clave en

Visual FoxPro

Comentar código ' //, /* */ for // //, /* */ para //, /* */ for multiline *; &&



32

Rem

multiline

comments

/// for XML

comments

/**

*/

/*

*/

comentarios de

varias líneas

comments

Distinguir mayúsculas

de minúsculas

No Sí Sí Sí Sí No

Lamar a la API de

Windows

Declare <API> Utilizar invocación

de la plataforma

Llamar

directamente

no disponible no disponible DECLARE - DLL

Declarar y provocar

un evento.

Event, RaiseEvent event __event no disponible no disponible no disponible

Tipos primitivos de

subprocesamiento

SyncLock lock Está en las clases

del espacio de

nombres

System.Threading.


Ir a Goto goto no disponible goto no disponible no disponible

1. El único lugar donde se puede utilizar la palabra clave Static por sí misma para declarar una variable, por ejemplo, Static x As Long, es en un

procedimiento.

2. En Visual Basic, los procedimientos declarados con la palabra clave Sub no pueden devolver valores. Si un procedimiento tiene que devolver un

valor, se debe declarar con la palabra clave Function.

3. Me no se resuelve en tiempo de compilación, por lo que se puede utilizar como el valor devuelto de una propiedad o un método.

4. Todavía se admite la función substr, pero no es la forma más recomendada para el acceso a los caracteres de una cadena. La mejor manera de tener

acceso a un carácter desde una ubicación concreta de una cadena es la de utilizar corchetes. Por ejemplo, para tener acceso al décimo carácter de la

cadena, utilice str[10].

5. En Visual Basic, los constructores para las clases derivadas de System.Object de .NET Framework se denominan siempre New.

6. No se permite la sobrecarga en constructores de JScript.

7. Normalmente, el código de este método libera recursos del sistema que no liberaría automáticamente el recolector de elementos no utilizados.

8. En C++ una clase abstracta incluye al menos un miembro virtual puro.

9. Observe que no hay un punto inicial como se utilizaría en Visual Basic. Esta característica puede crear confusión fácilmente porque las variables se

pueden confundir con propiedades, y viceversa. Tenga en cuenta también que la instrucción with produce un código lento.

ms-help://MS.VSCC/MS.MSDNVS.3082/vsintro7/html/vxtskaddingcommentsincode.htm

ms-help://MS.VSCC/MS.MSDNVS.3082/vsintro7/html/vxtskaddingcommentsincode.htm



33

10. No reasigna la matriz ni aumenta su tamaño. Las matrices JScript (declaradas como tipo Array) son siempre dispersas y dinámicas. Las matrices

nativas (declaradas como System.Array o como type[]) no son dinámicas.

11. Las variables locales estáticas de métodos de clases no compartidos se almacenan por instancias de clase en Visual Basic, en vez de compartir una

copia única como ocurre en otros lenguajes. Cuando se utiliza Static para declarar una variable, se conserva el valor de esa variable aunque la variable

pierda el ámbito y lo vuelva a obtener después.



34

12. Operadores comparados en diferentes lenguajes

En este tema se enumeran los operadores de Visual Basic, Java, Visual C++, Visual C#, JScript y Visual FoxPro.

Visual Basic C# NUEVO

Java C++ JScript Visual FoxPro

Aditivo

Suma + + + + + +

Resta - - - - - -

Multiplicativo

Multiplicación * * * * * *

División / / / / / /

División de número entero \ /1 no disponible

Módulo (división que

devuelve sólo el resto) Mod % % % % (también

funciona con

punto flotante)

%; Mod

Exponenciación ^ no disponible no disponible no disponible ^, **

Asignación

Asignación = = = = = =

Suma += NUEVO

+= += += += +

Resta -= NUEVO

-= -= -= -= -

Multiplicación *= NUEVO

*= *= *= *= *

División /= NUEVO

/= /= /= /= /

División de número entero \= NUEVO

/=1 no disponible no disponible no disponible no disponible

Concatenar &= NUEVO

+= += += +

-

$

Módulo no disponible %= %= %= %= %

Desplazamiento a la

izquierda

no disponible <<= <<= <<= <<= BITLSHIFT( )



35

Desplazamiento a la derecha no disponible >>= >>= >>= >>= BITRSHIFT( )

AND bit a bit no disponible &= &= &= &= BITAND( )

OR exclusivo bit a bit no disponible ^= ^= ^= ^= BITXOR( )

Bitwise-inclusive-OR no disponible |= |= |= |= BITOR( )

Relacional e igualdad

Menor que < < < < < <

Menor o igual que <= <= <= <= <= <=

Mayor que > > > > > >

Mayor o igual que >= >= >= >= >= >=

Igual = == == == == =

No igual <> != != != != <>; #; !=

Comparar dos variables de

referencia de objeto.

Is == == no disponible == COMPOBJ()

Comparar el tipo de

referencia de objeto

TypeOf x es

Class1

x is Class1 (vea

también as y

typeof)

x instanceof

Class1

no disponible instanceof no disponible

Comparar cadenas = ==

-or-

String.Equals()

String.equals() Existen

funciones para

comparar y

concatenar

cadenas

== =

Concatenar cadenas & + + + +

AND booleano

cortocircuitado AndAlso && && && && no disponible

OR booleano cortocircuitado OrElse || || || || no disponible

Desplazamiento

Desplazamiento a la

izquierda

no disponible << << << << no disponible

Desplazamiento a la derecha no disponible >> >> >> >>, >>> no disponible

Resolución de ámbito



36

Resolución de ámbito . . y base no disponible :: no disponible ::

Postfijo2

Elemento de matriz () [ ] [ ] [ ] [ ] [ ]; ()

Llamada a función () ( ) ( ) ( ) ( ) ( )

Conversión de tipos Cint, CDbl, …,

CType

(tipo) (tipo) (tipo) tipo() no disponible

Selección de miembro . . . . O bien -> . .

Postfijo de incremento no disponible ++ ++ ++ ++ no disponible

Postfijo de decremento no disponible -- -- -- -- no disponible

Unario3

Direccionamiento indirecto no disponible * (sólo modo

unsafe)

no disponible * no disponible no disponible

Dirección de AddressOf & (sólo modo

unsafe; vea

también fixed)

no disponible & no disponible no disponible

NOT lógico Not ! ! ! ! !

Complemento de uno Not ~ ~ ~ ~ BITNOT( )

Prefijo de incremento no disponible ++ ++ ++ ++ no disponible

Prefijo de decremento no disponible -- -- -- -- no disponible

Tamaño de tipo no disponible sizeof no disponible Sizeof no disponible no disponible

coma no disponible no disponible , , , no disponible

Bit a bit

AND bit a bit And & & & & BITAND( )

OR exclusivo bit a bit Xor ^ ^ ^ ^ BITXOR( )

OR inclusivo bit a bit Or | | | | no disponible

Lógico

AND lógico And && && && && AND

OR lógico Or || || || || OR

Condicional

Condicional IIf Function () ?: ?: ?: ?: no disponible



37

Puntero a miembro

Puntero a miembro no disponible . (sólo modo

Unsafe)

no disponible .* o bien -> no disponible no disponible

Referencia

Referencia no disponible no disponible

(utilizar tipos de

referencia)

no disponible & no disponible @

1. El operador de división se sobrecarga para controlar tanto una división de enteros como de punto flotante, en función de los operandos. 2. Los operadores postfijos tienen el máximo nivel de prioridad en la evaluación de expresiones. 3. Los operadores unarios aparecen delante del operando y se asocian de derecha a izquierda.

13. Tipos de datos comparados en diferentes lenguajes

En este tema se enumeran los tipos de datos de Visual Basic, Java, Visual C++, Visual C#, JScript y Visual FoxPro.

Tamaño de

almacenamiento

Visual Basic C# NUEVO

Java Visual C++ JScript Visual FoxPro

16 bytes no disponible no disponible no disponible VARIANT Object Variant

Decimal Decimal NUEVO

(clase de .NET

Framework)

decimal no disponible DECIMAL decimal NUEVO

no disponible

Fecha Date NUEVO

(clase de

.NET Framework)

DateTime NUEVO

(clase de .NET

Framework)

java.util.Date DATE System.DateTime.

También el objeto

Date. para fechas en

JScript.

Date; DateTime

(tamaño variable) String NUEVO

(clase

de .NET

Framework)

string java.lang.String no disponible String NUEVO

no disponible

1 byte Byte byte byte BYTE, bool byte NUEVO

Lógico

2 bytes Boolean bool Boolean VARIANT_BOOL boolean NUEVO

no disponible

2 bytes Short, Char (carácter

Unicode)

short, char (carácter

Unicode) short signed short int,

__int16

short NUEVO

, char NUEVO

no disponible



38

1 byte no disponible char signed char, __int8 Sbyte NUEVO

Character

4 bytes Integer int int long, (long int, signed

long int)

int NUEVO

Integer

8 bytes Long NUEVO

long long __int64 long NUEVO

Tipo Float

4 bytes Single float float float float NUEVO

no disponible

8 bytes Double double double double double NUEVO

Double

4 bytes en tabla no disponible no disponible no disponible no disponible no disponible General



39

14. Comparación de los controles y objetos programables de distintos lenguajes y bibliotecas

En este tema se enumeran los controles de Visual Basic 6.0, los controles de formularios Windows Forms, los controles de servidor de ASP.NET y

HTML, las clases de MFC y ATL, y los objetos de Visual FoxPro.

Objeto de Visual

Basic 6.0

Control de

formularios

Windows Forms

NUEVO

Control de

servidor ASP.NET

NUEVO

Control de servidor

HTML NUEVO

Clase de MFC Clase de ATL Objeto de Visual

FoxPro

ComboBox ComboBox DropDownList no disponible CComboBox no disponible ComboBox

ImageCombo ComboBox no disponible no disponible CComboBoxEx no disponible Image

CheckBox ComboBox CheckBox,

CheckBoxList

HtmlInputCheckBox CButton no disponible CheckBox

CommandButton Button Button, LinkButton,

ImageButton

HtmlInputButton,

HtmlButton

CButton no disponible CommandButton

Frame GroupBox, Panel Panel no disponible no disponible no disponible no disponible

OptionButton RadioButton RadioButton,

RadioButtonList

HtmlInputRadioButton CButton no disponible OptionButton;

OptionGroup

CommonDialog FileDialog,

PrintDialog,

ColorDialog,

FontDialog

no disponible no disponible CCommonDialog no disponible CommonDialog;

GETFILE( ;

GETDIR( )

ListBox ListBox ListBox HtmlSelect CListBox no disponible ListBox

FileSystemObject Clases en System.IO no disponible no disponible CFile no disponible Varios functions

HScrollBar,

VScrollBar

HscrollBar,

VscrollBar

no disponible no disponible CScrollBar no disponible no disponible

COOLBar no disponible no disponible no disponible CRebarCtrl no disponible Toolbar

Label Label Label no disponible CStatic no disponible Label

TextBox TextBox TextBox HtmlInputText CEdit no disponible TextBox; EditBox

Menu MainMenu, no disponible no disponible CMenu no disponible Comandos de menú



40

ContextMenu

Animation Las imágenes en los

controles admiten

GIF animados

no disponible no disponible CAnimateCtrl no disponible no disponible

Form Form no disponible HtmlForm CDialog,

CFormView

CDialogImpl,

CWindow,

CWindowImpl

Form; FormSet

Timer Timer no disponible no disponible CWnd::SetTimer no disponible Timer

DataGrid DataGrid DataGrid, DataList,

Repeater

HtmlTable no disponible no disponible Cuadrícula

DateTimePicker DateTimePicker no disponible no disponible CDateTimeCtrl no disponible no disponible

ImageList ImageList no disponible no disponible CImageList no disponible ImageList

ListView ListView no disponible no disponible CListCtrl no disponible ListView

Internet Transfer Clases en

System.Net

no disponible HtmlInputFile CHttpConnection,

CFtpConnection

no disponible Explorador Web

MonthView MonthCalendar Calendar no disponible CMonthCalCtrl no disponible ActiveX Calendar;

MonthView

ProgressBar ProgressBar no disponible no disponible CProgressCtrl no disponible ProgressBar

PictureBox PictureBox Image HtmlInputImage CPictureHolder no disponible no disponible

RichTextBox RichTextBox no disponible no disponible CRichEditCtrl no disponible RichTextBox

SSTab, TabStrip TabControl no disponible no disponible CTabCtrl no disponible SSTab

StatusBar StatusBar no disponible no disponible CStatusBarCtrl no disponible StatusBar

Slider Trackbar no disponible no disponible CSliderCtrl no disponible Slider

Toolbar Toolbar no disponible no disponible CToolBarCtrl no disponible Toolbar

TreeView TreeView no disponible no disponible CTreeCtrl no disponible TreeView

UpDown NumericUpDown,

DomainUpDown

no disponible no disponible CSpinButtonCtrl no disponible Spinner

WinSock Clases en

System.Net

no disponible no disponible CSocket no disponible WinSock

Apuntes sobre C# - chsos20112906536.files.wordpress.com · APUNTES SOBRE C# y comparación otros...

Documents

Transcript of Apuntes sobre C# - chsos20112906536.files.wordpress.com · APUNTES SOBRE C# y comparación otros...