Tipos de Usuario.

Si tienes el tamaño del array y sabes que es un array de tipo char ¿porqué no
haces algo como esto?:
(variable es la que contiene el tamaño del array)
char[] unArray = new char[variable];
Aunque debes tener en cuenta que los arrays de .NET siempre empiezan por el
índice 0, por tanto esa declaración creará elementos que van desde 0 hasta
variable-1

Nos vemos.
Guillermo
Microsoft VB MVP desde 1997
Te invito a mi sitio dedicado al VB y más...
http://www.elguille.info/
http://www.mundoprogramacion.com/
(puede que el correo usado sea anti-spam)


"Vas" wrote in message
news:090a01c56741$f0c1e020$
Hi grupo, haber si me podeis hechar una mano. Estoy
migrando una aplicación de delphi a C# y me he encontrado
con una "chorrada" que me ha dejado un poco afuscado.
Tengo una librería externa para la cual me he creado una
clase implementando las llamadas externas a través
de "dllimport", y en su versión delphi ténía definido 3
tipos de usuario con arrays tipo "char".

Pues bien, no he encontrado forma "decente" de crear
tipos "similares" en c#, algo tan sencillo como tener una
constante tipo int que guarda el tamaño del array y un
tipo de usuario que dimensiona un array tipo char con la
longitud de la constante, algo así:

constante "nombre" = 256;
tipo "nombretipo" = array [1..constante] de char.

Bueno, espero no haber sido muy "chapas" en la exposición
y si alguien tiene alguna idea, gracias de antemano.

PD: Actualmente lo he resuelto de una manera
bastante "chapucera", pero bueno.

El problema es que lo tengo que usar como tipo definido
por usuario ya que tengo que pasarselos a las
declaraciones de funciones de la Dll. No se si me explico,
si quereis puedo publicar el "cacho" en concreto.

Gracias de antemano.

Si tienes el tamaño del array y sabes que es un array de

tipo char ¿porqué no

haces algo como esto?:
(variable es la que contiene el tamaño del array)
char[] unArray = new char[variable];
Aunque debes tener en cuenta que los arrays de .NET

siempre empiezan por el

índice 0, por tanto esa declaración creará elementos que

van desde 0 hasta

variable-1

Nos vemos.
Guillermo
Microsoft VB MVP desde 1997
Te invito a mi sitio dedicado al VB y más...
http://www.elguille.info/
http://www.mundoprogramacion.com/
(puede que el correo usado sea anti-spam)


"Vas" wrote in message
news:090a01c56741$f0c1e020$
Hi grupo, haber si me podeis hechar una mano. Estoy
migrando una aplicación de delphi a C# y me he encontrado
con una "chorrada" que me ha dejado un poco afuscado.
Tengo una librería externa para la cual me he creado una
clase implementando las llamadas externas a través
de "dllimport", y en su versión delphi ténía definido 3
tipos de usuario con arrays tipo "char".

Pues bien, no he encontrado forma "decente" de crear
tipos "similares" en c#, algo tan sencillo como tener una
constante tipo int que guarda el tamaño del array y un
tipo de usuario que dimensiona un array tipo char con la
longitud de la constante, algo así:

constante "nombre" = 256;
tipo "nombretipo" = array [1..constante] de char.

Bueno, espero no haber sido muy "chapas" en la exposición
y si alguien tiene alguna idea, gracias de antemano.

PD: Actualmente lo he resuelto de una manera
bastante "chapucera", pero bueno.


.

VAS,

a) Esa definición de cadenas estilo Pascal viene de tiempos en los que la
necesidad de economizar el espacio era grande. En C# y otros lenguajes
modernos para representar cadenas se utiliza el tipo String, sin necesidad
de indicar estáticamente cuál será la longitud máxima que va a tener.

b) En C# cuando una función recibe un String le puedes pasar una cadena de
la logitud que sea. Incluso si la función recibe un array, no hay necesidad
de indicar la cantidad máxima de elementos que este podrá tener:

