SoloCodigo

Puede que estes usando punteros para editar valores, pero por algun motivo estas editando la memoria fuera del tamaño de esos valores, si postearas codigo seria mucho mas facil saber que puede ser.

Hola, la clase string posee una funcion llamada Split, una de las sobrecargas es pasar un caracter, y retornara un arrglo de strings que seran todos los strings obtenidos luego de separar el string principal usando el caracter.

por ejemplo
using (StreamReader reader = new StreamReader("registros.txt"))
{
      while(reader.Peek() > 0)
      {
             string[] datos = reader.ReadLine().Split(';');
             if(datos.Length > 1)
             {
                    //procesas datos[0]
             }
      }
}

 

La verdad no se si hay maneras mas 'fáciles' de hacerlo, quizás algún miembro con mas experiencia pueda ayudarte más, te daré un pequeño ejemplo, explica más que 1000 palabras.

supondremos que hay un label en el form que se llama "label1"

public delegate void InvocacionCrossThread(string valor);
class form1 : Form
{
     public void ActualizarLabel1(string texto)
     {
          if(this.InvokeRequired)
          {
               InvocacionCrossThread actualizador = ActualizarLabel1();
               this.Invoke(actualizador, texto);
          }
          else
               label1.Text = texto;
     }
}

Hola a todos, lo que les queria pedir era su experiencia en cuanto a algoritmos "famosos" que hayan hecho, con una breve explicacion, cita o link sobre como funciona el algoritmo para intentar hacerlos, por ejemplo el metodo simplex que fue posteado; por alguna razon me interese bastante en esto, estoy estudiando un poco el algoritmo A* ultimamente(aunque es algo dificil de hacer global), y la verdad me interesa bastante el tema, espero no sea el unico tratando de re-hacer la misma rueda  gracias de antemano.
PD: Por si a alguien le interesa el algoritmo A* yo comence a entenderlo gracias a este articulo http://www.policyalmanac.org/games/aStarTutorial.htm y obviamente de otros sitios que voy viendo, pero principalmente ese.

Hola a todos.
Hoy vengo con algo un poco mas avanzado(no avanzado en nivel de programacion, sino que en cantidad ^^) a lo que antes habia puesto aqui.
Pasa que por alguna razon, MySql es excesivamente lento en mi pc(sobre 1 segundo para ejecutar un comando) y decidi hacer una base de datos con FileStreams, no soy muy experimentado como programador, por eso decidi postearlo aqui, porque quisiera comentarios de que esta mal, o el porque no es una buena idea(en caso de no serlo), que seria una buena idea para mejorarlo, etc...

Funciona de la siguiente manera.
-Se crea un archivo .map que contiene las ubicaciones de cada valor dentro del archivo, este se crea antes de usar la base de datos(como en Sql)
-Al crear la clase DBEngine, se escoge una Tabla(una carpeta donde estan los archivos y asi se obtienen los datos cargados previamente del .map)
-Se usa el metodo Select() para escoger un objeto (archivo sobre el cual actuara el FileStream), en este metodo se crea el FileStream.

2 metodos principales para escribir y leer, los demas son solo conversiones a otros tipos de variables.

DBEngine hereda la interface IDisposable para usar la palabra clave 'using' como con cualquier otro tipo de Stream

MappedFile.cs
    //Field vs offset vs Size
    using Map = Selector<string, int, int>;

    /// <summary>
    /// clase con los mapas de los archivos de la database
    /// </summary>
    internal class MappedFile
    {
        static bool hasLoadedMaps = false;
        const string MapsPath = "C:\\Database\\DBMaps\\";
        /// <summary>
        /// table name vs fileMap
        /// </summary>
        static Dictionary<string, Map> DBMaps = new Dictionary<string, Map>();
        static void GetMaps()
        {
            if (hasLoadedMaps)
                return;
            if (!Directory.Exists(MapsPath))
                Directory.CreateDirectory(MapsPath);
            foreach (string file in Directory.GetFiles(MapsPath))
            {
                if (file.EndsWith(".map"))
                {
                    Map map = new Map();
                    StreamReader sr = new StreamReader(file);
                    while (sr.Peek() > 0)
                    {
                        string line = sr.ReadLine();
                        if (line.Contains('='))
                        {
                            string[] field = line.Split('=');
                            map.TryAdd(field[0], int.Parse(field[1]), int.Parse(field[2]));
                        }
                    }
                    string mapName = file.Substring(MapsPath.Length);
                    mapName = mapName.Remove(mapName.Length - 4);
                    DBMaps.Add(mapName, map);
                }

            }
            hasLoadedMaps = true;
        }
        public static Selector<string, int, int> GetMap(string table)
        {
            if (!hasLoadedMaps)
                GetMaps();
            if (DBMaps.ContainsKey(table))
                return DBMaps[table];
            else
                throw new Exception("El mapa para la tabla " + table + " no ha sido creado!");
        }
    }

