Controles personalizados para aplicaciones WEB

2007-11-01T20:11:00Z

Ejemplo de creacion de control personalizado para permitir contenido flash (SWF) en paginas ASPX

<%@ Register Assembly="Flash" Namespace="Flash" TagPrefix="cc1" %>

<cc1:FlashControl ID="FlashControl1" runat="server"
        BackColor="#000"
        Quality="high"
        Movie="filename.swf"
        Height="180px"
        Width="389px"
        Align="middle" />

</object>

RFID

2007-01-26T22:37:00Z

Diseñado para lectura/escritura de tags 4Kbits
El dispositivo móvil usado es un Teklogix

namespace RFID
{

        #region using directives
        using System;
        using System.Collections.Generic;
        using System.IO;
        using System.Text;
        using System.Xml;
        using RFID_NET;
        using mSoft.RFID.Properties;

        #endregion

        #region .:RFIDHandler:.
        public sealed class RFIDHandler
        {

                #region Fields
                private const int FIXED_LENGTH = 3;
                private string tagType, tagId, data;
                private XmlDocument response, request;

                #endregion

                #region Properties
                ///
                /// Obtiene el tipo de Tag.
                ///
                public string TagType
                {
                        get { return tagType; }
                }

                ///
                /// Obtiene la identificacin del Tag.
                ///
                public string TagID
                {
                        get { return tagId; }
                }

                ///
                /// Obtiene la informacin leida por el mtodo ReadTag.
                ///
                public string Data
                {
                        get { return data; }
                }

                #endregion

                #region Events and Delegates
                ///
                /// Provee informacin de errores en las operaciones con RFID.
                ///
                public event EventHandler RFIDError;

                #endregion

                #region Methods

                #region .ctor()
                public RFIDHandler() { }

                #endregion

                #region Privates

                #region ProcessResponse : void
                ///
                /// Procesa el XML devuelto por RFID,
                /// Si existe algun error dispara el evento RFIDError
                ///
                /// Verdadero si no ocurrio error en procesar la respuesta.
                private bool ProcessResponse()
                {
                        int errorCode = GetError();
                        bool hasError = (errorCode != 0);
                        if (hasError)
                        {
                                string errorText = GetParameter("error-text");
                                OnRFIDError(new ErrorEventArgs(errorCode, errorText));
                        }
                        return !hasError;
                }

                #endregion

                #region OnRFIDError : void
                private void OnRFIDError(ErrorEventArgs e)
                {
                        if (RFIDError != null)
                                RFIDError(this, e);
                }

                #endregion

                #region GetDataLength : int
                ///
                /// Devuelve la cantidad de caracteres almacenados luego de.
                ///
                /// Indice donde sacar los tres (3) caracteres que representan la longitud de lo que leera posteriormente.
                ///
                private int GetDataLength(int startIndex)
                {
                        request = new XmlDocument();
                        request.LoadXml(string.Format(Resources.ReadTagInnerXml, tagType, tagId, startIndex, FIXED_LENGTH));
                        response = RFID_NET.RFID.call(request);
                        ProcessResponse();

                        byte[] bytes = DecodeHex(GetParameter("data"));
                        string length = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
                        int bytesToRead = int.Parse(length);

                        return bytesToRead;
                }

                #endregion

                #region GetError : int
                private int GetError()
                {
                        return RFID_NET.RFID.getError(this.response);
                }

                #endregion

                #region GetParameter : string
                private string GetParameter(string name)
                {
                        return RFID_NET.RFID.getParameter(this.response, name);
                }

                #endregion

                #region EncodeHex : string
                private string EncodeHex(byte[] data)
                {
                        return RFID_NET.RFID.encodeHex(data);
                }

                #endregion

                #region DecodeHex : byte[]
                private byte[] DecodeHex(string s)
                {
                        return RFID_NET.RFID.decodeHex(s);
                }

                #endregion

                #endregion

                #region Publics

                #region Initialize : void
                public bool Initialize()
                {
                        bool succeeded = false;
                        try
                        {
                                request = new XmlDocument();
                                request.LoadXml(Resources.InitializeInnerXml);
                                response = RFID_NET.RFID.call(request);
                                succeeded = ProcessResponse();
                        }
                        catch (Exception ex)
                        {
                                OnRFIDError(new ErrorEventArgs(ex.Message));
                        }
                        return succeeded;
                }

                #endregion

                #region GetAPIInfo : string
                public string GetAPIInfo()
                {
                        string version = null;
                        try
                        {
                                request = new XmlDocument();
                                request.LoadXml(mSoft.RFID.Properties.Resources.GetAPIInfo);
                                response = RFID_NET.RFID.call(request);
                                ProcessResponse();
                                version = GetParameter("version");
                        }
                        catch (Exception ex)
                        {
                                OnRFIDError(new ErrorEventArgs(ex.Message));
                        }
                        return version;
                }

                #endregion

                #region Load : void
                public bool Load()
                {
                        bool succeeded = false;
                        try
                        {
                                request = new XmlDocument();
                                request.LoadXml(Resources.GetTagInfoInnerXml);
                                response = RFID_NET.RFID.call(request);
                                succeeded = ProcessResponse();

                                tagId = GetParameter("tag-id");
                                tagType = GetParameter("tag-type");
                        }
                        catch (Exception ex)
                        {
                                OnRFIDError(new ErrorEventArgs(ex.Message));
                        }
                        return succeeded;
                }

