none
Propriedade de Classe X Parâmetro de Método RRS feed

  • Pergunta

  • Olá a todos

    Recentemente tive que criar uma classe com vários métodos e todos recebiam uma parametro em comum, hora utilizava apenas um método, hora utilizava os 3.

    Class Teste

    {

    Metodo1(string Par1) 

    Metodo2(string Par1)

    Metodo3(string Par3)

    }

    Para não ter que passar o mesmo parâmetro a cada método criei uma propriedade da classe e passei a utilizar como parâmetro dos métodos. 

    Class Teste

    {

    public string Par { get; set; }

    Metodo1()

    Metodo2()

    Metodo3()

    }

    Pergunta: Isso é desaconselhável?

    quarta-feira, 29 de julho de 2015 14:42

Respostas

  • Bom, sim, quando você tem um número x de métodos que vão usar uma mesma informação, você, ao invés de pedir a informação como parâmetro, pode defini-la em uma propriedade.

    Tudo questão de necessidade, e do cenário. Veja por exemplo a classe abaixo:

    using System;
    using System.Text;
    using System.Security.Cryptography;
    
    namespace HL
    {
        public class Aes256 : IDisposable
        {
            private RijndaelManaged Engine;
            private SHA256CryptoServiceProvider HashProvider;
            private byte[] HashBytes;
    
            private string _Password;
    
            /// <summary>
            /// Retorna ou modifica a senha usada por esta instância para opeções de criptografia e decriptografia
            /// </summary>
            public string Password
            {
                get { return _Password; }
                set
                {
                    _Password = value;
                    HashBytes = HashProvider.ComputeHash(Encoding.UTF8.GetBytes(value));
                    Engine.Key = HashBytes;
                }
            }
    
            /// <summary>
            /// Cria uma nova instância
            /// </summary>
            /// <param name="Password">Senha utilizada para criptografar e decriptografar</param>
            public Aes256(string Password)
            {
                _Password = Password;
                Engine = new RijndaelManaged();
                HashProvider = new SHA256CryptoServiceProvider();
                HashBytes = HashProvider.ComputeHash(Encoding.UTF8.GetBytes(Password));
                Engine.Mode = CipherMode.CBC;
                Engine.Key = HashBytes;
            }
    
            /// <summary>
            /// Criptografa um buffer de bytes
            /// </summary>
            /// <param name="Buffer"></param>
            /// <returns></returns>
            public byte[] Encrypt(byte[] Buffer)
            {
                using (ICryptoTransform Encryptor = Engine.CreateEncryptor())
                    return Encryptor.TransformFinalBlock(Buffer, 0, Buffer.Length);
    
            }
    
            /// <summary>
            /// Decriptografa um buffer de bytes
            /// </summary>
            /// <param name="Buffer"></param>
            /// <returns></returns>
            public byte[] Decrypt(byte[] Buffer)
            {
                using (ICryptoTransform Decryptor = Engine.CreateDecryptor())
                    return Decryptor.TransformFinalBlock(Buffer, 0, Buffer.Length);
            }
    
            /// <summary>
            /// Criptografa um texto
            /// </summary>
            /// <param name="Str"></param>
            /// <returns></returns>
            public string Encrypt(string Str)
            {
                return Convert.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(Str)));
            }
    
            /// <summary>
            /// Decriptografa um texto
            /// </summary>
            /// <param name="Str"></param>
            /// <returns></returns>
            public string Decrypt(string Str)
            {
                return Encoding.UTF8.GetString(Decrypt(Convert.FromBase64String(Str)));
            }
    
            public void Dispose()
            {
                Engine.Dispose();
                HashProvider.Dispose();
                HashBytes = null;
                _Password = null;
            }
    
        }
    }

    É uma classe para criptografia AES 256 que eu escrevi a um tempo atrás. Veja que nos métodos, ao invés de pedir um parâmetro para a senha, eu defini uma propriedade para isso (Password). Assim o programador define a senha na propriedade Password, e então vai criptografar e descriptografar dados usando essa mesma senha, sem a necessidade de estar passando essa senha nos métodos à cada chamada.

    É mais ou menos esse cenário que você tem, correto?


    Herbert Lausmann

    quarta-feira, 29 de julho de 2015 17:00