VariableType.cs
/// <summary>
    /// Contiene el tipo de la variable y su longitudo maxima como string mas el caracter '>'
    /// </summary>
    internal class VariableSize
    {
        public const int Int8 = 4,
        Int16 = 6,
        Int32 = 11,
        Int64 = 20,
        SmallString = 30,
        MediumString = 65,
        BigString = 100;
    }

DBEngine.cs
   public class DBEngine : IDisposable
    {
        /// <summary>
        /// Obtiene el nombre del objeto que se esta manipulando
        /// </summary>
        public string CurrentObject { get; private set; }
        /// <summary>
        /// obtiene el nombre de la tabla a la que pertenece el objeto que se esta manipulando
        /// </summary>
        public string CurrentTable { get; private set; }

        const char NullChar = '~';

        private Selector<string, int, int> FileMap;
        private FileStream fs;
        /// <summary>
        /// Crea una nueva instancia de DBEngine con la tabla seleccionada
        /// </summary>
        /// <param name="Object">tabla en la que se encuentra el objeto a manipular</param>
        public DBEngine(string Table)
        {
            FileMap = MappedFile.GetMap(Table);
            CurrentTable = Table;
        }

        /// <summary>
        /// Objeto a manipular por el DBEngine
        /// </summary>
        /// <param name="Object"></param>
        public DBEngine SelectObject(string Object)
        {
            CurrentObject = Object;
            fs = new FileStream(Constants.DatabaseFolder + CurrentTable + "\\" + CurrentObject + ".dbe", FileMode.OpenOrCreate);
            return this;
        }

        /// <summary>
        /// devuelve true si el objeto existe en la base de datos, o false si no exist
        /// </summary>
        /// <param name="Object"></param>
        /// <returns></returns>
        public bool Exist(string Object)
        {
            return File.Exists(Constants.DatabaseFolder + CurrentTable + "\\" + Object + ".dbe");
        }

        /// <summary>
        /// Escribe el campo 'field' a la variable 'value'
        /// </summary>
        /// <param name="value"></param>
        /// <param name="field"></param>
        public void Write(object value, string field)
        {
            int size;
            FileMap.TryGetValue(field, out size);
            lock (fs)
            {
                StringBuilder sb = new StringBuilder(value.ToString(), size);
                sb.Append(NullChar, size - value.ToString().Length);
                int offset;
                if (FileMap.TryGetKey2(field, out offset))
                {
                    byte[] writeBuffer = Encoding.ASCII.GetBytes(sb.ToString());
                    fs.Seek(offset, SeekOrigin.Begin);
                    fs.Write(writeBuffer, 0, size);
                    fs.Flush();
                }
                else
                    throw new Exception("El campo " + field + " no existe en la tabla " + CurrentTable);
            }
        }

        private string MainRead(string field, int length)
        {
            lock (fs)
            {
                int offset;
                FileMap.TryGetKey2(field, out offset);
                StringBuilder sb = new StringBuilder(length);
                fs.Seek(offset, SeekOrigin.Begin);
                for (int i = 0; i < length; i++)
                {
                    char e;
                    e = (char)fs.ReadByte();
                    if (e == NullChar)
                        break;
                    else
                        sb.Append(e);
                }
                return sb.ToString();
            }
        }

        public bool ReadBool(string field)
        {
            return ReadByte(field) == 1;
        }

        public byte ReadByte(string field)
        {
            return byte.Parse(MainRead(field, VariableSize.Int8));
        }

        public sbyte ReadSByte(string field)
        {
            return sbyte.Parse(MainRead(field, VariableSize.Int8));
        }

        public short ReadInt16(string field)
        {
            return short.Parse(MainRead(field, VariableSize.Int16));
        }

        public ushort ReadUInt16(string field)
        {
            return ushort.Parse(MainRead(field, VariableSize.Int16));
        }

        public int ReadInt32(string field)
        {
            return int.Parse(MainRead(field, VariableSize.Int32));
        }

        public uint ReadUInt32(string field)
        {
            return uint.Parse(MainRead(field, VariableSize.Int32));
        }

        public long ReadInt64(string field)
        {
            return long.Parse(MainRead(field, VariableSize.Int64));
        }

        public ulong ReadUInt64(string field)
        {
            return ulong.Parse(MainRead(field, VariableSize.Int64));
        }

        /// <summary>
        /// Lee un String de 30 caracteres
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public string ReadSmallString(string field)
        {
            return MainRead(field, VariableSize.SmallString);
        }

        /// <summary>
        /// Lee un string de 65 caracteres
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public string ReadMediumString(string field)
        {
            return MainRead(field, VariableSize.MediumString);
        }

        /// <summary>
        /// Lee un string de 100 caracteres
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public string BigString(string field)
        {
            return MainRead(field, VariableSize.BigString);
        }

        /// <summary>
        /// Escribe los nombres de los campos y les asigna el valor nullChar('~').
        /// </summary>
        public void Create()
        {
            int length;
            //int offset;
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            StringBuilder sb = new StringBuilder();
            foreach (string field in FileMap.Keys1)
            {
                FileMap.TryGetValue(field, out length);
                sb.Append(field + '=');
                sb.Append(NullChar, length);
                sb.Append(Environment.NewLine);
            }
            byte[] writeBuffer = Encoding.ASCII.GetBytes(sb.ToString());
            fs.Write(writeBuffer, 0, writeBuffer.Length);
            sw.Stop();
            Output.Line(sw.ElapsedMilliseconds + "-" + sw.ElapsedTicks);
        }

        public void Dispose()
        {
            try
            {
                fs.Dispose();
                fs.Close();
            }
            catch { }
        }
    }