                #endregion

                #region ReadTag : void
                ///
                /// Lee el texto Unicode almacenado en el RFID desde la posicin indicada,
                /// la longitud a leer ser calculada de los (n) primeros caracteres grabados como prefijo de la data.
                ///
                /// Indice de donde comenzar la lectura del RFID.
                ///
                public bool ReadTag(int startIndex)
                {
                        return ReadTag(startIndex, -1);
                }

                ///
                /// Lee el texto Unicode almacenado en el RFID desde la posicin inidicada, los caracteres especificados.
                ///
                /// Indice de donde comenzar la lectura del RFID.
                /// Longitud a leer.
                ///
                public bool ReadTag(int startIndex, int length)
                {
                        bool succeeded = false;
                        try
                        {
                                // obtenemos longitud real de la data
                                int bytesToRead = (length
                                // leemos la data desde el 4to byte
                                request = new XmlDocument();
                                request.LoadXml(string.Format(Resources.ReadTagInnerXml, tagType, tagId,
                                        (length
                                response = RFID_NET.RFID.call(request);
                                succeeded = ProcessResponse();

                                byte[] bytes = DecodeHex(GetParameter("data"));
                                data = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
                        }
                        catch (Exception ex)
                        {
                                OnRFIDError(new ErrorEventArgs(ex.Message));
                        }
                        return succeeded;
                }

                #endregion

                #region WriteTag : void
                ///
                /// Escribe la data desde la primera posicin (0), la longitud de la misma.
                ///
                /// Texto Unicode a guardar en RFID.
                ///
                public bool WriteTag(string data)
                {
                        return WriteTag(data, 0);
                }

                ///
                /// Escribe la data comenzando en una posicin indicada, la longitud de la misma.
                ///
                /// Texto Unicode a guardar en RFID.
                /// Indice de donde comenzar la grabacin.
                ///
                public bool WriteTag(string data, int startIndex)
                {
                        return WriteTag(data, startIndex, -1);
                }

                ///
                /// Escribe la data comenzando en una posicin indicada, la longitud especificada.
                ///
                /// Texto Unicode a guardar en RFID.
                /// Indice de donde comenzar la grabacin.
                /// Longitud que trunca la data a grabar. Menor a 1 si desea que guarde la longitud de la data.
                ///
                public bool WriteTag(string data, int startIndex, int length)
                {
                        bool succeeded = false;
                        try
                        {
                                request = new XmlDocument();
                                byte[] bytes = Encoding.ASCII.GetBytes(data);
                                #region solo en caso de no saber la longitud a escribir en RFID
                                string dataLength = bytes.Length.ToString();
                                while (dataLength.Length
                                        dataLength = string.Concat("0", dataLength);
                                #endregion
                                if (length > 0)
                                {
                                        while (data.Length
                                                data = string.Concat(" ", data);
                                }
                                string dataToWrite = string.Format("{0}{1}", (length
                                byte[] bytesToWrite = Encoding.ASCII.GetBytes(dataToWrite);
                                //Console.WriteLine("{0}={1}", dataToWrite, bytesToWrite.Length);
                                request.LoadXml(string.Format(Resources.WriteTagInnerXml, tagType, tagId,
                                        startIndex, bytesToWrite.Length, EncodeHex(bytesToWrite)));
                                response = RFID_NET.RFID.call(request);
                                succeeded = ProcessResponse();
                        }
                        catch (Exception ex)
                        {
                                OnRFIDError(new ErrorEventArgs(ex.Message));
                        }
                        return succeeded;
                }

                #endregion

                #endregion

                #endregion

        }

        #endregion

}

>        #region .:ErrorCode:.
        internal sealed class ErrorCode
        {

                #region Publics
                internal static string ToString(ErrorCodes errorCode)
                {
                        string message = null;
                        switch (errorCode)
                        {
                                case ErrorCodes.RFIDE_SYSTEM_ERROR:
                                        message = "System error. For more information please see 'error-text' field.";
                                        break;
                                case ErrorCodes.RFIDE_XML_PARSER_INITIALIZATION:
                                        message = "Error of initializacion of the XML parser.";
                                        break;
                                case ErrorCodes.RFIDE_REQUEST_PARSING_ERROR:
                                        message = "Bad XML request.";
                                        break;
                                case ErrorCodes.RFIDE_BAD_PARAMETERS:
                                        message = "Bad parameters for the command.";
                                        break;
                                case ErrorCodes.RFIDE_HARDWARE_PROBLEM:
                                        message = "Hardware problems.";
                                        break;
                                case ErrorCodes.RFIDE_LICENSE_PROBLEM:
                                        message = "Wrong license.";
                                        break;
                                case ErrorCodes.RFIDE_PROTOCOL_ERROR:
                                        message = "Incorrect sequence of commands.";
                                        break;
                                case ErrorCodes.RFIDE_NOT_ENOUGH_MEMORY:
                                        message = "Not enough memory to process the command.";
                                        break;
                                case ErrorCodes.RFIDE_SECURITY_ERROR:
                                        message = "Security error.";
                                        break;
                                default:
                                        message = "No error.";
                                        break;
                        }
                        return message;
                }

                #endregion

        }

John Moscoso

Controles personalizados para aplicaciones WEB

RFID