public static void Main(string[] args) // no se indica la dimensión
máxima !
{

Hay muchos cambios de filosofía que tendrás que asimilar. En este caso
particular, estoy casi seguro de que esos tres tipos de que hablas los
puedes eliminar sin peligro alguno...

Slds - Octavio

"Vas" escribió en el mensaje
news:090a01c56741$f0c1e020$
Hi grupo, haber si me podeis hechar una mano. Estoy
migrando una aplicación de delphi a C# y me he encontrado
con una "chorrada" que me ha dejado un poco afuscado.
Tengo una librería externa para la cual me he creado una
clase implementando las llamadas externas a través
de "dllimport", y en su versión delphi ténía definido 3
tipos de usuario con arrays tipo "char".

Pues bien, no he encontrado forma "decente" de crear
tipos "similares" en c#, algo tan sencillo como tener una
constante tipo int que guarda el tamaño del array y un
tipo de usuario que dimensiona un array tipo char con la
longitud de la constante, algo así:

constante "nombre" = 256;
tipo "nombretipo" = array [1..constante] de char.

Bueno, espero no haber sido muy "chapas" en la exposición
y si alguien tiene alguna idea, gracias de antemano.

PD: Actualmente lo he resuelto de una manera
bastante "chapucera", pero bueno.

He intentado realizarlo convirtiendo las variables y tipos
delphi a los que creo que se deben utilizar en C#,
cambiando los "pchar" por "strings" los "LongInt"
por "long", etc, pero las llamadas a funciones de la
dll "petan". Os pongo la definición de una de la funciones
originales de delphi, haber si se os ocurre algo.

procedure PI_OpenValidIndexBase
(IBS:IBSType;IndexBaseName:PChar;SeatNumber:LongInt;
Buffer:Pointer;BufferSize:LongInt;UserID:LongInt;var
ErrorCode:LongInt);
stdcall; far; external 'pi_w32.dll';

Yo estoy utilizando para la "traducción" a C# las
definiciones basadas en "DllImport", cambiando sus
definiciones, como por ejemplo "IBSType" que es un array
de char en Delphi, yo lo cambio por "string", etc, aunque
con el tema de los punteros ando un poco perdido.

Bueno, os agradezco mucho vuestras respuestas una vez más,
y si teneis cualquier idea, pues agradecido de que la
compartais, un saludo, VAS.

VAS,

a) Esa definición de cadenas estilo Pascal viene de

tiempos en los que la

necesidad de economizar el espacio era grande. En C# y

otros lenguajes

modernos para representar cadenas se utiliza el tipo

String, sin necesidad

de indicar estáticamente cuál será la longitud máxima que

va a tener.

b) En C# cuando una función recibe un String le puedes

pasar una cadena de

la logitud que sea. Incluso si la función recibe un

array, no hay necesidad

de indicar la cantidad máxima de elementos que este podrá

tener:

public static void Main(string[] args) // no se

indica la dimensión

máxima !
{

Hay muchos cambios de filosofía que tendrás que asimilar.

En este caso

particular, estoy casi seguro de que esos tres tipos de

que hablas los

puedes eliminar sin peligro alguno...

Slds - Octavio

"Vas" escribió en el mensaje
news:090a01c56741$f0c1e020$
Hi grupo, haber si me podeis hechar una mano. Estoy
migrando una aplicación de delphi a C# y me he encontrado
con una "chorrada" que me ha dejado un poco afuscado.
Tengo una librería externa para la cual me he creado una
clase implementando las llamadas externas a través
de "dllimport", y en su versión delphi ténía definido 3
tipos de usuario con arrays tipo "char".

Pues bien, no he encontrado forma "decente" de crear
tipos "similares" en c#, algo tan sencillo como tener una
constante tipo int que guarda el tamaño del array y un
tipo de usuario que dimensiona un array tipo char con la
longitud de la constante, algo así:

constante "nombre" = 256;
tipo "nombretipo" = array [1..constante] de char.

Bueno, espero no haber sido muy "chapas" en la exposición
y si alguien tiene alguna idea, gracias de antemano.

PD: Actualmente lo he resuelto de una manera
bastante "chapucera", pero bueno.


.

Perdona, vas, no me di cuenta de que quierías llamar la DLL de Delphi desde
C#.
Te diré que el asunto es bastante complicado:

a) en Delphi un array es lo que en .NET diríamos un "tipo-valor" que se
almacena en el lugar, y cuando lo pasas por valor se mete en la pila el
array completo, y no un referencia, como ocurriría en C#. Además en C# se
utiliza UNICODE para representar los caracteres y en Delphi ASCII.

Para definir un tipo compatible con:

IBS5 = array [1..5] of char.

creo que tendrías que hacer esto:

[StructLayout(LayoutKind.Sequential, Pack=1)] // para que los bytes queden
"pegaditos" en memoria
public struct IBS5 // estructura (tipo valor) y no clase (tipo ref)
{
byte c1; // tantos como caracteres tiene el array Delphi
byte c2; // no puedes usar el array de C#, que es tipo-referencia
byte c3;
byte c4;
byte c5;
// constructor para simplificar el manejo
public IBS5(string s)
{
if (s.Length >= 1) c1 = (char) s[0] else c1 = 0;
if (s.Length >= 2) c2 = (char) s[1] else c2 = 0;
if (s.Length >= 3) c3 = (char) s[2] else c3 = 0;
if (s.Length >= 4) c4 = (char) s[3] else c4 = 0;
c5 = 0;
}
}

Para crear e inicializar con el valor 'Hola':

IBS5 hola = new IBS5("Hola");

Esto ya podrías pasarlo por valor como parámetro.

b) Debes tener en cuenta también que el convenio de paso de parámetros
predeterminado en Delphi es 'register', que no es estándar. Deberías
redefinir los métodos en Delphi utilizando la directiva stdcall:

procedure Prueba(cadena: IBS5); stdcall;

y recompilar la DLL. Luego en en C# puedes indicar que vas a utilizar el
convenio estándar de paso de parámetros mediante uno de los argumentos del
atributo DllImport.

En C# 2.0 será más fácil esto, mira el siguiente artículo de E. Gunnerson:

http://blogs.msdn.com/ericgu/archiv...13676.aspx

Salu2,

Octavio

"vas" escribió en el mensaje
news:0db601c56815$c7514080$
He intentado realizarlo convirtiendo las variables y tipos
delphi a los que creo que se deben utilizar en C#,
cambiando los "pchar" por "strings" los "LongInt"
por "long", etc, pero las llamadas a funciones de la
dll "petan". Os pongo la definición de una de la funciones
originales de delphi, haber si se os ocurre algo.

procedure PI_OpenValidIndexBase
(IBS:IBSType;IndexBaseName:PChar;SeatNumber:LongInt;
Buffer:Pointer;BufferSize:LongInt;UserID:LongInt;var
ErrorCode:LongInt);
stdcall; far; external 'pi_w32.dll';

Yo estoy utilizando para la "traducción" a C# las
definiciones basadas en "DllImport", cambiando sus
definiciones, como por ejemplo "IBSType" que es un array
de char en Delphi, yo lo cambio por "string", etc, aunque
con el tema de los punteros ando un poco perdido.

Bueno, os agradezco mucho vuestras respuestas una vez más,
y si teneis cualquier idea, pues agradecido de que la
compartais, un saludo, VAS.

VAS,

a) Esa definición de cadenas estilo Pascal viene de

tiempos en los que la

necesidad de economizar el espacio era grande. En C# y

otros lenguajes

modernos para representar cadenas se utiliza el tipo

String, sin necesidad

de indicar estáticamente cuál será la longitud máxima que

va a tener.

b) En C# cuando una función recibe un String le puedes

pasar una cadena de

la logitud que sea. Incluso si la función recibe un

array, no hay necesidad

de indicar la cantidad máxima de elementos que este podrá

tener:

public static void Main(string[] args) // no se

indica la dimensión

máxima !
{

Hay muchos cambios de filosofía que tendrás que asimilar.

En este caso

particular, estoy casi seguro de que esos tres tipos de

que hablas los

puedes eliminar sin peligro alguno...

Slds - Octavio

"Vas" escribió en el mensaje
news:090a01c56741$f0c1e020$
Hi grupo, haber si me podeis hechar una mano. Estoy
migrando una aplicación de delphi a C# y me he encontrado
con una "chorrada" que me ha dejado un poco afuscado.
Tengo una librería externa para la cual me he creado una
clase implementando las llamadas externas a través
de "dllimport", y en su versión delphi ténía definido 3
tipos de usuario con arrays tipo "char".

Pues bien, no he encontrado forma "decente" de crear
tipos "similares" en c#, algo tan sencillo como tener una
constante tipo int que guarda el tamaño del array y un
tipo de usuario que dimensiona un array tipo char con la
longitud de la constante, algo así:

constante "nombre" = 256;
tipo "nombretipo" = array [1..constante] de char.

Bueno, espero no haber sido muy "chapas" en la exposición
y si alguien tiene alguna idea, gracias de antemano.

PD: Actualmente lo he resuelto de una manera
bastante "chapucera", pero bueno.


.