tambien usa otra clase llamada Selector que son 3 ConcurrentDictionaries para tener valores que pueden ser obtenidos desde 2 claves distintas

    public class Selector<TKey1, TKey2, TValue>
    {
        ConcurrentDictionary<TKey1, TValue> Key1ToValue;
        ConcurrentDictionary<TKey2, TKey1> Key2ToKey1;
        ConcurrentDictionary<TKey1, TKey2> Key1ToKey2;

        public Selector()
        {
            Key1ToValue = new ConcurrentDictionary<TKey1, TValue>();
            Key2ToKey1 = new ConcurrentDictionary<TKey2, TKey1>();
            Key1ToKey2 = new ConcurrentDictionary<TKey1, TKey2>();
        }

        public bool TryGetValue(TKey1 key, out TValue value)
        {
            return Key1ToValue.TryGetValue(key, out value);
        }

        public bool TryGetValue(TKey2 key2, out TValue value)
        {
            TKey1 key1;
            if (Key2ToKey1.TryGetValue(key2, out key1))
                return Key1ToValue.TryGetValue(key1, out value);
            value = default(TValue);
            return false;
        }

        public bool TryGetKey1(TKey2 key2, out TKey1 value)
        {
            return Key2ToKey1.TryGetValue(key2, out value);
        }

        public bool TryGetKey2(TKey1 key1, out TKey2 value)
        {
            return Key1ToKey2.TryGetValue(key1, out value);
        }

        public bool TryAdd(TKey1 key1, TKey2 key2, TValue value)
        {
            return (Key1ToKey2.TryAdd(key1, key2) &&
                    Key1ToValue.TryAdd(key1, value) &&
                    Key2ToKey1.TryAdd(key2, key1));
        }

        public bool TryRemove(TKey1 key1)
        {
            TValue deletedval;
            TKey1 deleted1;
            TKey2 key2;

            if (Key1ToKey2.TryRemove(key1, out key2))
                return (Key2ToKey1.TryRemove(key2, out deleted1) &&
                       Key1ToValue.TryRemove(key1, out deletedval));
            return false;



        }

        public bool ContainsKey1(TKey1 value)
        {
            return Key1ToValue.ContainsKey(value);
        }

        public bool ContainsKey2(TKey2 value)
        {
            return Key2ToKey1.ContainsKey(value);
        }

        public bool ContainsValue(TValue value)
        {
            return Key1ToValue.Values.Contains(value);
        }

        public ICollection<TKey1> Keys1
        {
            get { return Key1ToKey2.Keys; }
        }

        public ICollection<TKey2> Keys2
        {
            get { return Key2ToKey1.Keys; }
        }

        public ICollection<TValue> Values
        {
            get { return Key1ToValue.Values; }
        }
    }



