Apuntes sobre C

APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
1
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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:
2
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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)
{
3
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
}
}
}
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
{
class C1
{
class C2
{
}
}
namespace N2
{
class C2
{
}
}
}
// N1
// N1.C1
// N1.C1.C2
// N1.N2
// 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.
4
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.

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;
5
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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]);
6
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
7
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
8
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.























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.
9
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.



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)
{
10
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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();
} } } }
11
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
Listas de instrucciones e instrucciones
de bloque
Instrucciones con etiqueta e
instrucciones goto
Declaraciones de constantes locales
Declaraciones de variables locales
Ejemplo
static void Main() {
F();
G();
{
H();
I();
}
}
static void Main(string[] args) {
if (args.Length == 0)
goto done;
Console.WriteLine(args.Length);
done:
Console.WriteLine("Done");
}
static void Main() {
const float pi = 3.14f;
const int r = 123;
Console.WriteLine(pi * r * r);
}
static void Main() {
int a;
int b = 2, c = 3;
a = 1;
Console.WriteLine(a + b + c);
}
12
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Instrucciones de expresiones
static int F(int a, int b) {
return a + b;
}
static void Main() {
F(1, 2); // Expression statement
}
Instrucciones if
static void Main(string[] args) {
if (args.Length == 0)
Console.WriteLine("No args");
else
Console.WriteLine("Args");
}
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;
}
}
static void Main(string[] args) {
int i = 0;
while (i < args.Length) {
Console.WriteLine(args[i]);
i++;
}
}
Instrucciones switch
Instrucciones while
13
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Instrucciones do
Instrucciones for
Instrucciones foreach
Instrucciones break
Instrucciones continue
static void Main() {
string s;
do { s = Console.ReadLine(); }
while (s != "Exit");
}
static void Main(string[] args) {
for (int i = 0; i < args.Length; i++)
Console.WriteLine(args[i]);
}
static void Main(string[] args) {
foreach (string s in args)
Console.WriteLine(s);
}
static void Main(string[] args) {
int i = 0;
while (true) {
if (i == args.Length)
break;
Console.WriteLine(args[i++]);
}
}
static void Main(string[] args) {
int i = 0;
while (true) {
Console.WriteLine(args[i++]);
if (i < args.Length)
continue;
break;
}
}
14
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Instrucciones return
static int F(int a, int b) {
return a + b;
}
static void Main() {
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;
}
static void Main() {
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
}
15
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Instrucciones lock
using statements
static void Main() {
A a = ...;
lock(a) {
a.P = a.P + 1;
}
}
static void Main() {
using (Resource r = new Resource()) {
r.F();
}
}
16
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
2. Comparativo entre lenguajes
Concepto
Declarar
variables
Visual Basic
Dim x As Integer
Public x As Integer = 10
int x;
int x = 10;
Comentarios
' comment
x = 1
' comment
Rem comment
// comment
/* multiline
comment */
Instrucciones
de asignación
nVal = 7
C#
nVal = 7;
Java
int x;
int x =
10;
C++
int x;
int x = 10;
//
/*
multilin
e
comment
*/
/**
Class
Document
ation
*/
// comment
nVal = 7;
nVal = 7;
/* multiline
comment */
JScript
var x : int;
var x : int =
10;
var x = 10;
// comment
/* multiline
comment */
VisualFoxPro
LOCAL x
X = 10
* full line
USE && end
of line
NOTE
multiline ;
comment
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
17
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Instruccione
s 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;
switch(n) {
case 0:
printf("Zero
\n");
break;
case 1:
printf("One\
n");
break;
case 2:
printf("Two\
n");
break;
default:
switch(int(n))
{
case 0 :
print("Zero")
break
case 1 :
DO CASE
CASE n = 0
? 'Zero'
CASE n > 0
? 'Pos'
OTHERWISE
? 'Neg'
ENDCASE
print("One")
break
case 2 :
print("Two")
default :
print("Default
")
}
printf("?\n"
);}
default:
System.o
ut.print
ln("?\n"
);
}
Bucles FOR
For n = 1 To 10
MsgBox("The number
is " & n)
Next
For Each prop In obj
prop = 42
Next prop
Bucles
WHILE
While n < 100 ' Test
at start of loop.
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++
)
while (n < 100)
n++;
while (n
< 100)
System.o
ut.print
ln("The
number
is " +
n);
for(int n=1;
n<11; n++)
printf("%d\n
",n);
while(int n
< 100)
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
while (n <
100)
DO WHILE n <
100
18
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
n += 1
' Same
as n = n + 1.
End While '
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))
n++;
/* 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:
Objects are
always
passed
by
reference,
and
primitive
data types
are always
passed
by
value.
n++;
MyMethod(i,j
);
n++;
ABC(i)
n = n + n
ENDDO
=ABC(X)
ABC(i);
19
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
Try
Control
estructurado
de
excepciones
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
/* 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);
// 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");
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);
try{
if (x
== 0)
__try{
throw
new
Exceptio
n ("x
equals
zero");
else
throw new
Exception
("x equals
zero");
else
try {
if (x == 0)
throw "x
equals zero"
else
throw "x
does not equal
zero"
}
catch(e) {
throw
new
Exceptio
n ("x
does not
equal
zero");
}
catch
(Excepti
on err){
if (x
== 0)
throw new
Exception
("x does not
equal
zero");
}
__catch(Exce
ption e)
{
=ABC(@X)
O bien
DO ABC WITH X
print("Error
description: "
+ e)
}
finally {
print("Executi
ng finally
block.")
}
Console.Writ
eLine("Caugh
20
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
}
if
(err.get
Message(
) == "x
equals
zero")
t
Exception");
}
System.o
ut.print
ln(err.g
etMessag
e());
Console.Writ
eLine("Execu
ting finally
block");
}
__finally
{
//Handle
Error
Here
}
o = Nothing
Establecer
una
referencia
de objeto a
Nothing
o = null;
stringVar =
null;
o = undefined;
MyObj = null O
bien
Obj.RELEASE
21
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
3. Palabras clave comparadas en diferentes lenguajes
Propósito
Palabra clave en
Visual Basic
Declarar una Private, Public,
variable
Friend,
Protected,
Static1, Shared,
Dim
Declarar una Const
constante
con nombre
NUEVA
Palabra clave en
Java
NUEVO
declaradores (las
palabras clave
incluyen tipos
definidos por el
usuario y tipos
integrados)
const
Crear un
New
nuevo objeto
CreateObject()
Asignar un
=
objeto a una
variable
objeto
La
Sub2
función/méto
do no
devuelve un
valor
Sobrecargar Overloads
una función
o un método
(Visual
Basic:
sobrecargar
un
procedimient
Palabra clave en C#
readonly
New
public, private,
protected (si es
una variable
miembro)
Palabra clave en Palabra clave en
C++
JScript
declaradores
(concepto, no
palabra clave)
const, volatile
(Nota: no son
necesarias para una
declaración).
final (se aplica a const
una declaración de
campo)
var
const
NUEVA
Palabra clave
en Visual
FoxPro
[declaración
implícita];
también PUBLIC,
LOCAL, PRIVATE
#DEFINE
New
new
no disponible
CREATEOBJECT;
CoCreateInstance new
()
ActiveXObject() NEWOBJECT
=
=
=; también
STORE
=
=
Void
void
No se requiere
No se requiere
ninguna palabra clave ninguna palabra
para esta finalidad clave para esta
finalidad
new
no disponible
void
void
Void (sólo
servidores COM)
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
22
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
o o un
método)
Hacer
referencia
al objeto
actual
Realizar una
llamada no
virtual a un
método
virtual del
objeto
actual
Recuperar
caracteres
de una
cadena
Declarar un
tipo de
datos
compuesto
(Visual
Basic:
Structure)
Inicializar
un objeto
(constructor
es)
Finalizar un
objeto de
forma
directa
Llamada del
método por
el sistema
antes de que
el
recolector
de elementos
Me3
this
this
This
This;
this
Thisform
MyClass
GetChar
Function
no disponible
MyClass:Func1(), no disponible
donde MyClass es
una clase de C+
con una función
miembro Func1.
[]
getChar
struct, class,
interface
no disponible
SUBSTR( )
*(p + 10) o
str[10], donde
p[10] donde p es str es una
un char*
cadena, charAt,
substring,
substr4
class, struct,
class,
no disponible
union
interface NUEVA
NUEVA
Structure
<miembros> End
Structure
no disponible
__interface
Sub New()5
no disponible
Constructores, o
Constructores
constructores de
(concepto, no
tipos predeterminados palabra clave)
del sistema
no disponible
no disponible
Finalize NUEVA (En destructor
Visual Basic 6.0,
Class_Terminate)
finalize
evento Init
constructores
(concepto, no
palabra clave)
constructor
(concepto, no
palabra clave)
~ClassName
no disponible
no disponible
destructor
no disponible
evento Destroy
6
23
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
no
utilizados
reclame un
objeto7
Inicializar Dim x As Long = 5 // inicializar con un int x = 5;
int x=5;
una variable
valor:
donde se
Dim c As New
//or initialized by
declara
Car(FuelTypeEnum. int x = 123;
constructor
Gas)
// o utilizar el
C c(10);
constructor
predeterminado:
int x = new int();
Tomar la
AddressOf (para
delegate
dirección de los miembros de
una función clase, este
operador devuelve
una referencia a
una función en el
formulario de una
instancia de
delegado)
Devolución
no disponible
no disponible
de llamada
Declarar que no disponible
un objeto se
puede
modificar de
forma
asincrónica
Forzar la
Option Explicit
var x = 5
no disponible
var y : car =
new car()
no disponible
__delegate
Utilice el
nombre de la
función sin
paréntesis
no disponible
CALLBACK (tipo
estándar);
callback
(atributo IDL)
no disponible
no disponible
volatile
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.
volatile
volatile
no disponible
no disponible
no disponible. Es
no disponible. Es
no disponible.
modo rápido
_VFP.LanguageOp
24
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
declaración
explícita de
variables
preciso declarar
preciso declarar
todas las variables todas las variables
antes de utilizarlas. antes de
utilizarlas.
(activada de
tions
manera
predeterminada)
pObj == 0
Es preciso
declarar todas
las variables
antes de
utilizarlas.
pobj == NULL
Probar una
obj = Nothing
variable
objeto que
no hace
referencia a
un objeto
Valor de una Nothing
variable
objeto que
no hace
referencia a
un objeto
Probar una
IsDbNull
expresión de
tipo null de
una base de
datos
obj == null
Null
null
no disponible
null
Probar si
no disponible
una variable
Variant se
ha
inicializado
Definir una Default NUEVA
propiedad
predetermina
da
no disponible
NUEVA
obj == undefined EMPTY();
ISNULL()
obj == null
no disponible
undefined
no disponible
Compatible con
no disponible
diversos tipos de
datos del espacio
de nombres
System.Data.SqlType
s
no disponible
no disponible
utilizar indizadores [System::Reflection no disponible
::DefaultMember("Na
me")]
x == null
ISNULL( )
x == undefined
EMPTY( )
no disponible
no disponible
4. Programación orientada a objetos
Propósito
Hacer referencia a
una clase base
Palabra clave en Visual Palabra clave Palabra clave en Palabra clave
Palabra clave en
NUEVO
Basic
en C#
Java
en C++
JScript
NUEVA
NUEVA
MyBase
base
__super
super
super
Palabra clave en Visual
FoxPro
BaseClass property;
ParentClass property;
25
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
NUEVA
Declarar una
Interface
interfaz
Especificar una
Implements (instrucción)
interfaz para que se
implemente
NUEVA
DODEFAULT()
DEFINE CLASS
interface
interface
__interface
Interface
class C1 : I1
implements
(cláusula en una
declaración de
clase)
Sólo hay que
derivar de la
interfaz.
implements NUEVA
IMPLEMENTS NUEVA
class NUEVA
DEFINE CLASS MyClass
AS <BaseClass>
no disponible
class C1 :
public I1
class
Declarar una clase Class NUEVA
<implementación>
Especificar que una MustInherit NUEVA
clase sólo se puede
heredar. No se
puede crear una
instancia de la
clase.
Especificar que una NotInheritable NUEVA
clase no se puede
heredar
class
class
abstract
abstract
__abstract8 (sólo abstract NUEVA
en extensiones
administradas
de C++)
sealed
final
final NUEVA
no disponible
Declarar un tipo
enumerado
Declarar una
constante de clase
Enum <miembros> End
Enum
Const
enum
no disponible
__sealed (sólo
en extensiones
administradas
de C++)
enum
enum NUEVA
no disponible
const
const NUEVA
#DEFINE
Derivar una clase
de una clase base
Inherits C2 NUEVA
const (se aplica a static final (se
una declaración aplica a una
de campo)
declaración de
campo)
clase C1 : C2
class C1 extends
C2
Clase C1 : base class c1 extends
pública (No se c2 NUEVA
requiere
ninguna palabra
clave para esta
finalidad)
DEFINE CLASS MyClass
AS ParentClass
26
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Reemplazar un
método
Overrides NUEVA
Declarar un método MustOverride NUEVA
que se debe
implementar en una
clase que se deriva
override
abstract
No se requiere
ninguna palabra
clave para esta
finalidad
abstract
Declarar un método NotOverridable NUEVA (Los sealed
que no se puede
métodos no se reemplazan
reemplazar
de forma predeterminada.)
final
Declarar un
Overridable
método, una
propiedad (Visual
Basic) o un
descriptor de acceso
a propiedad (C#,
C++) virtual
Declarar una
Delegate NUEVA
referencia con
seguridad de tipos a
un método de una
clase
Especificar que una WithEvents
variable puede
contener un objeto
cuyos eventos se
desea controlar
Especificar los
Handles NUEVA(Los
eventos para los
procedimientos de evento
que se llamará a un se pueden seguir asociando
virtual
Los métodos son
virtuales de forma
predeterminada
delegate
no disponible
No se requiere
ninguna palabra
clave para esta
finalidad
Poner = 0 al
final de la
declaración
(método virtual
puro)
__sealed (sólo
en extensiones
administradas
de C++)
virtual
No se requiere
No se requiere ninguna
ninguna palabra clave palabra clave para esta
para esta finalidad
finalidad
abstract NUEVA
No se requiere ninguna
palabra clave para esta
finalidad
final NUEVA
no disponible
Los métodos son
virtuales de forma
predeterminada
no disponible
__delegate (sólo Utilice el nombre de
en extensiones la función sin
administradas paréntesis
de C++)
no disponible
Escribir código. no disponible
No hay una
palabra clave
específica
no disponible
Escribir código. No EVENTHANDLER( )
hay una palabra clave NUEVA
específica
no disponible
no disponible
no disponible
no disponible
no disponible
27
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
procedimiento de
evento.
a una variable WithEvents
mediante el modelo de
nomenclatura)
Evaluar una
With objExpr <.miembro> no disponible
expresión de objeto <.miembro> End With
una vez para tener
acceso a varios
miembros
no disponible
no disponible
with9
WITH…ENDWITH
5. Control de excepciones
Propósito
Palabra clave en
Visual Basic
NUEVA
Control estructurado Try
de excepciones
<attempt>
Catch
<handle errors>
Finally
<always execute>
End Try
Control de
no disponible
excepciones de C++
Palabra clave en Palabra clave en Palabra clave en Palabra clave en Palabra clave en Visual
C# NUEVO
Java
C++
JScript
FoxPro
try, catch, finally, Try, catch,
__try, __except, try, catch, finally, ONERROR( ),
throw
__finally
throw
COMRETURNERROR( ),
finally, throw
ERROR(); MESSAGE(),
AERROR()
no disponible
no disponible
try, catch, throw No disponible
no disponible
28
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
6. Estructuras de decisión
Propósito
Palabra clave en
Visual Basic
Estructura de decisión Select Case …, Case,
(selección)
Case Else, End Select
Estructura de decisión
(if ... then)
Estructura de bucle
(condicional)
Estructura de bucle
(iteración)
Palabra clave en
C# NUEVO
switch, case,
default, goto,
break
if, else
Palabra clave en Palabra clave en Palabra clave en
Palabra clave en
Java
C++
JScript
Visual FoxPro
switch, case,
switch, case, break CASE
switch, case,
break; default;
default, goto,
break;
if, else
if, else
if, else
IF ... ENDIF
If … Then, ElseIf …
Then, Else, End If
While, Do [While,
do, while, continue do, while,
Until] …, Loop [While,
continue
Until]
For …, [Exit For,] Next for, foreach
for, break
do, while, continue do, while, break,
continue
for
For Each …, [Exit
For,] Next
DO, WHILE
(cláusulas)
for
FOR (cláusulas),
(x=0;x<10;x++){…} FOR … ENDFOR,
Continue, Next
for (prop in obj) {
print (obj[prop]);}
7. Matrices
Propósito
Palabra clave en
Visual Basic
Dim a() As Long
Palabra clave en
C# NUEVO
Declarar una matriz
int[] x = new
int[5];
Inicializar una matriz Dim a() As Long = {3, int[] x = new
4, 5}
int[5] {1, 2, 3, 4,
5};
Reasignar matriz
ReDim
no disponible
Palabra clave en
Java
int[] x = new
int[5];
int[] x = new int[]
{1,2,3,4,5};
no disponible
Palabra clave en
Palabra clave en
C++
JScript
int x[5];
var x : int[], var arr =
Array()
int x[5]=
var x : int[] = [1, 2, 3, 4,
{1,2,3,4,5};
5], var arr = new
Array(1, 2, 3, 4, 5)]
no disponible
arr.length=newSize(sólo
para matrices de
JScript)10
Palabra clave en
Visual FoxPro
DIMENSION,
DECLARE
DIMENSION,
DECLARE
DIMENSION,
DECLARE
29
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
8. Ámbito de clase
Propósito
Palabra clave en
Visual Basic
Public
Visible fuera del
proyecto o del
ensamblado
Invisible outside the Friend
assembly (C#/Visual
Basic) or within the
package (Java,
JScript)
Sólo visible dentro
Private
del proyecto (para
clases anidadas,
dentro de la clase
envolvente)
Palabra clave en Palabra clave en Palabra clave en Palabra clave en
Palabra clave en
NUEVO
C#
Java
C++
JScript
Visual FoxPro
NUEVA
public
public
public
public
PUBLIC
internal
private
Al omitir la
private
palabra clave del
ámbito se
especifica "ámbito
del paquete"
private
private
internal NUEVA
no disponible
private NUEVA
HIDDEN
9. Ámbito de miembro
Propósito
Palabra clave en
Visual Basic
Accesible desde fuera de Public
la clase y del proyecto
(Java/JScript/C++/Visual
Basic) o del módulo
(Visual Basic)
Accesible desde fuera de Friend
la clase, pero desde
dentro del proyecto (C#,
Visual Basic, C++) o del
paquete (Java, JScript)
Accesible sólo desde
Private
dentro de la clase
Palabra clave en Palabra clave en Palabra clave en Palabra clave en Palabra clave en
C# NUEVO
Java
C++
JScript
Visual FoxPro
NUEVA
public
public
public
public
PUBLIC
internal
private
Al omitir la
public private:
palabra clave del
ámbito se
especifica "ámbito
del paquete"
private
private
internal NUEVA
no disponible
private NUEVA
HIDDEN
30
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
(Java/JScript/C++/Visual
Basic) o del módulo
(Visual Basic)
Accesible sólo para
Protected NUEVA
clases actuales y
derivadas
Especificar que una
no disponible
función u otra clase tiene
acceso a miembros
privados de la clase que
se declara
Protegido dentro del
no disponible
ensamblado y privado
para los demás
ensamblados
protected
protected
protected
protected NUEVA
PROTECTED
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
friend (no se
permite en las
extensiones
administradas de
C++)
protected
private:
(Sólo en las
extensiones
administradas de
C++)
no disponible
no disponible
10. Varios Período de duración
Propósito
Palabra clave en
Visual Basic
Static11
Conservar las
variables locales de
un procedimiento
Compartido por todas Shared NUEVA
las instancias de una
clase.
Palabra clave en Palabra clave en Palabra clave en Palabra clave en
Palabra clave en
C# NUEVO
Java
C++
JScript
Visual FoxPro
no disponible
static
no disponible
static
PRIVATE
static
static
static
static NUEVA
no disponible
11. Varios
Propósito
Comentar código
Palabra clave en
Visual Basic
'
Palabra clave en Palabra clave en Palabra clave en Palabra clave en
Palabra clave en
C# NUEVO
Java
C++
JScript
Visual FoxPro
//, /* */ for
//
//, /* */ para
//, /* */ for multiline *; &&
31
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Rem
multiline
comments
/// for XML
comments
/**
comentarios de
varias líneas
comments
Sí
Sí
No
no disponible
no disponible
DECLARE - DLL
no disponible
no disponible
no disponible
*/
/*
Distinguir mayúsculas No
de minúsculas
Lamar a la API de
Declare <API>
Windows
Declarar y provocar Event, RaiseEvent
un evento.
Tipos primitivos de SyncLock
subprocesamiento
Sí
*/
Sí
Utilizar invocación Llamar
de la plataforma
directamente
event
__event
lock
Está en las clases
no disponible
no disponible
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.
32
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
33
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
C# NUEVO
Visual Basic
Aditivo
Suma
Resta
Multiplicativo
Multiplicación
División
División de número entero
Módulo (división que
devuelve sólo el resto)
Java
C++
JScript
Visual FoxPro
+
-
+
-
+
-
+
-
+
-
+
-
*
/
\
Mod
*
/
/1
%
*
/
no disponible
%
*
/
*
/
*
/
%
%; Mod
Exponenciación
Asignación
Asignación
Suma
Resta
Multiplicación
División
División de número entero
Concatenar
^
no disponible
no disponible
% (también
funciona con
punto flotante)
no disponible
=
+= NUEVO
-= NUEVO
*= NUEVO
/= NUEVO
\= NUEVO
&= NUEVO
=
+=
-=
*=
/=
/=1
+=
=
+=
-=
*=
/=
no disponible
+=
=
+=
-=
*=
/=
no disponible
=
+=
-=
*=
/=
no disponible
+=
Módulo
Desplazamiento a la
izquierda
no disponible
no disponible
%=
<<=
%=
<<=
%=
<<=
%=
<<=
=
+
*
/
no disponible
+
$
%
BITLSHIFT( )
^, **
34
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Desplazamiento a la derecha
AND bit a bit
OR exclusivo bit a bit
Bitwise-inclusive-OR
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.
Comparar el tipo de
referencia de objeto
no disponible
no disponible
no disponible
no disponible
>>=
&=
^=
|=
>>=
&=
^=
|=
>>=
&=
^=
|=
>>=
&=
^=
|=
BITRSHIFT( )
BITAND( )
BITXOR( )
BITOR( )
<
<=
>
>=
=
<>
Is
<
<=
>
>=
==
!=
==
<
<=
>
>=
==
!=
==
<
<=
>
>=
==
!=
no disponible
<
<=
>
>=
==
!=
==
<
<=
>
>=
=
<>; #; !=
COMPOBJ()
TypeOf x es
Class1
instanceof
no disponible
Comparar cadenas
=
x is Class1 (vea x instanceof
no disponible
también as y
Class1
typeof)
==
String.equals() Existen
funciones para
comparar y
-orconcatenar
String.Equals()
cadenas
+
+
&&
&&
&&
==
=
+
&&
+
no disponible
||
||
||
||
no disponible
<<
<<
<<
<<
no disponible
>>
>>
>>
>>, >>>
no disponible
Concatenar cadenas
&
AND booleano
AndAlso
cortocircuitado
OR booleano cortocircuitado OrElse
Desplazamiento
Desplazamiento a la
no disponible
izquierda
Desplazamiento a la derecha no disponible
Resolución de ámbito
35
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Resolución de ámbito
Postfijo2
Elemento de matriz
Llamada a función
Conversión de tipos
.
. y base
no disponible
::
no disponible
::
()
()
Cint, CDbl, …,
CType
.
no disponible
no disponible
[]
()
(tipo)
[]
()
(tipo)
[]
()
(tipo)
[]
()
tipo()
[ ]; ()
()
no disponible
.
++
--
.
++
--
. O bien ->
++
--
.
++
--
.
no disponible
no disponible
no disponible
*
no disponible
no disponible
no disponible
&
no disponible
no disponible
!
~
++
-no disponible
,
!
~
++
-Sizeof
,
!
~
++
-no disponible
,
!
BITNOT( )
no disponible
no disponible
no disponible
no disponible
Selección de miembro
Postfijo de incremento
Postfijo de decremento
Unario3
Direccionamiento indirecto no disponible
Dirección de
AddressOf
NOT lógico
Complemento de uno
Prefijo de incremento
Prefijo de decremento
Tamaño de tipo
coma
Bit a bit
AND bit a bit
OR exclusivo bit a bit
OR inclusivo bit a bit
Lógico
AND lógico
OR lógico
Condicional
Condicional
Not
Not
no disponible
no disponible
no disponible
no disponible
* (sólo modo
unsafe)
& (sólo modo
unsafe; vea
también fixed)
!
~
++
-sizeof
no disponible
And
Xor
Or
&
^
|
&
^
|
&
^
|
&
^
|
BITAND( )
BITXOR( )
no disponible
And
Or
&&
||
&&
||
&&
||
&&
||
AND
OR
?:
?:
?:
no disponible
IIf Function () ?:
36
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Puntero a miembro
Puntero a miembro
no disponible
Referencia
Referencia
no disponible
. (sólo modo
Unsafe)
no disponible
.* o bien ->
no disponible
no disponible
no disponible
no disponible
&
no disponible
@
(utilizar tipos de
referencia)
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
Visual Basic
almacenamiento
16 bytes
no disponible
Decimal
Decimal NUEVO
(clase de .NET
Framework)
Fecha
Date NUEVO (clase de
.NET Framework)
(tamaño variable)
1 byte
2 bytes
2 bytes
C# NUEVO
Java
Visual C++
JScript
Visual FoxPro
no disponible
decimal
no disponible
no disponible
VARIANT
DECIMAL
Object
decimal NUEVO
DateTime NUEVO
(clase de .NET
Framework)
java.util.Date
DATE
java.lang.String
no disponible
System.DateTime. Date; DateTime
También el objeto
Date. para fechas en
JScript.
String NUEVO
no disponible
byte
Boolean
short
BYTE, bool
VARIANT_BOOL
signed short int,
__int16
String NUEVO (clase string
de .NET
Framework)
Byte
byte
Boolean
bool
Short, Char (carácter short, char (carácter
Unicode)
Unicode)
byte NUEVO
boolean NUEVO
short NUEVO, char
Variant
no disponible
Lógico
no disponible
no disponible
NUEVO
37
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
1 byte
4 bytes
no disponible
Integer
int
char
int
8 bytes
4 bytes
8 bytes
4 bytes en tabla
Long NUEVO
Single
Double
no disponible
long
float
double
no disponible
long
float
double
no disponible
signed char, __int8
long, (long int, signed
long int)
__int64
float
double
no disponible
Sbyte NUEVO
int NUEVO
Character
Integer
long NUEVO
float NUEVO
double NUEVO
no disponible
Tipo Float
no disponible
Double
General
38
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
Control de
Control de servidor
servidor ASP.NET
HTML NUEVO
Clase de MFC
Clase de ATL
Objeto de Visual
FoxPro
NUEVO
NUEVO
ComboBox
ImageCombo
CheckBox
ComboBox
ComboBox
ComboBox
CommandButton
Button
Frame
OptionButton
GroupBox, Panel
RadioButton
CommonDialog
FileDialog,
PrintDialog,
ColorDialog,
FontDialog
ListBox
ListBox
Clases en System.IO no disponible
HscrollBar,
no disponible
VscrollBar
no disponible
no disponible
Label
Label
TextBox
TextBox
MainMenu,
no disponible
ListBox
FileSystemObject
HScrollBar,
VScrollBar
COOLBar
Label
TextBox
Menu
DropDownList
no disponible
CheckBox,
CheckBoxList
Button, LinkButton,
ImageButton
Panel
RadioButton,
RadioButtonList
no disponible
no disponible
no disponible
HtmlInputCheckBox
CComboBox
CComboBoxEx
CButton
no disponible
no disponible
no disponible
ComboBox
Image
CheckBox
HtmlInputButton,
CButton
HtmlButton
no disponible
no disponible
HtmlInputRadioButton CButton
no disponible
CommandButton
no disponible
no disponible
no disponible
CCommonDialog
no disponible
no disponible
OptionButton;
OptionGroup
CommonDialog;
GETFILE( ;
GETDIR( )
HtmlSelect
no disponible
no disponible
CListBox
CFile
CScrollBar
no disponible
no disponible
no disponible
ListBox
Varios functions
no disponible
no disponible
no disponible
HtmlInputText
no disponible
CRebarCtrl
CStatic
CEdit
CMenu
no disponible
no disponible
no disponible
no disponible
Toolbar
Label
TextBox; EditBox
Comandos de menú
39
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
Form
ContextMenu
Las imágenes en los no disponible
controles admiten
GIF animados
Form
no disponible
Timer
DataGrid
Timer
DataGrid
DateTimePicker
ImageList
ListView
Internet Transfer
DateTimePicker
ImageList
ListView
Clases en
System.Net
MonthCalendar
Animation
MonthView
ProgressBar
PictureBox
RichTextBox
SSTab, TabStrip
StatusBar
Slider
Toolbar
TreeView
UpDown
WinSock
ProgressBar
PictureBox
RichTextBox
TabControl
StatusBar
Trackbar
Toolbar
TreeView
NumericUpDown,
DomainUpDown
Clases en
System.Net
no disponible
CAnimateCtrl
no disponible
no disponible
HtmlForm
CDialog,
CFormView
Form; FormSet
no disponible
DataGrid, DataList,
Repeater
no disponible
no disponible
no disponible
no disponible
no disponible
HtmlTable
CWnd::SetTimer
no disponible
CDialogImpl,
CWindow,
CWindowImpl
no disponible
no disponible
no disponible
no disponible
no disponible
HtmlInputFile
no disponible
no disponible
no disponible
no disponible
no disponible
ImageList
ListView
Explorador Web
Calendar
no disponible
CDateTimeCtrl
CImageList
CListCtrl
CHttpConnection,
CFtpConnection
CMonthCalCtrl
no disponible
no disponible
Image
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
HtmlInputImage
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
CProgressCtrl
CPictureHolder
CRichEditCtrl
CTabCtrl
CStatusBarCtrl
CSliderCtrl
CToolBarCtrl
CTreeCtrl
CSpinButtonCtrl
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
no disponible
ActiveX Calendar;
MonthView
ProgressBar
no disponible
RichTextBox
SSTab
StatusBar
Slider
Toolbar
TreeView
Spinner
no disponible
no disponible
CSocket
no disponible
WinSock
Timer
Cuadrícula
40