apuntes sobre c# - chsos20112906536.files.wordpress.com · apuntes sobre c# y comparación otros...
Post on 23-Dec-2018
220 Views
Preview:
TRANSCRIPT
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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:
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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)
{
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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;
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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]);
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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)
{
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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();
} } } }
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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);
}
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
13
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");
}
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++;
}
}
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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;
}
}
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
15
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
}
}
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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();
}
}
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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)
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.")
}
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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)
no disponible no disponible
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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;
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
29
6. Estructuras de decisión
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
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
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 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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
30
8. Ámbito de clase
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
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
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
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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++)
no disponible no disponible
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++)
no disponible no disponible
10. Varios Período de duración
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
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
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
Comentar código ' //, /* */ for // //, /* */ para //, /* */ for multiline *; &&
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
no disponible no disponible
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.
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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.
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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( )
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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ú
APUNTES SOBRE C# y comparación otros lenguajes
Carlos Hernán Gómez G.
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
top related