Espero comentarios

hola a todos, pues mi duda radica en que si es buena idea mantener varios FileStreams abiertos(actualizando datos con intervalo sobre 1 segundo), o simplemente crear uno nuevo cada vez que necesite hacerlo? es que para un emulador de servidor de un mmorpg lo estoy usando por ahora como base de datos porque se me hizo mas facil de usar que alguna sql(0 experiencia, ademas cuando he usado codigos hechos por otros, pues no me siento bien usandolo)

pues espero la opinion.

PD: este es el codigo que estoy usando

    public class Manager : IDisposable
    {
        #region Constructors
        public Manager(string _File)
        {
            fs = new FileStream(_File, FileMode.OpenOrCreate);
            sw = new StreamWriter(fs);
            sr = new StreamReader(fs);
            sb = new StringBuilder();
        }
        #endregion

        #region Private Fields

        private FileStream fs;
        private StreamWriter sw;
        private StreamReader sr;
        private StringBuilder sb;
        const char def = '*';
        const int ByteSize = 4, ShortSize = 6, IntSize = 11, LongSize = 20, StringSize = 20;

        #endregion

        #region Methods

        public void Dispose()
        {
            sw.Dispose();
            sw.Close();
        }

        private void Write(string value, int MaxLength, int position)
        {
            lock (fs)
            {
                sb.Append(value);
                sb.Append(def, MaxLength - value.Length);
                fs.Seek(position, SeekOrigin.Begin);
                sw.Write(sb.ToString());
                sb.Clear();
            }
        }

        public void WriteString(string value, int position)
        {
            Write(value, StringSize, position);
        }

        public void WriteUlong(ulong val, int position)
        {
            Write(val.ToString(), LongSize, position);
        }

        public void WriteLong(long val, int position)
        {
            Write(val.ToString(), LongSize, position);
        }

        public void WriteUInt(uint val, int position)
        {
            Write(val.ToString(), IntSize, position);
        }

        public void WriteInt(int val, int position)
        {
            Write(val.ToString(), IntSize, position);
        }

        public void WriteUshort(ushort val, int position)
        {
            Write(val.ToString(), ShortSize, position);
        }

        public void WriteShort(short val, int position)
        {
            Write(val.ToString(), ShortSize, position);
        }

        public void WriteByte(byte val, int position)
        {
            Write(val.ToString(), ByteSize, position);
        }

        public void WriteBool(bool val, int position)
        {
            WriteByte((byte)(val == true ? 1 : 0), position);
        }
       
        public string GetString(int position, int length)
        {
            lock (fs)
            {
                fs.Seek(position, SeekOrigin.Begin);
                string val = sr.ReadToEnd();
                return val.Substring(0, val.IndexOf(def));
                //return val.TrimEnd(def);
            }
        }

        public string GetString(int position)
        {
            return GetString(position, StringSize);
        }

        public ulong GetUlong(int position)
        {
            return ulong.Parse(GetString(position, LongSize));
        }

        public long GetLong(int position)
        {
            return long.Parse(GetString(position, LongSize));
        }

        public uint GetUInt(int position)
        {
            return uint.Parse(GetString(position, IntSize).TrimEnd('*'));
        }

        public int GetInt(int position)
        {
            return int.Parse(GetString(position, IntSize));
        }

        public ushort GetUshort(int position)
        {
            return ushort.Parse(GetString(position, ShortSize));
        }

        public short GetShort(int position)
        {
            return short.Parse(GetString(position, ShortSize));
        }

        public byte GetByte(int position)
        {
            return byte.Parse(GetString(position, ByteSize));
        }

        public bool GetBool(int position)
        {
            return GetByte(position) == 1 ? true : false;
        }
       
        #endregion
    }

