Welcome to the Lounge

using (var outerStream = new MemoryStream(someData))
{
 using (var innerStream = new TextReader(outerStream))
 {
  // do something
 }
}

var outerStream = new MemoryStream(someData);
using (var innerStream = new TextReader(outerStream)
{
 // do something
}

// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
 {
  using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
  {
   using (StreamReader srDecrypt = new StreamReader(csDecrypt))
   {
    // Read the decrypted bytes from the decrypting stream
    // and place them in a string.
    plaintext = srDecrypt.ReadToEnd();
   }
  }
 }

MemoryStream memStream = new MemoryStream(data);
CryptoStream decStream = new CryptoStream(memStream, decryptor, CryptoStreamMode.Read);

using (StreamReader reader = new StreamReader(decStream))
{
 decryptedValue = Encoding.UTF8.GetBytes(reader.ReadToEnd());
}

Foothill wrote:

However, the proper way is this

C#

var outerStream = new MemoryStream(someData);
using (var innerStream = new TextReader(outerStream)
{
 // do something
}

This is because the a stream will dispose of the underlying streams when you call Stream.Dispose(). I had code analysis bark at me all the time until I figured this one out.

var outerStream = new AStream();
using (var innerStream = new AnotherStream(outerStream)) {...}

{
    var outerStream = new MyStream();  // line 59
    using (var innerStream = new MyStream(outerStream)) {
        bool i = innerStream.CanRead;
        Console.WriteLine("Read: " + i);
    }
}
{
    using (var outerStream = new MyStream())
    {
        using (var innerStream = new MyStream(outerStream))
        {
            bool i = innerStream.CanRead;
            Console.WriteLine("Read: " + i);
        }
    }   // Line 73
}

byte[] data = new byte[1000];
MemoryStream memStream = new MemoryStream(data);
CryptoStream decStream = new CryptoStream(memStream, SHA1.Create(), CryptoStreamMode.Read);

using (StreamReader reader = new StreamReader(decStream)) {
    byte[] decryptedValue = Encoding.UTF8.GetBytes(reader.ReadToEnd());
    Console.WriteLine(decryptedValue);
}

SHA1 sha1 = SHA1.Create();
byte[] data = new byte[1000];
using (MemoryStream memStream = new MemoryStream(data)) {
    CryptoStream decStream = new CryptoStream(memStream, sha1, CryptoStreamMode.Read);

    StreamReader reader = new StreamReader(decStream);
    byte[] decryptedValue = Encoding.UTF8.GetBytes(reader.ReadToEnd());
    Console.WriteLine(decryptedValue);
}

pherschel wrote:

const DateTime today = DateTime.Now;

pherschel wrote:

For properties, why can't I hide the worker variable for the rest of the class?

public int PageNbr
{
int _worker = 9;

get { return _worker;}
set { _worker = value; }
}

pherschel wrote:

I can see readonly for parameters and such,

Quote:

Why can't I say

C#

const DateTime today = DateTime.Now;

OriginalGriff wrote:

What would happen if two different classes (or worse assemblies) both declared the same value? Would they be the same? Should they be? How would the system decide for you?

OriginalGriff wrote:

That's the point of const vs readonly - the former is a compile time constant value, the later is a runtime constant value.

TheGreatAndPowerfulOz wrote:

The fact the compiler writers did it for string means they could have done it for any object.

const string _myString = String.Empty; //Compile-time error.

TheGreatAndPowerfulOz wrote:

readonly is used for objects (except for string )

To alcohol! The cause of, and solution to, all of life's problems - Homer Simpson

TheGreatAndPowerfulOz wrote:

could

To alcohol! The cause of, and solution to, all of life's problems - Homer Simpson