SoloCodigo

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, 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
    }

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

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

Hola a todos, esta es una clase que quizas a alguien le sirva, es para construir paquetes que son enviados a traves de la internet, solo he testeado agregar bytes y ints, pero deberia funcionar con el resto, habran maneras mejores pero me siento feliz por haber hecho esto ^^
Lo hice ya que como proyecto de aprendizaje estoy programando un servidor de Conquer online desde "0" (los sockets y la criptografia son copiadas)

Esta en ingles porque la comunidad mas desarrollada en servidores de este juego es de E.E.U.U







    public class Builder
    {
        public static void WriteByte(byte val, int offset, byte[] Data)
        {
            Data[offset] = val;
        }
        public static void WriteUInt16(ushort val, int offset, byte[] Data)
        {
            Data[offset] = (byte)val;
            Data[++offset] = (byte)(val >> 8);
        }
        public static void WriteUInt32(uint val, int offset, byte[] Data)
        {
            Data[offset] = (byte)val;
            Data[++offset] = (byte)(val >> 8);
            Data[++offset] = (byte)(val >> 16);
            Data[++offset] = (byte)(val >> 24);
        }
        public static void WriteUInt64(ulong val, int offset, byte[] Data)
        {
            Data[offset] = (byte)val;
            Data[++offset] = (byte)(val >> 8);
            Data[++offset] = (byte)(val >> 16);
            Data[++offset] = (byte)(val >> 24);
            Data[++offset] = (byte)(val >> 32);
            Data[++offset] = (byte)(val >> 40);
            Data[++offset] = (byte)(val >> 48);
            Data[++offset] = (byte)(val >> 56);
        }
        public static void WriteString(string val, int offset, byte[] Data)
        {
            for (int i = 0; i < val.Length; i++)
            {
                Data[offset + i] = (byte)val[i];
            }
        }
    }


Hola a todos, bueno, he estado tratando de aplicar un poco lo que he leido en unos tutoriales, y decidi hacer un editor de archivos ini entre otras cosas, pero tengo un problema: La velocidad, con 200 campos(campo=valor, a esa parte me refiero) tarda entre 400 y 900 milisegundos, lo cual encuentro que es demasiado.

esto es lo que hice(disculpen el que lo haga en ingles, pero me acostumbre)


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using IniHandler;

namespace IniHandler
{
    struct Item
    {
        public string Section;
        public string Field;
    }
}

namespace IniManager
{
    class IniManager
    {
        byte COUNT = 0;
        string SECTION, FILE;
        string[] SECTIONS = new string[255];
        Dictionary<Item, string> ITEMS;
        StreamReader READER;
        bool READING = true;

        public IniManager(string _FILE)
        {
            COUNT = 0;
            FILE = _FILE;
            ITEMS = new Dictionary<Item, string>();
            FILL();
            READING = true;
        }

        void FILL()
        {
            string[] Lines = File.ReadAllLines(FILE);
            foreach (string Line in Lines)
            {
                ANALYZELINE(Lines);
            }
            //for (ushort i = 0; i < LINES.Length; i++)
            //{
            //    ANALYZELINE(LINES[i]);
            //}
        }

        void ANALYZELINE(string LINE)
        {
            if (LINE.Length > 0)
            {
                if (LINE[0] == '[')
                {
                    SECTIONS[COUNT] = LINE;
                    COUNT++;
                    SECTION = LINE;
                }
                else
                {
                    Item i = new Item();
                    i.Section = SECTION;
                    string[] SPLIT = LINE.Split('=');
                    i.Field = SPLIT[0];
                    ITEMS.Add(i, SPLIT[1]);
                }
            }
            else
                return;
        }

        public Item GetItem(string Section, string Field)
        {
            Item i = new Item();
            i.Section = Section;
            i.Field = Field;
            return i;
        }

        public string ReadString(string Section, string Field)
        {
            string Value;
            Item I = new Item();
            I.Section = '[' + Section + ']';
            I.Field = Field;
            ITEMS.TryGetValue(I, out Value);
            return Value;
        }