Mira, lo de la eficiencia no creo que te afectara mucho en este caso, pasa que la principal diferencia entre Struct y Class es que la primera, al pasar como parametro en algun metodo, se crea una copia, en cambio con una class, es una referencia a la class creada, ahora si una struct pesa demasiado, la copia tardara demasiado y por ende se produciran problemas con el uso de memorio y posiblemente de velocidad.

en tu caso no parece importar demasiado, o nada, ya que lo que haces es editar la struct que ya tienes creada, la editas y luego la devuelves con return, por lo que struct es ideal ya que no se que es lo que haces con "vari".

los structs como dices deben tener un tamaño "limitado", pero cuando deben pasar como parametros, para evitar problemas de memoria y cpu, pero tambien son en casos de aplicaciones de gran tamaño, pero por supuesto es bienvenido ya que es una buena practica en las aplicaciones de menor tamaño.

espero te haya servido mi respuesta 

Pues la verdad dudo que esto sirva de mucho en algun momento, lo queria integrar a la criptografia de una aplicacion que hacemos con un amigo, pero resulto que no era lo suficientemente rapido como para usarlo(no es que sea lento, pero si lo era para nosotros porque necesitamos transferencia de datos rapida por Tcp, y el aumentar el tiempo en varios ms no era lo ideal), asi que agrugue los metodos para todos los tipos de variables y aqui esta xD
     |10011011|
basicamente lo que hice es lo siguiente
suponiendo que lo que esta dentro de las lineas '|' es un byte (con un tamaño de 8 bits),  para obtener cada bit lo que hago es.
aplico el operador ">" o "<" para correr los bits, uso ">>" con una cantidad igual a 7, si el numero es 0, continuo corriendo los bits hasta que sea distinto de 0, asi obtengo la cantidad de bits en uso por el numero para crear la matriz de bytes(conteniendo cada byte uno 1 o un 0).

luego empujo los bits hacia la izquierda con "<<" para eliminar los bits anteriores al que deseo obtener. y luego a la izquierda, para que me quede como valores posibles un 1 o un 0 (Esto es solo util despues de haber obtenido el primer bit)

luego empujo uso >> 7 para obtener el byte, y lo agrego a la matriz para finalmente tener el bit dentro de la matriz

asi por ejemplo tenemos el siguiente byte, y queremos obtener el bit en negrita
 
  |00110011|
  aplico << 6  y queda
   |11000000|
aplico >> 7 y queda
  |00000001|
y como un numero con esos bits es igual a 1, o si el bit fuera 0 seria 0, obtengo el bit, y asi lo agrego a la matriz

al finalizar me di cuenta de que los bits estaban entregados al reves, asi que use Array.Reverse para invertirlos.

tambien agrugue los metodos para revertir el proceso.

la clase:


/// <summary>
    /// Clase con metodos para obtener una matriz de bits de un valor numerico
    /// o el valor numerico de una matriz de bits
    /// </summary>
    public class Bits
    {
        public static byte[] GetBits(sbyte source)
        {
            return GetBits((byte)source);
        }

        public static byte[] GetBits(byte source)
        {
            byte[] CompleteBits;
            byte BitsAmount = 8;
            byte Copy = source;
            for (int i = 7; i >= 0; i--)
            {
                if (source >> i == 0)
                    BitsAmount--;
                else
                    break;
            }
            CompleteBits = new byte[BitsAmount];
            for (int i = 0; i < BitsAmount; i++)
            {
                Copy <<= (7 - i);
                Copy >>= 7;
                CompleteBits[i] = Copy;
                Copy = source;
            }
            Array.Reverse(CompleteBits);
            return CompleteBits;
        }

        public static byte[] GetBits(short source)
        {
            return GetBits((ushort)source);
        }

        public static byte[] GetBits(ushort source)
        {
            byte[] CompleteBits;
            byte BitsAmount = 16;
            ushort Copy = source;
            for (int i = 15; i >= 0; i--)
            {
                if (source >> i == 0)
                    BitsAmount--;
                else
                    break;
            }
            CompleteBits = new byte[BitsAmount];
            for (int i = 0; i < BitsAmount; i++)
            {
                Copy <<= (15 - i);
                Copy >>= 15;
                CompleteBits[i] = (byte)Copy;
                Copy = source;
            }
            Array.Reverse(CompleteBits);
            return CompleteBits;
        }

        public static byte[] GetBits(int source)
        {
            return GetBits((uint)source);
        }

        public static byte[] GetBits(uint source)
        {
            byte[] CompleteBits;
            byte BitsAmount = 32;
            uint Copy = source;
            for (int i = 31; i >= 0; i--)
            {
                if (source >> i == 0)
                    BitsAmount--;
                else
                    break;
            }
            CompleteBits = new byte[BitsAmount];
            for (int i = 0; i < BitsAmount; i++)
            {
                Copy <<= (31 - i);
                Copy >>= 31;
                CompleteBits[i] = (byte)Copy;
                Copy = source;
            }
            Array.Reverse(CompleteBits);
            return CompleteBits;
        }

        public static byte[] GetBits(long source)
        {
            return GetBits((ulong)source);
        }

        public static byte[] GetBits(ulong source)
        {
            byte[] CompleteBits;
            byte BitsAmount = 64;
            ulong Copy = source;
            for (int i = 63; i >= 0; i--)
            {
                if (source >> i == 0)
                    BitsAmount--;
                else
                    break;
            }
            CompleteBits = new byte[BitsAmount];
            for (int i = 0; i < BitsAmount; i++)
            {
                Copy <<= (63 - i);
                Copy >>= 63;
                CompleteBits[i] = (byte)Copy;
                Copy = source;
            }
            Array.Reverse(CompleteBits);
            return CompleteBits;
        }

        public static sbyte GetSByte(byte[] source)
        {
            return (sbyte)GetByte(source);
        }

        public static byte GetByte(byte[] source)
        {
            byte ToReturn = 0;
            for (int i = 0; i < source.Length; i++)
            {
                ToReturn += (byte)(source[i] << (source.Length - i - 1));
            }
            return ToReturn;
        }

        public static short GetInt16(byte[] source)
        {
            return (short)GetUInt32(source);
        }

        public static ushort GetUInt16(byte[] source)
        {
            ushort ToReturn = 0;
            for (int i = 0; i < source.Length; i++)
            {
                ToReturn += (ushort)(source[i] << (source.Length - i - 1));
            }
            return ToReturn;
        }

        public static int GetInt32(byte[] source)
        {
            return (int)GetUInt32(source);
        }

        public static uint GetUInt32(byte[] source)
        {
            uint ToReturn = 0;
            for (int i = 0; i < source.Length; i++)
            {
                ToReturn += (uint)(source[i] << (source.Length - i - 1));
            }
            return ToReturn;
        }

        public static long GetInt64(byte[] source)
        {
            return (long)GetUInt64(source);
        }

        public static ulong GetUInt64(byte[] source)
        {
            ulong ToReturn = 0;
            for (int i = 0; i < source.Length; i++)
            {
                ToReturn += (ulong)(source[i] << (source.Length - i - 1));
            }
            return ToReturn;
        }
    }

si no entienden que es, vayan a la calculadora de windows, la dejan en modo cientifico, escriben cualquier numero en "dec" y luego apretan en "bin", lo que obtienes, lo tendras como byte[] usando los metodos que puse.

No se si hayan mejores maneras de hacerlo dadas por .Net pero esto funciona relativamente rapido

Una solucion buena pero poco usada es agregar una linea en el load del formulario:

 CheckForIllegalCrossThreadCalls = true or false;

Yo no la recomiendo, pero es bueno saber

una buena practica es que recomienda el mensaje anterior

Código: [Seleccionar]

public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }
        delegate void crearBoton();
        private void Form2_Load(object sender, EventArgs e)
        {
            Thread T = new Thread(new ThreadStart(NuevoBoton));
            T.Start();
        }
        private void NuevoBoton()
        {
            if (this.InvokeRequired)
            {
                crearBoton CB = new crearBoton(NuevoBoton);//Creamos una instancia del delegate
                                      //pasandole el metodo que estamos ejecutando como parametro
                this.Invoke(CB);  //invocamos el Form pasando el delegate void que recien creamos
            }
            else
            {
                Button B = new Button();
                this.Controls.Add(B);
            }
        }
    }


interesante, ahora mismo investigare, pero solamente el nombre me suena a una gran cantidad de errores potenciales ^^, gracias por la respuesta

quizas yo te pueda ayudar, no tanto como gabio en C# pero yo basicamente me tope con C# editando servidores para un juego de rol asi que entiendo relativamente como funcionan, pero primero deberias preguntarte como haras para mostrar las animaciones en un windows form, tambien el como lo desarrollaras en cuanto a diseño y eso pero no es tan importante.

