using (FileStream fs = fi.OpenRead())
{
byte[] b = new byte[1024];
UTF8Encoding temp = new UTF8Encoding(true);
while (fs.Read(b,0,b.Length) > 0)
{
Console.WriteLine(temp.GetString(b));
}
}
The FileInfo.OpenText methods StreamReader code looks like the following:// Open the stream and read it back.I find the StreamReader makes it much easier to interact with the file.
using (StreamReader sr = File.OpenText(path))
{
string s = "";
while ((s = sr.ReadLine()) != null)
{
Console.WriteLine(s);
}
}
string origString =
"I never saw an author who was aware that there is any "+
"dimensional difference between a fact and a surmise.\n"+
" - Mark Twain";
// create the file, write to it, save it.
FileStream fs = new FileStream("quote.txt", FileMode.Create);
fs.Write(ASCIIEncoding.ASCII.GetBytes(origString),0, origString.Length);
fs.Close();
Compare this to the simpler code of the File class, which provides a series of static methods.
StreamWriter sw = File.CreateText("quote2.txt");
sw.Write(origString);
sw.Write(addString);
sw.Close();
delegate void StateChangedDelegate(object sender, EventArgs e);The event is then declared as a member of the class:
Finally the calling class can subscribe to the event:
public event StateChangedDelegate OnStateChangedHandler;
protected virtual OnStateChanged(EventArgs e)
{
if (OnStateChangedHandler != null)
{
OnStateChangedHandler(this, e);
}
}
otherClass.OnStateChanged += new StateChangedDelegate(OtherClass_StateChanged);
Common Members
Common Methods
Access files & folders by using the File System classes.
Manage byte streams by using Stream classes
Manage the .NET Framework application data by using Reader & Writer classes
Compress or decompress stream information in a .NET Framework application
Things you should be able to do by now if you have been following along and doing abit of your own research on the subject areas that have been mentioned.
public event EventHandler<EventArgs> RaiseCustomEvent;
protected virtual void OnRaiseCustomEvent(EventArgs e)
{
EventHandler<EventArgs> handler = RaiseCustomEvent;
if (handler != null)
{
handler(this, e);
}
}
void HandleCustomEvent(object sender, EventArgs e)
{
Console.WriteLine("Event Received");
}
public static void Main()
{
MyClass ourClass = new MyClass();
// Subscribe to event
ourClass.RaiseCustomEvent += ourClass.HandleCustomEvent;
// How to raise an event.
ourClass.OnRaiseCustomEvent(new EventArgs());
}
Narrowing Conversion
If the range of precision of the source type exceeds that of the destination type, the operation is called a narrowing conversion, which will usually require an explicit conversion.
Widening Conversion
If the destination type can accomodate all possible values from the source type, that is known as a widening conversion and doesn't require an explicit cast.
Defining conversion operators allows you to directly assign from a value type to your custom type. Use the Widening/implicit keyword for conversions that don't loose precision; use the Narrowing/explicit keyword for conversions that could loose precision.
struct TypeA
{
public int Value;
// Allows implicit conversion from an integer.
public static implicit operator TypeA(int arg)
{
TypeA res = new TypeA();
res.Value = arg;
return res;
}
// Allows explicit conversion to an integer.
public static explicit operator int(TypeA arg)
{
return arg.Value;
}
// Provides string conversion (avoids boxing).
public override string ToString()
{
return this.Value.ToString();
}
}
public static void Main()
{
TypeA a;
int i;
// Widening conversion is OK implicit.
a = 42;
// Narrowing conversion must be explicit.
i = (int)a;
// ..
Attribute declaration on the type being forwarded should look like the following
[assembly:TypeForwardedToAttribute(typeof(Example))]
Attributes all derieve from the System.Attribute class and are specified in C# using [] notation.
class EmployeeList<T>
where T : Employee, IEmployee, System.IComparable<T>, new()
{
// ...
}
Applying constrains allows you to use methods on base types as you count on the type passed in supporting the method. Within this generic code we are able to call methods specified by IEmployee because the generic type must implement IEmployee, removing this constraint and calling a method within IEmployee directly in the Generics code would lead to a compile time error.
static void Main(string[] args)Now this is not exactly type safe, we are assuming the ArrayList only contains Person objects, this case it does we added them but we can't always count on this. We are constantly casting & uncasting the objects, if dealing with value types we constantly box & unbox the objects in the list.
{
ArrayList people = new ArrayList();
people.Add(new Person("Dave", "Green"));
people.Add(new Person("Joe", "Bloggs"));
foreach (Person item in people)
{
Console.WriteLine(
string.Format("{0} {1}", people.Forename, people.Surname));
}
}
static void Main(string[] args)Now you specify the type expected in the list on declaration and attempting to add the wrong type will cause a compile-time error.
{
List<Person> people = new List<People>();
people.Add(new Person("Dave", "Green"));
people.Add(new Person("Joe", "Bloggs"));
foreach (Person item in people)
{
Console.WriteLine(
string.Format("{0} {1}", people.Forename, people.Surname));
}
}
interface IControlBoth IControl & ISurface will point to the same implementation this cause problems if the implementation needs to be different for each of the interfaces. You can explicitly define the interface implementation if this is the case. This method can only be called through the interface and is accomplished by naming the class member with the name of the interface and a period.
{
void Paint();
}
interface ISurface
{
void Paint();
}
class SampleClass : IControl, ISurface
{
public void Paint()
{
}
}
class SampleClass : IControl, ISurface
{
public void IControl.Paint()
{
}
public void ISurface.Paint()
{
}
}
Reference types are more than containers for data, they provide means to manipulate their members, System.String provides a set of members for working with text.
System.String class in .NET is immutable, meaning changes to a string instance causes the runtime to create a new string instance and abandon the old one. This happens behind the scenes this has the following implications.
string s = "first entry";
s += " second entry";
s += " third entry";
s += " fourth entry";
Only the last string has a reference, the first three entries will be disposed of during garbage collection. To avoid unnecessary garbage collection you can do one of several things.The System.Array class can be used to Sort items, as with the System.String type, System.Array provides members for working with its contained data.
int[] a = {3, 5, 6, 4 };
Array.Sort(a);
Streams are another very common type they provide a means for reading and writing to the disk and communicating across the network. The System.IO.Stream type is the base type for all task specific stream types. The most common stream classes are shown below.FileStream
Create a base stream used to write or read from a fileMemoryStream
Create a base stream used to write or read from memoryStreamReader
Read data from the streamStreamWriter
Write data to the streamSimplest of the stream classes is the StreamReader & StreamWriter classes. You can pass a filename to the constructor enabling you to read or write to a file. After processing the file you call the Close method on the stream to release the lock on the file.
StreamReader sr = new StreamReader(filename);
Console.WriteLine(sr.ReadToEnd());
sr.Close();
if (myInt != int.MinValue)An alternative now exists with nullable types, nullable types are instances of the System.Nullable struct. A nullable type can represent the normal range of values for its underlying type, plus an additional null value. How to declare nullable type of type Int32, both of the following declarations compile to the same IL code.
{
// Int has been set.
}
if (myDateTime != DateTime.MinValue)
{
// DateTime has been set.
}
int? a = null;You can determine whether a nullable type has a value by using the HasValue property, you can also return the value using the Value property if no value is assigned calling this method will result in a System.InvalidOperationException.
Nullable<int> a = null;
int? a = null;The code above defaults the value of a when null to -1, which is very like the statement below but a great deal neater.
Console.WriteLine(a ?? -1);
int? a = null;
Console.WriteLine(a == null ? -1 : a);
public class MyClass
{
interface ICustomValueType
{
int CustomVariable1 { get; set; }
}
struct MyValueType : ICustomValueType
{
public int CustomVariable1
{
get { return _customVariable1; }
set { _customVariable1 = value; }
} private int _customVariable1;
}
public static void Main()
{
// Direct reference to Value Type.
MyValueType valueType1 = new MyValueType();
valueType1.CustomVariable1 = 1;
MyValueType valueType2 = new MyValueType();
valueType2.CustomVariable1 = 2;
Console.WriteLine("Value Type 1 = {0}", valueType1.CustomVariable1);
Console.WriteLine("Value Type 2 = {0}", valueType2.CustomVariable1);
valueType2 = valueType1;
valueType1.CustomVariable1 = 5;
Console.WriteLine("Value Type 1 = {0}", valueType1.CustomVariable1);
Console.WriteLine("Value Type 2 = {0}", valueType2.CustomVariable1);
// Reference to ICustomValueType.
ICustomValueType interfaceValueType1 = new MyValueType();
interfaceValueType1.CustomVariable1 = 1;
ICustomValueType interfaceValueType2 = new MyValueType();
interfaceValueType2.CustomVariable1 = 2;
Console.WriteLine("Value Type 1 = {0}", interfaceValueType1.CustomVariable1);
Console.WriteLine("Value Type 2 = {0}", interfaceValueType2.CustomVariable1);
valueType2 = valueType1;
valueType1.CustomVariable1 = 5;
Console.WriteLine("Value Type 1 = {0}", valueType1.CustomVariable1);
Console.WriteLine("Value Type 2 = {0}", valueType2.CustomVariable1);
}
}
When interacting with the ValueType directly it acts like a ValueType and the variable is copied from the Stack. When referencing the Interface the reference to the variable is copied and changing the value of one causes both instances to change. Value types are derieved from two main categories Structs & Enumerations.
Structs fall into the following categories
- Integral types
- Floating-point types
- decimal
- bool
- User defined structs
Value types are contained on the stack , assigning one value type variable to another copies the
contained value. This differs from reference types, which are stored on the managed heap and
copying a reference type copies the reference to the object but not the object itself.Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
a = b;
b = 4;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
The variable a starts off with a value of 1 and b with a value of 2.
The contents of variable b are copied to a and variable b set to 4.
However changing variable b does not affect variable a, which has
a copy of the contents of variable b.
All value types are derieved from System.ValueType one interesting type is System.String this doesn't derieve from System.ValueType but acts like a value type, it is immutable a new instance is created
each time it is changed unlike other reference types.
string a = "first string";
string b = "second string";
Console.WriteLine("string a = {0}", a);
Console.WriteLine("string b = {0}", b);
b = a;
a = "modified string a";
Console.WriteLine("string a = {0}", a);
Console.WriteLine("string b = {0}", b);
Unlike reference types, it is not possible to derieve a new type from a value type. However, like reference types, structs can implement interfaces.
Manage data in .NET Framework application by using the .NET Framework 2.0 system types
Implement .NET Framework interfaces to cause components to comply with standard contracts.
Control interactions between .NET Framework application components by using events and delegates.