        public void Write(string Section, string Field, object Value)
        {
            StringBuilder BUILDER = new StringBuilder();
            Item I = GetItem(Section, Field);
            if (!ITEMS.ContainsKey(I))
            {
                ITEMS.Add(I, Value.ToString());
            }
            else
            {
                ITEMS.Remove(I);
                ITEMS.Add(I, Value.ToString());
            }
            for (byte i = 0; i <= COUNT; i++)
            {
                string section = SECTIONS[i];
                BUILDER.AppendLine(section);
                foreach(KeyValuePair<Item, string> item in ITEMS)
                {
                    if (item.Key.Section != section)
                        continue;
                    else
                    {
                        BUILDER.AppendLine(item.Key.Field + '=' + item.Value);
                    }
                }
            }
            File.WriteAllText(FILE, BUILDER.ToString());
        }
    }
}



ojala puedan ayudarme a mejorar esto, ya que obviamente debe ser una pesima forma por la cantidad de tiempo que toma, y que es exactamente lo que falla, tengo una idea pero la verdad no se si lo es, que seria el crear masivamente objetos a partir de la estructura "Item"

Gracias de antemano

Hola a todos, primero que nada, me presento, soy rodrigo cordova, uso el nick de U2_Caparzo, actualmente soy estudiante de 17 años(estoy en mi ultimo año del liceo) y uno de mis intereses es continuar como estudiante de ingenieria informatica.
Paso bastante tiempo, editando un servidor de un juego(conquer), los cuales todos estan escritos en C#. Vine a este foro, porque en el foro que participaba en desarrollo de estos servidores, no hay nadie que tenga grandes conocimientos, de hecho yo escribi algo basico para que algunos aprendieran de C#.

Bueno ahora al grano.

El otro dia, estuve tratando de ordenar un archivo de texto llamado ItemAdd.ini
el archivo solo son numeros por ejemplo

123510 12 4214 32141 421421 4213 5436 534 12

los 2 primeros numeros son los que estoy tratando de ordenar, o sea que a partir de esos trato de ordeanr el archivo

el primer numero se repite siempre 12 veces
por ejemplo
123510 1 ......
123510 2 ......

ahora, estan todos desordenados, asi que lo que hice fue 2 maneras de ordenarlo que es por el primer numero o el segundo numero.

Les proveere el codigo que estoy usando, como estructura generalizada, porque no me encuentro en mi Laptop y no tengo C# aca.

se que obviamente la ineficiencia esta en el uso masivo de ciclos asi que esperaria algo de ayuda con eso.

bueno, lo que hice fue esto

tengo un List<string> llamado IDsque almacenara todas las ID (primer numero) y un byte llamado Maximo plus = 12; (el maximo base del segundo numero)

creo un array de strings de todas las lineas con File.ReadAllLines

luego
foreach(string linea in lineas)//lineas es el array anterior
{
string[] sp = linea.Split(' ');
if(!IDs.Contains(sp[0]))
    IDs.Add(sp[0]);
if(Maximo < byte.Parse(sp[1]))
   Maximo = byte.Parse(sp[1]);
}

entonces aqui viene lo feo, son 3 ciclos en total... por cierto cree un stringbuilder sb

foreach(string ID in IDs)//el List<string> que cree antes
{
    for(byte i = 1; i <= Maximo; i++);
       {
        foreach(string linea in lineas)//del array al leer el archivo
             {
                if(Line.StartsWith(ID + " " + i.ToString() + " ")/*agrego un espacio al final porque el 1 se repetiria en 1, 10, 11, y 12, etc...*/
                         sb.AppendLine(linea);
             }
       }
}

y luego escribo el stringbuilder al archivo con StreamWriter.

lo que pasa es que tarda mucho ademas de que usa bastante memoria, asi que algo de guia con esto se los agradeceria demasiado. he escuchado algo de OrderBy en List<> pero no entendi mucho como usarlo

gracias por adelantado