Todas as Respostas

  • Olá,

    Não vejo nenhum problema. É normal termos classes com vários métodos que trabalham sobre o mesmo campo/propriedade.

    Espero ter ajudado.


    Herbert Lausmann

    quarta-feira, 29 de julho de 2015 15:44
  • Olá,

    Não vejo nenhum problema. É normal termos classes com vários métodos que trabalham sobre o mesmo campo/propriedade.

    Espero ter ajudado.


    Herbert Lausmann

    Olá Herbert. 

    Mas é normal trocar parâmetro de um método por uma propriedade de classe? 

    quarta-feira, 29 de julho de 2015 16:02
  • Bom, sim, quando você tem um número x de métodos que vão usar uma mesma informação, você, ao invés de pedir a informação como parâmetro, pode defini-la em uma propriedade.

    Tudo questão de necessidade, e do cenário. Veja por exemplo a classe abaixo:

    using System;
    using System.Text;
    using System.Security.Cryptography;
    
    namespace HL
    {
        public class Aes256 : IDisposable
        {
            private RijndaelManaged Engine;
            private SHA256CryptoServiceProvider HashProvider;
            private byte[] HashBytes;
    
            private string _Password;
    
            /// <summary>
            /// Retorna ou modifica a senha usada por esta instância para opeções de criptografia e decriptografia
            /// </summary>
            public string Password
            {
                get { return _Password; }
                set
                {
                    _Password = value;
                    HashBytes = HashProvider.ComputeHash(Encoding.UTF8.GetBytes(value));
                    Engine.Key = HashBytes;
                }
            }
    
            /// <summary>
            /// Cria uma nova instância
            /// </summary>
            /// <param name="Password">Senha utilizada para criptografar e decriptografar</param>
            public Aes256(string Password)
            {
                _Password = Password;
                Engine = new RijndaelManaged();
                HashProvider = new SHA256CryptoServiceProvider();
                HashBytes = HashProvider.ComputeHash(Encoding.UTF8.GetBytes(Password));
                Engine.Mode = CipherMode.CBC;
                Engine.Key = HashBytes;
            }
    
            /// <summary>
            /// Criptografa um buffer de bytes
            /// </summary>
            /// <param name="Buffer"></param>
            /// <returns></returns>
            public byte[] Encrypt(byte[] Buffer)
            {
                using (ICryptoTransform Encryptor = Engine.CreateEncryptor())
                    return Encryptor.TransformFinalBlock(Buffer, 0, Buffer.Length);
    
            }
    
            /// <summary>
            /// Decriptografa um buffer de bytes
            /// </summary>
            /// <param name="Buffer"></param>
            /// <returns></returns>
            public byte[] Decrypt(byte[] Buffer)
            {
                using (ICryptoTransform Decryptor = Engine.CreateDecryptor())
                    return Decryptor.TransformFinalBlock(Buffer, 0, Buffer.Length);
            }
    
            /// <summary>
            /// Criptografa um texto
            /// </summary>
            /// <param name="Str"></param>
            /// <returns></returns>
            public string Encrypt(string Str)
            {
                return Convert.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(Str)));
            }
    
            /// <summary>
            /// Decriptografa um texto
            /// </summary>
            /// <param name="Str"></param>
            /// <returns></returns>
            public string Decrypt(string Str)
            {
                return Encoding.UTF8.GetString(Decrypt(Convert.FromBase64String(Str)));
            }
    
            public void Dispose()
            {
                Engine.Dispose();
                HashProvider.Dispose();
                HashBytes = null;
                _Password = null;
            }
    
        }
    }

    É uma classe para criptografia AES 256 que eu escrevi a um tempo atrás. Veja que nos métodos, ao invés de pedir um parâmetro para a senha, eu defini uma propriedade para isso (Password). Assim o programador define a senha na propriedade Password, e então vai criptografar e descriptografar dados usando essa mesma senha, sem a necessidade de estar passando essa senha nos métodos à cada chamada.

    É mais ou menos esse cenário que você tem, correto?


    Herbert Lausmann

    quarta-feira, 29 de julho de 2015 17:00