diff --git a/TLSharp.Core/Network/MtProtoPlainSender.cs b/TLSharp.Core/Network/MtProtoPlainSender.cs
index d5d40e9..b790132 100644
--- a/TLSharp.Core/Network/MtProtoPlainSender.cs
+++ b/TLSharp.Core/Network/MtProtoPlainSender.cs
@@ -10,11 +10,11 @@ namespace TLSharp.Core.Network
         private int timeOffset;
         private long lastMessageId;
         private Random random;
-        private TcpTransport _transport;
+        private TcpTransport transport;
 
         public MtProtoPlainSender(TcpTransport transport)
         {
-            _transport = transport;
+            this.transport = transport;
             random = new Random();
         }
 
@@ -33,7 +33,7 @@ namespace TLSharp.Core.Network
 
                     byte[] packet = memoryStream.ToArray();
 
-                    await _transport.Send(packet, token).ConfigureAwait(false);
+                    await transport.Send(packet, token).ConfigureAwait(false);
                 }
             }
         }
@@ -42,7 +42,7 @@ namespace TLSharp.Core.Network
         {
             token.ThrowIfCancellationRequested();
 
-            var result = await _transport.Receive(token).ConfigureAwait(false);
+            var result = await transport.Receive(token).ConfigureAwait(false);
 
             using (var memoryStream = new MemoryStream(result.Body))
             {
diff --git a/TLSharp.Core/Network/MtProtoSender.cs b/TLSharp.Core/Network/MtProtoSender.cs
index 73a0abc..cccab37 100644
--- a/TLSharp.Core/Network/MtProtoSender.cs
+++ b/TLSharp.Core/Network/MtProtoSender.cs
@@ -21,20 +21,20 @@ namespace TLSharp.Core.Network
     {
         //private ulong sessionId = GenerateRandomUlong();
 
-        private readonly TcpTransport _transport;
-        private readonly Session _session;
+        private readonly TcpTransport transport;
+        private readonly Session session;
 
         public readonly List<ulong> needConfirmation = new List<ulong>();
 
         public MtProtoSender(TcpTransport transport, Session session)
         {
-            _transport = transport;
-            _session = session;
+            this.transport = transport;
+            this.session = session;
         }
 
         private int GenerateSequence(bool confirmed)
         {
-            return confirmed ? _session.Sequence++ * 2 + 1 : _session.Sequence * 2;
+            return confirmed ? session.Sequence++ * 2 + 1 : session.Sequence * 2;
         }
 
         public async Task Send(TeleSharp.TL.TLMethod request, CancellationToken token = default(CancellationToken))
@@ -62,14 +62,14 @@ namespace TLSharp.Core.Network
                 await Send(memory.ToArray(), request, token).ConfigureAwait(false);
             }
 
-            _session.Save();
+            session.Save();
         }
 
         public async Task Send(byte[] packet, TeleSharp.TL.TLMethod request, CancellationToken token = default(CancellationToken))
         {
             token.ThrowIfCancellationRequested();
 
-            request.MessageId = _session.GetNewMessageId();
+            request.MessageId = session.GetNewMessageId();
 
             byte[] msgKey;
             byte[] ciphertext;
@@ -77,15 +77,15 @@ namespace TLSharp.Core.Network
             {
                 using (BinaryWriter plaintextWriter = new BinaryWriter(plaintextPacket))
                 {
-                    plaintextWriter.Write(_session.Salt);
-                    plaintextWriter.Write(_session.Id);
+                    plaintextWriter.Write(session.Salt);
+                    plaintextWriter.Write(session.Id);
                     plaintextWriter.Write(request.MessageId);
                     plaintextWriter.Write(GenerateSequence(request.Confirmed));
                     plaintextWriter.Write(packet.Length);
                     plaintextWriter.Write(packet);
 
                     msgKey = Helpers.CalcMsgKey(plaintextPacket.GetBuffer());
-                    ciphertext = AES.EncryptAES(Helpers.CalcKey(_session.AuthKey.Data, msgKey, true), plaintextPacket.GetBuffer());
+                    ciphertext = AES.EncryptAES(Helpers.CalcKey(session.AuthKey.Data, msgKey, true), plaintextPacket.GetBuffer());
                 }
             }
 
@@ -93,11 +93,11 @@ namespace TLSharp.Core.Network
             {
                 using (BinaryWriter writer = new BinaryWriter(ciphertextPacket))
                 {
-                    writer.Write(_session.AuthKey.Id);
+                    writer.Write(session.AuthKey.Id);
                     writer.Write(msgKey);
                     writer.Write(ciphertext);
 
-                    await _transport.Send(ciphertextPacket.GetBuffer(), token).ConfigureAwait(false);
+                    await transport.Send(ciphertextPacket.GetBuffer(), token).ConfigureAwait(false);
                 }
             }
         }
@@ -116,7 +116,7 @@ namespace TLSharp.Core.Network
 
                 ulong remoteAuthKeyId = inputReader.ReadUInt64(); // TODO: check auth key id
                 byte[] msgKey = inputReader.ReadBytes(16); // TODO: check msg_key correctness
-                AESKeyData keyData = Helpers.CalcKey(_session.AuthKey.Data, msgKey, false);
+                AESKeyData keyData = Helpers.CalcKey(session.AuthKey.Data, msgKey, false);
 
                 byte[] plaintext = AES.DecryptAES(keyData, inputReader.ReadBytes((int)(inputStream.Length - inputStream.Position)));
 
@@ -138,7 +138,7 @@ namespace TLSharp.Core.Network
         {
             while (!request.ConfirmReceived)
             {
-                var result = DecodeMessage((await _transport.Receive(token).ConfigureAwait(false)).Body);
+                var result = DecodeMessage((await transport.Receive(token).ConfigureAwait(false)).Body);
 
                 using (var messageStream = new MemoryStream(result.Item1, false))
                 using (var messageReader = new BinaryReader(messageStream))
@@ -439,7 +439,7 @@ namespace TLSharp.Core.Network
 
             //logger.debug("bad_server_salt: msgid {0}, seq {1}, errorcode {2}, newsalt {3}", badMsgId, badMsgSeqNo, errorCode, newSalt);
 
-            _session.Salt = newSalt;
+            session.Salt = newSalt;
 
             //resend
             Send(request, token);
diff --git a/TLSharp.Core/Network/Requests/AckRequest.cs b/TLSharp.Core/Network/Requests/AckRequest.cs
index 5530301..8ec54be 100644
--- a/TLSharp.Core/Network/Requests/AckRequest.cs
+++ b/TLSharp.Core/Network/Requests/AckRequest.cs
@@ -7,19 +7,19 @@ namespace TLSharp.Core.Network.Requests
 {
     public class AckRequest : TLMethod
     {
-        private readonly List<ulong> _msgs;
+        private readonly List<ulong> msgs;
 
         public AckRequest(List<ulong> msgs)
         {
-            _msgs = msgs;
+            this.msgs = msgs;
         }
 
         public override void SerializeBody(BinaryWriter writer)
         {
             writer.Write(0x62d6b459); // msgs_ack
             writer.Write(0x1cb5c415); // Vector
-            writer.Write(_msgs.Count);
-            foreach (ulong messageId in _msgs)
+            writer.Write(msgs.Count);
+            foreach (ulong messageId in msgs)
             {
                 writer.Write(messageId);
             }
diff --git a/TLSharp.Core/Network/TcpTransport.cs b/TLSharp.Core/Network/TcpTransport.cs
index 058ff01..3750a76 100644
--- a/TLSharp.Core/Network/TcpTransport.cs
+++ b/TLSharp.Core/Network/TcpTransport.cs
@@ -10,8 +10,8 @@ namespace TLSharp.Core.Network
 
     public class TcpTransport : IDisposable
     {
-        private readonly TcpClient _tcpClient; 
-        private readonly NetworkStream _stream;
+        private readonly TcpClient tcpClient;
+        private readonly NetworkStream stream;
         private int sendCounter = 0;
 
         public TcpTransport(string address, int port, TcpClientConnectionHandler handler = null)
@@ -21,38 +21,38 @@ namespace TLSharp.Core.Network
                 var ipAddress = IPAddress.Parse(address);
                 var endpoint = new IPEndPoint(ipAddress, port);
 
-                _tcpClient = new TcpClient(ipAddress.AddressFamily);
-                _tcpClient.Connect(endpoint);
+                tcpClient = new TcpClient(ipAddress.AddressFamily);
+                tcpClient.Connect(endpoint);
             }
             else
-                _tcpClient = handler(address, port);
+                tcpClient = handler(address, port);
 
-            if (_tcpClient.Connected)
+            if (tcpClient.Connected)
             {
-                _stream = _tcpClient.GetStream();
+                stream = tcpClient.GetStream();
             }
         }
 
         public async Task Send(byte[] packet, CancellationToken token = default(CancellationToken))
         {
-            if (!_tcpClient.Connected)
+            if (!tcpClient.Connected)
                 throw new InvalidOperationException("Client not connected to server.");
 
             var tcpMessage = new TcpMessage(sendCounter, packet);
 
-            await _stream.WriteAsync(tcpMessage.Encode(), 0, tcpMessage.Encode().Length, token).ConfigureAwait(false);
+            await stream.WriteAsync(tcpMessage.Encode(), 0, tcpMessage.Encode().Length, token).ConfigureAwait(false);
             sendCounter++;
         }
 
         public async Task<TcpMessage> Receive(CancellationToken token = default(CancellationToken))
         {
             var packetLengthBytes = new byte[4];
-            if (await _stream.ReadAsync(packetLengthBytes, 0, 4, token).ConfigureAwait(false) != 4)
+            if (await stream.ReadAsync(packetLengthBytes, 0, 4, token).ConfigureAwait(false) != 4)
                 throw new InvalidOperationException("Couldn't read the packet length");
             int packetLength = BitConverter.ToInt32(packetLengthBytes, 0);
 
             var seqBytes = new byte[4];
-            if (await _stream.ReadAsync(seqBytes, 0, 4, token).ConfigureAwait(false) != 4)
+            if (await stream.ReadAsync(seqBytes, 0, 4, token).ConfigureAwait(false) != 4)
                 throw new InvalidOperationException("Couldn't read the sequence");
             int seq = BitConverter.ToInt32(seqBytes, 0);
 
@@ -63,7 +63,7 @@ namespace TLSharp.Core.Network
             do
             {
                 var bodyByte = new byte[packetLength - 12];
-                var availableBytes = await _stream.ReadAsync(bodyByte, 0, neededToRead, token).ConfigureAwait(false);
+                var availableBytes = await stream.ReadAsync(bodyByte, 0, neededToRead, token).ConfigureAwait(false);
                 neededToRead -= availableBytes;
                 Buffer.BlockCopy(bodyByte, 0, body, readBytes, availableBytes);
                 readBytes += availableBytes;
@@ -71,7 +71,7 @@ namespace TLSharp.Core.Network
             while (readBytes != packetLength - 12);
 
             var crcBytes = new byte[4];
-            if (await _stream.ReadAsync(crcBytes, 0, 4, token).ConfigureAwait(false) != 4)
+            if (await stream.ReadAsync(crcBytes, 0, 4, token).ConfigureAwait(false) != 4)
                 throw new InvalidOperationException("Couldn't read the crc");
             int checksum = BitConverter.ToInt32(crcBytes, 0);
 
@@ -96,17 +96,17 @@ namespace TLSharp.Core.Network
         {
             get
             {
-                return this._tcpClient.Connected;
+                return this.tcpClient.Connected;
             }
         }
 
 
         public void Dispose()
         {
-            if (_tcpClient.Connected)
+            if (tcpClient.Connected)
             {
-                _stream.Close();
-                _tcpClient.Close();
+                stream.Close();
+                tcpClient.Close();
             }
         }
     }
diff --git a/TLSharp.Core/Session.cs b/TLSharp.Core/Session.cs
index 9d32892..6a526cc 100644
--- a/TLSharp.Core/Session.cs
+++ b/TLSharp.Core/Session.cs
@@ -88,12 +88,12 @@ namespace TLSharp.Core
         public TLUser TLUser { get; set; }
         private Random random;
 
-        private ISessionStore _store;
+        private ISessionStore store;
 
         public Session(ISessionStore store)
         {
             random = new Random();
-            _store = store;
+            this.store = store;
         }
 
         public byte[] ToBytes()
@@ -169,7 +169,7 @@ namespace TLSharp.Core
 
         public void Save()
         {
-            _store.Save(this);
+            store.Save(this);
         }
 
         public static Session TryLoadOrCreateNew(ISessionStore store, string sessionUserId)
diff --git a/TLSharp.Core/TelegramClient.cs b/TLSharp.Core/TelegramClient.cs
index 9fcad4c..46e0ad4 100644
--- a/TLSharp.Core/TelegramClient.cs
+++ b/TLSharp.Core/TelegramClient.cs
@@ -24,17 +24,17 @@ namespace TLSharp.Core
 {
     public class TelegramClient : IDisposable
     {
-        private MtProtoSender _sender;
-        private TcpTransport _transport;
-        private string _apiHash = "";
-        private int _apiId = 0;
-        private Session _session;
+        private MtProtoSender sender;
+        private TcpTransport transport;
+        private string apiHash = String.Empty;
+        private int apiId = 0;
+        private Session session;
         private List<TLDcOption> dcOptions;
-        private TcpClientConnectionHandler _handler;
+        private TcpClientConnectionHandler handler;
 
         public Session Session
         {
-            get { return _session; }
+            get { return session; }
         }
 
         public TelegramClient(int apiId, string apiHash,
@@ -48,32 +48,32 @@ namespace TLSharp.Core
             if (store == null)
                 store = new FileSessionStore();
 
-            _apiHash = apiHash;
-            _apiId = apiId;
-            _handler = handler;
+            this.apiHash = apiHash;
+            this.apiId = apiId;
+            this.handler = handler;
 
-            _session = Session.TryLoadOrCreateNew(store, sessionUserId);
-            _transport = new TcpTransport(_session.DataCenter.Address, _session.DataCenter.Port, _handler);
+            session = Session.TryLoadOrCreateNew(store, sessionUserId);
+            transport = new TcpTransport (session.DataCenter.Address, session.DataCenter.Port, this.handler);
         }
 
         public async Task ConnectAsync(bool reconnect = false, CancellationToken token = default(CancellationToken))
         {
             token.ThrowIfCancellationRequested();
 
-            if (_session.AuthKey == null || reconnect)
+            if (session.AuthKey == null || reconnect)
             {
-                var result = await Authenticator.DoAuthentication(_transport, token).ConfigureAwait(false);
-                _session.AuthKey = result.AuthKey;
-                _session.TimeOffset = result.TimeOffset;
+                var result = await Authenticator.DoAuthentication(transport, token).ConfigureAwait(false);
+                session.AuthKey = result.AuthKey;
+                session.TimeOffset = result.TimeOffset;
             }
 
-            _sender = new MtProtoSender(_transport, _session);
+            sender = new MtProtoSender(transport, session);
 
             //set-up layer
             var config = new TLRequestGetConfig();
             var request = new TLRequestInitConnection()
             {
-                ApiId = _apiId,
+                ApiId = apiId,
                 AppVersion = "1.0.0",
                 DeviceModel = "PC",
                 LangCode = "en",
@@ -81,8 +81,8 @@ namespace TLSharp.Core
                 SystemVersion = "Win 10.0"
             };
             var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 66, Query = request };
-            await _sender.Send(invokewithLayer, token).ConfigureAwait(false);
-            await _sender.Receive(invokewithLayer, token).ConfigureAwait(false);
+            await sender.Send(invokewithLayer, token).ConfigureAwait(false);
+            await sender.Receive(invokewithLayer, token).ConfigureAwait(false);
 
             dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList();
         }
@@ -95,7 +95,7 @@ namespace TLSharp.Core
                 throw new InvalidOperationException($"Can't reconnect. Establish initial connection first.");
 
             TLExportedAuthorization exported = null;
-            if (_session.TLUser != null)
+            if (session.TLUser != null)
             {
                 TLRequestExportAuthorization exportAuthorization = new TLRequestExportAuthorization() { DcId = dcId };
                 exported = await SendRequestAsync<TLExportedAuthorization>(exportAuthorization, token).ConfigureAwait(false);
@@ -104,22 +104,22 @@ namespace TLSharp.Core
             var dc = dcOptions.First(d => d.Id == dcId);
             var dataCenter = new DataCenter (dcId, dc.IpAddress, dc.Port);
 
-            _transport = new TcpTransport(dc.IpAddress, dc.Port, _handler);
-            _session.DataCenter = dataCenter;
+            transport = new TcpTransport(dc.IpAddress, dc.Port, handler);
+            session.DataCenter = dataCenter;
 
             await ConnectAsync(true, token).ConfigureAwait(false);
 
-            if (_session.TLUser != null)
+            if (session.TLUser != null)
             {
                 TLRequestImportAuthorization importAuthorization = new TLRequestImportAuthorization() { Id = exported.Id, Bytes = exported.Bytes };
                 var imported = await SendRequestAsync<TLAuthorization>(importAuthorization, token).ConfigureAwait(false);
-                OnUserAuthenticated(((TLUser)imported.User));
+                OnUserAuthenticated((TLUser)imported.User);
             }
         }
 
         private async Task RequestWithDcMigration(TLMethod request, CancellationToken token = default(CancellationToken))
         {
-            if (_sender == null)
+            if (sender == null)
                 throw new InvalidOperationException("Not connected!");
 
             var completed = false;
@@ -127,14 +127,14 @@ namespace TLSharp.Core
             {
                 try
                 {
-                    await _sender.Send(request, token).ConfigureAwait(false);
-                    await _sender.Receive(request, token).ConfigureAwait(false);
+                    await sender.Send(request, token).ConfigureAwait(false);
+                    await sender.Receive(request, token).ConfigureAwait(false);
                     completed = true;
                 }
                 catch(DataCenterMigrationException e)
                 {
-                    if (_session.DataCenter.DataCenterId.HasValue &&
-                        _session.DataCenter.DataCenterId.Value == e.DC)
+                    if (session.DataCenter.DataCenterId.HasValue &&
+                        session.DataCenter.DataCenterId.Value == e.DC)
                     {
                         throw new Exception($"Telegram server replied requesting a migration to DataCenter {e.DC} when this connection was already using this DataCenter", e);
                     }
@@ -148,7 +148,7 @@ namespace TLSharp.Core
 
         public bool IsUserAuthorized()
         {
-            return _session.TLUser != null;
+            return session.TLUser != null;
         }
 
         public async Task<bool> IsPhoneRegisteredAsync(string phoneNumber, CancellationToken token = default(CancellationToken))
@@ -168,7 +168,7 @@ namespace TLSharp.Core
             if (String.IsNullOrWhiteSpace(phoneNumber))
                 throw new ArgumentNullException(nameof(phoneNumber));
 
-            var request = new TLRequestSendCode() { PhoneNumber = phoneNumber, ApiId = _apiId, ApiHash = _apiHash };
+            var request = new TLRequestSendCode() { PhoneNumber = phoneNumber, ApiId = apiId, ApiHash = apiHash };
 
             await RequestWithDcMigration(request, token).ConfigureAwait(false);
 
@@ -201,7 +201,7 @@ namespace TLSharp.Core
 
             await RequestWithDcMigration(request, token).ConfigureAwait(false);
 
-            return ((TLPassword)request.Response);
+            return (TLPassword)request.Response;
         }
 
         public async Task<TLUser> MakeAuthWithPasswordAsync(TLPassword password, string password_str, CancellationToken token = default(CancellationToken))
@@ -218,9 +218,9 @@ namespace TLSharp.Core
 
             await RequestWithDcMigration(request, token).ConfigureAwait(false);
 
-            OnUserAuthenticated(((TLUser)request.Response.User));
+            OnUserAuthenticated((TLUser)request.Response.User);
 
-            return ((TLUser)request.Response.User);
+            return (TLUser)request.Response.User;
         }
 
         public async Task<TLUser> SignUpAsync(string phoneNumber, string phoneCodeHash, string code, string firstName, string lastName, CancellationToken token = default(CancellationToken))
@@ -229,9 +229,9 @@ namespace TLSharp.Core
             
             await RequestWithDcMigration(request, token).ConfigureAwait(false);
 
-            OnUserAuthenticated(((TLUser)request.Response.User));
+            OnUserAuthenticated((TLUser)request.Response.User);
 
-            return ((TLUser)request.Response.User);
+            return (TLUser)request.Response.User;
         }
 
         public async Task<T> SendRequestAsync<T>(TLMethod methodToExecute, CancellationToken token = default(CancellationToken))
@@ -374,8 +374,7 @@ namespace TLSharp.Core
 
         public async Task<TLFile> GetFile(TLAbsInputFileLocation location, int filePartSize, int offset = 0, CancellationToken token = default(CancellationToken))
         {
-            TLFile result = null;
-            result = await SendAuthenticatedRequestAsync<TLFile>(new TLRequestGetFile
+            TLFile result = await SendAuthenticatedRequestAsync<TLFile>(new TLRequestGetFile
                 {
                     Location = location,
                     Limit = filePartSize,
@@ -387,7 +386,7 @@ namespace TLSharp.Core
 
         public async Task SendPingAsync(CancellationToken token = default(CancellationToken))
         {
-            await _sender.SendPingAsync(token)
+            await sender.SendPingAsync(token)
                 .ConfigureAwait(false);
         }
 
@@ -427,28 +426,28 @@ namespace TLSharp.Core
 
         private void OnUserAuthenticated(TLUser TLUser)
         {
-            _session.TLUser = TLUser;
-            _session.SessionExpires = int.MaxValue;
+            session.TLUser = TLUser;
+            session.SessionExpires = int.MaxValue;
 
-            _session.Save();
+            session.Save();
         }
 
         public bool IsConnected
         {
             get
             {
-                if (_transport == null)
+                if (transport == null)
                     return false;
-                return _transport.IsConnected;
+                return transport.IsConnected;
             }
         }
 
         public void Dispose()
         {
-            if (_transport != null)
+            if (transport != null)
             {
-                _transport.Dispose();
-                _transport = null;
+                transport.Dispose();
+                transport = null;
             }
         }
     }
diff --git a/TLSharp.Core/Utils/UploadHelper.cs b/TLSharp.Core/Utils/UploadHelper.cs
index 41256a7..eae5c51 100644
--- a/TLSharp.Core/Utils/UploadHelper.cs
+++ b/TLSharp.Core/Utils/UploadHelper.cs
@@ -15,7 +15,7 @@ namespace TLSharp.Core.Utils
     {
         private static string GetFileHash(byte[] data)
         {
-            string md5_checksum;
+            string md5CheckSum;
             using (var md5 = MD5.Create())
             {
                 var hash = md5.ComputeHash(data);
@@ -24,10 +24,10 @@ namespace TLSharp.Core.Utils
                 foreach (byte t in hash)
                     hashResult.Append(t.ToString("x2"));
 
-                md5_checksum = hashResult.ToString();
+                md5CheckSum = hashResult.ToString();
             }
 
-            return md5_checksum;
+            return md5CheckSum;
         }
 
         public static async Task<TLAbsInputFile> UploadFile(this TelegramClient client, string name, StreamReader reader, CancellationToken token = default(CancellationToken))
diff --git a/TLSharp.Tests/TLSharpTests.cs b/TLSharp.Tests/TLSharpTests.cs
index 24e905c..6acde72 100644
--- a/TLSharp.Tests/TLSharpTests.cs
+++ b/TLSharp.Tests/TLSharpTests.cs
@@ -141,10 +141,10 @@ namespace TLSharp.Tests
             }
             catch (CloudPasswordNeededException ex)
             {
-                var password = await client.GetPasswordSetting();
-                var password_str = PasswordToAuthenticate;
+                var passwordSetting = await client.GetPasswordSetting();
+                var password = PasswordToAuthenticate;
 
-                user = await client.MakeAuthWithPasswordAsync(password,password_str);
+                user = await client.MakeAuthWithPasswordAsync(passwordSetting, password);
             }
             catch (InvalidPhoneCodeException ex)
             {