para el servidor si es conveniente una consola, porque practicamente nadie la vera mas que tu, pero tambien puede ser un windows form y crear un thread con un ciclo while.

lo proximo, supongo que entiendes mas o menos lo que son los paquetes cierto? porque es vital para la comunicacion cliente-servidor.

Respecto a los sockets para el servidor, vagando en los foros dedicados a editar servidores como el que edito yo (y en donde se crearon las primeras en C# y todas ^^ que son unas 30) encontre un sistema asincrono que al parecer funciona bastante bien, es el que usa actualmente uno de los servidores mas prosperos de Conquer y mantiene cerca de 500 jugadores conectados casi todo el dia, la verdad yo no soy muy bueno en eso, pero se usarlo, si quieres te envio la clase y un ejemplo de como usarlo, para conectarse desde el cliente puedes usar un TcpClient.

Si aun no tienes muy claro todo, puedes tratar hacer un juego de 3 en raya en linea (tic tac toe, la vieja, gato, etc...) en el que 2 clientes se conecten a un servidor, si hay mas se elijan al azar, etc...

Pues quisiera hacer una pregunta bastante corta, he estado haciendo todo lo relacionado a paquetes en un proyecto que tengo, pero resulta que tengo lo siguiente

Clase Packet
{
     muchos metodos xD
}

clase XXXX : Packet// son 4 por los morbosos 
{
      algunas variables
}


pasa que quiero cambiar los valores de ciertas variables en la clase XXXX, pero intellisense al presionar XXXX. tambien muestra todos los metodos de la clase Packet.

Mi pregunta es si es posible hacer que solo muestre las variables de la clase XXXX?
 no se si podra heredar metodos con accesibilidad private, o algo que se pueda hacer?

gracias de antemano



SOLUCION ENCONTRADA, USO protected EN VEZ DE public EN LOS METODOS DE LA CLASE PACKET, GRACIAS DE TODOS MODOS

Puedes ponerlo como Object y hacerle un cast después, para convertirlo en el tipo de dato que tú quisieras, es decir:

Código: C#

1.  public class clsArray
2.     {
3.         byte[] Paquete;
4.        public clsArray(int _entero)
5.         {
6.             Paquete = BitConverter.GetBytes(_entero);
7.         }
8.         public byte[] getPacket()
9.         {
10.            return Paquete;
11.         }
12.     }
13.  
14.     class PruebaDictionary
15.     {
16.         static void Main()
17.         {
18.             Dictionary<string, object> miDiccionario = new Dictionary<string, object>(); //Creamos el Diccionario.
19.             clsArray miClaseArray = new clsArray(1024); //Objeto de tipo clsArray
20.             miDiccionario.Add("clsArray", miClaseArray); //Agregamos mi objeto a mi diccionario.
21.  
22.             //Ahora probamos un ejemplo sencillo.
23.             foreach (KeyValuePair<string, object> kvp in miDiccionario)
24.             {
25.                 if (kvp.Key.Contains("clsArray"))
26.                 {
27.                      // Aquí hago casting para convertir mi objeto en clsArray y lo convierto en cadena para imprimirlo en pantalla.
28.                     foreach (byte _byte in ((clsArray)kvp.Value).getPacket())
29.                     {
30.                         Console.WriteLine(_byte.ToString());
31.                     }
32.                 }
33.             }
34.            Console.ReadLine();
35.         }
36.     }
37.  

Realizé este pequeño ejemplo.. espero te sirva, aunque no sé si sea lo que pides, aunque para mi.. sigue siendo mejor la opción de generar un proyecto aparte donde crearias todas tus clases y luego sólo lo agregas como referencia a tú proyecto de la aplicación.. pero pues..  tampoco sé como tienes planeada tú aplicación.. bueno en fin.. espero sea de ayuda.., saludos!

Muchas gracias por el ejemplo, pero no satisface completamente mi duda, mira hice esta solucion con el EscritorDePaquetes que estoy usando, y algo que se asemeja a lo que debo hacer con los paquetes(sin el envio obviamente)

http://www.multiupload.nl/CHDNPJMJ32
(viene con comentarios lo mas importante solamente)

muchas gracias por tu interes en ayudar

viene con comentarios lo mas importante solamente